@zeyos/zx 4.3.0 → 4.3.4

package/dist/zx.esm.js

@@ -798,21 +798,26 @@ var Component = class extends EventTarget {
    * Dispatches a component event and a bubbling, composed `zx-*` DOM event.
    * @param {string} type Lowercase event name.
    * @param {Record<string, unknown>} [detail={}] Single event detail object.
+   * @param {{honorDomCancellation?:boolean}} [options={}] Mirrored DOM-event behavior. Components
+   * with a cancelable mutation boundary may opt into treating `preventDefault()` on the bubbling
+   * `zx-*` event exactly like cancellation of the component event.
    * @returns {Event & {detail: Record<string, unknown>}}
    * @fires Component#event
    */
-  emit(type, detail = {}) {
+  emit(type, detail = {}, options = {}) {
     if (detail === null || typeof detail !== "object" || Array.isArray(detail)) {
       throw new TypeError("Event detail must be an object");
     }
     const componentEvent = createCustomEvent(type, detail, { cancelable: true });
     this.dispatchEvent(componentEvent);
     if (this.el) {
-      this.el.dispatchEvent(createCustomEvent(`zx-${type}`, detail, {
+      const domEvent = createCustomEvent(`zx-${type}`, detail, {
         bubbles: true,
         composed: true,
         cancelable: true
-      }));
+      });
+      this.el.dispatchEvent(domEvent);
+      if (options.honorDomCancellation && domEvent.defaultPrevented) componentEvent.preventDefault();
     }
     return componentEvent;
   }
@@ -24009,6 +24014,29 @@ function calendarRange(view, anchor, options = {}) {
   }
   return { start, end };
 }
+function calendarPageDate(view, anchor, direction, options = {}) {
+  const date = validDate5(anchor, "Calendar date");
+  const step = integer(direction, "direction");
+  if (view === "day") date.setDate(date.getDate() + step);
+  else if (view === "agenda") {
+    date.setDate(date.getDate() + step * positiveInteger(options.agendaDays ?? 14, "agendaDays"));
+  } else if (view === "week") date.setDate(date.getDate() + step * 7);
+  else if (view === "month") return addCalendarMonths(date, step);
+  else if (view === "year") return addCalendarMonths(date, step * 12);
+  else throw new RangeError(`Unknown calendar view: ${view}`);
+  return date;
+}
+function addCalendarMonths(value, months) {
+  const date = validDate5(value, "Calendar date");
+  const day = date.getDate();
+  date.setDate(1);
+  date.setMonth(date.getMonth() + integer(months, "month amount"));
+  date.setDate(Math.min(day, daysInCalendarMonth(date.getFullYear(), date.getMonth())));
+  return date;
+}
+function daysInCalendarMonth(year, month) {
+  return new Date(year, month + 1, 0).getDate();
+}
 function normalizeCalendarEvents(records, options = {}) {
   if (!Array.isArray(records)) throw new TypeError("Calendar events must be an array");
   const readers = {
@@ -24452,7 +24480,7 @@ var Calendar = class extends Component {
       durationEditable: Object.prototype.hasOwnProperty.call(changes, "durationEditable") ? changes.durationEditable : current.durationEditable,
       data: changes.data ?? current.data
     };
-    const [next] = normalizeCalendarEvents([source]);
+    const [next] = normalizeCalendarEvents([source], { dateUnit: this.options.dateUnit });
     next.data = source.data;
     this._events = this._events.map((event, eventIndex) => eventIndex === index ? next : event);
     this._mutationVersions.delete(String(id));
@@ -25478,13 +25506,9 @@ var Calendar = class extends Component {
   }
   /** @param {number} direction @returns {this} */
   _page(direction) {
-    const date = new Date(this._date.getTime());
-    if (this._view === "day") date.setDate(date.getDate() + direction);
-    else if (this._view === "agenda") date.setDate(date.getDate() + direction * this.options.agendaDays);
-    else if (this._view === "week") date.setDate(date.getDate() + direction * 7);
-    else if (this._view === "month") date.setMonth(date.getMonth() + direction);
-    else date.setFullYear(date.getFullYear() + direction);
-    return this.setDate(date);
+    return this.setDate(calendarPageDate(this._view, this._date, direction, {
+      agendaDays: this.options.agendaDays
+    }));
   }
   /** @param {{start: Date, end: Date}} range @returns {string} */
   _rangeTitle(range) {
@@ -26641,6 +26665,16 @@ function createRecordCard(record, index, options = {}) {
     class: "zx-record-card__heading",
     id: headingId
   }, headingContent);
+  const fieldGroups = partitionRecordCardFields(visibleFields, titleSource, subtitleSource);
+  const eyebrow = createEyebrow(record, index, fieldGroups.eyebrowStart, fieldGroups.eyebrowEnd);
+  const titlePrefix = createFieldList(
+    record,
+    index,
+    fieldGroups.titlePrefix,
+    "zx-record-card__title-prefix",
+    "title-prefix"
+  );
+  const titleRow = titlePrefix ? h("div", { class: "zx-record-card__title-row" }, titlePrefix, heading) : heading;
   const selection = selectable === "multi" ? h("label", {
     class: "zx-record-card__selection"
   }, h("input", {
@@ -26662,19 +26696,19 @@ function createRecordCard(record, index, options = {}) {
     h(
       "div",
       { class: "zx-record-card__titles" },
-      heading,
+      titleRow,
       isEmptyContent(subtitle) ? null : h("p", { class: "zx-record-card__subtitle" }, contentNode(subtitle))
     ),
     actionArea
   );
-  const metadata = createMetadata(record, index, visibleFields, titleSource, subtitleSource);
-  const body = h("div", { class: "zx-record-card__body" }, header, metadata);
+  const metadata = createFieldList(record, index, fieldGroups.metadata, "zx-record-card__metadata");
+  const body = h("div", { class: "zx-record-card__body" }, eyebrow, header, metadata);
   const card = (
     /** @type {HTMLLIElement} */
     h("li", {
       class: "zx-record-card",
       tabindex: 0,
-      ariaSelected: selectable ? String(selected) : void 0,
+      ariaDescription: selectable ? selected ? "Selected" : "Not selected" : void 0,
       ariaLabelledby: headingId,
       dataset: {
         recordIndex: String(index),
@@ -26685,6 +26719,20 @@ function createRecordCard(record, index, options = {}) {
   );
   return card;
 }
+function partitionRecordCardFields(fields, titleSource = null, subtitleSource = null) {
+  const groups = { eyebrowStart: [], eyebrowEnd: [], titlePrefix: [], metadata: [] };
+  const titleId = typeof titleSource === "string" ? titleSource : null;
+  const subtitleId = typeof subtitleSource === "string" ? subtitleSource : null;
+  for (const field of Array.isArray(fields) ? fields : []) {
+    if (!field.duplicate && (field.id === titleId || field.id === subtitleId)) continue;
+    const slot = resolveRecordCardFieldSlot(field);
+    if (slot === "eyebrow-start") groups.eyebrowStart.push(field);
+    else if (slot === "eyebrow-end") groups.eyebrowEnd.push(field);
+    else if (slot === "title-prefix") groups.titlePrefix.push(field);
+    else groups.metadata.push(field);
+  }
+  return groups;
+}
 function resolveRecordPreview(record, index, preview, previewAlt, fields = []) {
   if (preview == null) return null;
   const candidate = typeof preview === "function" ? preview(record, index) : readRecordSource(record, index, preview, fields, false);
@@ -26753,21 +26801,49 @@ function createPreview(preview) {
     dataset: { failed: String(preview.rejected) }
   }, fallback, image);
 }
-function createMetadata(record, index, fields, titleSource, subtitleSource) {
-  const titleId = typeof titleSource === "string" ? titleSource : null;
-  const subtitleId = typeof subtitleSource === "string" ? subtitleSource : null;
-  const visible = fields.filter((field) => field.duplicate || field.id !== titleId && field.id !== subtitleId);
-  if (visible.length === 0) return null;
-  return h("dl", { class: "zx-record-card__metadata" }, visible.map((field) => h(
+function createEyebrow(record, index, eyebrowStart, eyebrowEnd) {
+  const start = createFieldList(
+    record,
+    index,
+    eyebrowStart,
+    "zx-record-card__eyebrow-group",
+    "eyebrow-start"
+  );
+  const end = createFieldList(
+    record,
+    index,
+    eyebrowEnd,
+    "zx-record-card__eyebrow-group",
+    "eyebrow-end"
+  );
+  return start || end ? h("div", { class: "zx-record-card__eyebrow" }, start, end) : null;
+}
+function createFieldList(record, index, fields, className, slot = null) {
+  if (fields.length === 0) return null;
+  return h("dl", {
+    class: className,
+    dataset: slot ? { cardSlot: slot } : void 0
+  }, fields.map((field) => h(
     "div",
     {
       class: "zx-record-card__field",
-      dataset: { fieldId: field.id }
+      dataset: { fieldId: field.id, ...slot ? { cardSlot: slot } : {} }
     },
     h("dt", { class: "zx-record-card__label" }, field.label),
     h("dd", { class: "zx-record-card__value" }, contentNode(renderViewField(field, record, index)))
   )));
 }
+function resolveRecordCardFieldSlot(field) {
+  const view = field?.view;
+  if (!view || typeof view !== "object" || Array.isArray(view)) return null;
+  const card = view.card;
+  if (!card || typeof card !== "object" || Array.isArray(card)) return null;
+  const slot = (
+    /** @type {{slot?:unknown}} */
+    card.slot
+  );
+  return slot === "eyebrow-start" || slot === "eyebrow-end" || slot === "title-prefix" ? slot : null;
+}
 function createAction(action) {
   const label = String(action.label ?? "");
   const title = String(action.title ?? (label || action.id));
@@ -26837,7 +26913,7 @@ function safePreviewUrl(value) {
   try {
     const base = globalThis.location?.href ?? "https://zx.invalid/";
     const protocol = new URL(href, base).protocol.toLowerCase();
-    return ["http:", "https:", "blob:", "file:"].includes(protocol) ? href : null;
+    return ["http:", "https:", "blob:"].includes(protocol) ? href : null;
   } catch {
     return null;
   }
@@ -26881,7 +26957,7 @@ var CardView = class extends RecordView {
     actions: [],
     groupBy: null,
     groupOrder: [],
-    minCardWidth: "18rem",
+    minCardWidth: "15rem",
     maxColumns: null,
     variant: "outlined",
     loadingCount: 6,
@@ -27155,7 +27231,7 @@ var CardView = class extends RecordView {
     for (const [id, card] of this._cardNodesById) {
       const selected = this._isViewSelected(id);
       card.dataset.selected = String(selected);
-      if (this.options.selectable) card.setAttribute("aria-selected", String(selected));
+      if (this.options.selectable) card.setAttribute("aria-description", selected ? "Selected" : "Not selected");
       const checkbox = (
         /** @type {HTMLInputElement|null} */
         card.querySelector("[data-record-selection]")
@@ -27299,11 +27375,11 @@ function normalizeGroupId(value) {
   return value == null || value === "" ? "" : String(value);
 }
 function normalizeCardWidth(value) {
-  if (typeof value === "number") return Number.isFinite(value) && value > 0 ? `${value}px` : "18rem";
+  if (typeof value === "number") return Number.isFinite(value) && value > 0 ? `${value}px` : "15rem";
   const text4 = String(value ?? "").trim();
-  if (!text4 || text4.length > 128 || /[;{}\u0000-\u001f\u007f]/.test(text4)) return "18rem";
-  if (/(?:url|image|image-set|cross-fade|element|expression)\s*\(/i.test(text4)) return "18rem";
-  if (typeof globalThis.CSS?.supports === "function" && !globalThis.CSS.supports("width", text4)) return "18rem";
+  if (!text4 || text4.length > 128 || /[;{}\u0000-\u001f\u007f]/.test(text4)) return "15rem";
+  if (/(?:url|image|image-set|cross-fade|element|expression)\s*\(/i.test(text4)) return "15rem";
+  if (typeof globalThis.CSS?.supports === "function" && !globalThis.CSS.supports("width", text4)) return "15rem";
   return text4;
 }
 function normalizeMaxColumns(value) {
@@ -27341,8 +27417,284 @@ function safeDomPart(value) {
   return value.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "empty";
 }
 
+// src/components/kanban-view/kanban-policy.js
+var RULE_TONES = Object.freeze(["neutral", "accent", "success", "warning", "danger", "info"]);
+function normalizeKanbanRules(rules) {
+  if (rules == null) return [];
+  if (!Array.isArray(rules)) throw new TypeError("Kanban rules must be an array or null");
+  const seen = /* @__PURE__ */ new Set();
+  return rules.map((rule, index) => {
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+      throw new TypeError(`Kanban rule at index ${index} must be an object`);
+    }
+    const source = (
+      /** @type {Record<string, any>} */
+      rule
+    );
+    const id = String(source.id ?? "").trim();
+    if (!id) throw new TypeError(`Kanban rule at index ${index} requires an id`);
+    if (seen.has(id)) throw new TypeError(`Duplicate Kanban rule: ${id}`);
+    if (typeof source.when !== "function") {
+      throw new TypeError(`Kanban rule ${id} requires a when predicate`);
+    }
+    seen.add(id);
+    return {
+      id,
+      when: source.when,
+      tone: RULE_TONES.includes(source.tone) ? source.tone : "accent",
+      label: source.label == null ? "" : String(source.label),
+      icon: source.icon == null ? null : String(source.icon),
+      description: source.description == null ? "" : String(source.description)
+    };
+  });
+}
+function resolveKanbanRules(rules, record, context) {
+  if (!Array.isArray(rules) || !rules.length) return [];
+  return rules.filter((rule) => {
+    try {
+      return rule.when(record, context) === true;
+    } catch {
+      return false;
+    }
+  });
+}
+function evaluateKanbanMove(input) {
+  const { records, column, swimlane, context, from } = input;
+  const moving = Math.max(1, records.length);
+  const policy = column?.wipPolicy === "block" || column?.wipPolicy === "warn" ? column.wipPolicy : input.policy === "block" ? "block" : "warn";
+  const refuse = (reason, extra = {}) => ({
+    allowed: false,
+    reason,
+    limit: null,
+    count: 0,
+    limitExceeded: false,
+    limitReached: false,
+    policy,
+    ...extra
+  });
+  const blockedTransition = allowsKanbanTransition(column, swimlane, from);
+  if (blockedTransition) return refuse(blockedTransition);
+  for (const record of records) {
+    if (column.accept && column.accept(record, context) === false) return refuse("accept");
+    if (swimlane?.accept && swimlane.accept(record, context) === false) return refuse("lane-accept");
+  }
+  const capacities = [];
+  if (column.limit != null) {
+    capacities.push({ reason: "wip", limit: column.limit, count: input.columnCount + moving });
+  }
+  const cellLimit = swimlane ? readLaneLimit(column.laneLimits, swimlane.id) : null;
+  if (cellLimit != null) {
+    capacities.push({ reason: "wip", limit: cellLimit, count: input.cellCount + moving });
+  }
+  if (swimlane?.limit != null) {
+    capacities.push({ reason: "lane-wip", limit: swimlane.limit, count: input.laneCount + moving });
+  }
+  const violated = capacities.find((capacity) => capacity.count > capacity.limit);
+  const reported = violated ?? capacities.find((capacity) => capacity.count === capacity.limit) ?? capacities[0];
+  if (violated && policy === "block") {
+    return refuse(violated.reason, {
+      limit: violated.limit,
+      count: violated.count,
+      limitExceeded: true
+    });
+  }
+  return {
+    allowed: true,
+    reason: null,
+    limit: reported ? reported.limit : null,
+    count: reported ? reported.count : 0,
+    limitExceeded: Boolean(violated),
+    limitReached: Boolean(reported && !violated && reported.count === reported.limit),
+    policy
+  };
+}
+function allowsKanbanTransition(column, swimlane, from) {
+  if (column.id !== from.column && !allowsOrigin(column.from, from.column)) return "transition";
+  if (swimlane && swimlane.id !== from.lane && !allowsOrigin(swimlane.from, from.lane)) {
+    return "lane-transition";
+  }
+  return null;
+}
+function kanbanSearchTerms(search) {
+  const text4 = search == null ? "" : String(search).trim().toLowerCase();
+  if (!text4) return [];
+  return [...text4.matchAll(/"([^"]*)"|(\S+)/g)].map((match) => (match[1] ?? match[2] ?? "").trim()).filter(Boolean);
+}
+function matchesKanbanSearch(text4, terms) {
+  if (!terms.length) return true;
+  const haystack = text4.toLowerCase();
+  return terms.every((term) => haystack.includes(term));
+}
+function createKanbanHistory(limit = 50) {
+  const max = Number.isFinite(Number(limit)) && Number(limit) > 0 ? Math.floor(Number(limit)) : 50;
+  let undoStack = [];
+  let redoStack = [];
+  return {
+    push(entry) {
+      undoStack.push(entry);
+      if (undoStack.length > max) undoStack = undoStack.slice(-max);
+      redoStack = [];
+    },
+    undo(current) {
+      const entry = undoStack.pop();
+      if (!entry) return null;
+      redoStack.push(current);
+      if (redoStack.length > max) redoStack = redoStack.slice(-max);
+      return entry;
+    },
+    redo(current) {
+      const entry = redoStack.pop();
+      if (!entry) return null;
+      undoStack.push(current);
+      if (undoStack.length > max) undoStack = undoStack.slice(-max);
+      return entry;
+    },
+    canUndo: () => undoStack.length > 0,
+    canRedo: () => redoStack.length > 0,
+    clear() {
+      undoStack = [];
+      redoStack = [];
+    },
+    depth: () => ({ undo: undoStack.length, redo: redoStack.length })
+  };
+}
+function reorderKanbanRecords(records, entries, options) {
+  if (!Array.isArray(records) || !Array.isArray(entries) || !entries.length) return null;
+  const sources = entries.map((entry) => ({
+    ...entry,
+    index: records.findIndex((record) => Object.is(viewRecordId(record, options.recordId), entry.id))
+  }));
+  if (sources.some((source) => source.index < 0 || !source.record || typeof source.record !== "object")) {
+    return null;
+  }
+  sources.sort((left, right) => left.index - right.index);
+  const moves = sources.map((source) => ({
+    id: source.id,
+    from: locateKanbanRecord(records, source.index, options)
+  }));
+  const movingIndices = new Set(sources.map((source) => source.index));
+  const next = records.filter((_, index) => !movingIndices.has(index));
+  const destinationRecords = next.filter((record, index) => normalizeAxisId(readKanbanAccessor(record, index, options.columnBy)) === options.destination.column && (options.swimlaneBy == null || normalizeAxisId(readKanbanAccessor(record, index, options.swimlaneBy)) === options.destination.lane));
+  const targetIndex = clampKanbanIndex(options.destination.index, destinationRecords.length);
+  let insertion = next.length;
+  if (destinationRecords[targetIndex]) insertion = next.indexOf(destinationRecords[targetIndex]);
+  else if (destinationRecords.length) insertion = next.indexOf(destinationRecords.at(-1)) + 1;
+  next.splice(insertion, 0, ...sources.map((source) => source.record));
+  return {
+    records: next,
+    moves,
+    to: {
+      column: options.destination.column,
+      lane: options.swimlaneBy == null ? null : options.destination.lane,
+      index: targetIndex
+    }
+  };
+}
+function locateKanbanRecord(records, index, options) {
+  const record = records[index];
+  const column = normalizeAxisId(readKanbanAccessor(record, index, options.columnBy));
+  const lane = options.swimlaneBy == null ? null : normalizeAxisId(readKanbanAccessor(record, index, options.swimlaneBy));
+  const group = records.filter((candidate, candidateIndex) => normalizeAxisId(readKanbanAccessor(candidate, candidateIndex, options.columnBy)) === column && (options.swimlaneBy == null || normalizeAxisId(readKanbanAccessor(candidate, candidateIndex, options.swimlaneBy)) === lane));
+  const id = viewRecordId(record, options.recordId);
+  return {
+    column,
+    lane,
+    index: group.findIndex((candidate) => Object.is(viewRecordId(candidate, options.recordId), id))
+  };
+}
+function absoluteKanbanIndex(visibility, visibleIndex) {
+  const target = clampKanbanIndex(visibleIndex, visibility.filter(Boolean).length);
+  let seen = 0;
+  for (let index = 0; index < visibility.length; index += 1) {
+    if (!visibility[index]) continue;
+    if (seen === target) return index;
+    seen += 1;
+  }
+  return visibility.length;
+}
+function readKanbanAccessor(record, index, accessor) {
+  return typeof accessor === "function" ? accessor(record, index) : accessor == null ? null : record?.[accessor];
+}
+function normalizeAxisId(value) {
+  return value == null ? "" : String(value);
+}
+function clampKanbanIndex(value, maximum) {
+  if (value == null || !Number.isFinite(Number(value))) return maximum;
+  return Math.max(0, Math.min(maximum, Math.trunc(Number(value))));
+}
+function allowsOrigin(allowed, origin) {
+  if (allowed == null) return true;
+  if (!Array.isArray(allowed)) return true;
+  if (!allowed.length) return false;
+  return allowed.some((entry) => String(entry) === "*" || String(entry) === normalizeAxisId(origin));
+}
+function readLaneLimit(laneLimits, lane) {
+  if (!laneLimits || typeof laneLimits !== "object") return null;
+  const value = (
+    /** @type {Record<string, unknown>} */
+    laneLimits[lane]
+  );
+  if (value == null || value === "") return null;
+  const number2 = Number(value);
+  return Number.isFinite(number2) && number2 >= 0 ? Math.floor(number2) : null;
+}
+
 // src/components/kanban-view/kanban-view.js
 var INTERACTIVE = 'a, button, input, select, textarea, summary, [contenteditable="true"]';
+var DRAG_THRESHOLD = 4;
+var TOUCH_HOLD = 350;
+var SEARCH_DEBOUNCE = 120;
+var SCROLL_EDGE = 56;
+var SCROLL_SPEED = 18;
+var DEFAULT_LABELS = Object.freeze({
+  fields: "Fields",
+  search: "Search board",
+  searchPlaceholder: "Search cards",
+  clearSearch: "Clear search",
+  searchSummary: "%count% of %total% cards match.",
+  undo: "Undo",
+  redo: "Redo",
+  add: "Add card",
+  addTo: "Add card to %target%",
+  move: "Move %name%",
+  moveMultiple: "Move %count% selected cards",
+  collapseColumn: "Collapse column %label%",
+  expandColumn: "Expand column %label%",
+  collapseLane: "Collapse swim lane %label%",
+  expandLane: "Expand swim lane %label%",
+  count: "%count% records",
+  countFiltered: "%count% of %total% records",
+  countLimit: "%count% records, work-in-progress limit %limit%",
+  countLimitInLane: "%count% records in this lane, %total% of work-in-progress limit %limit% in the column",
+  empty: "No records",
+  columnEmpty: "",
+  selected: "Selected",
+  notSelected: "Not selected",
+  noMatches: "No cards match the current search.",
+  record: "record",
+  grabbed: "Grabbed %name%. Use left and right for columns, up and down for position, and Alt plus up or down for swim lanes.",
+  grabbedMultiple: "Grabbed %count% cards. Use left and right for columns, up and down for position, and Alt plus up or down for swim lanes.",
+  target: "Target %target%, position %position% of %total%.",
+  moved: "Moved %name% to %target%.%wip%",
+  movedMultiple: "Moved %count% cards to %target%.%wip%",
+  moveRequested: "Move requested for %name% to %target%.%wip%",
+  moveCanceled: "Move canceled for %name%.",
+  moveCanceledPlain: "Move canceled.",
+  limitReached: " Work-in-progress limit %limit% reached.",
+  limitExceeded: " Work-in-progress limit %limit% exceeded.",
+  rejectAccept: "Move rejected: %target% does not accept %name%.",
+  rejectTransition: "Move rejected: %target% does not accept cards from %origin%.",
+  rejectWip: "Move rejected: %target% is at its work-in-progress limit of %limit%.",
+  rejectDestination: "Move rejected: the destination is not available.",
+  rejectGrouping: "Move rejected: callback grouping requires external move mode.",
+  undone: "Move undone.",
+  redone: "Move redone.",
+  nothingToUndo: "Nothing to undo.",
+  nothingToRedo: "Nothing to redo.",
+  menuMoveTo: "Move to %target%",
+  menuMoveToLane: "Move to lane %target%",
+  dragPreview: "%count% cards"
+});
 var KanbanView = class extends RecordView {
   static cssName = "kanban-view";
   /** @type {Readonly<KanbanViewOptions & RecordViewOptions>} */
@@ -27359,6 +27711,27 @@ var KanbanView = class extends RecordView {
     link: null,
     actions: [],
     moveMode: "local",
+    dragFrom: "card",
+    multiMove: true,
+    autoScroll: true,
+    wipPolicy: "warn",
+    rules: [],
+    search: "",
+    searchFields: null,
+    filter: null,
+    searchControl: false,
+    history: true,
+    historyLimit: 50,
+    historyControls: false,
+    columnHeight: null,
+    allowAdd: false,
+    contextMenu: false,
+    renderCard: null,
+    renderColumnHeader: null,
+    renderSwimlaneHeader: null,
+    renderColumnEmpty: null,
+    renderDragPreview: null,
+    labels: {},
     columnOrder: [],
     swimlaneOrder: [],
     collapsedColumns: [],
@@ -27394,17 +27767,45 @@ var KanbanView = class extends RecordView {
       this._kanbanSwimlaneOrder = normalizeOrder(options.swimlaneOrder);
       this._collapsedColumns = new Set(normalizeOrder(options.collapsedColumns));
       this._collapsedSwimlanes = new Set(normalizeOrder(options.collapsedSwimlanes));
+      this._kanbanRules = normalizeKanbanRules(options.rules);
+      this._kanbanSearch = options.search == null ? "" : String(options.search);
+      this._kanbanFilter = typeof options.filter === "function" ? options.filter : null;
+      this._kanbanHistory = createKanbanHistory(options.historyLimit);
       this._keyboardMove = /** @type {KanbanKeyboardMove|null} */
       null;
-      this._dragId = null;
+      this._dragIds = /** @type {unknown[]} */
+      [];
       this._dragDestination = /** @type {KanbanMovePoint|null} */
       null;
+      this._pointerStart = /** @type {{x:number,y:number,id:number,ids:unknown[],touch:boolean}|null} */
+      null;
+      this._pointerHold = 0;
+      this._dragFrame = 0;
+      this._dragPreview = /** @type {HTMLElement|null} */
+      null;
+      this._dragPointer = /** @type {number|null} */
+      null;
+      this._dragCaptured = false;
+      this._searchTimer = 0;
+      this._dragPoint = { x: 0, y: 0 };
+      this._suppressClick = false;
       this._announcementToken = 0;
       this._cardMeta = /* @__PURE__ */ new WeakMap();
       this._sectionMeta = /* @__PURE__ */ new WeakMap();
       this._cardsById = /* @__PURE__ */ new Map();
+      this._visibleIds = /* @__PURE__ */ new Set();
+      this._kanbanMenu = /** @type {ContextMenu|null} */
+      null;
+      this._searchInput = /** @type {HTMLInputElement|null} */
+      null;
+      this._undoButton = /** @type {HTMLButtonElement|null} */
+      null;
+      this._redoButton = /** @type {HTMLButtonElement|null} */
+      null;
       this._toolbar = h("div", { class: "zx-record-view__toolbar zx-kanban-view__toolbar" });
-      if (options.fieldControls) this._toolbar.append(this._createViewFieldControls());
+      if (options.fieldControls) this._toolbar.append(this._createViewFieldControls(this._text("fields")));
+      if (options.searchControl) this._toolbar.append(this._createSearchControl());
+      if (options.historyControls) this._toolbar.append(this._createHistoryControls());
       this._board = h("div", {
         class: "zx-kanban-view__board",
         role: "region",
@@ -27417,6 +27818,10 @@ var KanbanView = class extends RecordView {
         ariaAtomic: "true"
       });
       root.replaceChildren(this._toolbar, this._board, this._live);
+      if (options.columnHeight) {
+        root.style.setProperty("--zx-kanban-column-height", String(options.columnHeight));
+        root.dataset.columnScroll = "true";
+      }
       this.listen(this._board, "click", (event) => this._handleBoardClick(
         /** @type {MouseEvent} */
         event
@@ -27430,20 +27835,22 @@ var KanbanView = class extends RecordView {
         event
       ));
       this.listen(this._board, "error", (event) => this._handlePreviewError(event), { capture: true });
-      this.listen(this._board, "dragstart", (event) => this._handleDragStart(
-        /** @type {DragEvent} */
+      this.listen(this._board, "pointerdown", (event) => this._handlePointerDown(
+        /** @type {PointerEvent} */
         event
       ));
-      this.listen(this._board, "dragover", (event) => this._handleDragOver(
-        /** @type {DragEvent} */
+      this.listen(this._board, "pointermove", (event) => this._handlePointerMove(
+        /** @type {PointerEvent} */
         event
       ));
-      this.listen(this._board, "drop", (event) => this._handleDrop(
-        /** @type {DragEvent} */
+      this.listen(this._board, "pointerup", (event) => this._handlePointerUp(
+        /** @type {PointerEvent} */
         event
       ));
-      this.listen(this._board, "dragend", () => this._clearDrag());
+      this.listen(this._board, "pointercancel", () => this._clearDrag());
+      this.listen(this._board, "dragstart", (event) => event.preventDefault());
       this._refreshView("init");
+      if (options.contextMenu) this._createContextMenu();
       return root;
     } catch (error2) {
       if (this._kanbanSnapshot) restoreTarget(root, this._kanbanSnapshot);
@@ -27461,7 +27868,16 @@ var KanbanView = class extends RecordView {
    */
   setColumns(columns) {
     this._kanbanColumns = columns === null ? null : normalizeKanbanDescriptors(columns, "column");
-    this._kanbanColumnOrder = reconcileKanbanOrder(this._rawColumns(), this._kanbanColumnOrder);
+    const descriptors = this._rawColumns();
+    this._kanbanColumnOrder = reconcileKanbanPreference(
+      descriptors,
+      this._kanbanColumnOrder,
+      this._kanbanColumns === null
+    );
+    if (this._kanbanColumns !== null) {
+      const ids = new Set(descriptors.map((column) => column.id));
+      this._collapsedColumns = new Set([...this._collapsedColumns].filter((id) => ids.has(id)));
+    }
     this._refreshView("columns");
     this._emitKanbanState("columns");
     return this;
@@ -27477,7 +27893,17 @@ var KanbanView = class extends RecordView {
    */
   setSwimlanes(lanes) {
     this._kanbanSwimlanes = lanes === null ? null : normalizeKanbanDescriptors(lanes, "swimlane");
-    this._kanbanSwimlaneOrder = reconcileKanbanOrder(this._rawSwimlanes(), this._kanbanSwimlaneOrder);
+    const descriptors = this._rawSwimlanes();
+    const preserveUnknown = this._kanbanSwimlanes === null && this._kanbanOptions().swimlaneBy != null;
+    this._kanbanSwimlaneOrder = reconcileKanbanPreference(
+      descriptors,
+      this._kanbanSwimlaneOrder,
+      preserveUnknown
+    );
+    if (!preserveUnknown) {
+      const ids = new Set(descriptors.map((lane) => lane.id));
+      this._collapsedSwimlanes = new Set([...this._collapsedSwimlanes].filter((id) => ids.has(id)));
+    }
     this._refreshView("swimlanes");
     this._emitKanbanState("swimlanes");
     return this;
@@ -27493,9 +27919,16 @@ var KanbanView = class extends RecordView {
    * @returns {this}
    */
   setColumnOrder(order, options = {}) {
-    const next = reconcileKanbanOrder(this._rawColumns(), order);
-    if (sameArray3(next, this.getColumnOrder())) return this;
-    this._kanbanColumnOrder = next;
+    const descriptors = this._rawColumns();
+    const current = this.getColumnOrder();
+    const next = reconcileKanbanOrder(descriptors, order);
+    if (sameArray3(next, current)) return this;
+    this._kanbanColumnOrder = mergeKanbanResolvedOrder(
+      this._kanbanColumnOrder,
+      descriptors,
+      next,
+      this._kanbanColumns === null
+    );
     this._refreshView("columnorder");
     if (!options.silent) this._emitKanbanState("columnorder");
     return this;
@@ -27521,9 +27954,17 @@ var KanbanView = class extends RecordView {
    * @returns {this}
    */
   setSwimlaneOrder(order, options = {}) {
-    const next = reconcileKanbanOrder(this._rawSwimlanes(), order);
-    if (sameArray3(next, this.getSwimlaneOrder())) return this;
-    this._kanbanSwimlaneOrder = next;
+    const descriptors = this._rawSwimlanes();
+    const current = this.getSwimlaneOrder();
+    const next = reconcileKanbanOrder(descriptors, order);
+    if (sameArray3(next, current)) return this;
+    const preserveUnknown = this._kanbanSwimlanes === null && this._kanbanOptions().swimlaneBy != null;
+    this._kanbanSwimlaneOrder = mergeKanbanResolvedOrder(
+      this._kanbanSwimlaneOrder,
+      descriptors,
+      next,
+      preserveUnknown
+    );
     this._refreshView("swimlaneorder");
     if (!options.silent) this._emitKanbanState("swimlaneorder");
     return this;
@@ -27591,91 +28032,244 @@ var KanbanView = class extends RecordView {
     return this.setSwimlaneCollapsed(id, !this._collapsedSwimlanes.has(String(id)));
   }
   /**
-   * Proposes and, in local mode, commits a record move. Destination acceptance is checked before
-   * a cancelable `recordmove` event. WIP limits are reported but remain advisory.
+   * Proposes and, in local mode, commits a record move. Equivalent to `moveRecords([id], …)`.
    * @param {unknown} id Record id.
    * @param {KanbanDestination} destination Destination.
    * @returns {this}
    * @fires KanbanView#recordmove
+   * @fires KanbanView#movereject
    * @fires RecordView#datachange
    */
   moveRecord(id, destination) {
+    return this.moveRecords([id], destination);
+  }
+  /**
+   * Proposes and, in local mode, commits an atomic move of one or more records. Destination
+   * eligibility, transition rules, and work-in-progress policy are all checked before a single
+   * cancelable `recordmove` event; the move commits completely or not at all, and the moving
+   * records keep their relative order at the destination.
+   * @param {unknown[]} ids Record ids, in any order.
+   * @param {KanbanDestination} destination Destination.
+   * @returns {this}
+   * @fires KanbanView#recordmove
+   * @fires KanbanView#movereject
+   * @fires RecordView#datachange
+   */
+  moveRecords(ids, destination) {
     const options = this._kanbanOptions();
-    const record = this.getRecord(id);
-    const from = this._recordLocation(id);
-    if (!record || !from || !destination || typeof destination !== "object") return this;
+    if (!Array.isArray(ids) || !destination || typeof destination !== "object") return this;
+    const moving = this._orderedIds(ids);
+    if (!moving.length) return this;
+    const records = moving.map((id) => (
+      /** @type {KanbanRecord} */
+      this.getRecord(id)
+    ));
+    const origins = moving.map((id) => (
+      /** @type {KanbanMovePoint} */
+      this._recordLocation(id)
+    ));
+    const from = origins[0];
     const columns = this._resolvedColumns();
     const lanes = this._resolvedSwimlanes();
     const columnId = destination.column == null ? from.column : String(destination.column);
     const laneId = options.swimlaneBy == null ? null : destination.lane === void 0 ? from.lane : normalizeAxisId(destination.lane);
     const column = columns.find((candidate) => candidate.id === columnId);
-    const lane = options.swimlaneBy == null ? null : lanes.find((candidate) => candidate.id === laneId);
+    const lane = options.swimlaneBy == null ? null : lanes.find((candidate) => candidate.id === laneId) ?? null;
     if (!column || options.swimlaneBy != null && !lane) {
-      this._announce("Move rejected: the destination is not available.");
+      this._rejectMove("destination", { ids: moving, records, from, to: null, column: null, swimlane: null });
       return this;
     }
-    const destinationCount = this._recordsIn(columnId, laneId).filter((candidate) => !Object.is(this._viewRecordId(candidate.record), id)).length;
-    const destinationColumnCount = this._viewData.filter((candidate, candidateIndex) => normalizeAxisId(this._readAxis(options.columnBy, candidate, candidateIndex)) === columnId && !Object.is(this._viewRecordId(candidate), id)).length;
-    const index = normalizeMoveIndex(destination.index, destinationCount);
+    const excluded = new Set(moving);
+    const cellCount = this._recordsIn(columnId, laneId).filter((entry) => !excluded.has(this._viewRecordId(entry.record))).length;
+    const index = clampKanbanIndex(destination.index, cellCount);
     const to = { column: columnId, lane: laneId, index };
-    if (sameMovePoint(from, to)) return this;
-    const context = { id, from: { ...from }, to: { ...to }, column: { ...column }, swimlane: lane ? { ...lane } : null };
-    if (column.accept && column.accept(record, context) === false || lane?.accept && lane.accept(record, context) === false) {
-      this._announce(`Move rejected for ${this._recordName(record, from.index)}.`);
+    if (moving.length === 1 && sameMovePoint(from, to)) return this;
+    const context = {
+      id: moving[0],
+      from: { ...from },
+      to: { ...to },
+      column: { ...column },
+      swimlane: lane ? { ...lane } : null
+    };
+    const evaluation = this._evaluateMove(records, origins, column, lane, to, context, excluded);
+    if (!evaluation.allowed) {
+      this._rejectMove(
+        /** @type {KanbanRejectReason} */
+        evaluation.reason,
+        {
+          ids: moving,
+          records,
+          from,
+          to,
+          column,
+          swimlane: lane,
+          evaluation
+        }
+      );
       return this;
     }
-    let movedRecord = record;
-    if (options.moveMode === "local") {
-      movedRecord = this._localMovedRecord(record, from, to, column, lane);
-      if (!movedRecord) {
-        this._announce("Move rejected: callback grouping requires external move mode.");
+    const entries = [];
+    for (let position2 = 0; position2 < moving.length; position2 += 1) {
+      const record = records[position2];
+      const moved = options.moveMode === "local" ? this._localMovedRecord(record, origins[position2], to, column, lane) : record;
+      if (!moved) {
+        this._rejectMove("grouping", { ids: moving, records, from, to, column, swimlane: lane });
         return this;
       }
+      entries.push({ id: moving[position2], record: moved });
     }
-    const next = reorderKanbanData(this._viewData, id, movedRecord, {
+    const next = reorderKanbanRecords(this._viewData, entries, {
       recordId: options.recordId,
       columnBy: (candidate, candidateIndex) => this._readAxis(options.columnBy, candidate, candidateIndex),
       swimlaneBy: options.swimlaneBy == null ? null : (candidate, candidateIndex) => this._readAxis(options.swimlaneBy, candidate, candidateIndex),
       destination: to
     });
     if (!next) {
-      this._announce("Move rejected: the destination could not be resolved.");
+      this._rejectMove("destination", { ids: moving, records, from, to, column, swimlane: lane });
       return this;
     }
-    const finalCount = destinationColumnCount + 1;
-    const limitExceeded = column.limit != null && finalCount > column.limit;
+    const wip = this._wipAnnouncement(evaluation);
     const moveEvent = this.emit("recordmove", {
-      record,
-      id,
+      record: records[0],
+      id: moving[0],
+      records: [...records],
+      ids: [...moving],
+      moves: next.moves.map((move) => ({ id: move.id, from: { ...move.from } })),
       from: { ...from },
       to: { ...next.to },
       column: { ...column },
       swimlane: lane ? { ...lane } : null,
-      limitExceeded
-    });
+      limitExceeded: evaluation.limitExceeded
+    }, { honorDomCancellation: true });
     if (moveEvent.defaultPrevented) {
-      this._announce(`Move canceled for ${this._recordName(record, from.index)}.`);
+      this._announce(this._text("moveCanceled", { name: this._movingName(records) }));
       return this;
     }
     if (options.moveMode === "external") {
-      this._announce(`Move requested for ${this._recordName(record, from.index)} to ${this._targetName(next.to)}.`);
+      this._announce(this._text("moveRequested", {
+        name: this._movingName(records),
+        target: this._targetName(next.to),
+        wip
+      }));
       return this;
     }
-    this._viewData = next.records;
-    this._refreshView("move");
-    this.emit("datachange", { records: this.getData() });
-    this._announce(`Moved ${this._recordName(movedRecord, next.to.index)} to ${this._targetName(next.to)}.`);
-    queueMicrotask(() => this._moveHandle(id)?.focus());
+    this._commitLocalRecords(next.records);
+    this._announce(moving.length > 1 ? this._text("movedMultiple", { count: moving.length, target: this._targetName(next.to), wip }) : this._text("moved", {
+      name: this._recordName(entries[0].record, next.to.index),
+      target: this._targetName(next.to),
+      wip
+    }));
+    queueMicrotask(() => this._moveHandle(moving[0])?.focus());
+    return this;
+  }
+  /** Whether a committed local move can be reverted. @returns {boolean} */
+  canUndo() {
+    return this._kanbanOptions().history !== false && this._kanbanHistory.canUndo();
+  }
+  /** Whether a reverted local move can be reapplied. @returns {boolean} */
+  canRedo() {
+    return this._kanbanOptions().history !== false && this._kanbanHistory.canRedo();
+  }
+  /**
+   * Reverts the last committed local move, restoring the exact record order and selection.
+   * @returns {this}
+   * @fires RecordView#datachange
+   * @fires KanbanView#historychange
+   */
+  undo() {
+    return this._travelHistory("undo");
+  }
+  /**
+   * Reapplies the last reverted local move.
+   * @returns {this}
+   * @fires RecordView#datachange
+   * @fires KanbanView#historychange
+   */
+  redo() {
+    return this._travelHistory("redo");
+  }
+  /** Empties both history stacks. @returns {this} @fires KanbanView#historychange */
+  clearHistory() {
+    this._kanbanHistory.clear();
+    this._syncHistoryControls();
+    this._emitHistory();
+    return this;
+  }
+  /** Returns the current board search text. @returns {string} */
+  getSearch() {
+    return this._kanbanSearch;
+  }
+  /**
+   * Narrows visible cards to those matching a search. Hidden records keep their position in the
+   * data, so a card dropped between two visible cards still lands between them.
+   * @param {string} search Search text.
+   * @param {{silent?:boolean}} [options={}] Event behavior.
+   * @returns {this}
+   * @fires KanbanView#searchchange
+   */
+  setSearch(search, options = {}) {
+    const next = search == null ? "" : String(search);
+    if (next === this._kanbanSearch) return this;
+    this._kanbanSearch = next;
+    if (this._searchInput && this._searchInput.value !== next) this._searchInput.value = next;
+    this._refreshView("search");
+    if (!options.silent) this.emit("searchchange", { search: next });
+    return this;
+  }
+  /**
+   * Replaces the extra card predicate. Pass null to clear it.
+   * @param {((record:KanbanRecord,index:number)=>boolean)|null} filter Predicate.
+   * @returns {this}
+   */
+  setFilter(filter) {
+    if (filter != null && typeof filter !== "function") {
+      throw new TypeError("Kanban filter must be a function or null");
+    }
+    this._kanbanFilter = filter ?? null;
+    this._refreshView("filter");
     return this;
   }
+  /** Returns the records currently rendered, in board order. @returns {KanbanRecord[]} */
+  getVisibleRecords() {
+    return this._viewData.filter((record) => this._visibleIds.has(this._viewRecordId(record)));
+  }
+  /**
+   * Replaces every record. History is dropped because its snapshots describe records the host has
+   * just replaced, and reinstating them would resurrect data the application no longer owns.
+   * @param {KanbanRecord[]} records New records.
+   * @returns {this}
+   */
+  setData(records) {
+    this._resetHistory();
+    return super.setData(records);
+  }
+  /** @param {KanbanRecord[]} records Records to append. @returns {this} */
+  addData(records) {
+    this._resetHistory();
+    return super.addData(records);
+  }
+  /** @param {unknown} id Existing record id. @param {KanbanRecord} record Replacement. @returns {this} */
+  updateRecord(id, record) {
+    this._resetHistory();
+    return super.updateRecord(id, record);
+  }
+  /** @param {unknown} id Record id. @returns {this} */
+  removeRecord(id) {
+    this._resetHistory();
+    return super.removeRecord(id);
+  }
   /** Returns common plus board-specific serializable configuration. @returns {KanbanViewState} */
   getViewState() {
+    this.getColumnOrder();
+    this.getSwimlaneOrder();
+    const derivedColumns = this._kanbanColumns === null;
+    const derivedSwimlanes = this._kanbanSwimlanes === null && this._kanbanOptions().swimlaneBy != null;
     return {
       ...super.getViewState(),
-      columnOrder: this.getColumnOrder(),
-      swimlaneOrder: this.getSwimlaneOrder(),
-      collapsedColumns: this.getCollapsedColumns(),
-      collapsedSwimlanes: this.getCollapsedSwimlanes()
+      columnOrder: derivedColumns ? [...this._kanbanColumnOrder] : this.getColumnOrder(),
+      swimlaneOrder: derivedSwimlanes ? [...this._kanbanSwimlaneOrder] : this.getSwimlaneOrder(),
+      collapsedColumns: derivedColumns ? [...this._collapsedColumns] : this.getCollapsedColumns(),
+      collapsedSwimlanes: derivedSwimlanes ? [...this._collapsedSwimlanes] : this.getCollapsedSwimlanes()
     };
   }
   /**
@@ -27687,21 +28281,29 @@ var KanbanView = class extends RecordView {
   setViewState(state, options = {}) {
     const source = state && typeof state === "object" ? state : {};
     super.setViewState(source, { silent: true });
-    this._kanbanColumnOrder = reconcileKanbanOrder(
-      this._rawColumns(),
-      Array.isArray(source.columnOrder) ? source.columnOrder : this._kanbanColumnOrder
-    );
-    this._kanbanSwimlaneOrder = reconcileKanbanOrder(
-      this._rawSwimlanes(),
-      Array.isArray(source.swimlaneOrder) ? source.swimlaneOrder : this._kanbanSwimlaneOrder
-    );
-    const columnIds = new Set(this._rawColumns().map((column) => column.id));
-    const laneIds = new Set(this._rawSwimlanes().map((lane) => lane.id));
+    const columns = this._rawColumns();
+    const lanes = this._rawSwimlanes();
+    const derivedColumns = this._kanbanColumns === null;
+    const derivedSwimlanes = this._kanbanSwimlanes === null && this._kanbanOptions().swimlaneBy != null;
+    this._kanbanColumnOrder = reconcileKanbanPreference(
+      columns,
+      Array.isArray(source.columnOrder) ? source.columnOrder : this._kanbanColumnOrder,
+      derivedColumns
+    );
+    this._kanbanSwimlaneOrder = reconcileKanbanPreference(
+      lanes,
+      Array.isArray(source.swimlaneOrder) ? source.swimlaneOrder : this._kanbanSwimlaneOrder,
+      derivedSwimlanes
+    );
+    const columnIds = new Set(columns.map((column) => column.id));
+    const laneIds = new Set(lanes.map((lane) => lane.id));
     if (Array.isArray(source.collapsedColumns)) {
-      this._collapsedColumns = new Set(source.collapsedColumns.map(String).filter((id) => columnIds.has(id)));
+      const collapsed = normalizeOrder(source.collapsedColumns);
+      this._collapsedColumns = new Set(derivedColumns ? collapsed : collapsed.filter((id) => columnIds.has(id)));
     }
     if (Array.isArray(source.collapsedSwimlanes)) {
-      this._collapsedSwimlanes = new Set(source.collapsedSwimlanes.map(String).filter((id) => laneIds.has(id)));
+      const collapsed = normalizeOrder(source.collapsedSwimlanes);
+      this._collapsedSwimlanes = new Set(derivedSwimlanes ? collapsed : collapsed.filter((id) => laneIds.has(id)));
     }
     this._refreshView("state");
     if (!options.silent) this._emitKanbanState("restore");
@@ -27711,6 +28313,11 @@ var KanbanView = class extends RecordView {
   destroy() {
     if (this._kanbanDestroyed) return;
     this._kanbanDestroyed = true;
+    this._clearDrag();
+    clearTimeout(this._pointerHold);
+    clearTimeout(this._searchTimer);
+    this._kanbanMenu?.destroy();
+    this._kanbanMenu = null;
     const root = this.el;
     const snapshot10 = this._kanbanSnapshot;
     super.destroy();
@@ -27725,25 +28332,61 @@ var KanbanView = class extends RecordView {
     }
     if (_reason === "loading") return;
     const options = this._kanbanOptions();
+    const activeElement = document.activeElement;
     const activeMeta = this._metaForTarget(document.activeElement);
     const restoreHandle = Boolean(document.activeElement?.classList?.contains("zx-kanban-view__move-handle"));
+    const activeCollapse = activeElement instanceof Element ? activeElement.closest("[data-kanban-collapse]") : null;
+    const activeSection = activeCollapse?.closest(".zx-kanban-view__column");
+    const activeCollapseFocus = activeCollapse && this._board.contains(activeCollapse) ? {
+      axis: (
+        /** @type {'column'|'swimlane'} */
+        /** @type {HTMLElement} */
+        activeCollapse.dataset.kanbanCollapse
+      ),
+      id: String(
+        /** @type {HTMLElement} */
+        activeCollapse.dataset.kanbanId
+      ),
+      lane: activeSection ? this._sectionMeta.get(activeSection)?.lane ?? null : null
+    } : null;
     const columns = this._resolvedColumns();
     const lanes = this._resolvedSwimlanes();
     this._cardMeta = /* @__PURE__ */ new WeakMap();
     this._sectionMeta = /* @__PURE__ */ new WeakMap();
     this._cardsById = /* @__PURE__ */ new Map();
+    this._resolveVisibility();
     const content = [];
     if (options.swimlaneBy == null) {
       content.push(this._renderColumns(columns, null, false));
     } else {
       lanes.forEach((lane) => content.push(this._renderLane(lane, columns)));
     }
-    const shownCards = this._cardsById.size;
-    if (shownCards === 0 && !this._viewData.length) content.push(this._emptyContent());
+    if (!this._viewData.length) content.push(this._emptyContent(this._text("empty")));
+    else if (!this._visibleIds.size) content.push(this._emptyContent(this._text("noMatches")));
     this._board.replaceChildren(...content);
-    if (this._keyboardMove && !this.getRecord(this._keyboardMove.id)) this._keyboardMove = null;
+    if (this._keyboardMove) {
+      this._keyboardMove.ids = this._keyboardMove.ids.filter((id) => this.getRecord(id));
+      if (!this._keyboardMove.ids.length) this._keyboardMove = null;
+    }
     this._syncKeyboardTarget();
-    if (activeMeta) queueMicrotask(() => {
+    if (activeCollapseFocus || activeMeta) queueMicrotask(() => {
+      if (activeCollapseFocus) {
+        this._collapseControl(
+          activeCollapseFocus.axis,
+          activeCollapseFocus.id,
+          activeCollapseFocus.lane
+        )?.focus();
+        return;
+      }
+      if (!activeMeta) return;
+      if (activeMeta.lane != null && this._collapsedSwimlanes.has(activeMeta.lane)) {
+        this._collapseControl("swimlane", activeMeta.lane)?.focus();
+        return;
+      }
+      if (this._collapsedColumns.has(activeMeta.column)) {
+        this._collapseControl("column", activeMeta.column, activeMeta.lane)?.focus();
+        return;
+      }
       const card = this._cardsById.get(activeMeta.id);
       const target = restoreHandle ? card?.querySelector(".zx-kanban-view__move-handle") : card;
       if (target?.isConnected) target.focus();
@@ -27755,21 +28398,36 @@ var KanbanView = class extends RecordView {
     const collapsed = this._collapsedSwimlanes.has(lane.id);
     const headingId = uid("zx-kanban-lane");
     const bodyId = uid("zx-kanban-lane-body");
-    const count2 = this._viewData.filter((record, index) => normalizeAxisId(this._readAxis(options.swimlaneBy, record, index)) === lane.id).length;
+    const entries = this._viewData.filter((record, index) => normalizeAxisId(this._readAxis(options.swimlaneBy, record, index)) === lane.id);
+    const total = entries.length;
+    const count2 = entries.filter((record) => this._visibleIds.has(this._viewRecordId(record))).length;
     const toggle = h("button", {
       class: "zx-kanban-view__collapse",
       type: "button",
       ariaExpanded: String(!collapsed),
       ariaControls: bodyId,
-      ariaLabel: `${collapsed ? "Expand" : "Collapse"} swim lane ${lane.label}`,
+      ariaLabel: this._text(collapsed ? "expandLane" : "collapseLane", { label: lane.label }),
       dataset: { kanbanCollapse: "swimlane", kanbanId: lane.id }
     }, icon(collapsed ? "chevron-right" : "chevron-down", { size: 13 }));
+    const limit = lane.limit ?? null;
+    const wip = wipState(total, limit);
+    const custom = this._renderHook("renderSwimlaneHeader", {
+      swimlane: { ...lane },
+      count: count2,
+      total,
+      columnTotal: total,
+      limit,
+      wip,
+      collapsed
+    });
     const heading = h(
       "h2",
       { class: "zx-kanban-view__lane-heading", id: headingId },
       toggle,
-      h("span", {}, lane.label),
-      options.showCounts ? h("span", { class: "zx-kanban-view__count", ariaLabel: `${count2} records` }, String(count2)) : null
+      custom ?? [
+        h("span", {}, lane.label),
+        options.showCounts || limit != null ? this._countIndicator(count2, total, limit) : null
+      ]
     );
     const body = this._renderColumns(columns, lane, true);
     body.id = bodyId;
@@ -27777,7 +28435,7 @@ var KanbanView = class extends RecordView {
     return h("section", {
       class: "zx-kanban-view__lane",
       ariaLabelledby: headingId,
-      dataset: { collapsed: String(collapsed) }
+      dataset: { collapsed: String(collapsed), wip }
     }, heading, body);
   }
   /** @param {KanbanColumn[]} columns @param {KanbanSwimlane|null} lane @param {boolean} hasLanes @returns {HTMLElement} */
@@ -27803,36 +28461,67 @@ var KanbanView = class extends RecordView {
     const collapsed = this._collapsedColumns.has(column.id);
     const headingId = uid("zx-kanban-column");
     const listId = uid("zx-kanban-column-list");
-    const columnCount = this._viewData.filter((record, index) => normalizeAxisId(this._readAxis(options.columnBy, record, index)) === column.id).length;
-    const wip = column.limit == null ? "none" : columnCount > column.limit ? "exceeded" : columnCount === column.limit ? "limit" : "within";
+    const columnEntries = this._viewData.filter((record, index) => normalizeAxisId(this._readAxis(options.columnBy, record, index)) === column.id);
+    const columnTotal = columnEntries.length;
+    const visible = entries.filter((entry) => this._visibleIds.has(this._viewRecordId(entry.record)));
+    const laneLimit = lane ? readColumnLaneLimit(column, lane.id) : null;
+    const limit = laneLimit ?? column.limit ?? null;
+    const wip = wipState(laneLimit == null ? columnTotal : entries.length, limit);
     const toggle = h("button", {
       class: "zx-kanban-view__collapse",
       type: "button",
       ariaExpanded: String(!collapsed),
       ariaControls: listId,
-      ariaLabel: `${collapsed ? "Expand" : "Collapse"} column ${column.label}`,
+      ariaLabel: this._text(collapsed ? "expandColumn" : "collapseColumn", { label: column.label }),
       dataset: { kanbanCollapse: "column", kanbanId: column.id }
     }, icon(collapsed ? "chevron-right" : "chevron-down", { size: 13 }));
-    const indicator = options.showCounts || column.limit != null ? h("span", {
-      class: "zx-kanban-view__count",
-      ariaLabel: column.limit == null ? `${entries.length} records` : hasLanes ? `${entries.length} records in this lane, ${columnCount} of work-in-progress limit ${column.limit} in the column` : `${columnCount} records, work-in-progress limit ${column.limit}`
-    }, column.limit == null ? String(entries.length) : hasLanes ? `${entries.length} \xB7 ${columnCount} / ${column.limit}` : `${columnCount} / ${column.limit}`) : null;
+    const custom = this._renderHook("renderColumnHeader", {
+      column: { ...column },
+      swimlane: lane ? { ...lane } : null,
+      count: visible.length,
+      total: entries.length,
+      columnTotal,
+      limit,
+      wip,
+      collapsed
+    });
+    const indicator = options.showCounts || limit != null ? this._columnIndicator(visible.length, entries.length, columnTotal, limit, hasLanes && laneLimit == null) : null;
     const heading = h(hasLanes ? "h3" : "h2", {
       class: "zx-kanban-view__column-heading",
       id: headingId
-    }, toggle, h("span", { class: "zx-kanban-view__column-label" }, column.label), indicator);
+    }, toggle, custom ?? [h("span", { class: "zx-kanban-view__column-label" }, column.label), indicator]);
     const list = h("ul", {
       class: "zx-kanban-view__cards",
       id: listId,
       ariaLabel: `${column.label}${lane ? `, ${lane.label}` : ""}`
     });
-    entries.forEach((entry) => list.append(this._renderCard(entry.record, entry.index, column.id, lane?.id ?? null, hasLanes)));
+    visible.forEach((entry) => list.append(this._renderCard(entry.record, entry.index, column.id, lane?.id ?? null, hasLanes)));
+    if (!visible.length) {
+      const placeholder = this._renderHook("renderColumnEmpty", {
+        column: { ...column },
+        swimlane: lane ? { ...lane } : null,
+        count: 0,
+        total: entries.length,
+        columnTotal,
+        limit,
+        wip,
+        collapsed
+      }) ?? this._placeholderText();
+      if (placeholder) list.append(h("li", { class: "zx-kanban-view__column-empty", role: "presentation" }, placeholder));
+    }
     list.hidden = collapsed;
+    const add = this._allowsAdd(column, lane) ? h("button", {
+      class: "zx-kanban-view__add",
+      type: "button",
+      ariaLabel: this._text("addTo", { target: `${column.label}${lane ? `, ${lane.label}` : ""}` }),
+      dataset: { kanbanAdd: column.id, kanbanLane: lane?.id ?? "" }
+    }, icon("plus", { size: 13 }), h("span", {}, this._text("add"))) : null;
+    if (add) add.hidden = collapsed;
     const section = h("section", {
       class: "zx-kanban-view__column",
       ariaLabelledby: headingId,
       dataset: { column: column.id, collapsed: String(collapsed), wip }
-    }, heading, list);
+    }, heading, list, add);
     this._sectionMeta.set(section, { column: column.id, lane: lane?.id ?? null, list });
     return section;
   }
@@ -27840,13 +28529,14 @@ var KanbanView = class extends RecordView {
   _renderCard(record, index, column, lane, hasLanes) {
     const options = this._kanbanOptions();
     const id = this._viewRecordId(record);
-    const grabbed = Boolean(this._keyboardMove && Object.is(this._keyboardMove.id, id));
+    const grabbed = Boolean(this._keyboardMove?.ids.some((candidate) => Object.is(candidate, id)));
+    const rules = resolveKanbanRules(this._kanbanRules, record, { index, column, lane });
+    const multiple = grabbed && this._keyboardMove ? this._keyboardMove.ids.length : 1;
     const handle = h("button", {
       class: "zx-kanban-view__move-handle",
       type: "button",
-      draggable: true,
       ariaPressed: String(grabbed),
-      ariaLabel: `Move ${this._recordName(record, index)}`
+      ariaLabel: multiple > 1 ? this._text("moveMultiple", { count: multiple }) : this._text("move", { name: this._recordName(record, index) })
     }, icon("drag", { size: 13 }));
     const card = createRecordCard(record, index, {
       fields: this.getFields(),
@@ -27865,15 +28555,81 @@ var KanbanView = class extends RecordView {
     });
     card.tabIndex = 0;
     if (grabbed) card.dataset.grabbed = "true";
+    this._applyCardContent(card, { record, id, index, column, lane, rules, selected: this._isViewSelected(id) });
+    this._applyCardRules(card, rules);
+    this._applyCardDescription(card, id);
     const meta = { record, id, index, column, lane };
     this._cardMeta.set(card, meta);
     this._cardsById.set(id, card);
     return card;
   }
-  /** @returns {HTMLElement} */
-  _emptyContent() {
+  /**
+   * Hands card content to `renderCard` while keeping the managed shell: the list item, its
+   * selection control, the action group, and the move handle are never given away, because they
+   * carry the drop, focus, and movement semantics the board is responsible for.
+   * @param {HTMLElement} card Card built from the shared anatomy.
+   * @param {KanbanCardContext} context Card context.
+   * @returns {void}
+   */
+  _applyCardContent(card, context) {
+    const custom = this._renderHook("renderCard", context);
+    if (!custom) return;
+    const body = card.querySelector(".zx-record-card__body");
+    const titles = card.querySelector(".zx-record-card__titles");
+    if (!body || !titles) return;
+    titles.replaceChildren(custom);
+    body.querySelector(".zx-record-card__eyebrow")?.remove();
+    body.querySelector(".zx-record-card__metadata")?.remove();
+    card.removeAttribute("aria-labelledby");
+    card.setAttribute("aria-label", this._recordName(context.record, context.index));
+    card.dataset.customCard = "true";
+  }
+  /**
+   * Applies ordered card rules. The first match owns the marker tone; every match with a label adds
+   * a badge, and rule descriptions join the accessible description so the marker is never the only
+   * carrier of the meaning.
+   * @param {HTMLElement} card Card element.
+   * @param {KanbanRule[]} rules Matching rules.
+   * @returns {void}
+   */
+  _applyCardRules(card, rules) {
+    if (!rules.length) return;
+    card.dataset.rule = rules.map((rule) => rule.id).join(" ");
+    card.dataset.ruleTone = rules[0].tone;
+    const badges = rules.filter((rule) => rule.label);
+    if (badges.length) {
+      const list = h("p", { class: "zx-kanban-view__rules" }, badges.map((rule) => badge({
+        label: rule.label,
+        icon: rule.icon ?? void 0,
+        kind: rule.tone,
+        size: "sm",
+        variant: "soft"
+      })));
+      card.querySelector(".zx-record-card__body")?.append(list);
+    }
+    const descriptions = rules.map((rule) => rule.description).filter(Boolean).join(". ");
+    if (descriptions) card.dataset.ruleDescription = descriptions;
+  }
+  /**
+   * Composes one card's accessible description from its selection state and its rules, so that
+   * refreshing selection cannot quietly drop what a rule contributed.
+   * @param {HTMLElement} card Card element.
+   * @param {unknown} id Record id.
+   * @returns {void}
+   */
+  _applyCardDescription(card, id) {
+    const parts = [];
+    if (this.options.selectable) {
+      parts.push(this._text(this._isViewSelected(id) ? "selected" : "notSelected"));
+    }
+    if (card.dataset.ruleDescription) parts.push(card.dataset.ruleDescription);
+    if (parts.length) card.setAttribute("aria-description", parts.join(". "));
+    else card.removeAttribute("aria-description");
+  }
+  /** @param {string} text Board-level empty message. @returns {HTMLElement} */
+  _emptyContent(text4) {
     const supplied = typeof this.options.emptyText === "function" ? this.options.emptyText() : this.options.emptyText;
-    const content = supplied ?? "No records";
+    const content = supplied ?? text4;
     return h(
       "div",
       { class: "zx-kanban-view__empty", role: "status" },
@@ -27883,6 +28639,37 @@ var KanbanView = class extends RecordView {
       ) : String(content)
     );
   }
+  /** @returns {string} Per-column placeholder text, or an empty string for none. */
+  _placeholderText() {
+    return this._text("columnEmpty");
+  }
+  /**
+   * @param {number} count Visible records.
+   * @param {number} total Records before search and filters.
+   * @param {number|null} limit Applicable limit.
+   * @returns {HTMLElement}
+   */
+  _countIndicator(count2, total, limit) {
+    const filtered = count2 !== total;
+    return h("span", {
+      class: "zx-kanban-view__count",
+      ariaLabel: limit != null ? this._text("countLimit", { count: total, limit }) : filtered ? this._text("countFiltered", { count: count2, total }) : this._text("count", { count: count2 })
+    }, limit != null ? `${total} / ${limit}` : filtered ? `${count2} / ${total}` : String(count2));
+  }
+  /**
+   * @param {number} count Visible records in this column and lane.
+   * @param {number} total Records in this column and lane before search and filters.
+   * @param {number} columnTotal Records across the whole column.
+   * @param {number|null} limit Applicable limit.
+   * @param {boolean} columnScoped Whether the limit counts the column rather than this lane.
+   * @returns {HTMLElement}
+   */
+  _columnIndicator(count2, total, columnTotal, limit, columnScoped) {
+    const filtered = count2 !== total;
+    const label = limit == null ? filtered ? this._text("countFiltered", { count: count2, total }) : this._text("count", { count: count2 }) : columnScoped ? this._text("countLimitInLane", { count: total, total: columnTotal, limit }) : this._text("countLimit", { count: total, limit });
+    const text4 = limit == null ? filtered ? `${count2} / ${total}` : String(count2) : columnScoped ? `${total} \xB7 ${columnTotal} / ${limit}` : `${total} / ${limit}`;
+    return h("span", { class: "zx-kanban-view__count", ariaLabel: label }, text4);
+  }
   /** @returns {KanbanColumn[]} */
   _rawColumns() {
     const options = this._kanbanOptions();
@@ -27891,7 +28678,11 @@ var KanbanView = class extends RecordView {
   /** @returns {KanbanColumn[]} */
   _resolvedColumns() {
     const columns = this._rawColumns();
-    this._kanbanColumnOrder = reconcileKanbanOrder(columns, this._kanbanColumnOrder);
+    this._kanbanColumnOrder = reconcileKanbanPreference(
+      columns,
+      this._kanbanColumnOrder,
+      this._kanbanColumns === null
+    );
     return orderDescriptors(columns, this._kanbanColumnOrder);
   }
   /** @returns {KanbanSwimlane[]} */
@@ -27903,7 +28694,12 @@ var KanbanView = class extends RecordView {
   /** @returns {KanbanSwimlane[]} */
   _resolvedSwimlanes() {
     const lanes = this._rawSwimlanes();
-    this._kanbanSwimlaneOrder = reconcileKanbanOrder(lanes, this._kanbanSwimlaneOrder);
+    const preserveUnknown = this._kanbanSwimlanes === null && this._kanbanOptions().swimlaneBy != null;
+    this._kanbanSwimlaneOrder = reconcileKanbanPreference(
+      lanes,
+      this._kanbanSwimlaneOrder,
+      preserveUnknown
+    );
     return orderDescriptors(lanes, this._kanbanSwimlaneOrder);
   }
   /** @param {KanbanAccessor} accessor @param {KanbanRecord} record @param {number} index @returns {unknown} */
@@ -27927,13 +28723,84 @@ var KanbanView = class extends RecordView {
   /** @param {unknown} id @returns {KanbanMovePoint|null} */
   _recordLocation(id) {
     const options = this._kanbanOptions();
-    const index = this._viewData.findIndex((record2) => Object.is(this._viewRecordId(record2), id));
+    const index = this._viewData.findIndex((record) => Object.is(this._viewRecordId(record), id));
     if (index < 0) return null;
-    const record = this._viewData[index];
-    const column = normalizeAxisId(this._readAxis(options.columnBy, record, index));
-    const lane = options.swimlaneBy == null ? null : normalizeAxisId(this._readAxis(options.swimlaneBy, record, index));
-    const within = this._recordsIn(column, lane).findIndex((entry) => Object.is(this._viewRecordId(entry.record), id));
-    return { column, lane, index: within };
+    return locateKanbanRecord(this._viewData, index, {
+      recordId: options.recordId,
+      columnBy: (record, recordIndex) => this._readAxis(options.columnBy, record, recordIndex),
+      swimlaneBy: options.swimlaneBy == null ? null : (record, recordIndex) => this._readAxis(options.swimlaneBy, record, recordIndex)
+    });
+  }
+  /**
+   * Recomputes which records survive the search and the filter predicate.
+   * @returns {void}
+   */
+  _resolveVisibility() {
+    const terms = kanbanSearchTerms(this._kanbanSearch);
+    const filter = this._kanbanFilter;
+    const sources = terms.length ? this._searchSources() : null;
+    this._visibleIds = /* @__PURE__ */ new Set();
+    this._viewData.forEach((record, index) => {
+      if (filter && filter(record, index) !== true) return;
+      if (sources && !matchesKanbanSearch(this._searchableText(record, index, sources), terms)) return;
+      this._visibleIds.add(this._viewRecordId(record));
+    });
+  }
+  /**
+   * Resolves what a search looks at, once. `searchFields` names them explicitly; otherwise the
+   * visible fields are searched, plus the title and subtitle sources — a card is findable by the
+   * name it shows even when that field is hidden from the metadata list.
+   * @returns {{fields:import('../view/record-view.js').ViewField[],readers:((record:KanbanRecord,index:number)=>unknown)[]}}
+   */
+  _searchSources() {
+    const options = this._kanbanOptions();
+    const configured = Array.isArray(options.searchFields) ? options.searchFields.map(String) : null;
+    const all = this.getFields();
+    if (configured) return { fields: all.filter((field) => configured.includes(field.id)), readers: [] };
+    const fields = this.getVisibleFields();
+    const known = new Set(fields.map((field) => field.id));
+    const readers = [];
+    for (const source of [options.titleField, options.subtitleField]) {
+      if (source == null) continue;
+      if (typeof source === "function") {
+        readers.push(source);
+        continue;
+      }
+      if (known.has(source)) continue;
+      const field = all.find((candidate) => candidate.id === source);
+      if (field) fields.push(field);
+      else readers.push((record) => record?.[source]);
+    }
+    return { fields, readers };
+  }
+  /**
+   * Builds the text one record is searched through. Field `render` output is deliberately ignored:
+   * it may be a DOM node, and matching what a formatter produced rather than what the record holds
+   * would make the same query behave differently in two views over the same data.
+   * @param {KanbanRecord} record Record.
+   * @param {number} index Display index.
+   * @param {{fields:import('../view/record-view.js').ViewField[],readers:((record:KanbanRecord,index:number)=>unknown)[]}} sources Resolved sources.
+   * @returns {string} Searchable text.
+   */
+  _searchableText(record, index, sources) {
+    const parts = sources.fields.map((field) => stringifyValue(readViewField(field, record, index)));
+    for (const reader of sources.readers) parts.push(stringifyValue(reader(record, index)));
+    return parts.filter(Boolean).join(" ");
+  }
+  /**
+   * Translates a position among rendered cards into a position among all records in one bucket.
+   * @param {string} column Column id.
+   * @param {string|null} lane Lane id.
+   * @param {number} visibleIndex Position among visible cards.
+   * @param {Set<unknown>} excluded Ids being moved, which the visible list already omits.
+   * @returns {number} Absolute position.
+   */
+  _absoluteIndex(column, lane, visibleIndex, excluded) {
+    const entries = this._recordsIn(column, lane).filter((entry) => !excluded.has(this._viewRecordId(entry.record)));
+    return absoluteKanbanIndex(
+      entries.map((entry) => this._visibleIds.has(this._viewRecordId(entry.record))),
+      visibleIndex
+    );
   }
   /**
    * @param {KanbanRecord} record @param {KanbanMovePoint} from @param {KanbanMovePoint} to
@@ -27955,8 +28822,327 @@ var KanbanView = class extends RecordView {
     if (options.swimlaneBy != null && normalizeAxisId(this._readAxis(options.swimlaneBy, clone, currentIndex)) !== to.lane) return null;
     return clone;
   }
+  /**
+   * Runs transition, eligibility, and capacity policy for a whole move. Every distinct origin is
+   * checked, so a multi-card move drawn from two columns cannot slip past a transition rule that
+   * only the second origin violates.
+   * @param {KanbanRecord[]} records Moving records.
+   * @param {KanbanMovePoint[]} origins Their origins.
+   * @param {KanbanColumn} column Destination column.
+   * @param {KanbanSwimlane|null} lane Destination lane.
+   * @param {KanbanMovePoint} to Destination point.
+   * @param {KanbanMoveContext} context Predicate context.
+   * @param {Set<unknown>} excluded Moving ids, excluded from destination counts.
+   * @returns {KanbanMoveEvaluation} Decision.
+   */
+  _evaluateMove(records, origins, column, lane, to, context, excluded) {
+    const options = this._kanbanOptions();
+    for (const origin of origins) {
+      const blocked = allowsKanbanTransition(column, lane, origin);
+      if (blocked) {
+        return {
+          allowed: false,
+          reason: blocked,
+          limit: null,
+          count: 0,
+          limitExceeded: false,
+          limitReached: false,
+          policy: column.wipPolicy ?? (options.wipPolicy === "block" ? "block" : "warn")
+        };
+      }
+    }
+    const excludes = (record) => !excluded.has(this._viewRecordId(record));
+    const columnCount = this._viewData.filter((record, index) => normalizeAxisId(this._readAxis(options.columnBy, record, index)) === to.column && excludes(record)).length;
+    const laneCount = options.swimlaneBy == null ? 0 : this._viewData.filter((record, index) => normalizeAxisId(this._readAxis(options.swimlaneBy, record, index)) === to.lane && excludes(record)).length;
+    const cellCount = this._recordsIn(to.column, to.lane).filter((entry) => excludes(entry.record)).length;
+    return evaluateKanbanMove({
+      records,
+      column,
+      swimlane: lane,
+      context,
+      from: origins[0],
+      columnCount,
+      laneCount,
+      cellCount,
+      policy: options.wipPolicy === "block" ? "block" : "warn"
+    });
+  }
+  /**
+   * Announces and reports a refused move. Nothing is written and no `recordmove` is emitted, so a
+   * listener can neither observe nor undo a move that never happened.
+   * @param {KanbanRejectReason} reason Refusal reason.
+   * @param {{ids:unknown[],records:KanbanRecord[],from:KanbanMovePoint|null,to:KanbanMovePoint|null,column:KanbanColumn|null,swimlane:KanbanSwimlane|null,evaluation?:KanbanMoveEvaluation}} detail Context.
+   * @returns {void}
+   * @fires KanbanView#movereject
+   */
+  _rejectMove(reason, detail) {
+    const target = detail.to ? this._targetName(detail.to) : "";
+    const name = this._movingName(detail.records);
+    const message = reason === "destination" ? this._text("rejectDestination") : reason === "grouping" ? this._text("rejectGrouping") : reason === "transition" || reason === "lane-transition" ? this._text("rejectTransition", { target, origin: detail.from ? this._targetName(detail.from) : "" }) : reason === "wip" || reason === "lane-wip" ? this._text("rejectWip", { target, limit: detail.evaluation?.limit ?? "" }) : this._text("rejectAccept", { target, name });
+    this._announce(message);
+    this.emit("movereject", {
+      reason,
+      ids: [...detail.ids],
+      records: [...detail.records],
+      record: detail.records[0] ?? null,
+      id: detail.ids[0],
+      from: detail.from ? { ...detail.from } : null,
+      to: detail.to ? { ...detail.to } : null,
+      column: detail.column ? { ...detail.column } : null,
+      swimlane: detail.swimlane ? { ...detail.swimlane } : null,
+      limit: detail.evaluation?.limit ?? null,
+      count: detail.evaluation?.count ?? 0,
+      message
+    });
+  }
+  /**
+   * Installs a committed local record order, remembering the previous one for undo.
+   * @param {KanbanRecord[]} records Next record order.
+   * @returns {void}
+   */
+  _commitLocalRecords(records) {
+    const options = this._kanbanOptions();
+    if (options.history !== false) {
+      this._kanbanHistory.push({ records: [...this._viewData], selection: this.getSelectionIds() });
+      this._syncHistoryControls();
+    }
+    this._viewData = records;
+    if (options.sortMode === "local" && this.getSort()) this.setSort(null);
+    else this._refreshView("move");
+    this.emit("datachange", { records: this.getData() });
+    if (options.history !== false) this._emitHistory();
+  }
+  /**
+   * @param {'undo'|'redo'} direction Travel direction.
+   * @returns {this}
+   */
+  _travelHistory(direction) {
+    if (this._kanbanOptions().history === false) return this;
+    const current = { records: [...this._viewData], selection: this.getSelectionIds() };
+    const entry = direction === "undo" ? this._kanbanHistory.undo(current) : this._kanbanHistory.redo(current);
+    if (!entry) {
+      this._announce(this._text(direction === "undo" ? "nothingToUndo" : "nothingToRedo"));
+      return this;
+    }
+    this._viewData = [...entry.records];
+    this._refreshView(direction);
+    this.setSelection(entry.selection);
+    this._syncHistoryControls();
+    this.emit("datachange", { records: this.getData() });
+    this._emitHistory();
+    this._announce(this._text(direction === "undo" ? "undone" : "redone"));
+    return this;
+  }
+  /** Drops both stacks without announcing, for host-driven data replacement. @returns {void} */
+  _resetHistory() {
+    if (!this._kanbanHistory) return;
+    const had = this._kanbanHistory.canUndo() || this._kanbanHistory.canRedo();
+    this._kanbanHistory.clear();
+    this._syncHistoryControls();
+    if (had) this._emitHistory();
+  }
+  /** @returns {void} */
+  _emitHistory() {
+    this.emit("historychange", {
+      canUndo: this.canUndo(),
+      canRedo: this.canRedo(),
+      depth: this._kanbanHistory.depth()
+    });
+  }
+  /** @returns {void} */
+  _syncHistoryControls() {
+    if (this._undoButton) this._undoButton.disabled = !this.canUndo();
+    if (this._redoButton) this._redoButton.disabled = !this.canRedo();
+  }
+  /** @returns {HTMLElement} Built-in search control. */
+  _createSearchControl() {
+    const input = (
+      /** @type {HTMLInputElement} */
+      h("input", {
+        class: "zx-kanban-view__search-input",
+        type: "search",
+        value: this._kanbanSearch,
+        ariaLabel: this._text("search"),
+        placeholder: this._text("searchPlaceholder")
+      })
+    );
+    this._searchInput = input;
+    this.listen(input, "input", () => {
+      clearTimeout(this._searchTimer);
+      this._searchTimer = setTimeout(() => {
+        this._searchTimer = 0;
+        if (!this._kanbanDestroyed) this.setSearch(input.value);
+      }, SEARCH_DEBOUNCE);
+    });
+    this.listen(input, "keydown", (event) => {
+      if (
+        /** @type {KeyboardEvent} */
+        event.key !== "Escape" || !input.value
+      ) return;
+      event.stopPropagation();
+      clearTimeout(this._searchTimer);
+      this._searchTimer = 0;
+      this.setSearch("");
+    });
+    return h("div", { class: "zx-kanban-view__search" }, icon("search", { size: 13 }), input);
+  }
+  /** @returns {HTMLElement} Built-in history controls. */
+  _createHistoryControls() {
+    this._undoButton = /** @type {HTMLButtonElement} */
+    h("button", {
+      class: "zx-button zx-button--sm",
+      type: "button",
+      disabled: true,
+      dataset: { kanbanHistory: "undo" }
+    }, this._text("undo"));
+    this._redoButton = /** @type {HTMLButtonElement} */
+    h("button", {
+      class: "zx-button zx-button--sm",
+      type: "button",
+      disabled: true,
+      dataset: { kanbanHistory: "redo" }
+    }, this._text("redo"));
+    const group = h(
+      "div",
+      { class: "zx-kanban-view__history", role: "group" },
+      this._undoButton,
+      this._redoButton
+    );
+    this.listen(group, "click", (event) => {
+      const control = (
+        /** @type {Element|null} */
+        event.target?.closest?.("[data-kanban-history]")
+      );
+      if (!control) return;
+      if (
+        /** @type {HTMLElement} */
+        control.dataset.kanbanHistory === "undo"
+      ) this.undo();
+      else this.redo();
+    });
+    return group;
+  }
+  /** Attaches the card context menu. @returns {void} */
+  _createContextMenu() {
+    this._kanbanMenu = new ContextMenu(this._board, {
+      selector: ".zx-record-card",
+      items: (context) => this._menuItems(context),
+      onselect: ({ detail }) => this._handleMenuSelect(detail)
+    });
+  }
+  /**
+   * Builds the menu for one card: every destination the same policy path would accept, plus any
+   * application items. Destinations the board would refuse are shown disabled rather than hidden,
+   * so a rule is discoverable instead of silently removing a command.
+   * @param {Element|null} context Card element the menu opened on.
+   * @returns {(MenuItem|'-')[]} Menu entries.
+   */
+  _menuItems(context) {
+    const meta = context ? this._cardMeta.get(context) : null;
+    if (!meta) return [];
+    const options = this._kanbanOptions();
+    const ids = this._movingIds(meta.id);
+    const items = [];
+    for (const column of this._resolvedColumns()) {
+      if (column.id === meta.column) continue;
+      items.push({
+        label: this._text("menuMoveTo", { target: column.label }),
+        value: { kind: "column", id: column.id, ids },
+        disabled: !this._canMove(ids, { column: column.id })
+      });
+    }
+    if (options.swimlaneBy != null) {
+      for (const lane of this._resolvedSwimlanes()) {
+        if (lane.id === meta.lane) continue;
+        items.push({
+          label: this._text("menuMoveToLane", { target: lane.label }),
+          value: { kind: "lane", id: lane.id, ids },
+          disabled: !this._canMove(ids, { lane: lane.id })
+        });
+      }
+    }
+    const extra = typeof options.contextMenu === "function" ? options.contextMenu({
+      record: meta.record,
+      id: meta.id,
+      index: meta.index,
+      column: meta.column,
+      lane: meta.lane,
+      rules: resolveKanbanRules(this._kanbanRules, meta.record, meta),
+      selected: this._isViewSelected(meta.id)
+    }) : Array.isArray(options.contextMenu) ? options.contextMenu : [];
+    if (Array.isArray(extra) && extra.length) items.push("-", ...extra);
+    return items;
+  }
+  /**
+   * @param {{value:unknown,item:MenuItem,context:Element|null}} detail Selection detail.
+   * @returns {void}
+   */
+  _handleMenuSelect(detail) {
+    const value = (
+      /** @type {{kind?:string,id?:string,ids?:unknown[]}|null} */
+      detail.value
+    );
+    if (!value || typeof value !== "object" || !value.kind || !Array.isArray(value.ids)) return;
+    this.moveRecords(value.ids, value.kind === "lane" ? { lane: value.id } : { column: value.id });
+  }
+  /**
+   * Dry-runs the policy path for a destination without emitting or committing anything.
+   * @param {unknown[]} ids Moving ids.
+   * @param {KanbanDestination} destination Destination.
+   * @returns {boolean} Whether the move would be allowed.
+   */
+  _canMove(ids, destination) {
+    const options = this._kanbanOptions();
+    const moving = this._orderedIds(ids);
+    if (!moving.length) return false;
+    const records = moving.map((id) => (
+      /** @type {KanbanRecord} */
+      this.getRecord(id)
+    ));
+    const origins = moving.map((id) => (
+      /** @type {KanbanMovePoint} */
+      this._recordLocation(id)
+    ));
+    const from = origins[0];
+    const columnId = destination.column == null ? from.column : String(destination.column);
+    const laneId = options.swimlaneBy == null ? null : destination.lane === void 0 ? from.lane : normalizeAxisId(destination.lane);
+    const column = this._resolvedColumns().find((candidate) => candidate.id === columnId);
+    const lane = options.swimlaneBy == null ? null : this._resolvedSwimlanes().find((candidate) => candidate.id === laneId) ?? null;
+    if (!column || options.swimlaneBy != null && !lane) return false;
+    const excluded = new Set(moving);
+    const to = { column: columnId, lane: laneId, index: 0 };
+    const context = {
+      id: moving[0],
+      from: { ...from },
+      to: { ...to },
+      column: { ...column },
+      swimlane: lane ? { ...lane } : null
+    };
+    return this._evaluateMove(records, origins, column, lane, to, context, excluded).allowed;
+  }
+  /**
+   * Resolves the ids one gesture moves: the whole selection when the grabbed card belongs to it,
+   * otherwise just that card. Picking up an unselected card never drags the selection along.
+   * @param {unknown} id Grabbed record id.
+   * @returns {unknown[]} Ids to move, in board order.
+   */
+  _movingIds(id) {
+    const options = this._kanbanOptions();
+    if (options.multiMove === false || options.selectable !== "multi" || !this._isViewSelected(id)) return [id];
+    const selection = this.getSelectionIds();
+    return selection.length > 1 ? selection : [id];
+  }
+  /** @param {unknown[]} ids Requested ids. @returns {unknown[]} Existing ids in board order. */
+  _orderedIds(ids) {
+    const requested = new Set(ids);
+    return this._viewData.map((record) => this._viewRecordId(record)).filter((id) => requested.has(id));
+  }
   /** @param {MouseEvent} event @returns {void} */
   _handleBoardClick(event) {
+    if (this._suppressClick) {
+      this._suppressClick = false;
+      return;
+    }
     const target = elementTarget(event);
     const collapse = target?.closest("[data-kanban-collapse]");
     if (collapse) {
@@ -27968,6 +29154,23 @@ var KanbanView = class extends RecordView {
       else this.toggleSwimlane(String(element.dataset.kanbanId));
       return;
     }
+    const add = target?.closest("[data-kanban-add]");
+    if (add) {
+      const element = (
+        /** @type {HTMLElement} */
+        add
+      );
+      const columnId = String(element.dataset.kanbanAdd);
+      const laneId = element.dataset.kanbanLane || null;
+      this.emit("recordadd", {
+        column: this._resolvedColumns().find((candidate) => candidate.id === columnId) ?? null,
+        swimlane: laneId == null ? null : this._resolvedSwimlanes().find((candidate) => candidate.id === laneId) ?? null,
+        columnId,
+        laneId,
+        event
+      });
+      return;
+    }
     const meta = this._metaForTarget(target);
     if (!meta) return;
     const selection = (
@@ -28016,7 +29219,14 @@ var KanbanView = class extends RecordView {
   }
   /** @param {KeyboardEvent} event @returns {void} */
   _handleBoardKeydown(event) {
+    if (this._dragIds.length && event.key === "Escape") {
+      event.preventDefault();
+      this._clearDrag();
+      this._announce(this._text("moveCanceledPlain"));
+      return;
+    }
     const target = elementTarget(event);
+    if (this._handleHistoryKeydown(event, target)) return;
     const handle = target?.closest(".zx-kanban-view__move-handle");
     const meta = this._metaForTarget(handle);
     if (handle && meta) {
@@ -28040,12 +29250,33 @@ var KanbanView = class extends RecordView {
       this.toggleSelection(cardMeta.id);
     }
   }
+  /**
+   * @param {KeyboardEvent} event Keyboard event.
+   * @param {Element|null} target Event target.
+   * @returns {boolean} Whether the event was handled as a history command.
+   */
+  _handleHistoryKeydown(event, target) {
+    if (this._kanbanOptions().history === false || !(event.ctrlKey || event.metaKey)) return false;
+    if (target?.closest('input, textarea, [contenteditable="true"]')) return false;
+    const key = event.key.toLowerCase();
+    if (key === "z" && !event.shiftKey && this.canUndo()) {
+      event.preventDefault();
+      this.undo();
+      return true;
+    }
+    if ((key === "y" || key === "z" && event.shiftKey) && this.canRedo()) {
+      event.preventDefault();
+      this.redo();
+      return true;
+    }
+    return false;
+  }
   /** @param {KeyboardEvent} event @param {HTMLElement} handle @param {KanbanCardMeta} meta @returns {void} */
   _handleMoveKeydown(event, handle, meta) {
     if (event.key === " " || event.key === "Enter") {
       event.preventDefault();
-      if (this._keyboardMove && Object.is(this._keyboardMove.id, meta.id)) {
-        const destination = { ...this._keyboardMove.to };
+      if (this._keyboardMove?.ids.some((candidate) => Object.is(candidate, meta.id))) {
+        const move2 = this._keyboardMove;
         this._keyboardMove = null;
         handle.setAttribute("aria-pressed", "false");
         const card = (
@@ -28054,22 +29285,24 @@ var KanbanView = class extends RecordView {
         );
         if (card) delete card.dataset.grabbed;
         this._syncKeyboardTarget();
-        this.moveRecord(meta.id, destination);
+        this._commitInteractionMove(move2.ids, move2.to);
       } else {
         const from = this._recordLocation(meta.id);
         if (!from) return;
-        this._keyboardMove = { id: meta.id, from: { ...from }, to: { ...from } };
+        const ids = this._movingIds(meta.id);
+        const start = { ...from, index: this._visibleIndex(meta.id) };
+        this._keyboardMove = { ids, from: { ...from }, to: start };
         handle.setAttribute("aria-pressed", "true");
         const card = handle.closest(".zx-record-card");
         if (card) card.dataset.grabbed = "true";
         this._syncKeyboardTarget();
-        this._announce(`Grabbed ${this._recordName(meta.record, meta.index)}. Use left and right for columns, up and down for position, and Alt plus up or down for swim lanes.`);
+        this._announce(ids.length > 1 ? this._text("grabbedMultiple", { count: ids.length }) : this._text("grabbed", { name: this._recordName(meta.record, meta.index) }));
       }
       return;
     }
     if (event.key === "Escape" && this._keyboardMove) {
       event.preventDefault();
-      const record = this.getRecord(this._keyboardMove.id);
+      const records = this._keyboardMove.ids.map((id) => this.getRecord(id)).filter(Boolean);
       this._keyboardMove = null;
       handle.setAttribute("aria-pressed", "false");
       const card = (
@@ -28078,10 +29311,13 @@ var KanbanView = class extends RecordView {
       );
       if (card) delete card.dataset.grabbed;
       this._syncKeyboardTarget();
-      this._announce(`Move canceled${record ? ` for ${this._recordName(record, meta.index)}` : ""}.`);
+      this._announce(records.length ? this._text("moveCanceled", { name: this._movingName(
+        /** @type {KanbanRecord[]} */
+        records
+      ) }) : this._text("moveCanceledPlain"));
       return;
     }
-    if (!this._keyboardMove || !Object.is(this._keyboardMove.id, meta.id) || !["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) return;
+    if (!this._keyboardMove || !this._keyboardMove.ids.some((candidate) => Object.is(candidate, meta.id)) || !["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) return;
     event.preventDefault();
     const move = this._keyboardMove;
     const laneModifier = event.altKey || event.ctrlKey || event.metaKey;
@@ -28098,10 +29334,14 @@ var KanbanView = class extends RecordView {
     } else if (event.key === "ArrowUp" || event.key === "ArrowDown") {
       move.to.index += event.key === "ArrowUp" ? -1 : 1;
     }
-    const targetCount = this._recordsIn(move.to.column, move.to.lane).filter((entry) => !Object.is(this._viewRecordId(entry.record), move.id)).length;
-    move.to.index = normalizeMoveIndex(move.to.index, targetCount);
+    const targetCount = this._visibleCount(move.to.column, move.to.lane, new Set(move.ids));
+    move.to.index = clampKanbanIndex(move.to.index, targetCount);
     this._syncKeyboardTarget();
-    this._announce(`Target ${this._targetName(move.to)}, position ${move.to.index + 1} of ${targetCount + 1}.`);
+    this._announce(this._text("target", {
+      target: this._targetName(move.to),
+      position: move.to.index + 1,
+      total: targetCount + 1
+    }));
   }
   /** @param {Event} event @returns {void} */
   _handlePreviewError(event) {
@@ -28117,80 +29357,246 @@ var KanbanView = class extends RecordView {
     if (preview) preview.dataset.failed = "true";
     image.hidden = true;
   }
-  /** @param {DragEvent} event @returns {void} */
-  _handleDragStart(event) {
-    const handle = elementTarget(event)?.closest(".zx-kanban-view__move-handle");
-    const meta = this._metaForTarget(handle);
-    if (!handle || !meta) {
-      event.preventDefault();
-      return;
+  /**
+   * Records a candidate drag. Nothing moves yet: a press that never travels stays a click, and a
+   * touch on the card body stays a scroll until the long press elapses.
+   * @param {PointerEvent} event Pointer event.
+   * @returns {void}
+   */
+  _handlePointerDown(event) {
+    this._suppressClick = false;
+    if (event.button != null && event.button !== 0) return;
+    const target = elementTarget(event);
+    const handle = target?.closest(".zx-kanban-view__move-handle");
+    const meta = this._metaForTarget(handle ?? target);
+    if (!meta) return;
+    if (!handle) {
+      if (this._kanbanOptions().dragFrom !== "card") return;
+      if (target?.closest(INTERACTIVE) || target?.closest(".zx-record-card__selection")) return;
+    }
+    const ids = this._movingIds(meta.id);
+    this._pointerStart = {
+      x: event.clientX,
+      y: event.clientY,
+      id: event.pointerId,
+      ids,
+      touch: event.pointerType === "touch"
+    };
+    this._dragPoint = { x: event.clientX, y: event.clientY };
+    clearTimeout(this._pointerHold);
+    if (event.pointerType !== "touch" || handle) return;
+    this._pointerHold = setTimeout(() => this._beginDrag(this._dragPoint.x, this._dragPoint.y), TOUCH_HOLD);
+  }
+  /** @param {PointerEvent} event @returns {void} */
+  _handlePointerMove(event) {
+    const start = this._pointerStart;
+    if (!this._dragIds.length) {
+      if (!start || event.pointerId !== start.id) return;
+      const distance = Math.hypot(event.clientX - start.x, event.clientY - start.y);
+      this._dragPoint = { x: event.clientX, y: event.clientY };
+      if (distance <= DRAG_THRESHOLD) return;
+      if (start.touch && this._pointerHold) {
+        clearTimeout(this._pointerHold);
+        this._pointerHold = 0;
+        this._pointerStart = null;
+        return;
+      }
+      this._beginDrag(event.clientX, event.clientY);
+      if (!this._dragIds.length) return;
     }
-    this._dragId = meta.id;
-    const card = handle.closest(".zx-record-card");
-    if (card) card.dataset.dragging = "true";
-    event.dataTransfer?.setData("text/plain", "zx-kanban-record");
-    if (event.dataTransfer) event.dataTransfer.effectAllowed = "move";
+    if (this._dragPointer != null && event.pointerId !== this._dragPointer) return;
+    event.preventDefault();
+    this._dragPoint = { x: event.clientX, y: event.clientY };
+    this._positionDragPreview();
+    this._updateDropTarget(event.clientX, event.clientY);
   }
-  /** @param {DragEvent} event @returns {void} */
-  _handleDragOver(event) {
-    if (this._dragId == null) return;
-    const section = elementTarget(event)?.closest(".zx-kanban-view__column");
-    const sectionMeta = section ? this._sectionMeta.get(section) : null;
-    if (!sectionMeta) return;
+  /** @param {PointerEvent} event @returns {void} */
+  _handlePointerUp(event) {
+    if (this._dragIds.length && this._dragPointer != null && event.pointerId !== this._dragPointer) return;
+    clearTimeout(this._pointerHold);
+    this._pointerHold = 0;
+    this._pointerStart = null;
+    if (!this._dragIds.length) return;
     event.preventDefault();
-    const destination = this._pointerDestination(event, sectionMeta);
-    this._dragDestination = destination;
+    const ids = [...this._dragIds];
+    const destination = this._dragDestination ? { ...this._dragDestination } : null;
+    this._clearDrag();
+    this._suppressClick = true;
+    if (destination) this._commitInteractionMove(ids, destination);
+  }
+  /**
+   * Starts a pointer drag: the floating preview appears, the board stops selecting text, and the
+   * auto-scroll loop begins.
+   * @param {number} x Pointer client x.
+   * @param {number} y Pointer client y.
+   * @returns {void}
+   */
+  _beginDrag(x, y) {
+    const start = this._pointerStart;
+    if (!start || this._dragIds.length) return;
+    this._pointerHold = 0;
+    this._dragIds = start.ids.filter((id) => this.getRecord(id));
+    if (!this._dragIds.length) return;
+    this._dragPoint = { x, y };
+    this._board.dataset.dragging = "true";
+    for (const id of this._dragIds) {
+      const card = this._cardsById.get(id);
+      if (card) card.dataset.dragging = "true";
+    }
+    this._dragPointer = start.id;
+    try {
+      this._board.setPointerCapture(start.id);
+      this._dragCaptured = true;
+    } catch {
+    }
+    globalThis.getSelection?.()?.removeAllRanges();
+    this._dragPreview = this._createDragPreview();
+    this.el.append(this._dragPreview);
+    this._positionDragPreview();
+    this._updateDropTarget(x, y);
+    if (this._kanbanOptions().autoScroll !== false) this._scheduleAutoScroll();
+  }
+  /** @returns {HTMLElement} Floating drag preview. */
+  _createDragPreview() {
+    const records = this._dragIds.map((id) => (
+      /** @type {KanbanRecord} */
+      this.getRecord(id)
+    ));
+    const custom = this._renderHook("renderDragPreview", {
+      records,
+      ids: [...this._dragIds],
+      count: this._dragIds.length
+    });
+    const content = custom ?? (this._dragIds.length > 1 ? this._text("dragPreview", { count: this._dragIds.length }) : this._movingName(records));
+    return h("div", {
+      class: "zx-kanban-view__drag-preview",
+      ariaHidden: "true",
+      dataset: { count: String(this._dragIds.length) }
+    }, content);
+  }
+  /** @returns {void} */
+  _positionDragPreview() {
+    if (!this._dragPreview) return;
+    this._dragPreview.style.transform = `translate3d(${Math.round(this._dragPoint.x)}px, ${Math.round(this._dragPoint.y)}px, 0)`;
+  }
+  /**
+   * Resolves and marks the drop destination under the pointer. Pointer capture retargets events to
+   * the board, so the element under the pointer is looked up rather than read off the event.
+   * @param {number} x Pointer client x.
+   * @param {number} y Pointer client y.
+   * @returns {void}
+   */
+  _updateDropTarget(x, y) {
+    const element = document.elementFromPoint(x, y);
+    const section = element?.closest(".zx-kanban-view__column");
+    const sectionMeta = section && this._board.contains(section) ? this._sectionMeta.get(section) : null;
     this._clearDropMarkers();
-    const card = elementTarget(event)?.closest(".zx-record-card");
-    const cardMeta = card ? this._cardMeta.get(card) : null;
-    if (card && cardMeta && !Object.is(cardMeta.id, this._dragId)) {
-      const rectangle = card.getBoundingClientRect();
-      card.dataset.drop = event.clientY >= rectangle.top + rectangle.height / 2 ? "after" : "before";
-    } else {
-      sectionMeta.list.dataset.drop = "append";
+    if (!sectionMeta || this._collapsedColumns.has(sectionMeta.column)) {
+      this._dragDestination = null;
+      return;
     }
-    if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+    const cards = this._draggableCards(sectionMeta.list);
+    const index = cards.findIndex((card) => {
+      const rectangle = card.getBoundingClientRect();
+      return y < rectangle.top + rectangle.height / 2;
+    });
+    const position2 = index < 0 ? cards.length : index;
+    if (cards[position2]) cards[position2].dataset.drop = "before";
+    else if (cards.length) cards[cards.length - 1].dataset.drop = "after";
+    else sectionMeta.list.dataset.drop = "append";
+    this._dragDestination = { column: sectionMeta.column, lane: sectionMeta.lane, index: position2 };
   }
-  /** @param {DragEvent} event @returns {void} */
-  _handleDrop(event) {
-    if (this._dragId == null || !this._dragDestination) return;
-    event.preventDefault();
-    const id = this._dragId;
-    const destination = { ...this._dragDestination };
-    this._clearDrag();
-    this.moveRecord(id, destination);
-  }
-  /** @param {DragEvent} event @param {KanbanSectionMeta} section @returns {KanbanMovePoint} */
-  _pointerDestination(event, section) {
-    const cards = [...section.list.querySelectorAll(":scope > .zx-record-card")].filter((card) => !Object.is(this._cardMeta.get(card)?.id, this._dragId));
-    const target = elementTarget(event)?.closest(".zx-record-card");
-    const targetMeta = target ? this._cardMeta.get(target) : null;
-    if (target && targetMeta && Object.is(targetMeta.id, this._dragId)) {
-      const from = this._recordLocation(this._dragId);
-      return { column: section.column, lane: section.lane, index: from?.index ?? cards.length };
-    }
-    const targetIndex = target ? cards.indexOf(target) : -1;
-    if (targetIndex < 0) return { column: section.column, lane: section.lane, index: cards.length };
-    const rectangle = target.getBoundingClientRect();
-    return {
-      column: section.column,
-      lane: section.lane,
-      index: targetIndex + (event.clientY >= rectangle.top + rectangle.height / 2 ? 1 : 0)
-    };
+  /** @returns {void} */
+  _scheduleAutoScroll() {
+    if (this._dragFrame) return;
+    this._dragFrame = requestAnimationFrame(() => {
+      this._dragFrame = 0;
+      if (!this._dragIds.length) return;
+      this._autoScroll();
+      this._scheduleAutoScroll();
+    });
+  }
+  /** Scrolls the board horizontally and the hovered column vertically near their edges. @returns {void} */
+  _autoScroll() {
+    const { x, y } = this._dragPoint;
+    const board = this._board.getBoundingClientRect();
+    if (x < board.left + SCROLL_EDGE) this._board.scrollLeft -= SCROLL_SPEED;
+    else if (x > board.right - SCROLL_EDGE) this._board.scrollLeft += SCROLL_SPEED;
+    const list = document.elementFromPoint(x, y)?.closest(".zx-kanban-view__cards");
+    if (!list || !this._board.contains(list) || list.scrollHeight <= list.clientHeight) return;
+    const bounds = list.getBoundingClientRect();
+    if (y < bounds.top + SCROLL_EDGE) list.scrollTop -= SCROLL_SPEED;
+    else if (y > bounds.bottom - SCROLL_EDGE) list.scrollTop += SCROLL_SPEED;
+  }
+  /**
+   * Commits a move whose index came from rendered cards. Search and filters hide records without
+   * removing them, so the visible position is translated back before anything is proposed.
+   * @param {unknown[]} ids Moving ids.
+   * @param {KanbanMovePoint} point Destination in visible-card space.
+   * @returns {void}
+   */
+  _commitInteractionMove(ids, point) {
+    const excluded = new Set(ids);
+    this.moveRecords(ids, {
+      column: point.column,
+      lane: point.lane,
+      index: this._absoluteIndex(point.column, point.lane, point.index, excluded)
+    });
   }
   /** @returns {void} */
   _clearDrag() {
-    this._clearDropMarkers();
-    for (const card of this._board.querySelectorAll("[data-dragging]")) delete /** @type {HTMLElement} */
-    card.dataset.dragging;
-    this._dragId = null;
+    if (this._dragFrame) cancelAnimationFrame(this._dragFrame);
+    this._dragFrame = 0;
+    clearTimeout(this._pointerHold);
+    this._pointerHold = 0;
+    this._pointerStart = null;
+    this._dragPreview?.remove();
+    this._dragPreview = null;
+    this._dragIds = [];
     this._dragDestination = null;
+    if (this._board) {
+      if (this._dragCaptured && this._dragPointer != null) {
+        try {
+          this._board.releasePointerCapture(this._dragPointer);
+        } catch {
+        }
+      }
+      this._clearDropMarkers();
+      delete this._board.dataset.dragging;
+      for (const card of this._board.querySelectorAll("[data-dragging]")) delete /** @type {HTMLElement} */
+      card.dataset.dragging;
+    }
+    this._dragPointer = null;
+    this._dragCaptured = false;
   }
   /** @returns {void} */
   _clearDropMarkers() {
     for (const element of this._board.querySelectorAll("[data-drop]")) delete /** @type {HTMLElement} */
     element.dataset.drop;
   }
+  /** @param {HTMLElement} list Card list. @returns {HTMLElement[]} Cards excluding the ones in flight. */
+  _draggableCards(list) {
+    const moving = new Set(this._dragIds.length ? this._dragIds : this._keyboardMove?.ids ?? []);
+    return (
+      /** @type {HTMLElement[]} */
+      [...list.querySelectorAll(":scope > .zx-record-card")].filter((card) => !hasId(moving, this._cardMeta.get(card)?.id))
+    );
+  }
+  /** @param {string} column @param {string|null} lane @param {Set<unknown>} excluded @returns {number} */
+  _visibleCount(column, lane, excluded) {
+    return this._recordsIn(column, lane).filter((entry) => {
+      const id = this._viewRecordId(entry.record);
+      return !hasId(excluded, id) && this._visibleIds.has(id);
+    }).length;
+  }
+  /** @param {unknown} id Record id. @returns {number} Position among visible cards in its bucket. */
+  _visibleIndex(id) {
+    const location = this._recordLocation(id);
+    if (!location) return 0;
+    const visible = this._recordsIn(location.column, location.lane).filter((entry) => this._visibleIds.has(this._viewRecordId(entry.record)));
+    const position2 = visible.findIndex((entry) => Object.is(this._viewRecordId(entry.record), id));
+    return position2 < 0 ? visible.length : position2;
+  }
   /** @returns {void} */
   _syncKeyboardTarget() {
     for (const element of this._board.querySelectorAll("[data-keyboard-target]")) {
@@ -28205,7 +29611,7 @@ var KanbanView = class extends RecordView {
     });
     const sectionMeta = section ? this._sectionMeta.get(section) : null;
     if (!sectionMeta) return;
-    const cards = [...sectionMeta.list.querySelectorAll(":scope > .zx-record-card")].filter((card) => !Object.is(this._cardMeta.get(card)?.id, move.id));
+    const cards = this._draggableCards(sectionMeta.list);
     const target = cards[move.to.index];
     if (target) target.dataset.keyboardTarget = "before";
     else sectionMeta.list.dataset.keyboardTarget = "append";
@@ -28215,7 +29621,7 @@ var KanbanView = class extends RecordView {
     for (const [id, card] of this._cardsById) {
       const selected = this._isViewSelected(id);
       card.dataset.selected = String(selected);
-      if (this.options.selectable) card.setAttribute("aria-selected", String(selected));
+      this._applyCardDescription(card, id);
       const input = (
         /** @type {HTMLInputElement|null} */
         card.querySelector("[data-record-selection]")
@@ -28235,6 +29641,50 @@ var KanbanView = class extends RecordView {
       this._cardsById.get(id)?.querySelector(".zx-kanban-view__move-handle") ?? null
     );
   }
+  /**
+   * Resolves a collapse control after a board refresh, retaining the same lane copy for columns.
+   * @param {'column'|'swimlane'} axis Collapse axis.
+   * @param {string} id Descriptor id.
+   * @param {string|null} [lane=null] Column copy's lane.
+   * @returns {HTMLElement|null}
+   */
+  _collapseControl(axis, id, lane = null) {
+    return (
+      /** @type {HTMLElement|null} */
+      [...this._board.querySelectorAll("[data-kanban-collapse]")].find((candidate) => {
+        const control = (
+          /** @type {HTMLElement} */
+          candidate
+        );
+        if (control.dataset.kanbanCollapse !== axis || control.dataset.kanbanId !== id) return false;
+        if (axis !== "column") return true;
+        const section = control.closest(".zx-kanban-view__column");
+        return section ? this._sectionMeta.get(section)?.lane === lane : false;
+      }) ?? null
+    );
+  }
+  /**
+   * Runs one presentation hook, ignoring anything that is not a node so a hook cannot smuggle
+   * markup in as a string.
+   * @param {'renderCard'|'renderColumnHeader'|'renderSwimlaneHeader'|'renderColumnEmpty'|'renderDragPreview'} name Hook name.
+   * @param {any} context Hook context.
+   * @returns {Node|null} Node to adopt, or null for the default presentation.
+   */
+  _renderHook(name, context) {
+    const hook = this._kanbanOptions()[name];
+    if (typeof hook !== "function") return null;
+    const result = hook(context);
+    return result && typeof result === "object" && "nodeType" in result ? (
+      /** @type {Node} */
+      result
+    ) : null;
+  }
+  /** @param {KanbanColumn} column @param {KanbanSwimlane|null} lane @returns {boolean} */
+  _allowsAdd(column, lane) {
+    const allow = this._kanbanOptions().allowAdd;
+    if (typeof allow === "function") return allow(column, lane) === true;
+    return allow === true;
+  }
   /** @param {KanbanRecord} record @param {number} index @returns {string} */
   _recordName(record, index) {
     const source = this._kanbanOptions().titleField;
@@ -28242,10 +29692,16 @@ var KanbanView = class extends RecordView {
     if (value && typeof value === "object" && "nodeType" in value) {
       return (
         /** @type {Node} */
-        value.textContent?.trim() || "record"
+        value.textContent?.trim() || this._text("record")
       );
     }
-    return String(value ?? "record");
+    return String(value ?? this._text("record"));
+  }
+  /** @param {KanbanRecord[]} records Moving records. @returns {string} */
+  _movingName(records) {
+    if (!records.length) return this._text("record");
+    if (records.length === 1) return this._recordName(records[0], this._viewData.indexOf(records[0]));
+    return this._text("dragPreview", { count: records.length });
   }
   /** @param {KanbanMovePoint} point @returns {string} */
   _targetName(point) {
@@ -28253,6 +29709,26 @@ var KanbanView = class extends RecordView {
     const lane = point.lane == null ? null : this._resolvedSwimlanes().find((candidate) => candidate.id === point.lane);
     return `${column?.label ?? point.column}${lane ? `, ${lane.label}` : ""}`;
   }
+  /** @param {KanbanMoveEvaluation} evaluation Capacity report. @returns {string} */
+  _wipAnnouncement(evaluation) {
+    if (evaluation.limit == null) return "";
+    if (evaluation.limitExceeded) return this._text("limitExceeded", { limit: evaluation.limit });
+    return evaluation.limitReached ? this._text("limitReached", { limit: evaluation.limit }) : "";
+  }
+  /**
+   * Resolves one localizable string.
+   * @param {keyof typeof DEFAULT_LABELS|string} key Label key.
+   * @param {Record<string, unknown>} [args] Placeholder values.
+   * @returns {string} Resolved text.
+   */
+  _text(key, args) {
+    const overrides = this._kanbanOptions().labels;
+    const source = overrides && typeof overrides === "object" && key in overrides ? overrides[key] : (
+      /** @type {Record<string,string>} */
+      DEFAULT_LABELS[key]
+    );
+    return printf(source == null ? String(key) : String(source), args);
+  }
   /** @param {string} message @returns {void} */
   _announce(message) {
     const token = ++this._announcementToken;
@@ -28292,6 +29768,9 @@ function normalizeKanbanDescriptors(descriptors, axis = "column") {
       if (source.accept != null && typeof source.accept !== "function") {
         throw new TypeError(`Kanban ${axis} ${id} accept must be a function`);
       }
+      if (source.from != null && !Array.isArray(source.from)) {
+        throw new TypeError(`Kanban ${axis} ${id} from must be an array or null`);
+      }
       seen.add(id);
       const normalized = (
         /** @type {Record<string, any>} */
@@ -28299,11 +29778,21 @@ function normalizeKanbanDescriptors(descriptors, axis = "column") {
           ...source,
           id,
           label: String(source.label ?? axisLabel(source.id)),
+          limit: normalizeLimit2(source.limit),
+          from: Array.isArray(source.from) ? source.from.map(String) : null,
           ...Object.prototype.hasOwnProperty.call(source, "value") ? {} : { value: source.id }
         }
       );
-      if (axis === "column") normalized.limit = normalizeLimit2(source.limit);
-      else delete normalized.limit;
+      if (axis === "column") {
+        const laneLimits = normalizeLaneLimits(source.laneLimits);
+        if (laneLimits) normalized.laneLimits = laneLimits;
+        if (source.wipPolicy === "block" || source.wipPolicy === "warn") {
+          normalized.wipPolicy = source.wipPolicy;
+        }
+      } else {
+        delete normalized.laneLimits;
+        delete normalized.wipPolicy;
+      }
       return normalized;
     })
   );
@@ -28326,37 +29815,11 @@ function reconcileKanbanOrder(descriptors, order) {
   const preferred = normalizeOrder(order).filter((id) => allowed.has(id));
   return [...new Set(preferred), ...available.filter((id) => !preferred.includes(id))];
 }
-function reorderKanbanData(records, id, movedRecord, options) {
-  if (!Array.isArray(records) || !movedRecord || typeof movedRecord !== "object") return null;
-  const sourceIndex = records.findIndex((record) => Object.is(viewRecordId(record, options.recordId), id));
-  if (sourceIndex < 0) return null;
-  const source = records[sourceIndex];
-  const sourceColumn = normalizeAxisId(readKanbanAccessor(source, sourceIndex, options.columnBy));
-  const sourceLane = options.swimlaneBy == null ? null : normalizeAxisId(readKanbanAccessor(source, sourceIndex, options.swimlaneBy));
-  const sourceGroup = records.filter((record, index) => normalizeAxisId(readKanbanAccessor(record, index, options.columnBy)) === sourceColumn && (options.swimlaneBy == null || normalizeAxisId(readKanbanAccessor(record, index, options.swimlaneBy)) === sourceLane));
-  const from = {
-    column: sourceColumn,
-    lane: sourceLane,
-    index: sourceGroup.findIndex((record) => Object.is(viewRecordId(record, options.recordId), id))
-  };
-  const next = records.filter((_, index) => index !== sourceIndex);
-  const destinationRecords = next.filter((record, index) => normalizeAxisId(readKanbanAccessor(record, index, options.columnBy)) === options.destination.column && (options.swimlaneBy == null || normalizeAxisId(readKanbanAccessor(record, index, options.swimlaneBy)) === options.destination.lane));
-  const targetIndex = normalizeMoveIndex(options.destination.index, destinationRecords.length);
-  let insertion = next.length;
-  if (destinationRecords[targetIndex]) insertion = next.indexOf(destinationRecords[targetIndex]);
-  else if (destinationRecords.length) insertion = next.indexOf(destinationRecords.at(-1)) + 1;
-  next.splice(insertion, 0, movedRecord);
-  return {
-    records: next,
-    from,
-    to: { column: options.destination.column, lane: options.swimlaneBy == null ? null : options.destination.lane, index: targetIndex }
-  };
-}
-function readKanbanAccessor(record, index, accessor) {
-  return typeof accessor === "function" ? accessor(record, index) : accessor == null ? null : record?.[accessor];
-}
-function normalizeAxisId(value) {
-  return value == null ? "" : String(value);
+function reconcileKanbanPreference(descriptors, order, preserveUnknown = false) {
+  if (!preserveUnknown) return reconcileKanbanOrder(descriptors, order);
+  const preferred = normalizeOrder(order);
+  const available = descriptors.map((descriptor) => descriptor.id);
+  return [...preferred, ...available.filter((id) => !preferred.includes(id))];
 }
 function axisLabel(value) {
   if (value == null || String(value).trim() === "") return "Unassigned";
@@ -28368,13 +29831,42 @@ function normalizeLimit2(value) {
   if (!Number.isFinite(number2) || number2 < 0) throw new TypeError("Kanban column limit must be a non-negative number");
   return Math.floor(number2);
 }
-function normalizeMoveIndex(value, maximum) {
-  if (value == null || !Number.isFinite(Number(value))) return maximum;
-  return Math.max(0, Math.min(maximum, Math.trunc(Number(value))));
+function normalizeLaneLimits(value) {
+  if (value == null) return void 0;
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError("Kanban column laneLimits must be an object");
+  }
+  const result = {};
+  for (const [lane, limit] of Object.entries(
+    /** @type {Record<string, unknown>} */
+    value
+  )) {
+    const normalized = normalizeLimit2(limit);
+    if (normalized != null) result[lane] = normalized;
+  }
+  return result;
+}
+function readColumnLaneLimit(column, lane) {
+  const limits = column.laneLimits;
+  if (!limits || typeof limits !== "object") return null;
+  const value = limits[lane];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function wipState(count2, limit) {
+  if (limit == null) return "none";
+  return count2 > limit ? "exceeded" : count2 === limit ? "limit" : "within";
 }
 function normalizeOrder(value) {
   return Array.isArray(value) ? [...new Set(value.map(String))] : [];
 }
+function stringifyValue(value) {
+  if (value == null) return "";
+  if (typeof value === "object") return "nodeType" in value ? String(
+    /** @type {Node} */
+    value.textContent ?? ""
+  ) : "";
+  return String(value);
+}
 function orderDescriptors(descriptors, order) {
   const byId = new Map(descriptors.map((descriptor) => [descriptor.id, descriptor]));
   return order.map((id) => byId.get(id)).filter(Boolean);
@@ -28388,12 +29880,28 @@ function moveOrderedId(order, id, targetId, position2) {
   next.splice(target + (position2 === "after" ? 1 : 0), 0, String(id));
   return next;
 }
+function mergeKanbanResolvedOrder(preference, descriptors, resolvedOrder, preserveUnknown) {
+  if (!preserveUnknown) return [...resolvedOrder];
+  const available = new Set(descriptors.map((descriptor) => descriptor.id));
+  const replacements = [...resolvedOrder];
+  let cursor = 0;
+  const merged = normalizeOrder(preference).flatMap((id) => {
+    if (!available.has(id)) return [id];
+    return cursor < replacements.length ? [replacements[cursor++]] : [];
+  });
+  merged.push(...replacements.slice(cursor));
+  return normalizeOrder(merged);
+}
 function sameMovePoint(left, right) {
   return left.column === right.column && left.lane === right.lane && left.index === right.index;
 }
 function sameArray3(left, right) {
   return left.length === right.length && left.every((value, index) => Object.is(value, right[index]));
 }
+function hasId(haystack, needle) {
+  for (const candidate of haystack) if (Object.is(candidate, needle)) return true;
+  return false;
+}
 function elementTarget(event) {
   const target = event.target;
   if (!target) return null;
@@ -32993,9 +34501,12 @@ export {
   TreeView,
   ValueList,
   __,
+  absoluteKanbanIndex,
   addCalendarDays,
+  addCalendarMonths,
   addDays,
   addMonths,
+  allowsKanbanTransition,
   appIcon,
   appendCompact,
   appendCompactChild,
@@ -33014,6 +34525,7 @@ export {
   calendarDayKey,
   calendarEventIntersects,
   calendarEventSpansDays,
+  calendarPageDate,
   calendarRange,
   chartSummaryTable,
   clamp,
@@ -33027,6 +34539,7 @@ export {
   configureIcons,
   copyButton,
   copyToClipboard,
+  createKanbanHistory,
   debounce,
   deepMerge,
   defaultDateRangePresets,
@@ -33036,6 +34549,7 @@ export {
   emptyFilterAst,
   emptyState,
   escapeRegExp,
+  evaluateKanbanMove,
   faFamilies,
   faIconClasses,
   faNames,
@@ -33070,15 +34584,19 @@ export {
   isSameDay,
   isTruncated,
   joinTime,
+  kanbanSearchTerms,
   kitUrl,
   layoutCalendarSpans,
   layoutTimedCalendarEvents,
   loadFontAwesome,
   loadFontAwesomeKit,
+  locateKanbanRecord,
   matchBreakpoint,
+  matchesKanbanSearch,
   moveViewField,
   normalizeAppItems,
   normalizeCalendarEvents,
+  normalizeKanbanRules,
   normalizeRange,
   normalizeViewFields,
   normalizeViewState,
@@ -33103,8 +34621,10 @@ export {
   registerFieldAdapters,
   registerIcons,
   renderViewField,
+  reorderKanbanRecords,
   reorderTableRows,
   resolveElement,
+  resolveKanbanRules,
   resolveSize,
   rovingTabindex,
   setLanguage,