@icen.ai/ui 0.10.0 → 0.11.1

package/dist/behaviors/ai-tools.mjs

@@ -116,6 +116,7 @@ var ICEN_LOCALE_ZH_CN = {
   "aiChat.roleTool": "\u5DE5",
   "aiChat.roleUser": "\u6211",
   "aiChat.thinking": "\u601D\u8003 {p0}",
+  "aiChat.thinkingNow": "\u6B63\u5728\u601D\u8003\u2026",
   /* ── aiComposer ── */
   "aiComposer.attachAgent": "\u4EE3\u7406",
   "aiComposer.library": "\u6DFB\u52A0\u4E0A\u4E0B\u6587\u4E0E\u547D\u4EE4",
@@ -298,6 +299,19 @@ var ICEN_LOCALE_ZH_CN = {
   "charts.noData": "\u6682\u65E0\u6570\u636E",
   "charts.resetZoom": "\u91CD\u7F6E\u7F29\u653E",
   "charts.sampled": "\u5DF2\u62BD\u6837 {p0}\u2192{p1} \u70B9",
+  "charts.a11y.keyboardHint": "\u65B9\u5411\u952E\u9010\u70B9\u6D4F\u89C8\uFF0CHome/End \u8DF3\u9996\u5C3E\uFF0CEsc \u91CD\u7F6E\u7F29\u653E",
+  "charts.a11y.max": "\u6700\u5927 {p0}\uFF08{p1}\uFF09",
+  "charts.a11y.min": "\u6700\u5C0F {p0}\uFF08{p1}\uFF09",
+  "charts.a11y.point": "{p0}\uFF1A{p1}\uFF0C\u7B2C {p2}/{p3} \u70B9",
+  "charts.a11y.pointSeries": "{p0} \xB7 {p1}\uFF1A{p2}\uFF0C\u7B2C {p3}/{p4} \u70B9",
+  "charts.a11y.range": "\u7C7B\u76EE {p0} \u81F3 {p1}",
+  "charts.a11y.scatterRange": "x \u8303\u56F4 {p0}\u2013{p1}\uFF0Cy \u8303\u56F4 {p2}\u2013{p3}",
+  "charts.a11y.seriesCount": "{p0} \u4E2A\u7CFB\u5217",
+  "charts.a11y.tableCaption": "{p0} \u6570\u636E\u8868",
+  "charts.a11y.trend": "\u9996\u7CFB\u5217\u8D8B\u52BF{p0}",
+  "charts.a11y.trendDown": "\u4E0B\u964D",
+  "charts.a11y.trendFlat": "\u6301\u5E73",
+  "charts.a11y.trendUp": "\u4E0A\u5347",
   "charts.type.area": "\u9762\u79EF\u56FE",
   "charts.type.donut": "\u73AF\u5F62\u56FE",
   "charts.type.gauge": "\u4EEA\u8868\u76D8",
@@ -1163,7 +1177,8 @@ function withChrome(el, opts, hasLegend, paint, state, extras) {
     emitIcen(el, "icen:chart-legend-visibility", { visible: hidden ? false : true });
   });
   syncEye();
-  head.append(title, eye);
+  if (hasLegend) head.append(title, eye);
+  else head.append(title);
   el.append(head, body);
   paint(body);
 }
@@ -1264,7 +1279,7 @@ function renderVBar(el, opts) {
       wrap.appendChild(track);
     }
     body.append(wrap, labelsRow(labelsUsed));
-    if (seriesList.length > 1) body.appendChild(toggleLegend(seriesList.map((s, si) => ({ key: s.name, label: s.name, tone: s.tone ?? (si === 0 ? opts.tone : void 0), si })), wrap));
+    if (seriesList.length > 1) body.appendChild(toggleLegend(seriesList.map((s, si) => ({ key: `${si}:${s.name}`, label: s.name, tone: s.tone ?? (si === 0 ? opts.tone : void 0), si })), wrap));
   });
   attachChartInteraction(el, "vbar");
   return el;
@@ -1359,8 +1374,10 @@ function renderDonut(el, opts) {
       "stroke-width": "14"
     }));
     let offset = 0;
