Skip to content

CanvasAnvil is an open source AI diagram maker and flowchart generator - an infinite-canvas diagram editor and self-hosted drawio alternative that writes editable .drawio files. Text to diagram, then fix nodes, layout and labels in place. Also AI presentations, interior design CAD/BOM, posters and infographics.

36.2 KB
Raw Blame
import { useEffect, useRef, useState } from "react";
import { toast } from "sonner";
import { cn } from "@/shared/lib/utils";
import { t, useUiLanguage } from "@/shared/i18n";
import { getCadRenderFallbackTitle } from "@/workspaces/cad/lib/render-titles";
import { CAD_ANALYSIS_IMAGES_KEY, CAD_RENDERS_KEY, cadStore } from "@/workspaces/cad/storage";
import {
  ResizableHandle,
  ResizablePanel,
  ResizablePanelGroup,
  type PanelImperativeHandle,
} from "@/shared/ui/resizable";
import { CAD_SYSTEM_PROMPT } from "@/workspaces/cad/lib/prompts";
import {
  applyStringEdits,
  extractLatestSvgFromText,
  normalizeSvgMarkup,
} from "@/workspaces/cad/lib/svg-markup";
import { hasDrawableSvgContent, isValidSvgMarkup } from "@/workspaces/cad/lib/svg-dom";
import type { ChatMessage } from "@/ai/client";
import { generateImage } from "@/ai/client";
import { CadCanvas } from "@/workspaces/cad/canvas/CadCanvas";
import { ChatPanel as CadChatPanel } from "@/workspaces/cad/chat/ChatPanel";

type Attachment = {
  id: string;
  type: "xml" | "python" | "json";
  content: string;
  name: string;
};

type CodeActionResult = { ok: boolean; retry?: boolean; error?: string; svg?: string };

const CAD_WORKSPACE_STORAGE_KEY = "CanvasAnvil-cad-state-v1";
const CAD_RENDERS_STORAGE_KEY = "CanvasAnvil-cad-renders-v1";
const CAD_ANALYSIS_IMAGES_STORAGE_KEY = "CanvasAnvil-cad-analysis-images-v1";
const CAD_CHAT_STORAGE_KEY = "chat_history_v2_cad";
/**
 * Image gateways sometimes accept a request and never answer. Without a limit
 * that sheet spins forever and holds up the rest of its batch; with one it
 * falls through to the retries below.
 */
const CAD_IMAGE_TIMEOUT_MS = 240_000;

/** What the model returns for a CAD image request; every field is unverified. */
type CadImagePrompt = { title?: unknown; prompt?: unknown };

const tryParseJson = (text: string) => {
  try {
    return JSON.parse(text);
  } catch {
    const start = text.indexOf("{");
    const end = text.lastIndexOf("}");
    if (start >= 0 && end > start) {
      try {
        return JSON.parse(text.slice(start, end + 1));
      } catch {
        // Not this payload; the caller falls through to the next shape.
      }
    }
    return null;
  }
};

type CadRenderItem = { title: string; url: string };

const normalizeCadRenderItems = (
  input: any,
  options?: { allowBlob?: boolean; max?: number },
): CadRenderItem[] => {
  const allowBlob = options?.allowBlob === true;
  const max = typeof options?.max === "number" && options.max > 0 ? options.max : 30;
  if (!Array.isArray(input)) return [];
  return input
    .map((x: any) => ({
      title: typeof x?.title === "string" ? x.title : "",
      url: typeof x?.url === "string" ? x.url : "",
    }))
    .filter((x: CadRenderItem) => {
      if (!x.url) return false;
      if (!allowBlob && x.url.startsWith("blob:")) return false;
      return true;
    })
    .slice(0, max);
};

const readPersistedCadRenders = (): CadRenderItem[] => {
  if (typeof window === "undefined") return [];
  try {
    const raw = localStorage.getItem(CAD_RENDERS_STORAGE_KEY);
    const parsed = raw ? JSON.parse(raw) : [];
    return normalizeCadRenderItems(parsed, { allowBlob: false, max: 30 });
  } catch {
    return [];
  }
};

const readPersistedCadAnalysisImages = (): CadRenderItem[] => {
  if (typeof window === "undefined") return [];
  try {
    const raw = localStorage.getItem(CAD_ANALYSIS_IMAGES_STORAGE_KEY);
    const parsed = raw ? JSON.parse(raw) : [];
    return normalizeCadRenderItems(parsed, { allowBlob: false, max: 2 });
  } catch {
    return [];
  }
};

const blobToDataUrl = async (blob: Blob) =>
  await new Promise<string>((resolve) => {
    const reader = new FileReader();
    reader.onerror = () => resolve("");
    reader.onloadend = () => resolve(typeof reader.result === "string" ? reader.result : "");
    reader.readAsDataURL(blob);
  });