+    const gap = opts.segments.length > 1 ? 2.5 : 0;
     opts.segments.forEach((seg, segIndex) => {
-      const dash = seg.value / total * circumference;
+      const arcLength = Math.max(0, seg.value / total * circumference);
+      const dash = arcLength - Math.min(gap, arcLength * 0.1);
       const arc = svgEl("circle", {
         cx: "60",
         cy: "60",
@@ -1374,7 +1391,7 @@ function renderDonut(el, opts) {
       });
       setMarkData(arc, { index: segIndex, label: seg.label, value: seg.value });
       svg.appendChild(arc);
-      offset += dash;
+      offset += arcLength;
     });
     const legend = document.createElement("div");
     legend.className = "icen-chart-legend";
@@ -1409,8 +1426,9 @@ function renderLine(el, opts) {
     const svg = svgEl("svg", { viewBox: `0 0 ${width} ${height}`, role: "img", "aria-label": chartAriaLabel(opts.title, t("charts.type.line")) });
     const defs = svgEl("defs", {});
     for (let i = 0; i < 4; i++) {
-      const y = pad + i * (height - pad * 2) / 3;
+      const y = Math.round(pad + i * (height - pad * 2) / 3) + 0.5;
       svg.appendChild(svgEl("line", {
+        class: i === 3 ? "icen-chart-grid icen-chart-baseline" : "icen-chart-grid",
         x1: String(pad),
         x2: String(width - pad),
         y1: String(y),
@@ -1494,7 +1512,7 @@ function renderLine(el, opts) {
     if (defs.firstChild) svg.insertBefore(defs, svg.firstChild);
     wrap.append(svg, pointLabelsRow(labelsUsed, width, pad));
     body.appendChild(wrap);
-    if (seriesList.length > 1) body.appendChild(toggleLegend(seriesList.map((s, si) => ({ key: s.name, label: s.name, tone: s.tone ?? (si === 0 ? opts.tone : void 0), si })), wrap));
+    if (seriesList.length > 1) body.appendChild(toggleLegend(seriesList.map((s, si) => ({ key: `${si}:${s.name}`, label: s.name, tone: s.tone ?? (si === 0 ? opts.tone : void 0), si })), wrap));
   });
   if (el.dataset.icenChartBody == null) observeFluidWidth(el, () => renderLine(el, opts));
   attachChartInteraction(el, "line");
@@ -1601,7 +1619,7 @@ function renderRadar(el, opts) {
         setMarkData(dot, { index: i, seriesIndex: si, seriesName: s.name || void 0, label: axes[i] ?? "", value: s.values[i] ?? 0 });
         svg.appendChild(dot);
       }
-      legendItems.push({ key: s.name || t("charts.seriesName", { p0: si + 1 }), label: s.name || t("charts.seriesName", { p0: si + 1 }), tone: s.tone, si });
+      legendItems.push({ key: `${si}:${s.name || t("charts.seriesName", { p0: si + 1 })}`, label: s.name || t("charts.seriesName", { p0: si + 1 }), tone: s.tone, si });
     });
     wrap.appendChild(svg);
     body.appendChild(wrap);
@@ -1623,6 +1641,11 @@ function niceCeil(v) {
   else nice = 10;
   return nice * base;
 }
+function tickPrecision(min, max, steps) {
+  const span = Math.abs(max - min);
+  if (!Number.isFinite(span) || span <= 0) return 0;
+  return Math.max(0, Math.ceil(-Math.log10(span / steps)));
+}
 function isoDate(d) {
   const m = String(d.getMonth() + 1).padStart(2, "0");
   const day = String(d.getDate()).padStart(2, "0");
@@ -1718,7 +1741,8 @@ function renderSparkline(el, opts) {
     const tone = toneVar(opts.tone);
     const points = values.map((value, i) => ({
       x: values.length <= 1 ? width / 2 : pad + i / (values.length - 1) * (width - pad * 2),
-      y: height - pad - value / max * (height - pad * 2),
+      /* 负值钳到基线（与折线图同口径）：viewBox 仅 28 高，反向射出更刺眼 */
+      y: height - pad - Math.max(0, value) / max * (height - pad * 2),
       value
     }));
     const line = points.map((p, i) => `${i === 0 ? "M" : "L"}${p.x.toFixed(1)},${p.y.toFixed(1)}`).join(" ");
@@ -1843,6 +1867,7 @@ function renderCalendar(el, opts) {
       weekdayRow.appendChild(s);
     });
     const max = maxOf(entries.map((e) => e.value));
+    entries.sort((a, b) => a.date.localeCompare(b.date));
     const pad = padFirstWeek(grid, entries[0].date, weekStart);
     let lastMonth = -1;
     entries.forEach((entry, i) => {
@@ -1901,8 +1926,9 @@ function renderScatter(el, opts) {
     const xAt = (x) => pad + (x - xMin) / (xMax - xMin) * (width - pad * 2);
     const yAt = (y) => height - pad - (y - yMin) / (yMax - yMin) * (height - pad * 2);
     for (let i = 0; i <= 3; i++) {
-      const y = pad + i * (height - pad * 2) / 3;
+      const y = Math.round(pad + i * (height - pad * 2) / 3) + 0.5;
       svg.appendChild(svgEl("line", {
+        class: i === 3 ? "icen-chart-grid icen-chart-baseline" : "icen-chart-grid",
         x1: String(pad),
         x2: String(width - pad),
         y1: String(y),
@@ -1918,12 +1944,13 @@ function renderScatter(el, opts) {
         "font-size": "8",
         fill: "var(--icen-token-text-faint)"
       });
-      txt.textContent = fmt(opts, Math.round(tv * 10) / 10);
+      txt.textContent = fmt(opts, +tv.toFixed(tickPrecision(yMin, yMax, 3)));
       svg.appendChild(txt);
     }
     for (let i = 0; i <= 4; i++) {
-      const x = pad + i * (width - pad * 2) / 4;
+      const x = Math.round(pad + i * (width - pad * 2) / 4) + 0.5;
       svg.appendChild(svgEl("line", {
+        class: i === 0 ? "icen-chart-grid icen-chart-grid--v icen-chart-axis" : "icen-chart-grid icen-chart-grid--v",
         x1: String(x),
         x2: String(x),
         y1: String(pad),
@@ -1940,7 +1967,7 @@ function renderScatter(el, opts) {
         "font-size": "8",
         fill: "var(--icen-token-text-faint)"
       });
-      txt.textContent = fmt(opts, Math.round(tv * 10) / 10);
+      txt.textContent = fmt(opts, +tv.toFixed(tickPrecision(xMin, xMax, 4)));
       svg.appendChild(txt);
     }
     if (opts.yLabel) {
@@ -2177,6 +2204,14 @@ function normalizeChartSpec(raw) {
   }
   if (s.zoom === "x" || s.zoom === "brush") spec.zoom = s.zoom;
   if (typeof s.loading === "boolean") spec.loading = s.loading;
+  if (s.a11y && typeof s.a11y === "object") {
+    const a = s.a11y;
+    const a11y = {};
+    if (typeof a.summary === "boolean") a11y.summary = a.summary;
+    if (typeof a.table === "boolean") a11y.table = a.table;
+    if (typeof a.keyboard === "boolean") a11y.keyboard = a.keyboard;
+    if (Object.keys(a11y).length > 0) spec.a11y = a11y;
+  }
   if (Array.isArray(s.marks)) {
     const marks = [];
     for (const raw2 of s.marks) {
@@ -2304,6 +2339,7 @@ function renderChartSkeleton(body) {
   body.appendChild(box);
 }
 var CHART_MARK_ACCENT = "var(--icen-token-accent)";
+var CHART_MARK_ACCENT_TEXT = "var(--icen-token-accent-text)";
 function markToneVar(tone) {
   switch (tone) {
     case "success":
@@ -2439,7 +2475,7 @@ function paintSvgChartMarks(root, view, marks, formatValue, warned) {
         y: String(clampNum(y - 10, 8, CHART_LINE_H - 4)),
         "text-anchor": "middle",
         "font-size": "8",
-        fill: CHART_MARK_ACCENT
+        fill: CHART_MARK_ACCENT_TEXT
       });
       label.textContent = mark.text ?? mark.label;
       g.appendChild(label);
@@ -2531,6 +2567,81 @@ function paintVBarChartMarks(root, view, spec, marks, formatValue, warned) {
 function chartAriaLabel(title, typeName) {
   return title ? `${typeName}\uFF1A${title}` : typeName;
 }
+function summarizeChart(view, type, fmt2) {
+  const series = view.series && view.series.length > 0 ? view.series : [{ name: "", values: view.values ?? [] }];
+  const parts = [];
+  if (series.length > 1) parts.push(t("charts.a11y.seriesCount", { p0: series.length }));
+  if (type === "scatter") {
+    const pts = view.points ?? [];
+    if (pts.length > 0) {
+      const xs = pts.map((p) => p.x);
+      const ys = pts.map((p) => p.y);
+      parts.push(t("charts.a11y.scatterRange", { p0: fmt2(Math.min(...xs)), p1: fmt2(Math.max(...xs)), p2: fmt2(Math.min(...ys)), p3: fmt2(Math.max(...ys)) }));
+    }
+    return parts.join("\uFF1B");
+  }
+  const labels = view.labels ?? [];
+  if (labels.length > 1) parts.push(t("charts.a11y.range", { p0: labels[0], p1: labels[labels.length - 1] }));
+  let min = Infinity;
+  let max = -Infinity;
+  let minAt = "";
+  let maxAt = "";
+  for (const s of series) {
+    s.values.forEach((v, i) => {
+      if (v < min) {
+        min = v;
+        minAt = labels[i] ?? String(i + 1);
+      }
+      if (v > max) {
+        max = v;
+        maxAt = labels[i] ?? String(i + 1);
+      }
+    });
+  }
+  if (Number.isFinite(min) && Number.isFinite(max)) {
+    parts.push(t("charts.a11y.min", { p0: fmt2(min), p1: minAt }));
+    parts.push(t("charts.a11y.max", { p0: fmt2(max), p1: maxAt }));
+  }
+  const first = series[0]?.values ?? [];
+  if (first.length > 1) {
+    const d = first[first.length - 1] - first[0];
+    const key = Math.abs(d) < 1e-9 ? "charts.a11y.trendFlat" : d > 0 ? "charts.a11y.trendUp" : "charts.a11y.trendDown";
+    parts.push(t("charts.a11y.trend", { p0: t(key) }));
+  }
+  return parts.join("\uFF1B");
+}
+function buildChartTable(view, spec, type, fmt2) {
+  const table = document.createElement("table");
+  table.className = "icen-chart-table";
+  const caption = document.createElement("caption");
+  caption.textContent = t("charts.a11y.tableCaption", { p0: spec.title ?? String(type) });
+  table.appendChild(caption);
+  const addRow = (target, cells, head) => {
+    const tr = document.createElement("tr");
+    for (const c of cells) {
+      const cell = document.createElement(head ? "th" : "td");
+      if (head) cell.scope = target.tagName === "THEAD" ? "col" : "row";
+      cell.textContent = c;
+      tr.appendChild(cell);
+    }
+    target.appendChild(tr);
+  };
+  const thead = table.createTHead();
+  const tbody = table.createTBody();
+  if (type === "scatter") {
+    addRow(thead, ["x", "y"], true);
+    for (const p of view.points ?? []) addRow(tbody, [fmt2(p.x), fmt2(p.y)], false);
+    return table;
+  }
+  const series = view.series && view.series.length > 0 ? view.series : [{ name: "", values: view.values ?? [] }];
+  const labels = view.labels ?? [];
+  addRow(thead, ["", ...series.map((s, i) => s.name || String(i + 1))], true);
+  const n = Math.max(labels.length, ...series.map((s) => s.values.length));
+  for (let i = 0; i < n; i++) {
+    addRow(tbody, [labels[i] ?? String(i + 1), ...series.map((s) => fmt2(s.values[i] ?? 0))], false);
+  }
+  return table;
+}
 function svgDimsOf(svg) {
   const vb = (svg.getAttribute("viewBox") ?? "").split(/\s+/).map(Number);
   const w = Number.isFinite(vb[2]) && (vb[2] ?? 0) > 0 ? vb[2] : CHART_LINE_W;
@@ -2871,6 +2982,7 @@ function renderChart(el, raw) {
     if (!isZoomableType(t2) || fullLength() < 2) return;
     const plot = t2 === "vbar" ? root.querySelector(".icen-chart-vbar") : root.querySelector(".icen-chart-line svg");
     if (!plot) return;
+    plot.style.touchAction = current2.zoom === "x" ? "pan-y" : "none";
     const on = (type, fn) => {
       plot.addEventListener(type, fn);
     };
@@ -2926,6 +3038,149 @@ function renderChart(el, raw) {
       render();
     });
   };
+  const KB_TYPES = /* @__PURE__ */ new Set(["line", "area", "vbar", "hbar", "scatter"]);
+  const kbCursor = { si: 0, i: 0, active: false };
+  let liveRegion = null;
+  let a11ySeq = 0;
+  const a11yOf = () => ({
+    summary: current2.a11y?.summary !== false,
+    table: current2.a11y?.table === true,
+    keyboard: current2.a11y?.keyboard !== false
+  });
+  const seriesViewOf = (view) => view.series && view.series.length > 0 ? view.series : [{ name: "", values: view.values ?? [] }];
+  const kbPointCount = (view) => typeOf() === "scatter" ? view.points?.length ?? 0 : Math.max(0, ...seriesViewOf(view).map((s) => s.values.length), view.labels?.length ?? 0);
+  const kbCursorEl = () => {
+    const t2 = typeOf();
+    const view = viewOf();
+    const series = seriesViewOf(view);
+    const n = kbPointCount(view);
+    if (n < 1) return null;
+    const si = clampNum(kbCursor.si, 0, Math.max(0, series.length - 1));
+    const i = clampNum(kbCursor.i, 0, n - 1);
+    if (t2 === "line" || t2 === "area") {
+      const svg = root.querySelector(".icen-chart-line svg");
+      if (!svg) return null;
+      const dots = svg.querySelectorAll("circle");
+      let base = 0;
+      for (let k = 0; k < si; k++) base += Math.min(series[k].values.length, n);
+      return dots.item(base + i) ?? null;
+    }
+    if (t2 === "scatter") return root.querySelector(".icen-chart-scatter svg")?.querySelectorAll("circle").item(i) ?? null;
+    if (t2 === "vbar") return root.querySelectorAll(".icen-chart-vbar-bar").item(series.length > 1 ? i * series.length + si : i) ?? null;
+    if (t2 === "hbar") return root.querySelectorAll(".icen-chart-hbar-bar").item(i) ?? null;
+    return null;
+  };
+  const announceKb = (text) => {
+    if (!liveRegion || !liveRegion.isConnected) {
+      liveRegion = document.createElement("div");
+      liveRegion.className = "icen-chart-live";
+      liveRegion.setAttribute("aria-live", "polite");
+      root.appendChild(liveRegion);
+    }
+    liveRegion.textContent = "";
+    liveRegion.textContent = text;
+  };
+  const applyKbCursor = () => {
+    for (const el2 of root.querySelectorAll(".icen-chart-kb-focus")) el2.classList.remove("icen-chart-kb-focus");
+    if (!kbCursor.active) return;
+    kbCursorEl()?.classList.add("icen-chart-kb-focus");
+  };
+  const announceCursor = () => {
+    const view = viewOf();
+    const series = seriesViewOf(view);
+    const n = kbPointCount(view);
+    if (n < 1) return;
+    const si = clampNum(kbCursor.si, 0, Math.max(0, series.length - 1));
+    const i = clampNum(kbCursor.i, 0, Math.max(0, n - 1));
+    const fmt2 = chartFormatValue(current2.format);
+    if (typeOf() === "scatter") {
+      const p = view.points?.[i];
+      if (!p) return;
+      announceKb(t("charts.a11y.point", { p0: `x ${fmt2(p.x)}`, p1: `y ${fmt2(p.y)}`, p2: i + 1, p3: n }));
+      return;
+    }
+    const label = view.labels?.[i] ?? String(i + 1);
+    const value = series[si]?.values[i] ?? 0;
+    if (series.length > 1) announceKb(t("charts.a11y.pointSeries", { p0: series[si].name || String(si + 1), p1: label, p2: fmt2(value), p3: i + 1, p4: n }));
+    else announceKb(t("charts.a11y.point", { p0: label, p1: fmt2(value), p2: i + 1, p3: n }));
+  };
+  const onKbKeydown = (e) => {
+    const conf = a11yOf();
+    if (!conf.keyboard || !KB_TYPES.has(typeOf())) return;
+    const g = root.querySelector("[data-icen-chart-kb]");
+    if (!g || e.target !== g) return;
+    if (e.key === "Escape") {
+      if (zoomWindow) {
+        zoomWindow = null;
+        kbCursor.active = false;
+        render();
+      }
+      return;
+    }
+    const view = viewOf();
+    const series = seriesViewOf(view);
+    const n = kbPointCount(view);
+    if (n < 1) return;
+    const siMax = Math.max(0, series.length - 1);
+    let moved = true;
+    switch (e.key) {
+      case "ArrowRight":
+        kbCursor.i = clampNum(kbCursor.i + 1, 0, n - 1);
+        break;
+      case "ArrowLeft":
+        kbCursor.i = clampNum(kbCursor.i - 1, 0, n - 1);
+        break;
+      case "ArrowDown":
+        kbCursor.si = clampNum(kbCursor.si + 1, 0, siMax);
+        break;
+      case "ArrowUp":
+        kbCursor.si = clampNum(kbCursor.si - 1, 0, siMax);
+        break;
+      case "Home":
+        kbCursor.i = 0;
+        break;
+      case "End":
+        kbCursor.i = n - 1;
+        break;
+      default:
+        moved = false;
+    }
+    if (!moved) return;
+    e.preventDefault();
+    kbCursor.active = true;
+    applyKbCursor();
+    announceCursor();
+  };
+  root.addEventListener("keydown", onKbKeydown);
+  const applyChartA11yPlus = (view, spec, type, formatValue) => {
+    const conf = a11yOf();
+    const graphic = root.querySelector('[role="img"]');
+    if (!graphic) return;
+    const body = root.querySelector(".icen-chart-body") ?? graphic.parentElement ?? root;
+    const summaryParts = [];
+    if (conf.summary) summaryParts.push(summarizeChart(view, type, formatValue));
+    if (conf.keyboard && KB_TYPES.has(type)) summaryParts.push(t("charts.a11y.keyboardHint"));
+    const summaryText = summaryParts.filter(Boolean).join("\uFF1B");
+    if (summaryText) {
+      const p = document.createElement("p");
+      p.className = "icen-chart-summary";
+      p.id = `icen-chart-a11y-${++a11ySeq}`;
+      p.textContent = summaryText;
+      body.appendChild(p);
+      graphic.setAttribute("aria-describedby", p.id);
+    } else {
+      graphic.removeAttribute("aria-describedby");
+    }
+    if (conf.keyboard && KB_TYPES.has(type)) {
+      graphic.setAttribute("tabindex", "0");
+      graphic.setAttribute("data-icen-chart-kb", "");
+    } else {
+      graphic.removeAttribute("tabindex");
+      graphic.removeAttribute("data-icen-chart-kb");
+    }
+    if (conf.table) body.appendChild(buildChartTable(view, spec, type, formatValue));
+    applyKbCursor();
+  };
   const render = () => {
     if (!current2.type) current2 = { ...current2, type: inferChartType(current2) };
     const spec = current2;
@@ -2997,9 +3252,16 @@ function renderChart(el, raw) {
       const graphic = root.querySelector('[role="img"]');
       if (graphic && !graphic.getAttribute("aria-label")) {
         graphic.setAttribute("aria-label", spec.title ? `${spec.title}\uFF08${type}\uFF09` : type);
+      } else if (!graphic) {
+        const dom = root.querySelector(".icen-chart-vbar, .icen-chart-hbar");
+        if (dom) {
+          dom.setAttribute("role", "img");
+          dom.setAttribute("aria-label", spec.title ? `${spec.title}\uFF08${type}\uFF09` : type);
+        }
       }
     }
     if (loading) return;
+    applyChartA11yPlus(view, spec, type, formatValue);
     paintChartMarks(root, view, spec, formatValue, warnedMarks);
     bindZoomGesture();
   };
@@ -3081,6 +3343,7 @@ function renderChart(el, raw) {
       releaseFluidWidth(root);
       hiddenLegendKeys.delete(root);
       zoomDragCleanup?.();
+      root.removeEventListener("keydown", onKbKeydown);
       root.textContent = "";
       root.classList.remove("is-loading");
       unbindEvents();
@@ -3498,7 +3761,13 @@ function onKeyDown(e) {
 
 // src/behaviors/datatable.ts
 function defaultCompare(a, b) {
-  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "number" && typeof b === "number") {
+    if (Number.isNaN(a) || Number.isNaN(b)) {
+      if (Number.isNaN(a) && Number.isNaN(b)) return 0;
+      return Number.isNaN(a) ? 1 : -1;
+    }
+    return a - b;
+  }
   return String(a ?? "").localeCompare(String(b ?? ""), "zh-CN", { numeric: true });
 }
 function toNum2(v) {
@@ -3787,11 +4056,13 @@ function createTable(el, opts) {
   const body = document.createElement("div");
   body.className = "icen-dt-body";
   body.setAttribute("role", "rowgroup");
-  const summaryEl = document.createElement("div");
-  summaryEl.className = "icen-dt-row icen-dt-row--summary";
-  summaryEl.setAttribute("role", "row");
-  summaryEl.hidden = true;
-  canvas.append(head, body, summaryEl);
+  const summaryEl = opts.summaryRow ? document.createElement("div") : null;
+  if (summaryEl) {
+    summaryEl.className = "icen-dt-row icen-dt-row--summary";
+    summaryEl.setAttribute("role", "row");
+    summaryEl.hidden = true;
+  }
+  canvas.append(head, body, ...summaryEl ? [summaryEl] : []);
   scroll.appendChild(canvas);
   root.appendChild(scroll);
   const foot = document.createElement("div");
@@ -4604,7 +4875,8 @@ function createTable(el, opts) {
     else wrap.textContent = String(out);
     return wrap;
   }
-  function renderSummary() {
+  function renderSummary2() {
+    if (!summaryEl) return;
     summaryEl.textContent = "";
     summaryEl.hidden = true;
     const cfg = opts.summaryRow;
@@ -4801,9 +5073,9 @@ function createTable(el, opts) {
     }
   }
   let currentTotal = 0;
-  function visibleRange(total) {
+  function visibleRange(total, avail) {
     if (!virtual) {
-      if (opts.remote || opts.pagination === false) return [0, total];
+      if (opts.remote || opts.pagination === false) return [0, Math.min(total, avail)];
       const start2 = (page - 1) * pageSize;
       return [start2, Math.min(total, start2 + pageSize)];
     }
@@ -4818,6 +5090,10 @@ function createTable(el, opts) {
     const rows = pipeline();
     const entries = groupFn ? flatEntries() : null;
     const total = entries ? entries.length : opts.remote ? opts.totalCount ?? data.length : rows.length;
+    if (!opts.remote && opts.pagination !== false) {
+      const pages = Math.max(1, Math.ceil(total / pageSize));
+      if (page > pages) page = pages;
+    }
     navTotal = entries ? entries.length : rows.length;
     currentTotal = total;
     const keepTop = virtual ? scroll.scrollTop : 0;
@@ -4834,7 +5110,7 @@ function createTable(el, opts) {
         body.appendChild(sk);
       }
       renderFoot(total, rows.length);
-      renderSummary();
+      renderSummary2();
       return;
     }
     if (total === 0) {
@@ -4843,10 +5119,10 @@ function createTable(el, opts) {
       empty.textContent = opts.emptyLabel ?? t("datatable.empty");
       body.appendChild(empty);
       renderFoot(total, rows.length);
-      renderSummary();
+      renderSummary2();
       return;
     }
-    const [start, end] = visibleRange(total);
+    const [start, end] = visibleRange(total, rows.length);
     const frag = document.createDocumentFragment();
     const offsets = frozenOffsets();
     if (virtual && start > 0) {
@@ -4880,7 +5156,7 @@ function createTable(el, opts) {
     if (virtual) scroll.scrollTop = keepTop;
     syncNavFocus();
     renderFoot(total, rows.length);
-    renderSummary();
+    renderSummary2();
   }
   function renderFoot(total, dataCount = total) {
     foot.textContent = "";
@@ -4909,11 +5185,21 @@ function createTable(el, opts) {
     const pages = Math.ceil(total / pageSize);
     const pager = document.createElement("nav");
     pager.className = "icen-dt-pager";
-    pager.setAttribute("aria-label", t("datatable.paginationAria"));
+    {
+      const base = t("datatable.paginationAria");
+      const used = /* @__PURE__ */ new Set();
+      for (const el2 of document.querySelectorAll(".icen-dt-pager[aria-label]")) {
+        if (!root.contains(el2)) used.add(el2.getAttribute("aria-label") ?? "");
+      }
+      let label = base, n = 2;
+      while (used.has(label)) label = `${base} ${n++}`;
+      pager.setAttribute("aria-label", label);
+    }
     const sizeSel = document.createElement("select");
     sizeSel.className = "icen-dt-page-size";
     sizeSel.setAttribute("aria-label", t("datatable.pageSizeAria"));
-    for (const s of pageSizes) {
+    const sizeOptions = pageSizes.includes(pageSize) ? pageSizes : [...pageSizes, pageSize].sort((a, b) => a - b);
+    for (const s of sizeOptions) {
       const o = document.createElement("option");
       o.value = String(s);
       o.textContent = t("pagination.pageSize", { p0: s });
@@ -5005,6 +5291,7 @@ function createTable(el, opts) {
     if (destroyed) return;
     renderHead();
     renderBody();
+    syncFrozenWidths();
   }
   rekey();
   renderAll();
@@ -5025,12 +5312,52 @@ function createTable(el, opts) {
     opts.onPageChange?.(page, pageSize);
     renderAll();
   }
+  function hasFluidFrozen() {
+    return cols().some((c) => frozenSide(c) != null && !/^(\d+(?:\.\d+)?)px/.test(colWidths.get(c.key) ?? c.width ?? ""));
+  }
+  function syncFrozenWidths() {
+    if (!hasFluidFrozen()) return;
+    const visible = cols();
+    const headCells = Array.from(headRow.children);
+    const lead = headCells.length - visible.length;
+    const left = /* @__PURE__ */ new Map();
+    const right = /* @__PURE__ */ new Map();
+    let acc = headCells.slice(0, lead).reduce((s, c) => s + c.offsetWidth, 0);
+    for (let i = 0; i < visible.length; i++) {
+      const c = visible[i];
+      if (frozenSide(c) === "left") left.set(c.key, acc);
+      acc += headCells[lead + i]?.offsetWidth ?? 0;
+    }
+    let accR = 0;
+    for (let i = visible.length - 1; i >= 0; i--) {
+      const c = visible[i];
+      if (frozenSide(c) === "right") right.set(c.key, accR);
+      accR += headCells[lead + i]?.offsetWidth ?? 0;
+    }
+    const rows = [headRow, ...summaryEl ? [summaryEl] : [], ...Array.from(body.querySelectorAll(".icen-dt-row"))];
+    for (const row of rows) {
+      const cells = Array.from(row.children);
+      if (cells.length !== headCells.length) continue;
+      cells.forEach((cell, i) => {
+        const col = i >= lead ? visible[i - lead] : void 0;
+        if (!col) return;
+        const l = left.get(col.key);
+        if (l != null && cell.classList.contains("icen-dt-cell--frozen")) cell.style.left = `${l}px`;
+        const r = right.get(col.key);
+        if (r != null && cell.classList.contains("icen-dt-cell--frozen-right")) cell.style.right = `${r}px`;
+      });
+    }
+  }
   return {
     setPage,
     setPageSize,
     setData(next) {
       if (editing) cancelEdit(true);
       data = next;
+      if (typeof opts.rowKey !== "function" && typeof opts.rowKey !== "string" && selected.size > 0) {
+        selected.clear();
+        emitSelection();
+      }
       rekey();
       invalidate();
       page = 1;
@@ -5107,6 +5434,823 @@ function createTable(el, opts) {
   };
 }
 
+// src/behaviors/form-validate.ts
+var DEFAULT_MESSAGES = {
+  required: t("formValidate.required"),
+  email: t("formValidate.email"),
+  url: t("formValidate.url"),
+  number: t("formValidate.number"),
+  minlength: t("formValidate.minlength"),
+  maxlength: t("formValidate.maxlength"),
+  pattern: t("formValidate.pattern"),
+  min: t("formValidate.min"),
+  max: t("formValidate.max"),
+  step: t("formValidate.step"),
+  matches: t("formValidate.matches")
+};
+var messageTable = { ...DEFAULT_MESSAGES };
+function formatMessage(template, tokens) {
+  return template.replace(/\{(\w+)\}/g, (m, key) => key in tokens ? String(tokens[key]) : m);
+}
+var customValidators = /* @__PURE__ */ new Map();
+function attrNumber(el, name) {
+  const raw = el.getAttribute(name);
+  if (raw == null || raw === "" || !Number.isFinite(Number(raw))) return null;
+  return Number(raw);
+}
+function resolveFieldRules(field) {
+  const rules = [];
+  const type = (field.getAttribute("type") ?? "").toLowerCase();
+  if (field.hasAttribute("required")) rules.push({ rule: "required" });
+  if (type === "email" || type === "url") rules.push({ rule: type });
+  if (type === "number" || type === "range") rules.push({ rule: "number" });
+  const minlength = attrNumber(field, "minlength");
+  if (minlength != null) rules.push({ rule: "minlength", attr: String(minlength) });
+  const maxlength = attrNumber(field, "maxlength");
+  if (maxlength != null) rules.push({ rule: "maxlength", attr: String(maxlength) });
+  const pattern = field.getAttribute("pattern");
+  if (pattern) rules.push({ rule: "pattern", attr: pattern });
+  const min = field.getAttribute("min");
+  if (min != null && min !== "") rules.push({ rule: "min", attr: min });
+  const max = field.getAttribute("max");
+  if (max != null && max !== "") rules.push({ rule: "max", attr: max });
+  const step = field.getAttribute("step");
+  if (step != null && step !== "" && step !== "any") rules.push({ rule: "step", attr: step });
+  const extra = field.getAttribute("data-icen-validate") ?? "";
+  for (const token of extra.trim().split(/\s+/)) {
+    if (!token) continue;
+    const idx = token.indexOf(":");
+    const rule = idx === -1 ? token : token.slice(0, idx);
+    const arg = idx === -1 ? void 0 : token.slice(idx + 1) || void 0;
+    if (!rule || rule === "matches" && !arg) continue;
+    rules.push({ rule, arg });
+  }
+  return rules;
+}
+function fieldValue(field) {
+  if (field instanceof HTMLInputElement && (field.type === "checkbox" || field.type === "radio")) {
+    return field.checked ? field.value || "on" : "";
+  }
+  return field.value;
+}
+function fieldLabel(field, fallback = "") {
+  if (!field) return fallback;
+  const wrap = field.closest(".icen-field, .icen-form-field");
+  const labelEl = wrap?.querySelector(".icen-field-label, .icen-form-label, label");
+  const text = labelEl?.textContent?.replace(/\s+/g, " ").trim();
+  return text || field.getAttribute("aria-label") || field.getAttribute("placeholder") || field.getAttribute("name") || fallback;
+}
+function ruleMessage(field, rule, tokens) {
+  const custom2 = field?.getAttribute(`data-icen-msg-${rule}`);
+  const template = custom2 || messageTable[rule] || DEFAULT_MESSAGES[rule] || t("formValidate.invalid");
+  return formatMessage(template, tokens);
+}
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var NUMBER_TYPES = /* @__PURE__ */ new Set(["number", "range"]);
+function compareValue(field, value, attr) {
+  const numericAttr = Number.isFinite(Number(attr));
+  const type = field?.getAttribute("type")?.toLowerCase() ?? "";
+  if (numericAttr && (NUMBER_TYPES.has(type) || Number.isFinite(Number(value)))) {
+    if (!Number.isFinite(Number(value))) return null;
+    return Number(value) - Number(attr);
+  }
+  if (!numericAttr) return value < attr ? -1 : value > attr ? 1 : 0;
+  return null;
+}
+async function applyRule(value, rule, ctx) {
+  const field = ctx.field;
+  const tokens = {
+    min: rule.attr ?? "",
+    max: rule.attr ?? "",
+    step: rule.attr ?? "",
+    length: value.length,
+    label: fieldLabel(field, rule.arg ?? rule.rule)
+  };
+  switch (rule.rule) {
+    case "required": {
+      if (field instanceof HTMLInputElement && field.type === "checkbox") {
+        return field.checked ? true : ruleMessage(field, "required", tokens);
+      }
+      if (field instanceof HTMLInputElement && field.type === "radio") {
+        const form = ctx.form ?? field.form;
+        const checked = form ? Array.from(form.elements).some(
+          (el) => el instanceof HTMLInputElement && el.type === "radio" && el.name === field.name && el.checked
+        ) : field.checked;
+        return checked ? true : ruleMessage(field, "required", tokens);
+      }
+      return value.trim() !== "" ? true : ruleMessage(field, "required", tokens);
+    }
+    case "email":
+      return value === "" || EMAIL_RE.test(value) ? true : ruleMessage(field, "email", tokens);
+    case "url": {
+      if (value === "") return true;
+      try {
+        new URL(value);
+        return true;
+      } catch {
+        return ruleMessage(field, "url", tokens);
+      }
+    }
+    case "number":
+      return value === "" || Number.isFinite(Number(value)) ? true : ruleMessage(field, "number", tokens);
+    case "minlength": {
+      if (value === "") return true;
+      const min = Number(rule.attr);
+      return value.length >= min ? true : ruleMessage(field, "minlength", tokens);
+    }
+    case "maxlength": {
+      if (value === "") return true;
+      const max = Number(rule.attr);
+      return value.length <= max ? true : ruleMessage(field, "maxlength", tokens);
+    }
+    case "pattern": {
+      if (value === "") return true;
+      try {
+        return new RegExp(`^(?:${rule.attr})$`).test(value) ? true : ruleMessage(field, "pattern", tokens);
+      } catch {
+        return true;
+      }
+    }
+    case "min": {
+      if (value === "") return true;
+      const cmp = compareValue(field, value, rule.attr ?? "");
+      return cmp == null || cmp >= 0 ? true : ruleMessage(field, "min", tokens);
+    }
+    case "max": {
+      if (value === "") return true;
+      const cmp = compareValue(field, value, rule.attr ?? "");
+      return cmp == null || cmp <= 0 ? true : ruleMessage(field, "max", tokens);
+    }
+    case "step": {
+      if (value === "") return true;
+      const step = Number(rule.attr);
+      if (!Number.isFinite(step) || step <= 0 || !Number.isFinite(Number(value))) return true;
+      const minAttr = field?.getAttribute("min");
+      const base = minAttr != null && minAttr !== "" && Number.isFinite(Number(minAttr)) ? Number(minAttr) : 0;
+      const rem = Math.abs((Number(value) - base) % step);
+      return rem < 1e-9 || step - rem < 1e-9 ? true : ruleMessage(field, "step", tokens);
+    }
+    case "matches": {
+      const form = ctx.form ?? field?.form ?? null;
+      const other = form && rule.arg ? form.elements.namedItem(rule.arg) : null;
+      const otherEl = other instanceof Element ? other : null;
+      if (!otherEl) return true;
+      return value === otherEl.value ? true : ruleMessage(field, "matches", tokens);
+    }
+    default: {
+      const fn = customValidators.get(rule.rule);
+      if (!fn || !field) return true;
+      const result = await fn(value, field, ctx.form ?? field.form ?? null);
+      return result === true ? true : typeof result === "string" ? result : true;
+    }
+  }
+}
+async function evaluateRules(value, rules, ctx = {}) {
+  for (const rule of rules) {
+    const fail = await applyRule(value, rule, ctx);
+    if (fail !== true) return fail;
+  }
+  return true;
+}
+var DEFAULT_DEBOUNCE = 160;
+var uidSeq = 0;
+var liveValidators = /* @__PURE__ */ new WeakMap();
+var composingFlags = /* @__PURE__ */ new WeakMap();
+var compositionTracked = /* @__PURE__ */ new WeakSet();
+function trackComposition(el) {
+  if (compositionTracked.has(el)) return;
+  compositionTracked.add(el);
+  el.addEventListener("compositionstart", () => composingFlags.set(el, true));
+  el.addEventListener("compositionend", () => composingFlags.set(el, false));
+}
+function isComposing(el) {
+  return composingFlags.get(el) === true;
+}
+function collectFormFields(form) {
+  const out = [];
+  for (const el of Array.from(form.elements)) {
+    if (!(el instanceof HTMLInputElement) && !(el instanceof HTMLTextAreaElement) && !(el instanceof HTMLSelectElement)) {
+      continue;
+    }
+    if (el.disabled || !el.name) continue;
+    if (el instanceof HTMLInputElement) {
+      const type = (el.getAttribute("type") ?? "").toLowerCase();
+      if (["submit", "button", "reset", "image", "file"].includes(type)) continue;
+    }
+    out.push(el);
+  }
+  return out;
+}
+function findFormField(form, name) {
+  const item = form.elements.namedItem(name);
+  if (item instanceof Element && (item instanceof HTMLInputElement || item instanceof HTMLTextAreaElement || item instanceof HTMLSelectElement)) {
+    return item;
+  }
+  if (item instanceof RadioNodeList) {
+    for (const el of Array.from(item)) {
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+        return el;
+      }
+    }
+  }
+  return null;
+}
+function fieldWrap(field) {
+  return closestSelfOrAncestor(field, ".icen-field, .icen-form-field");
+}
+function closestSelfOrAncestor(el, selector) {
+  return el.matches(selector) ? el : el.closest(selector);
+}
+function ensureControlId(field) {
+  if (!field.id) field.id = `icen-fv-${++uidSeq}`;
+  return field.id;
+}
+function findErrorEl(wrap) {
+  for (const el of Array.from(wrap.children)) {
+    if (el instanceof HTMLElement && el.classList.contains("icen-field-error")) return el;
+  }
+  return null;
+}
+function setValidating(field, on) {
+  const wrap = fieldWrap(field);
+  if (wrap) wrap.classList.toggle("is-validating", on);
+  if (on) field.setAttribute("aria-busy", "true");
+  else field.removeAttribute("aria-busy");
+}
+function presentField(field, outcome, showValid) {
+  const wrap = fieldWrap(field);
+  setValidating(field, false);
+  if (!wrap) {
+    if (!outcome.ok) field.setAttribute("aria-invalid", "true");
+    else field.removeAttribute("aria-invalid");
+    return;
+  }
+  if (!outcome.ok) {
+    wrap.classList.add("is-error");
+    wrap.setAttribute("data-icen-invalid", "true");
+    wrap.classList.remove("is-valid");
+    wrap.removeAttribute("data-icen-valid");
+    let errEl2 = findErrorEl(wrap);
+    if (!errEl2) {
+      errEl2 = document.createElement("p");
+      errEl2.className = "icen-field-error";
+      errEl2.id = `icen-fv-err-${++uidSeq}`;
+      errEl2.setAttribute("role", "alert");
+      errEl2.setAttribute("data-icen-fv-auto", "");
+      wrap.appendChild(errEl2);
+    }
+    errEl2.hidden = false;
+    errEl2.textContent = outcome.message ?? "";
+    field.setAttribute("aria-invalid", "true");
+    const described = new Set((field.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean));
+    described.add(errEl2.id);
+    field.setAttribute("aria-describedby", Array.from(described).join(" "));
+    return;
+  }
+  wrap.classList.remove("is-error");
+  wrap.removeAttribute("data-icen-invalid");
+  field.removeAttribute("aria-invalid");
+  const errEl = findErrorEl(wrap);
+  if (errEl) {
+    const rest = (field.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean).filter((id) => id !== errEl.id);
+    if (rest.length) field.setAttribute("aria-describedby", rest.join(" "));
+    else field.removeAttribute("aria-describedby");
+    if (errEl.hasAttribute("data-icen-fv-auto")) errEl.remove();
+    else {
+      errEl.textContent = "";
+      errEl.hidden = true;
+    }
+  }
+  if (showValid) {
+    wrap.classList.add("is-valid");
+    wrap.setAttribute("data-icen-valid", "true");
+  } else {
+    wrap.classList.remove("is-valid");
+    wrap.removeAttribute("data-icen-valid");
+  }
+}
+function clearFieldPresentation(field) {
+  const wrap = fieldWrap(field);
+  if (wrap) {
+    wrap.classList.remove("is-error", "is-valid", "is-validating");
+    wrap.removeAttribute("data-icen-invalid");
+    wrap.removeAttribute("data-icen-valid");
+    const errEl = findErrorEl(wrap);
+    if (errEl?.hasAttribute("data-icen-fv-auto")) errEl.remove();
+    else if (errEl) {
+      errEl.textContent = "";
+      errEl.hidden = true;
+    }
+  }
+  field.removeAttribute("aria-invalid");
+  field.removeAttribute("aria-busy");
+  const rest = (field.getAttribute("aria-describedby") ?? "").split(/\s+/).filter(Boolean).filter((id) => !id.startsWith("icen-fv-err-"));
+  if (rest.length) field.setAttribute("aria-describedby", rest.join(" "));
+  else field.removeAttribute("aria-describedby");
+}
+function focusField(field) {
+  try {
+    field.focus();
+  } catch {
+  }
+  if (typeof field.scrollIntoView === "function") {
+    try {
+      const reduced = typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+      field.scrollIntoView({ block: "center", behavior: reduced ? "auto" : "smooth" });
+    } catch {
+      try {
+        field.scrollIntoView();
+      } catch {
+      }
+    }
+  }
+}
+function renderSummary(form, errorsObj) {
+  if (!form.hasAttribute("data-icen-validate-summary")) return;
+  const names = Object.keys(errorsObj);
+  const existing = form.querySelector(":scope > .icen-form-validate-summary");
+  if (names.length === 0) {
+    existing?.remove();
+    return;
+  }
+  let box = existing;
+  if (!box) {
+    box = document.createElement("div");
+    box.className = "icen-form-validate-summary";
+    box.setAttribute("role", "alert");
+    box.setAttribute("data-icen-fv-auto", "");
+    box.addEventListener("click", (e) => {
+      const a = e.target instanceof Element ? closestSelfOrAncestor(e.target, "a[data-icen-fv-name]") : null;
+      if (!(a instanceof HTMLAnchorElement)) return;
+      e.preventDefault();
+      const field = findFormField(form, a.getAttribute("data-icen-fv-name") ?? "");
+      if (field) focusField(field);
+    });
+    form.prepend(box);
+  }
+  box.textContent = "";
+  const title = document.createElement("p");
+  title.className = "icen-form-validate-summary-title";
+  title.textContent = t("formValidate.summary", { p0: names.length });
+  const list = document.createElement("ul");
+  list.className = "icen-form-validate-summary-list";
+  for (const name of names) {
+    const field = findFormField(form, name);
+    if (!field) continue;
+    const li = document.createElement("li");
+    const a = document.createElement("a");
+    a.className = "icen-form-validate-summary-item";
+    a.href = `#${ensureControlId(field)}`;
+    a.setAttribute("data-icen-fv-name", name);
+    a.textContent = `${fieldLabel(field, name)}\uFF1A${errorsObj[name]}`;
+    li.appendChild(a);
+    list.appendChild(li);
+  }
+  box.append(title, list);
+}
+function createFormValidator(form, opts = {}) {
+  if (typeof document === "undefined") {
+    const stub = () => void 0;
+    return {
+      form,
+      validate: async () => true,
+      validateField: async () => true,
+      reset: stub,
+      errors: () => ({}),
+      destroy: stub
+    };
+  }
+  const existing = liveValidators.get(form);
+  if (existing) return existing;
+  const state = {
+    errors: /* @__PURE__ */ new Map(),
+    touched: /* @__PURE__ */ new Set(),
+    submitted: false,
+    seq: /* @__PURE__ */ new Map(),
+    debounceTimers: /* @__PURE__ */ new Map()
+  };
+  let pointerDown = false;
+  const pendingPresent = /* @__PURE__ */ new Map();
+  let pendingSummary = null;
+  let flushScheduled = false;
+  const showValidFor = (field) => field.hasAttribute("data-icen-validate-show-valid") || form.hasAttribute("data-icen-validate-show-valid");
+  async function checkField(field) {
+    const name = field.name;
+    const rules = resolveFieldRules(field);
+    if (rules.length === 0) return true;
+    trackComposition(field);
+    const seq = (state.seq.get(name) ?? 0) + 1;
+    state.seq.set(name, seq);
+    const hasAsync = rules.some((r) => customValidators.has(r.rule));
+    if (hasAsync) setValidating(field, true);
+    const result = await evaluateRules(fieldValue(field), rules, { field, form });
+    if (state.seq.get(name) !== seq) {
+      if (hasAsync) setValidating(field, false);
+      return !state.errors.has(name);
+    }
+    if (hasAsync) setValidating(field, false);
+    const outcome = result === true ? { ok: true } : { ok: false, message: result };
+    if (outcome.ok) state.errors.delete(name);
+    else state.errors.set(name, outcome.message ?? "");
+    presentFieldGuarded(field, outcome, showValidFor(field));
+    if (form.querySelector(":scope > .icen-form-validate-summary")) {
+      renderSummaryGuarded(errors());
+    }
+    emitIcen(
+      field,
+      "icen:form-field-validate",
+      outcome.ok ? { name, valid: true } : { name, valid: false, message: outcome.message }
+    );
+    return outcome.ok;
+  }
+  function debouncedCheck(field) {
+    const name = field.name;
+    const timer = state.debounceTimers.get(name);
+    if (timer) clearTimeout(timer);
+    const delay = opts.strategy?.debounceMs ?? DEFAULT_DEBOUNCE;
+    state.debounceTimers.set(
+      name,
+      setTimeout(() => {
+        state.debounceTimers.delete(name);
+        void checkField(field);
+      }, delay)
+    );
+  }
+  function presentFieldPressed(field, outcome, showValid) {
+    pendingPresent.set(field, { outcome, showValid });
+    const wrap = fieldWrap(field);
+    setValidating(field, false);
+    if (!wrap) {
+      if (!outcome.ok) field.setAttribute("aria-invalid", "true");
+      else field.removeAttribute("aria-invalid");
+      return;
+    }
+    if (!outcome.ok) {
+      wrap.classList.add("is-error");
+      wrap.setAttribute("data-icen-invalid", "true");
+      wrap.classList.remove("is-valid");
+      wrap.removeAttribute("data-icen-valid");
+      field.setAttribute("aria-invalid", "true");
+      const errEl = findErrorEl(wrap);
+      if (errEl && !errEl.hidden) errEl.textContent = outcome.message ?? "";
+      return;
+    }
+    wrap.classList.remove("is-error");
+    wrap.removeAttribute("data-icen-invalid");
+    field.removeAttribute("aria-invalid");
+    if (showValid) {
+      wrap.classList.add("is-valid");
+      wrap.setAttribute("data-icen-valid", "true");
+    } else {
+      wrap.classList.remove("is-valid");
+      wrap.removeAttribute("data-icen-valid");
+    }
+  }
+  function presentFieldGuarded(field, outcome, showValid) {
+    if (pointerDown) presentFieldPressed(field, outcome, showValid);
+    else presentField(field, outcome, showValid);
+  }
+  function renderSummaryGuarded(errorsObj) {
+    if (pointerDown) pendingSummary = errorsObj;
+    else renderSummary(form, errorsObj);
+  }
+  function flushDeferredPresentation() {
+    flushScheduled = false;
+    if (destroyed) return;
+    const items = Array.from(pendingPresent.entries());
+    pendingPresent.clear();
+    const summary = pendingSummary;
+    pendingSummary = null;
+    for (const [field, it] of items) presentField(field, it.outcome, it.showValid);
+    if (summary) renderSummary(form, summary);
+  }
+  function scheduleFlush() {
+    if (flushScheduled) return;
+    flushScheduled = true;
+    if (typeof requestAnimationFrame === "function") requestAnimationFrame(flushDeferredPresentation);
+    else setTimeout(flushDeferredPresentation, 0);
+  }
+  function resolveEventField(target) {
+    if (!(target instanceof Element)) return null;
+    const el = closestSelfOrAncestor(target, "input, textarea, select");
+    if (!(el instanceof HTMLInputElement) && !(el instanceof HTMLTextAreaElement) && !(el instanceof HTMLSelectElement)) {
+      return null;
+    }
+    if (el.form !== form || el.disabled || !el.name) return null;
+    if (el instanceof HTMLInputElement) {
+      const type = (el.getAttribute("type") ?? "").toLowerCase();
+      if (["submit", "button", "reset", "image", "file"].includes(type)) return null;
+    }
+    return el;
+  }
+  const onSubmit = (e) => {
+    e.preventDefault();
+    void validate();
+  };
+  const onFocusOut = (e) => {
+    const field = resolveEventField(e.target);
+    if (!field) return;
+    state.touched.add(field.name);
+    const mode = opts.strategy?.on;
+    if (mode === "blur") void checkField(field);
+    else if (!mode && state.submitted) void checkField(field);
+  };
+  const onInput = (e) => {
+    const field = resolveEventField(e.target);
+    if (!field) return;
+    trackComposition(field);
+    if (isComposing(field)) return;
+    state.touched.add(field.name);
+    const mode = opts.strategy?.on;
+    if (mode === "input") debouncedCheck(field);
+    else if (!mode && state.submitted && state.errors.has(field.name)) debouncedCheck(field);
+  };
+  async function validate() {
+    state.submitted = true;
+    const fields = collectFormFields(form);
+    const names = [];
+    let firstInvalid = null;
+    for (const field of fields) {
+      if (resolveFieldRules(field).length === 0) continue;
+      names.push(field.name);
+      const ok = await checkField(field);
+      if (!ok && !firstInvalid) firstInvalid = field;
+    }
+    const errorsSnapshot = errors();
+    if (firstInvalid) {
+      renderSummaryGuarded(errorsSnapshot);
+      emitIcen(form, "icen:form-invalid", { errors: errorsSnapshot, first: firstInvalid.name });
+      if (opts.scrollToError !== false) focusField(firstInvalid);
+      return false;
+    }
+    renderSummaryGuarded({});
+    emitIcen(form, "icen:form-valid", { names });
+    return true;
+  }
+  function errors() {
+    return Object.fromEntries(state.errors);
+  }
+  function reset() {
+    state.errors.clear();
+    state.touched.clear();
+    state.submitted = false;
+    state.seq.clear();
+    for (const timer of state.debounceTimers.values()) clearTimeout(timer);
+    state.debounceTimers.clear();
+    pendingPresent.clear();
+    pendingSummary = null;
+    for (const field of collectFormFields(form)) clearFieldPresentation(field);
+    form.querySelector(":scope > .icen-form-validate-summary")?.remove();
+  }
+  const onFormPointerDown = (e) => {
+    const btn = e.button;
+    if (typeof btn === "number" && btn !== 0) return;
+    pointerDown = true;
+  };
+  const onPressEnd = () => {
+    if (!pointerDown) return;
+    pointerDown = false;
+    if (pendingPresent.size > 0 || pendingSummary !== null) scheduleFlush();
+  };
+  form.addEventListener("submit", onSubmit);
+  form.addEventListener("focusout", onFocusOut);
+  form.addEventListener("input", onInput);
+  form.addEventListener("pointerdown", onFormPointerDown, true);
+  document.addEventListener("pointerup", onPressEnd, true);
+  document.addEventListener("pointercancel", onPressEnd, true);
+  window.addEventListener("blur", onPressEnd);
+  let destroyed = false;
+  const handle = {
+    form,
+    validate,
+    async validateField(name) {
+      const field = findFormField(form, name);
+      if (!field || field.disabled) return true;
+      return checkField(field);
+    },
+    reset,
+    errors,
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      form.removeEventListener("submit", onSubmit);
+      form.removeEventListener("focusout", onFocusOut);
+      form.removeEventListener("input", onInput);
+      form.removeEventListener("pointerdown", onFormPointerDown, true);
+      document.removeEventListener("pointerup", onPressEnd, true);
+      document.removeEventListener("pointercancel", onPressEnd, true);
+      window.removeEventListener("blur", onPressEnd);
+      reset();
+      liveValidators.delete(form);
+    }
+  };
+  liveValidators.set(form, handle);
+  return handle;
+}
+var SHOW_FORM_SCHEMA = {
+  type: "object",
+  properties: {
+    title: { type: "string", description: t("formValidate.tool.title") },
+    fields: {
+      type: "array",
+      description: t("formValidate.tool.fields"),
+      items: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: t("formValidate.tool.name") },
+          label: { type: "string", description: t("formValidate.tool.label") },
+          type: {
+            type: "string",
+            enum: ["text", "email", "number", "url", "textarea", "select", "date"],
+            description: t("formValidate.tool.type")
+          },
+          required: { type: "boolean", description: t("formValidate.tool.required") },
+          pattern: { type: "string", description: t("formValidate.tool.pattern") },
+          min: { type: "number", description: t("formValidate.tool.min") },
+          max: { type: "number", description: t("formValidate.tool.max") },
+          options: {
+            type: "array",
+            description: t("formValidate.tool.options"),
+            items: {
+              anyOf: [
+                { type: "string" },
+                {
+                  type: "object",
+                  properties: { label: { type: "string" }, value: { type: "string" } },
+                  required: ["label", "value"]
+                }
+              ]
+            }
+          },
+          help: { type: "string", description: t("formValidate.tool.help") }
+        },
+        required: ["name", "label"]
+      }
+    },
+    submitLabel: { type: "string", description: t("formValidate.tool.submitText") }
+  },
+  required: ["fields"]
+};
+function normalizeShowForm(input) {
+  const raw = input ?? {};
+  const fields = [];
+  if (Array.isArray(raw.fields)) {
+    for (const f of raw.fields) {
+      if (!f || typeof f !== "object") continue;
+      const name = typeof f.name === "string" ? f.name.trim() : "";
+      if (!name) continue;
+      const label = typeof f.label === "string" && f.label ? f.label : name;
+      fields.push({
+        name,
+        label,
+        type: f.type,
+        required: f.required === true,
+        pattern: typeof f.pattern === "string" ? f.pattern : void 0,
+        min: typeof f.min === "number" ? f.min : void 0,
+        max: typeof f.max === "number" ? f.max : void 0,
+        options: Array.isArray(f.options) ? f.options : void 0,
+        help: typeof f.help === "string" ? f.help : void 0
+      });
+    }
+  }
+  return {
+    title: typeof raw.title === "string" && raw.title ? raw.title : void 0,
+    fields,
+    submitLabel: typeof raw.submitLabel === "string" && raw.submitLabel ? raw.submitLabel : void 0
+  };
+}
+function renderShowFormField(spec) {
+  const wrap = document.createElement("div");
+  wrap.className = "icen-field";
+  const id = `icen-ai-form-${++uidSeq}`;
+  const label = document.createElement("label");
+  label.className = "icen-field-label";
+  label.htmlFor = id;
+  label.textContent = spec.label;
+  if (spec.required) {
+    const req = document.createElement("span");
+    req.className = "icen-req";
+    req.textContent = "*";
+    label.appendChild(req);
+  }
+  wrap.appendChild(label);
+  let control;
+  if (spec.type === "textarea") {
+    const ta = document.createElement("textarea");
+    ta.className = "icen-form-textarea";
+    ta.setAttribute("rows", "3");
+    control = ta;
+  } else if (spec.type === "select") {
+    const sel = document.createElement("select");
+    sel.className = "icen-form-input";
+    const placeholder = document.createElement("option");
+    placeholder.value = "";
+    placeholder.textContent = t("formValidate.selectPlaceholder");
+    sel.appendChild(placeholder);
+    for (const opt of spec.options ?? []) {
+      const option = document.createElement("option");
+      if (typeof opt === "string") {
+        option.value = opt;
+        option.textContent = opt;
+      } else {
+        option.value = opt.value;
+        option.textContent = opt.label;
+      }
+      sel.appendChild(option);
+    }
+    control = sel;
+  } else {
+    const input = document.createElement("input");
+    input.className = "icen-form-input";
+    input.type = spec.type ?? "text";
+    control = input;
+  }
+  control.id = id;
+  control.name = spec.name;
+  if (spec.required) control.required = true;
+  if (spec.pattern) control.setAttribute("pattern", spec.pattern);
+  if (spec.min != null) control.setAttribute("min", String(spec.min));
+  if (spec.max != null) control.setAttribute("max", String(spec.max));
+  wrap.appendChild(control);
+  if (spec.help) {
+    const hint = document.createElement("span");
+    hint.className = "icen-field-hint";
+    hint.textContent = spec.help;
+    wrap.appendChild(hint);
+  }
+  return wrap;
+}
+function collectFormValues(form) {
+  const out = {};
+  for (const field of collectFormFields(form)) {
+    if (field instanceof HTMLInputElement && field.type === "checkbox") {
+      out[field.name] = field.checked;
+      continue;
+    }
+    if (field instanceof HTMLInputElement && field.type === "radio") {
+      if (!(field.name in out)) out[field.name] = field.checked ? field.value : "";
+      else if (field.checked) out[field.name] = field.value;
+      continue;
+    }
+    out[field.name] = field.value;
+  }
+  return out;
+}
+function runShowForm(input, mount) {
+  return new Promise((resolve) => {
+    if (typeof document === "undefined") {
+      resolve({ cancelled: true });
+      return;
+    }
+    const spec = normalizeShowForm(input);
+    const root = document.createElement("div");
+    root.className = "icen-ai-form";
+    if (spec.title) {
+      const title = document.createElement("p");
+      title.className = "icen-ai-form-title";
+      title.textContent = spec.title;
+      root.appendChild(title);
+    }
+    const form = document.createElement("form");
+    form.className = "icen-form icen-ai-form-fields";
+    form.setAttribute("data-icen-validate", "");
+    form.setAttribute("data-icen-validate-summary", "");
+    form.setAttribute("novalidate", "");
+    for (const field of spec.fields) form.appendChild(renderShowFormField(field));
+    const actions = document.createElement("div");
+    actions.className = "icen-ai-form-actions";
+    const submit = document.createElement("button");
+    submit.type = "submit";
+    submit.className = "icen-btn icen-btn-primary";
+    submit.textContent = spec.submitLabel ?? t("common.submit");
+    const cancel = document.createElement("button");
+    cancel.type = "button";
+    cancel.className = "icen-btn icen-btn-ghost";
+    cancel.setAttribute("data-icen-ai-form-cancel", "");
+    cancel.textContent = t("common.cancel");
+    actions.append(submit, cancel);
+    form.appendChild(actions);
+    root.appendChild(form);
+    mount.appendChild(root);
+    const handle = createFormValidator(form, { scrollToError: true });
+    const finish = (value) => {
+      form.removeEventListener("icen:form-valid", onValid);
+      cancel.removeEventListener("click", onCancel);
+      handle.destroy();
+      root.remove();
+      resolve(value);
+    };
+    const onValid = () => {
+      finish(collectFormValues(form));
+    };
+    const onCancel = () => {
+      finish({ cancelled: true });
+    };
+    form.addEventListener("icen:form-valid", onValid);
+    cancel.addEventListener("click", onCancel);
+  });
+}
+
 // src/behaviors/ai-tools.ts
 var toolRegistry = /* @__PURE__ */ new Map();
 var LIVE_AREAS = /* @__PURE__ */ new Set();
@@ -5435,6 +6579,13 @@ registerAiTool({
     return { title, rows: rows.length };
   }
 });
+registerAiTool({
+  name: "show_form",
+  description: t("formValidate.tool.description"),
+  inputSchema: SHOW_FORM_SCHEMA,
+  present: "mount",
+  run: (input, mount) => runShowForm(input, mount)
+});
 function isBrowserTools() {
   return typeof document !== "undefined" && typeof window !== "undefined";
 }