const urlToDataUrl = async (url: string) => {
  if (typeof window === "undefined") return "";
  try {
    const resp = await fetch(url);
    if (!resp.ok) return "";
    const blob = await resp.blob();
    return await blobToDataUrl(blob);
  } catch {
    return "";
  }
};

const toPersistableRenderUrl = async (url: string) => {
  const raw = String(url || "").trim();
  if (!raw) return "";
  if (raw.startsWith("data:image")) return raw;
  if (raw.startsWith("blob:")) {
    const dataUrl = await urlToDataUrl(raw);
    return dataUrl || "";
  }
  if (raw.startsWith("http://") || raw.startsWith("https://")) {
    const dataUrl = await urlToDataUrl(raw);
    return dataUrl || raw;
  }
  return raw;
};

export function CadWorkspace() {
  const uiLang = useUiLanguage();
  const tr = (zh: string, en: string) => (uiLang === "zh" ? zh : en);
  const initialCadState = (() => {
    if (typeof window === "undefined") return null;
    try {
      const raw = localStorage.getItem(CAD_WORKSPACE_STORAGE_KEY);
      const parsed = raw ? JSON.parse(raw) : null;
      if (!parsed || typeof parsed !== "object") return null;
      return parsed as any;
    } catch {
      return null;
    }
  })();
  const initialCadRenders = (() => {
    const fromWorkspaceState = normalizeCadRenderItems(initialCadState?.cadImages, {
      allowBlob: false,
      max: 30,
    });
    if (fromWorkspaceState.length > 0) return fromWorkspaceState;
    return readPersistedCadRenders();
  })();
  const initialCadAnalysisImages = (() => {
    const fromWorkspaceState = normalizeCadRenderItems(initialCadState?.cadAnalysisImages, {
      allowBlob: false,
      max: 2,
    });
    if (fromWorkspaceState.length > 0) return fromWorkspaceState;
    return readPersistedCadAnalysisImages();
  })();

  const [cad2dSvg, setCad2dSvg] = useState<string | undefined>(() => {
    const v = initialCadState?.cad2dSvg;
    return typeof v === "string" ? v : undefined;
  });
  const [cadPlan, setCadPlan] = useState<any>(() => initialCadState?.cadPlan ?? null);
  const [cadAnalysisImages, setCadAnalysisImages] = useState<{ title: string; url: string }[]>(
    () => initialCadAnalysisImages,
  );
  const [cadAnalysisImagesLoading, setCadAnalysisImagesLoading] = useState(false);
  const [cadImages, setCadImages] = useState<{ title: string; url: string }[]>(() => initialCadRenders);
  const [cadImagesLoading, setCadImagesLoading] = useState(false);
  const [cadBom, setCadBom] = useState<{ columns: string[]; rows: any[] } | null>(() => {
    const v = initialCadState?.cadBom;
    if (!v || typeof v !== "object") return null;
    const columns = Array.isArray((v as any).columns)
      ? (v as any).columns.filter((c: any) => typeof c === "string")
      : [];
    const rows = Array.isArray((v as any).rows) ? (v as any).rows : [];
    return { columns, rows };
  });
  const [cadFocusPanel, setCadFocusPanel] = useState<"analysis" | "2d" | "renders" | "bom" | null>("analysis");
  const [isCadImagePersistenceHydrated, setIsCadImagePersistenceHydrated] = useState(false);

  const [attachments, setAttachments] = useState<Attachment[]>([]);
  const [chatHistory, setChatHistory] = useState<ChatMessage[]>([]);

  const cadImageObjectUrlsRef = useRef<string[]>([]);
  const cadStableImagesRef = useRef<CadRenderItem[]>(initialCadRenders);
  const cadStableAnalysisImagesRef = useRef<CadRenderItem[]>(initialCadAnalysisImages);
  const cadRenderPersistenceRunningRef = useRef(false);
  const cadRenderPersistenceRetryRef = useRef(false);
  const cadAnalysisPersistenceRunningRef = useRef(false);
  const cadAnalysisPersistenceRetryRef = useRef(false);
  const suppressChatSvgSyncRef = useRef(false);
  const cad2dSvgRef = useRef<string | undefined>(typeof initialCadState?.cad2dSvg === "string" ? initialCadState.cad2dSvg : undefined);
  const [isChatCollapsed, setIsChatCollapsed] = useState(false);
  const [cadResetTick, setCadResetTick] = useState(0);
  const [cadApplyTick, setCadApplyTick] = useState(0);
  const chatPanelRef = useRef<PanelImperativeHandle | null>(null);

  useEffect(() => {
    let cancelled = false;

    void (async () => {
      try {
        const [persistedRenders, persistedAnalysisImages] = await Promise.all([
          cadStore.read<CadRenderItem[]>(CAD_RENDERS_KEY),
          cadStore.read<CadRenderItem[]>(CAD_ANALYSIS_IMAGES_KEY),
        ]);
        if (cancelled) return;

        const nextRenders = normalizeCadRenderItems(persistedRenders, { allowBlob: false, max: 30 });
        if (nextRenders.length > 0 && cadStableImagesRef.current.length === 0) {
          cadStableImagesRef.current = nextRenders;
          setCadImages(nextRenders);
        }

        const nextAnalysisImages = normalizeCadRenderItems(persistedAnalysisImages, { allowBlob: false, max: 2 });
        if (nextAnalysisImages.length > 0 && cadStableAnalysisImagesRef.current.length === 0) {
          cadStableAnalysisImagesRef.current = nextAnalysisImages;
          setCadAnalysisImages(nextAnalysisImages);
        }
      } catch (e) {
        console.error("Failed to load persisted CAD images", e);
      } finally {
        if (!cancelled) setIsCadImagePersistenceHydrated(true);
      }
    })();

    return () => {
      cancelled = true;
    };
  }, []);

  useEffect(() => {
    cad2dSvgRef.current = cad2dSvg;
  }, [cad2dSvg]);

  useEffect(() => {
    if (typeof window === "undefined") return;
    try {
      localStorage.setItem(
        CAD_WORKSPACE_STORAGE_KEY,
        JSON.stringify({
          cad2dSvg: typeof cad2dSvg === "string" ? cad2dSvg : null,
          cadPlan: cadPlan ?? null,
          cadAnalysisImages: [],
          cadBom,
          cadFocusPanel,
          updatedAt: Date.now(),
        }),
      );
    } catch {
      // Losing one autosave is better than interrupting the user.
    }
  }, [cad2dSvg, cadPlan, cadAnalysisImages, cadBom, cadFocusPanel]);

  useEffect(() => {
    if (typeof window === "undefined") return;
    if (!isCadImagePersistenceHydrated) return;
    const stable = normalizeCadRenderItems(cadImages, { allowBlob: false, max: 30 });
    if (stable.length > 0) {
      cadStableImagesRef.current = stable;
      void cadStore.save(CAD_RENDERS_KEY, stable).catch((e) => {
        console.error("Failed to persist CAD render images", e);
      });
      try {
        localStorage.setItem(CAD_RENDERS_STORAGE_KEY, JSON.stringify(stable));
      } catch (e) {
        console.error("Failed to persist CAD render images snapshot", e);
      }
    }
  }, [cadImages, isCadImagePersistenceHydrated]);

  useEffect(() => {
    if (typeof window === "undefined") return;
    if (!isCadImagePersistenceHydrated) return;
    const stable = normalizeCadRenderItems(cadAnalysisImages, { allowBlob: false, max: 2 });
    if (stable.length > 0) {
      cadStableAnalysisImagesRef.current = stable;
      void cadStore.save(CAD_ANALYSIS_IMAGES_KEY, stable).catch((e) => {
        console.error("Failed to persist CAD analysis images", e);
      });
      try {
        localStorage.setItem(CAD_ANALYSIS_IMAGES_STORAGE_KEY, JSON.stringify(stable));
      } catch (e) {
        console.error("Failed to persist CAD analysis image snapshot", e);
      }
    }
  }, [cadAnalysisImages, isCadImagePersistenceHydrated]);

  useEffect(() => {
    if (cadRenderPersistenceRunningRef.current) {
      cadRenderPersistenceRetryRef.current = true;
      return;
    }

    const pending = cadImages.some((item) => {
      const raw = String(item?.url || "").trim();
      return raw.startsWith("blob:") || raw.startsWith("http://") || raw.startsWith("https://");
    });
    if (!pending) return;

    let cancelled = false;
    cadRenderPersistenceRunningRef.current = true;
    cadRenderPersistenceRetryRef.current = false;

    void (async () => {
      try {
        const cache = new Map<string, string>();
        let changed = false;
        const next = await Promise.all(
          cadImages.map(async (item) => {
            const raw = String(item?.url || "").trim();
            if (!raw) return item;
            if (!raw.startsWith("blob:") && !raw.startsWith("http://") && !raw.startsWith("https://")) {
              return item;
            }
            if (!cache.has(raw)) {
              cache.set(raw, await toPersistableRenderUrl(raw));
            }
            const persisted = cache.get(raw) || raw;
            if (persisted && persisted !== raw) {
              changed = true;
              return { ...item, url: persisted };
            }
            return item;
          }),
        );
        if (!cancelled && changed) {
          setCadImages(next);
        }
      } finally {
        cadRenderPersistenceRunningRef.current = false;
        if (!cancelled && cadRenderPersistenceRetryRef.current) {
          cadRenderPersistenceRetryRef.current = false;
          setCadImages((prev) => [...prev]);
        }
      }
    })();

    return () => {
      cancelled = true;
    };
  }, [cadImages]);

  useEffect(() => {
    if (cadAnalysisPersistenceRunningRef.current) {
      cadAnalysisPersistenceRetryRef.current = true;
      return;
    }

    const pending = cadAnalysisImages.some((item) => {
      const raw = String(item?.url || "").trim();
      return raw.startsWith("blob:") || raw.startsWith("http://") || raw.startsWith("https://");
    });
    if (!pending) return;

    let cancelled = false;
    cadAnalysisPersistenceRunningRef.current = true;
    cadAnalysisPersistenceRetryRef.current = false;

    void (async () => {
      try {
        const cache = new Map<string, string>();
        let changed = false;
        const next = await Promise.all(
          cadAnalysisImages.map(async (item) => {
            const raw = String(item?.url || "").trim();
            if (!raw) return item;
            if (!raw.startsWith("blob:") && !raw.startsWith("http://") && !raw.startsWith("https://")) {
              return item;
            }
            if (!cache.has(raw)) {
              cache.set(raw, await toPersistableRenderUrl(raw));
            }
            const persisted = cache.get(raw) || raw;
            if (persisted && persisted !== raw) {
              changed = true;
              return { ...item, url: persisted };
            }
            return item;
          }),
        );
        if (!cancelled && changed) {
          setCadAnalysisImages(next);
        }
      } finally {
        cadAnalysisPersistenceRunningRef.current = false;
        if (!cancelled && cadAnalysisPersistenceRetryRef.current) {
          cadAnalysisPersistenceRetryRef.current = false;
          setCadAnalysisImages((prev) => [...prev]);
        }
      }
    })();

    return () => {
      cancelled = true;
    };
  }, [cadAnalysisImages]);

  useEffect(() => {
    const nextObjectUrls = cadImages
      .map((x) => x?.url)
      .filter((u): u is string => typeof u === "string" && u.startsWith("blob:"));
    const prevObjectUrls = cadImageObjectUrlsRef.current;
    for (const u of prevObjectUrls) {
      if (!nextObjectUrls.includes(u)) {
        try {
          URL.revokeObjectURL(u);
        } catch {
          // The URL was already revoked, or never belonged to this document.
        }
      }
    }
    cadImageObjectUrlsRef.current = nextObjectUrls;
  }, [cadImages]);

  useEffect(() => {
    if (suppressChatSvgSyncRef.current) {
      if (!Array.isArray(chatHistory) || chatHistory.length === 0) {
        suppressChatSvgSyncRef.current = false;
      }
      return;
    }
    if (!Array.isArray(chatHistory) || chatHistory.length === 0) return;

    // Only recover from chat history when canvas has no SVG yet.
    const current = normalizeSvgMarkup(String(cad2dSvgRef.current || ""));
    if (current) return;

    for (let i = chatHistory.length - 1; i >= 0; i -= 1) {
      const msg = chatHistory[i];
      if (!msg || msg.role !== "assistant" || typeof msg.content !== "string") continue;
      const svg = extractLatestSvgFromText(msg.content);
      if (!svg) continue;
      cad2dSvgRef.current = svg;
      setCad2dSvg(svg);
      setCadFocusPanel("2d");
      return;
    }
  }, [chatHistory]);

  const toggleCollapse = () => {
    const panel = chatPanelRef.current;
    if (!panel) return;
    try {
      if (panel.isCollapsed?.() || isChatCollapsed) {
        panel.expand();
        setIsChatCollapsed(false);
      } else {
        panel.collapse();
        setIsChatCollapsed(true);
      }
    } catch {
      setIsChatCollapsed(false);
    }
  };

  const handleAddToChat = (payload: string) => {
    const trimmed = String(payload || "").trim();
    if (!trimmed) return;
    if (trimmed.startsWith("<svg")) {
      setAttachments((prev) => [
        ...prev,
        { id: Math.random().toString(36).slice(2), type: "xml", content: payload, name: "plan.svg" },
      ]);
      return;
    }
    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
      setAttachments((prev) => [
        ...prev,
        { id: Math.random().toString(36).slice(2), type: "json", content: payload, name: "cad.json" },
      ]);
      return;
    }
    setAttachments((prev) => [
      ...prev,
      { id: Math.random().toString(36).slice(2), type: "python", content: payload, name: "script.py" },
    ]);
  };

  const handleCadCodeAction = async (
    code: string,
    type: "diagram" | "cad" | "ppt",
  ): Promise<CodeActionResult> => {
    if (type !== "cad") return { ok: true };

    const raw = String(code || "");
    const trimmed = raw.trim();
    if (!trimmed) return { ok: false, retry: false, error: tr("输入为空", "Empty input") };

    const normalizedRawSvg = !trimmed.startsWith("{") ? normalizeSvgMarkup(raw) : "";
    if (normalizedRawSvg) {
      if (!isValidSvgMarkup(normalizedRawSvg)) {
        toast.warning(tr("SVG 可能包含 XML 问题,仍将尝试加载", "SVG may contain XML issues, trying to load anyway"));
      }
      if (!hasDrawableSvgContent(normalizedRawSvg)) {
        const msg = tr("SVG 不包含可绘制内容", "SVG has no drawable content");
        toast.error(msg);
        return { ok: false, retry: false, error: msg };
      }
      const current = normalizeSvgMarkup(String(cad2dSvgRef.current || ""));
      if (normalizedRawSvg === current) {
        // Keep "Apply" idempotent: same SVG still forces editor remount to recover stale iframe state.
        setCadFocusPanel("2d");
        setCadApplyTick((x) => x + 1);
        return { ok: true, svg: current || normalizedRawSvg };
      }
      cad2dSvgRef.current = normalizedRawSvg;
      setCad2dSvg(normalizedRawSvg);
      setCadFocusPanel("2d");
      setCadApplyTick((x) => x + 1);
      return { ok: true, svg: normalizedRawSvg };
    }

    if (!trimmed.startsWith("{")) return { ok: false, retry: false, error: tr("输入中未找到 SVG", "No SVG found in input") };
    const parsed = tryParseJson(trimmed);
    if (!parsed) return { ok: false, retry: false, error: tr("JSON 无效", "Invalid JSON") };
    const parsedType = String(parsed?.type || "").trim().toLowerCase();
    const parsedTarget = String(parsed?.target || "").trim().toLowerCase();
    const parsedMode = String(parsed?.mode || "").trim().toLowerCase();

    if (parsedType === "cad_plan") {
      setCadPlan(parsed);
      return { ok: true };
    }

    if (parsedType === "cad_bom") {
      const fallbackColumns =
        uiLang === "zh"
          ? ["类别", "名称", "规格", "数量", "单位", "备注"]
          : ["Category", "Name", "Spec", "Qty", "Unit", "Note"];
      const columns =
        Array.isArray(parsed.columns) && parsed.columns.length > 0
          ? parsed.columns.map((x: any) => String(x))
          : fallbackColumns;
      const rows = Array.isArray(parsed.rows) ? parsed.rows : [];
      setCadBom({ columns, rows });
      setCadFocusPanel("bom");
      return { ok: true };
    }

    if (parsedType === "cad_analysis_images") {
      const prompts: CadImagePrompt[] = Array.isArray(parsed.prompts) ? parsed.prompts : [];
      const defaultTitles = [
        uiLang === "zh" ? "整体方案图" : "Overall Scheme",
        uiLang === "zh" ? "重点策略图" : "Key Strategy",
      ];
      const previousStableAnalysis = normalizeCadRenderItems(cadAnalysisImages, { allowBlob: false, max: 2 });
      const items = prompts
        .map((p: any, idx: number) => ({
          title:
            typeof p?.title === "string" && p.title.trim()
              ? p.title
              : defaultTitles[idx] || (uiLang === "zh" ? `分析图${idx + 1}` : `Analysis ${idx + 1}`),
          prompt: typeof p?.prompt === "string" ? p.prompt : "",
        }))
        .filter((p: any) => p.prompt)
        .slice(0, 2);

      setCadFocusPanel("analysis");
      setCadAnalysisImagesLoading(true);
      setCadAnalysisImages(
        defaultTitles.map((title, idx) => ({
          title: previousStableAnalysis[idx]?.title || title,
          url: previousStableAnalysis[idx]?.url || "",
        })),
      );
      try {
        const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
        const generateWithRetry = async (prompt: string, maxRetries: number, retryDelayMs: number) => {
          for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
            try {
              const url = await generateImage({ prompt }, AbortSignal.timeout(CAD_IMAGE_TIMEOUT_MS));
              if (url) return url;
            } catch (err) {
              if (attempt >= maxRetries) {
                console.error("CAD analysis image generation attempt failed", err);
              }
            }
            if (attempt < maxRetries) {
              await wait(retryDelayMs * (attempt + 1));
            }
          }
          return "";
        };

        const settled = await Promise.allSettled(
          items.map(async (item) => ({
            title: item.title,
            url: await generateWithRetry(item.prompt, 2, 1200),
          })),
        );

        const final = defaultTitles.map((title, idx) => {
          const result = settled[idx];
          if (result?.status === "fulfilled" && result.value?.url) {
            return {
              title: result.value.title || title,
              url: result.value.url,
            };
          }
          return { title, url: "" };
        });

        const persistableFinal = await Promise.all(
          final.map(async (item) => ({
            title: item.title,
            url: await toPersistableRenderUrl(item.url),
          })),
        );
        setCadAnalysisImages(
          defaultTitles.map((title, idx) => ({
            title: persistableFinal[idx]?.title || previousStableAnalysis[idx]?.title || title,
            url: persistableFinal[idx]?.url || previousStableAnalysis[idx]?.url || "",
          })),
        );
        const failedCount = final.filter((x) => !x.url).length;
        if (failedCount > 0) {
          toast.warning(
            uiLang === "zh"
              ? `有 ${failedCount} 张分析图生成失败,请重试。`
              : `${failedCount} analysis image(s) failed. Please retry.`,
          );
        }
      } catch (e) {
        console.error("CAD analysis image generation failed", e);
        toast.error(tr("分析图生成失败", "Analysis image generation failed"));
        setCadAnalysisImages(
          defaultTitles.map((title, idx) => ({
            title: previousStableAnalysis[idx]?.title || title,
            url: previousStableAnalysis[idx]?.url || "",
          })),
        );
      } finally {
        setCadAnalysisImagesLoading(false);
        setCadFocusPanel("analysis");
      }
      return { ok: true };
    }

    if (parsedType === "cad_images") {
      const prompts: CadImagePrompt[] = Array.isArray(parsed.prompts) ? parsed.prompts : [];
      const previousStableRenders = normalizeCadRenderItems(cadImages, { allowBlob: false, max: 30 });
      const items = prompts
        .map((p: any) => ({
          title: typeof p?.title === "string" ? p.title : tr("视图", "View"),
          prompt: typeof p?.prompt === "string" ? p.prompt : "",
        }))
        .filter((p: any) => p.prompt)
        .slice(0, 7);

      setCadFocusPanel("renders");
      setCadImagesLoading(true);
      setCadImages(
        Array.from({ length: 7 }).map((_, idx) => ({
          title: getCadRenderFallbackTitle(uiLang, idx),
          url: previousStableRenders[idx]?.url || "",
        })),
      );
      try {
        const results: Array<{ title: string; url: string; prompt: string } | null> = new Array(items.length).fill(null);
        const presetRenderPrompt = [
          "orthographic 2D technical construction drawing sheet, CAD-like linework",
          "black and white printing, clean readable annotations, clear dimension text",
          "include drawing border/frame and bottom-right title block",
          "no perspective, no 3D, no photorealism",
          "no watermark, no logo, no decorative typography",
        ].join(", ");

        const planText = cadPlan ? JSON.stringify(cadPlan) : "";
        const svgText = typeof cad2dSvg === "string" ? cad2dSvg : "";
        const planShort = planText.length > 6000 ? planText.slice(0, 6000) : planText;
        const svgShort = svgText.length > 6000 ? svgText.slice(0, 6000) : svgText;

        const list = items.slice(0, 7);
        const buildFullPrompt = (sheetPrompt: string) =>
          [
            presetRenderPrompt,
            "",
            "Plan:",
            planShort,
            "",
            "2D SVG:",
            svgShort,
            "",
            "Sheet:",
            sheetPrompt,
          ]
            .filter(Boolean)
            .join("\n");

        const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

        const generateWithRetry = async (fullPrompt: string, maxRetries: number, retryDelayMs: number) => {
          for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
            try {
              const url = await generateImage({ prompt: fullPrompt }, AbortSignal.timeout(CAD_IMAGE_TIMEOUT_MS));
              if (url) return url;
            } catch (err) {
              if (attempt >= maxRetries) {
                console.error("CAD image generation attempt failed", err);
              }
            }
            if (attempt < maxRetries) {
              await wait(retryDelayMs * (attempt + 1));
            }
          }
          return "";
        };

        const syncPartialImages = () => {
          setCadImages(
            Array.from({ length: 7 }).map((_, idx) => ({
              title: getCadRenderFallbackTitle(uiLang, idx),
              url: results[idx]?.url || previousStableRenders[idx]?.url || "",
            })),
          );
        };

        const runPass = async (indices: number[], batchSize: number, maxRetriesPerItem: number, retryDelayMs: number) => {
          for (let i = 0; i < indices.length; i += batchSize) {
            const batch = indices.slice(i, i + batchSize);
            const settled = await Promise.allSettled(
              batch.map(async (idx) => {
                const p = list[idx];
                if (!p?.prompt) return null;
                const url = await generateWithRetry(buildFullPrompt(p.prompt), maxRetriesPerItem, retryDelayMs);
                return url ? { idx, value: { title: p.title, url, prompt: p.prompt } } : null;
              }),
            );
            for (const s of settled) {
              if (s.status === "fulfilled" && s.value?.idx !== undefined && s.value?.value?.url) {
                results[s.value.idx] = s.value.value;
              }
            }
            syncPartialImages();
          }
        };

        const allIndices = list.map((_, idx) => idx);
        await runPass(allIndices, 3, 1, 1200);
        const failedAfterConcurrent = allIndices.filter((idx) => !results[idx]?.url);
        if (failedAfterConcurrent.length > 0) {
          await runPass(failedAfterConcurrent, 1, 2, 1800);
        }

        const final = Array.from({ length: 7 }).map((_, idx) => ({
          title: getCadRenderFallbackTitle(uiLang, idx),
          url: results[idx]?.url || "",
        }));
        const persistableFinal = await Promise.all(
          final.map(async (item) => ({
            title: item.title,
            url: await toPersistableRenderUrl(item.url),
          })),
        );
        setCadImages(
          Array.from({ length: 7 }).map((_, idx) => ({
            title: getCadRenderFallbackTitle(uiLang, idx),
            url: persistableFinal[idx]?.url || previousStableRenders[idx]?.url || "",
          })),
        );
        const failedCount = list.filter((_, idx) => !results[idx]?.url).length;
        if (failedCount > 0) {
          toast.warning(
            uiLang === "zh"
              ? `有 ${failedCount} 张装修图在重试后仍失败,请重新生成。`
              : `${failedCount} render image(s) failed after retries. Please run generation again.`,
          );
        }
      } catch (e) {
        console.error("CAD image generation failed", e);
        toast.error(tr("装修图生成失败", "CAD image generation failed"));
        setCadImages(
          Array.from({ length: 7 }).map((_, idx) => ({
            title: getCadRenderFallbackTitle(uiLang, idx),
            url: previousStableRenders[idx]?.url || "",
          })),
        );
      } finally {
        setCadImagesLoading(false);
        setCadFocusPanel("renders");
      }
      return { ok: true };
    }

    if (parsedType === "cad_patch" && parsedTarget === "2d_svg") {
      if (parsedMode === "replace" && typeof parsed.full === "string") {
        const normalizedFull = normalizeSvgMarkup(parsed.full);
        if (!normalizedFull) {
          const msg = tr("replace 模式 SVG 无效", "Invalid replace svg");
          toast.error(msg);
          return { ok: false, retry: false, error: msg };
        }
        if (!isValidSvgMarkup(normalizedFull)) {
          toast.warning(tr("replace SVG 可能包含 XML 问题,仍将尝试加载", "Replace svg may contain XML issues, trying to load anyway"));
        }
        if (!hasDrawableSvgContent(normalizedFull)) {
          const msg = tr("replace SVG 不包含可绘制内容", "Replace svg has no drawable content");
          toast.error(msg);
          return { ok: false, retry: false, error: msg };
        }
        const current = normalizeSvgMarkup(String(cad2dSvgRef.current || ""));
        if (normalizedFull === current) {
          setCadFocusPanel("2d");
          setCadApplyTick((x) => x + 1);
          return { ok: true, svg: current || normalizedFull };
        }
        cad2dSvgRef.current = normalizedFull;
        setCad2dSvg(normalizedFull);
        setCadFocusPanel("2d");
        setCadApplyTick((x) => x + 1);
        return { ok: true, svg: normalizedFull };
      }
      if (parsedMode === "patch" && Array.isArray(parsed.edits)) {
        try {
          const current = normalizeSvgMarkup(String(cad2dSvgRef.current || ""));
          if (!current) {
            const msg = tr("当前 2D SVG 为空,无法应用补丁", "Current 2D SVG is empty, cannot apply patch");
            toast.error(msg);
            return { ok: false, retry: true, error: msg };
          }
          const next = applyStringEdits(current, parsed.edits);
          const normalizedNext = normalizeSvgMarkup(next);
          if (!normalizedNext) {
            const msg = tr("补丁结果不是有效 SVG", "Patch result is not valid svg");
            toast.error(msg);
            return { ok: false, retry: true, error: msg };
          }
          if (!isValidSvgMarkup(normalizedNext)) {
            toast.warning(tr("补丁结果可能包含 XML 问题,仍将尝试加载", "Patch result may contain XML issues, trying to load anyway"));
          }
          if (!hasDrawableSvgContent(normalizedNext)) {
            const msg = tr("补丁结果不包含可绘制内容", "Patch result has no drawable content");
            toast.error(msg);
            return { ok: false, retry: true, error: msg };
          }
          if (normalizedNext === current) {
            const msg = tr("补丁未产生可见 SVG 变化", "Patch produced no visible SVG change");
            toast.warning(msg);
            return { ok: false, retry: true, error: msg };
          }
          cad2dSvgRef.current = normalizedNext;
          setCad2dSvg(normalizedNext);
          setCadFocusPanel("2d");
          setCadApplyTick((x) => x + 1);
          return { ok: true, svg: normalizedNext };
        } catch (e) {
          const msg = e instanceof Error ? e.message : String(e);
          const err = uiLang === "zh" ? `补丁应用失败:${msg}` : `Patch apply failed: ${msg}`;
          toast.error(err);
          return { ok: false, retry: true, error: msg };
        }
      }
      const mode = String(parsedMode || "") || "unknown";
      const err = uiLang === "zh" ? `不支持的 cad_patch 模式:${mode}` : `Unsupported cad_patch mode: ${mode}`;
      toast.error(err);
      return { ok: false, retry: false, error: err };
    }

    return { ok: true };
  };

  const clearWorkspace = () => {
    suppressChatSvgSyncRef.current = true;
    cad2dSvgRef.current = undefined;
    cadStableImagesRef.current = [];
    cadStableAnalysisImagesRef.current = [];
    setCad2dSvg(undefined);
    setCadPlan(null);
    setCadAnalysisImages([]);
    setCadAnalysisImagesLoading(false);
    setCadImages([]);
    setCadImagesLoading(false);
    setCadBom(null);
    setCadFocusPanel("analysis");
    setChatHistory([]);
    setAttachments([]);
    try {
      localStorage.removeItem(CAD_WORKSPACE_STORAGE_KEY);
    } catch {
      // A blocked localStorage only means the old history lingers.
    }
    try {
      localStorage.removeItem(CAD_RENDERS_STORAGE_KEY);
    } catch {
      // A blocked localStorage only means the old history lingers.
    }
    try {
      localStorage.removeItem(CAD_ANALYSIS_IMAGES_STORAGE_KEY);
    } catch {
      // A blocked localStorage only means the old history lingers.
    }
    try {
      localStorage.removeItem(CAD_CHAT_STORAGE_KEY);
    } catch {
      // A blocked localStorage only means the old history lingers.
    }
    void Promise.all([
      cadStore.clear(CAD_RENDERS_KEY),
      cadStore.clear(CAD_ANALYSIS_IMAGES_KEY),
    ]).catch((e) => {
      console.error("Failed to clear persisted CAD images", e);
    });
    try {
      localStorage.removeItem("CanvasAnvil-history-cad-v1");
    } catch {
      // A blocked localStorage only means the old history lingers.
    }
    setCadResetTick((x) => x + 1);
  };

  return (
    <ResizablePanelGroup orientation="horizontal" className="h-full" style={{ height: "100%" }}>
      <ResizablePanel
        defaultSize="68%"
        minSize="30%"
        className={cn("transition-[flex-grow,flex-basis] duration-300 ease-in-out will-change-[flex-grow,flex-basis]")}
      >
        <div className="h-full w-full relative bg-muted/20">
          <CadCanvas
            key={`cad-ws-${cadResetTick}-${cadApplyTick}`}
            svg2d={cad2dSvg}
            onSvgChange={(nextSvg) => {
              cad2dSvgRef.current = nextSvg;
              setCad2dSvg(nextSvg);
            }}
            plan={cadPlan}
            analysisImages={cadAnalysisImages}
            analysisImagesLoading={cadAnalysisImagesLoading}
            images={cadImages}
            imagesLoading={cadImagesLoading}
            bom={cadBom}
            focusPanel={cadFocusPanel}
            onAddToChat={handleAddToChat}
          />
        </div>
      </ResizablePanel>

      <>
        <ResizableHandle withHandle className="bg-border/50 hover:bg-primary/50 transition-colors w-1.5" />
        <ResizablePanel
          id="cad-chat"
          panelRef={chatPanelRef}
          defaultSize="32%"
          minSize="20%"
          maxSize="70%"
          collapsible
          collapsedSize="56px"
          onResize={(panelSize) => setIsChatCollapsed(panelSize.inPixels <= 80)}
          className={cn("transition-[flex-grow,flex-basis] duration-300 ease-in-out will-change-[flex-grow,flex-basis]")}
        >
          <CadChatPanel
            key={`cad-chat-${cadResetTick}`}
            systemPrompt={CAD_SYSTEM_PROMPT}
            initialMessages={chatHistory}
            onMessagesChange={setChatHistory}
            attachments={attachments}
            workspaceId="cad"
            mode="text"
            collapsed={isChatCollapsed}
            title={t(uiLang, "workspace.cad.title")}
            inputPlaceholder={t(uiLang, "workspace.cad.placeholder")}
            onToggleCollapse={toggleCollapse}
            onRemoveAttachment={(id) => setAttachments((prev) => prev.filter((a) => a.id !== id))}
            onClearAttachments={() => setAttachments([])}
            onClearWorkspace={clearWorkspace}
            hideHistoryButton
            cadContext={{ plan: cadPlan, svg2d: cad2dSvg, analysisImages: cadAnalysisImages }}
            onCodeAction={handleCadCodeAction}
          />
        </ResizablePanel>
      </>
    </ResizablePanelGroup>
  );
}