@mosaicoo/kanban 0.1.0

package/fesm2022/mosaicoo-kanban-core.mjs

@@ -0,0 +1,1483 @@
+/**
+ * Versão do pacote em runtime.
+ *
+ * Mantida em sincronia com projects/kanban/package.json pelo processo de
+ * release (standard-version updater — mesmo mecanismo do @mosaicoo/svg-engine).
+ */
+const MKB_VERSION = '0.1.0';
+
+/**
+ * Modelo do board — TUDO aqui é serializável (JSON): é o que permite editar a
+ * configuração numa tela do host e persistir em banco (docs/01 §4). Código
+ * custom (regras, filtros programáticos) entra por NOME, via KanbanRegistry.
+ */
+
+/**
+ * Modelo DECLARATIVO de cartão — serializável (docs/01 §4). O cartão é uma
+ * LISTA ORDENADA de blocos tipados; qualquer tipo pode repetir à vontade, em
+ * qualquer posição (três `date`, dois `text`… tudo válido). Nenhum campo do
+ * item é especial — até o título é só um bloco `text` apontando um campo.
+ *
+ * Estilo NÃO mora aqui (docs: decisão de F5.5): posicionamento/altura/tema são
+ * CSS externo. Cada bloco carrega apenas `class` (combinação de classes do
+ * host) e recebe classes-base estáveis (`mkb-block`, `mkb-block-<tipo>`…) que
+ * são o CONTRATO de estilo. `tone` é a exceção — carrega SIGNIFICADO
+ * (a11y/semântica), não só aparência, e vira `mkb-tone-<tom>`.
+ */
+/** Todos os tipos de bloco conhecidos (usado pela validação). */
+const KANBAN_BLOCK_TYPES = [
+    'text',
+    'number',
+    'date',
+    'time',
+    'datetime',
+    'image',
+    'tag',
+    'badge',
+    'icon',
+    'avatar',
+    'facts',
+    'items',
+    'alert',
+    'progress',
+    'divider',
+    'actions',
+    'row',
+    'custom',
+];
+/** Blocos que leem um campo obrigatório do item. */
+const FIELD_BLOCKS = new Set([
+    'text',
+    'number',
+    'date',
+    'time',
+    'datetime',
+    'image',
+    'tag',
+    'badge',
+    'items',
+    'alert',
+    'progress',
+]);
+function isFieldBlock(type) {
+    return FIELD_BLOCKS.has(type);
+}
+
+/**
+ * Valida um BoardConfig vindo de fora (tela de configuração do host, banco,
+ * arquivo). Estrutural e barata — regras nomeadas NÃO são resolvidas aqui
+ * (o registry é runtime; a config só carrega nomes).
+ */
+function validateConfig(config) {
+    const errors = [];
+    const err = (path, message) => errors.push({ path, message });
+    if (typeof config !== 'object' || config === null || Array.isArray(config)) {
+        err('', 'config deve ser um objeto');
+        return { valid: false, errors };
+    }
+    const cfg = config;
+    validateAxis(cfg.columns, 'columns', true, err);
+    if (cfg.lanes !== undefined)
+        validateAxis(cfg.lanes, 'lanes', false, err);
+    if (cfg.items !== undefined) {
+        if (!Array.isArray(cfg.items)) {
+            err('items', 'deve ser um array');
+        }
+        else {
+            const seen = new Set();
+            cfg.items.forEach((item, i) => {
+                if (typeof item !== 'object' || item === null) {
+                    err(`items[${i}]`, 'deve ser um objeto');
+                    return;
+                }
+                const id = item.id;
+                if (typeof id !== 'string' || id === '') {
+                    err(`items[${i}].id`, 'obrigatório (string não vazia)');
+                }
+                else if (seen.has(id)) {
+                    err(`items[${i}].id`, `duplicado: '${id}'`);
+                }
+                else {
+                    seen.add(id);
+                }
+            });
+        }
+    }
+    if (cfg.sort !== undefined) {
+        if (typeof cfg.sort !== 'object' || cfg.sort === null) {
+            err('sort', 'deve ser um objeto { field, direction? }');
+        }
+        else {
+            if (typeof cfg.sort.field !== 'string' || cfg.sort.field === '') {
+                err('sort.field', 'obrigatório (string não vazia)');
+            }
+            const dir = cfg.sort.direction;
+            if (dir !== undefined && dir !== 'asc' && dir !== 'desc') {
+                err('sort.direction', "deve ser 'asc' ou 'desc'");
+            }
+        }
+    }
+    if (cfg.filters !== undefined && !Array.isArray(cfg.filters)) {
+        err('filters', 'deve ser um array');
+    }
+    if (cfg.rules !== undefined) {
+        if (typeof cfg.rules !== 'object' || cfg.rules === null) {
+            err('rules', 'deve ser um objeto');
+        }
+        else {
+            if (cfg.rules.transitions !== undefined && !Array.isArray(cfg.rules.transitions)) {
+                err('rules.transitions', 'deve ser um array');
+            }
+            if (cfg.rules.rules !== undefined) {
+                if (!Array.isArray(cfg.rules.rules)) {
+                    err('rules.rules', 'deve ser um array de nomes');
+                }
+                else {
+                    cfg.rules.rules.forEach((name, i) => {
+                        if (typeof name !== 'string' || name === '') {
+                            err(`rules.rules[${i}]`, 'deve ser um nome (string não vazia)');
+                        }
+                    });
+                }
+            }
+            if (cfg.rules.entryRules !== undefined) {
+                if (!Array.isArray(cfg.rules.entryRules)) {
+                    err('rules.entryRules', 'deve ser um array de nomes');
+                }
+                else {
+                    cfg.rules.entryRules.forEach((name, i) => {
+                        if (typeof name !== 'string' || name === '') {
+                            err(`rules.entryRules[${i}]`, 'deve ser um nome (string não vazia)');
+                        }
+                    });
+                }
+            }
+        }
+    }
+    if (cfg.card !== undefined) {
+        if (typeof cfg.card !== 'object' || cfg.card === null) {
+            err('card', 'deve ser um objeto { blocks }');
+        }
+        else {
+            if (cfg.card.dragHandle !== undefined &&
+                typeof cfg.card.dragHandle !== 'boolean') {
+                err('card.dragHandle', 'deve ser boolean');
+            }
+            if (!Array.isArray(cfg.card.blocks)) {
+                err('card.blocks', 'deve ser um array');
+            }
+            else {
+                cfg.card.blocks.forEach((block, i) => validateBlock(block, `card.blocks[${i}]`, err));
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+const KNOWN_BLOCK_TYPES = new Set(KANBAN_BLOCK_TYPES);
+function validateBlock(block, path, err) {
+    if (typeof block !== 'object' || block === null || Array.isArray(block)) {
+        err(path, 'deve ser um objeto de bloco');
+        return;
+    }
+    const b = block;
+    const type = b.type;
+    if (typeof type !== 'string' || !KNOWN_BLOCK_TYPES.has(type)) {
+        err(`${path}.type`, `tipo de bloco desconhecido: ${String(type)}`);
+        return;
+    }
+    if (isFieldBlock(type)) {
+        if (typeof b['field'] !== 'string' || b['field'] === '') {
+            err(`${path}.field`, `bloco '${type}' exige field (string não vazia)`);
+        }
+    }
+    if (b['class'] !== undefined) {
+        const cls = b['class'];
+        const ok = typeof cls === 'string' ||
+            (Array.isArray(cls) && cls.every((c) => typeof c === 'string'));
+        if (!ok)
+            err(`${path}.class`, 'deve ser string ou lista de strings');
+    }
+    switch (type) {
+        case 'facts': {
+            const items = b['items'];
+            if (!Array.isArray(items)) {
+                err(`${path}.items`, "bloco 'facts' exige items (array)");
+            }
+            else {
+                items.forEach((fact, i) => {
+                    if (typeof fact !== 'object' ||
+                        fact === null ||
+                        typeof fact.field !== 'string') {
+                        err(`${path}.items[${i}].field`, 'obrigatório (string)');
+                    }
+                });
+            }
+            break;
+        }
+        case 'actions': {
+            const items = b['items'];
+            if (!Array.isArray(items)) {
+                err(`${path}.items`, "bloco 'actions' exige items (array)");
+            }
+            else {
+                items.forEach((action, i) => {
+                    const a = action;
+                    if (typeof a?.id !== 'string' || a.id === '') {
+                        err(`${path}.items[${i}].id`, 'obrigatório (string não vazia)');
+                    }
+                    if (typeof a?.label !== 'string') {
+                        err(`${path}.items[${i}].label`, 'obrigatório (string)');
+                    }
+                });
+            }
+            break;
+        }
+        case 'icon':
+            if (typeof b['icon'] !== 'string' || b['icon'] === '') {
+                err(`${path}.icon`, "bloco 'icon' exige icon (string não vazia)");
+            }
+            break;
+        case 'custom':
+            if (typeof b['renderer'] !== 'string' || b['renderer'] === '') {
+                err(`${path}.renderer`, "bloco 'custom' exige renderer (nome do registry)");
+            }
+            break;
+        case 'row': {
+            const blocks = b['blocks'];
+            if (!Array.isArray(blocks)) {
+                err(`${path}.blocks`, "bloco 'row' exige blocks (array)");
+            }
+            else {
+                blocks.forEach((child, i) => validateBlock(child, `${path}.blocks[${i}]`, err));
+            }
+            break;
+        }
+    }
+}
+function validateAxis(axis, path, required, err) {
+    if (axis === undefined) {
+        if (required)
+            err(path, 'obrigatório');
+        return;
+    }
+    const groups = Array.isArray(axis)
+        ? axis
+        : typeof axis === 'object' && axis !== null
+            ? axis.groups
+            : undefined;
+    if (!Array.isArray(axis) && (typeof axis !== 'object' || axis === null)) {
+        err(path, 'deve ser um array de grupos ou um objeto de eixo');
+        return;
+    }
+    if (!Array.isArray(axis)) {
+        const cfg = axis;
+        if (cfg.field !== undefined && (typeof cfg.field !== 'string' || cfg.field === '')) {
+            err(`${path}.field`, 'deve ser uma string não vazia');
+        }
+        if (cfg.reorderable !== undefined && typeof cfg.reorderable !== 'boolean') {
+            err(`${path}.reorderable`, 'deve ser boolean');
+        }
+        if (cfg.sortGroups !== undefined &&
+            cfg.sortGroups !== 'asc' &&
+            cfg.sortGroups !== 'desc') {
+            err(`${path}.sortGroups`, "deve ser 'asc' ou 'desc'");
+        }
+        if (cfg.groups === undefined && cfg.field === undefined) {
+            err(path, 'eixo derivado precisa de field; eixo estático precisa de groups');
+        }
+        if (cfg.groups !== undefined && !Array.isArray(cfg.groups)) {
+            err(`${path}.groups`, 'deve ser um array');
+            return;
+        }
+    }
+    else if (axis.length === 0 && required) {
+        err(path, 'precisa de ao menos um grupo');
+    }
+    if (Array.isArray(groups)) {
+        const seen = new Set();
+        groups.forEach((g, i) => {
+            const id = typeof g === 'string' ? g : g?.id;
+            if (typeof id !== 'string' || id === '') {
+                err(`${path}[${i}].id`, 'obrigatório (string não vazia)');
+            }
+            else if (seen.has(id)) {
+                err(`${path}[${i}].id`, `duplicado: '${id}'`);
+            }
+            else {
+                seen.add(id);
+            }
+            if (typeof g === 'object' && g !== null) {
+                const limit = g.limit;
+                if (limit !== undefined && (typeof limit !== 'number' || limit < 0)) {
+                    err(`${path}[${i}].limit`, 'deve ser um número >= 0');
+                }
+            }
+        });
+    }
+}
+
+/**
+ * Registro nomeado de código custom (docs/01 §4): a config serializável
+ * referencia funções por NOME ('rule:berco-livre', 'filter:atrasados'…) e o
+ * host registra as implementações aqui, uma vez.
+ *
+ * É uma INSTÂNCIA (injetada em createBoard), nunca um singleton de módulo —
+ * higiene de instância (docs/01 §8).
+ */
+class KanbanRegistry {
+    entries = new Map();
+    register(name, value) {
+        if (!name)
+            throw new Error('KanbanRegistry: nome vazio');
+        this.entries.set(name, value);
+        return this;
+    }
+    get(name) {
+        return this.entries.get(name);
+    }
+    has(name) {
+        return this.entries.has(name);
+    }
+    names() {
+        return [...this.entries.keys()];
+    }
+}
+
+/** Motivos padronizados de recusa (regras nomeadas retornam texto livre). */
+const MOVE_REASONS = {
+    readOnly: 'read-only',
+    locked: 'locked',
+    transitionNotAllowed: 'transition-not-allowed',
+    wipLimit: 'wip-limit',
+    notFound: 'not-found',
+    unknownGroup: 'unknown-group',
+    forbidden: 'forbidden',
+    notReorderable: 'not-reorderable',
+    canceled: 'canceled',
+    destroyed: 'destroyed',
+};
+const sideMatches = (side, value) => side === undefined ||
+    (Array.isArray(side) ? side.includes(value) : side === value);
+/**
+ * Cadeia única de validação de movimento — usada tanto pelo preview
+ * (canMove) quanto pelo commit (moveItem): preview == commit por construção.
+ * Ordem: locked → transições → WIP → regras nomeadas.
+ */
+function evaluateMove(ev) {
+    const { ctx } = ev;
+    const columnChanged = ctx.from.column !== ctx.to.column;
+    const laneChanged = ctx.from.lane !== ctx.to.lane;
+    if (columnChanged && (ev.fromColumnGroup?.locked || ev.toColumnGroup?.locked)) {
+        return MOVE_REASONS.locked;
+    }
+    if (laneChanged && (ev.fromLaneGroup?.locked || ev.toLaneGroup?.locked)) {
+        return MOVE_REASONS.locked;
+    }
+    if (columnChanged && ev.transitions) {
+        const allowed = ev.transitions.some((t) => sideMatches(t.from, ctx.from.column) && sideMatches(t.to, ctx.to.column));
+        if (!allowed)
+            return MOVE_REASONS.transitionNotAllowed;
+    }
+    const colLimit = ev.toColumnGroup?.limit;
+    if (columnChanged && colLimit !== undefined && ev.targetColumnCount >= colLimit) {
+        return MOVE_REASONS.wipLimit;
+    }
+    const laneLimit = ev.toLaneGroup?.limit;
+    if (laneChanged && laneLimit !== undefined && ev.targetLaneCount >= laneLimit) {
+        return MOVE_REASONS.wipLimit;
+    }
+    for (const name of ev.ruleNames ?? []) {
+        const rule = ev.registry.get(name);
+        if (!rule)
+            return `regra não registrada: ${name}`;
+        const verdict = rule(ctx);
+        if (verdict !== true)
+            return verdict;
+    }
+    return true;
+}
+
+/**
+ * Helpers PUROS de entries (itens internos de card) — docs/02 §7.
+ * Uma entry vive num array serializável dentro de um campo do card:
+ * `card[field]: KanbanEntry[]`. Nada aqui toca estado.
+ */
+/** Lê as entries de um campo do card; valor ausente/malformado → []. */
+function entriesOf(card, field) {
+    const value = card[field];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((e) => typeof e === 'object' && e !== null && typeof e.id === 'string');
+}
+function findEntry(card, field, entryId) {
+    const list = entriesOf(card, field);
+    const index = list.findIndex((e) => e.id === entryId);
+    return index === -1 ? null : { entry: list[index], index };
+}
+/** Remove a entry da origem e insere no destino (imutável). Para movimento
+ * dentro da MESMA lista, `list` já vem sem a entry — `index` é a posição
+ * entre as REMANESCENTES (mesma semântica do moveItem/placeInCell). */
+function insertEntry(list, entry, index) {
+    const next = [...list];
+    const at = index === undefined ? next.length : Math.max(0, Math.min(index, next.length));
+    next.splice(at, 0, entry);
+    return next;
+}
+
+/** Emitter minimalista e tipado — o core não depende de RxJS de propósito
+ * (zero dependências; consumidores não-Angular não pagam nada). */
+class Emitter {
+    handlers = new Map();
+    on(event, handler) {
+        let set = this.handlers.get(event);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(event, set);
+        }
+        set.add(handler);
+        return () => set.delete(handler);
+    }
+    emit(event, payload) {
+        const set = this.handlers.get(event);
+        if (!set)
+            return;
+        // cópia: um handler pode (des)inscrever outros durante a emissão
+        for (const handler of [...set]) {
+            handler(payload);
+        }
+    }
+    clear() {
+        this.handlers.clear();
+    }
+}
+/** Cria o objeto de evento cancelável dos before:*. */
+function cancelable(data) {
+    let canceled = false;
+    let reason;
+    return {
+        data,
+        get canceled() {
+            return canceled;
+        },
+        get reason() {
+            return reason;
+        },
+        cancel(r) {
+            canceled = true;
+            reason = r ?? reason;
+        },
+    };
+}
+
+const toGroupDef = (g) => typeof g === 'string' ? { id: g } : { ...g };
+function normalizeAxis(input, defaultField) {
+    if (Array.isArray(input)) {
+        return {
+            field: defaultField,
+            isStatic: true,
+            groups: input.map(toGroupDef),
+            reorderable: false,
+        };
+    }
+    const groups = input.groups?.map(toGroupDef) ?? [];
+    return {
+        field: input.field ?? defaultField,
+        isStatic: groups.length > 0,
+        groups,
+        sortGroups: input.sortGroups,
+        reorderable: input.reorderable === true,
+    };
+}
+function normalizeConfig(config) {
+    return {
+        columns: normalizeAxis(config.columns, 'column'),
+        lanes: config.lanes ? normalizeAxis(config.lanes, 'lane') : null,
+    };
+}
+
+/** Congela o snapshot (raso + arrays); os itens são congelados na entrada. */
+function freezeState(state) {
+    Object.freeze(state.items);
+    Object.freeze(state.filters);
+    Object.freeze(state.selection);
+    Object.freeze(state.columnOrder);
+    Object.freeze(state.laneOrder);
+    return Object.freeze(state);
+}
+function freezeItem(item) {
+    return Object.freeze({ ...item });
+}
+/**
+ * Store imutável POR INSTÂNCIA de board (nada de estado de módulo — higiene
+ * de instância, docs/01 §8). Cada mudança produz um snapshot novo e congelado.
+ */
+class BoardStore {
+    current;
+    listeners = new Set();
+    constructor(initial) {
+        this.current = freezeState({
+            items: initial.items.map(freezeItem),
+            filters: [...initial.filters],
+            selection: [],
+            readOnly: initial.readOnly,
+            columnOrder: [...initial.columnOrder],
+            laneOrder: [...initial.laneOrder],
+        });
+    }
+    get state() {
+        return this.current;
+    }
+    /** Aplica um patch parcial e notifica os inscritos com o novo snapshot. */
+    set(patch) {
+        this.current = freezeState({ ...this.current, ...patch });
+        for (const listener of [...this.listeners])
+            listener(this.current);
+        return this.current;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}
+
+const DO = { record: true, cancelable: true, enforce: true };
+const REDO = { record: false, cancelable: false, enforce: true };
+const REMOTE = { record: false, cancelable: false, enforce: false };
+const MAX_HISTORY = 100;
+const str = (v) => v === undefined || v === null ? undefined : String(v);
+/**
+ * O board headless: estado imutável + comandos + regras + eventos + undo/redo.
+ * Instâncias são totalmente isoladas entre si (docs/01 §8) e nada aqui toca
+ * DOM, Angular ou persistência — a UI e os adapters consomem esta API.
+ */
+class KanbanBoard {
+    columnsAxis;
+    lanesAxis;
+    config;
+    store;
+    emitter = new Emitter();
+    host;
+    registry;
+    undoStack = [];
+    redoStack = [];
+    destroyed = false;
+    constructor(config, options = {}) {
+        this.config = config;
+        const normalized = normalizeConfig(config);
+        this.columnsAxis = normalized.columns;
+        this.lanesAxis = normalized.lanes;
+        this.registry = options.registry ?? new KanbanRegistry();
+        this.host = options.host ?? {};
+        this.store = new BoardStore({
+            items: config.items ?? [],
+            filters: config.filters ?? [],
+            readOnly: config.readOnly ?? false,
+            columnOrder: this.columnsAxis.isStatic
+                ? this.columnsAxis.groups.map((g) => g.id)
+                : [],
+            laneOrder: this.lanesAxis?.isStatic === true
+                ? this.lanesAxis.groups.map((g) => g.id)
+                : [],
+        });
+        this.store.subscribe((state) => this.emitter.emit('change', state));
+    }
+    // ---- Estado e eventos ----------------------------------------------------
+    get state() {
+        return this.store.state;
+    }
+    /** Modelo declarativo do cartão (docs/01 §4); undefined = cartão default. */
+    get cardConfig() {
+        return this.config.card;
+    }
+    /** Locale fornecido pelo host — usado por formatadores de data/número. */
+    get locale() {
+        return this.host.locale;
+    }
+    subscribe(listener) {
+        return this.store.subscribe(listener);
+    }
+    on(event, handler) {
+        return this.emitter.on(event, handler);
+    }
+    // ---- Comandos --------------------------------------------------------------
+    execute(command) {
+        if (this.destroyed)
+            return fail(MOVE_REASONS.destroyed);
+        switch (command.type) {
+            case 'moveItem':
+                return this.applyMove(command.itemId, command.to, DO);
+            case 'addItem':
+                return this.applyAdd(command.item, command.to, DO);
+            case 'updateItem':
+                return this.applyUpdate(command.itemId, command.changes, DO);
+            case 'removeItem':
+                return this.applyRemove(command.itemId, DO);
+            case 'moveGroup':
+                return this.applyMoveGroup(command.axis, command.groupId, command.index, DO);
+            case 'moveEntry':
+                return this.applyEntryMove(command, DO);
+            case 'addEntry':
+                return this.applyAddEntry(command, DO);
+            case 'updateEntry':
+                return this.applyUpdateEntry(command, DO);
+            case 'removeEntry':
+                return this.applyRemoveEntry(command, DO);
+            case 'setFilters':
+                this.store.set({ filters: Object.freeze([...command.filters]) });
+                return ok();
+            case 'setSelection': {
+                const valid = new Set(this.state.items.map((i) => i.id));
+                const selection = [...new Set(command.itemIds)].filter((id) => valid.has(id));
+                this.store.set({ selection });
+                return ok();
+            }
+            case 'setReadOnly':
+                this.store.set({ readOnly: command.readOnly });
+                return ok();
+        }
+    }
+    /**
+     * Aplica um comando de DADOS vindo de FORA (tempo real / rollback do
+     * adapter): não entra no histórico de undo, não dispara before:* e NÃO
+     * passa por readOnly/regras/permissões — o evento já aconteceu na origem
+     * (last-write-wins). A estrutura ainda é validada (item/grupo existem).
+     */
+    applyRemote(command) {
+        if (this.destroyed)
+            return fail(MOVE_REASONS.destroyed);
+        switch (command.type) {
+            case 'moveItem':
+                return this.applyMove(command.itemId, command.to, REMOTE);
+            case 'addItem':
+                return this.applyAdd(command.item, command.to, REMOTE);
+            case 'updateItem':
+                return this.applyUpdate(command.itemId, command.changes, REMOTE);
+            case 'removeItem':
+                return this.applyRemove(command.itemId, REMOTE);
+            case 'moveGroup':
+                return this.applyMoveGroup(command.axis, command.groupId, command.index, REMOTE);
+            case 'moveEntry':
+                return this.applyEntryMove(command, REMOTE);
+            case 'addEntry':
+                return this.applyAddEntry(command, REMOTE);
+            case 'updateEntry':
+                return this.applyUpdateEntry(command, REMOTE);
+            case 'removeEntry':
+                return this.applyRemoveEntry(command, REMOTE);
+            default:
+                return fail('unsupported-remote-command');
+        }
+    }
+    // ---- Undo / redo -----------------------------------------------------------
+    get canUndo() {
+        return this.undoStack.length > 0;
+    }
+    get canRedo() {
+        return this.redoStack.length > 0;
+    }
+    /** Desfaz o último comando de DADOS. Regras são revalidadas (o mundo pode
+     * ter mudado); before:* não dispara — undo não é vetável, mas é auditável
+     * pelos after:*. */
+    undo() {
+        if (this.destroyed)
+            return fail(MOVE_REASONS.destroyed);
+        const entry = this.undoStack.pop();
+        if (!entry)
+            return fail('nothing-to-undo');
+        const result = this.applyHistoryCmd(entry.undo);
+        if (result.ok)
+            this.redoStack.push(entry);
+        else
+            this.undoStack.push(entry);
+        return result;
+    }
+    redo() {
+        if (this.destroyed)
+            return fail(MOVE_REASONS.destroyed);
+        const entry = this.redoStack.pop();
+        if (!entry)
+            return fail('nothing-to-redo');
+        const result = this.applyHistoryCmd(entry.redo);
+        if (result.ok)
+            this.undoStack.push(entry);
+        else
+            this.redoStack.push(entry);
+        return result;
+    }
+    applyHistoryCmd(cmd) {
+        switch (cmd.type) {
+            case 'moveItem':
+                return this.applyMove(cmd.itemId, cmd.to, REDO);
+            case 'addItem':
+                return this.applyAdd(cmd.item, cmd.to, REDO);
+            case 'updateItem':
+                return this.applyUpdate(cmd.itemId, cmd.changes, REDO);
+            case 'removeItem':
+                return this.applyRemove(cmd.itemId, REDO);
+            case 'moveGroup':
+                return this.applyMoveGroup(cmd.axis, cmd.groupId, cmd.index, REDO);
+            case 'moveEntry':
+                return this.applyEntryMove(cmd, REDO);
+            case 'addEntry':
+                return this.applyAddEntry(cmd, REDO);
+            case 'updateEntry':
+                return this.applyUpdateEntry(cmd, REDO);
+            case 'removeEntry':
+                return this.applyRemoveEntry(cmd, REDO);
+            case 'insertItem': {
+                const items = [...this.state.items];
+                items.splice(Math.min(cmd.globalIndex, items.length), 0, freezeItem(cmd.item));
+                this.store.set({ items });
+                this.emitter.emit('after:add', { item: cmd.item });
+                return ok();
+            }
+            default:
+                return fail('unsupported-history-command');
+        }
+    }
+    // ---- Queries ---------------------------------------------------------------
+    /** Grupos resolvidos do eixo de colunas (estático ou derivado), com contagem. */
+    columns() {
+        return this.resolveGroups(this.columnsAxis);
+    }
+    /** Grupos do eixo de lanes; null quando o board não tem lanes. */
+    lanes() {
+        return this.lanesAxis ? this.resolveGroups(this.lanesAxis) : null;
+    }
+    /** Itens da célula (ordem manual ou `sort` da config). NÃO aplica filtros. */
+    itemsIn(columnId, laneId) {
+        const items = this.state.items.filter((item) => this.inCell(item, columnId, laneId));
+        return this.applySort(items);
+    }
+    /** Como itemsIn, mas só os itens visíveis pelos filtros ativos. */
+    visibleItemsIn(columnId, laneId) {
+        return this.itemsIn(columnId, laneId).filter((item) => this.isVisible(item));
+    }
+    isVisible(item) {
+        return this.state.filters.every((filter) => {
+            if ('equals' in filter)
+                return item[filter.field] === filter.equals;
+            if ('oneOf' in filter)
+                return filter.oneOf.includes(item[filter.field]);
+            if ('text' in filter) {
+                const needle = filter.text.toLowerCase();
+                const fields = filter.fields ?? Object.keys(item);
+                return fields.some((f) => String(item[f] ?? '')
+                    .toLowerCase()
+                    .includes(needle));
+            }
+            // filtro por predicado nomeado; nome não registrado NÃO filtra
+            const predicate = this.registry.get(filter.rule);
+            return predicate ? predicate(item) : true;
+        });
+    }
+    getItem(id) {
+        return this.state.items.find((item) => item.id === id);
+    }
+    find(predicate) {
+        return this.state.items.filter(predicate);
+    }
+    /**
+     * Dry-run do moveItem: roda EXATAMENTE a mesma cadeia de regras do commit
+     * (preview == commit). Não dispara eventos nem altera estado — é o que a UI
+     * usa para indicar drop válido/inválido durante o arrasto.
+     */
+    canMove(itemId, to) {
+        if (this.destroyed)
+            return fail(MOVE_REASONS.destroyed);
+        return this.validateMove(itemId, to).result;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.emitter.clear();
+        this.store.clear();
+        this.undoStack = [];
+        this.redoStack = [];
+    }
+    // ---- Movimento ---------------------------------------------------------------
+    validateMove(itemId, to, enforce = true) {
+        const item = this.getItem(itemId);
+        if (!item)
+            return { result: fail(MOVE_REASONS.notFound) };
+        if (enforce && this.state.readOnly)
+            return { result: fail(MOVE_REASONS.readOnly) };
+        if (enforce && this.host.can?.('move', item) === false) {
+            return { result: fail(MOVE_REASONS.forbidden) };
+        }
+        const from = this.cellOf(item);
+        const target = {
+            column: to.column ?? from.column,
+            lane: this.lanesAxis ? (to.lane ?? from.lane) : undefined,
+        };
+        if (!this.lanesAxis && to.lane !== undefined) {
+            return { result: fail(MOVE_REASONS.unknownGroup) };
+        }
+        if (target.column === undefined)
+            return { result: fail(MOVE_REASONS.unknownGroup) };
+        if (!this.groupExists(this.columnsAxis, target.column)) {
+            return { result: fail(MOVE_REASONS.unknownGroup) };
+        }
+        if (this.lanesAxis &&
+            target.lane !== undefined &&
+            !this.groupExists(this.lanesAxis, target.lane)) {
+            return { result: fail(MOVE_REASONS.unknownGroup) };
+        }
+        if (!enforce)
+            return { result: ok(), item, from, target };
+        const ctx = {
+            item,
+            from,
+            to: target,
+            targetCount: this.countInCell(target, item.id),
+            state: this.state,
+        };
+        const verdict = evaluateMove({
+            ctx,
+            fromColumnGroup: this.groupDef(this.columnsAxis, from.column),
+            toColumnGroup: this.groupDef(this.columnsAxis, target.column),
+            fromLaneGroup: this.lanesAxis ? this.groupDef(this.lanesAxis, from.lane) : undefined,
+            toLaneGroup: this.lanesAxis ? this.groupDef(this.lanesAxis, target.lane) : undefined,
+            targetColumnCount: this.countInColumn(target.column, item.id),
+            targetLaneCount: this.lanesAxis ? this.countInLane(target.lane, item.id) : 0,
+            transitions: this.config.rules?.transitions,
+            ruleNames: this.config.rules?.rules,
+            registry: this.registry,
+        });
+        if (verdict !== true)
+            return { result: fail(verdict) };
+        return { result: ok(), item, from, target };
+    }
+    /**
+     * Nota: mover grava o ID DO GRUPO (string) no campo do eixo — um campo
+     * numérico agrupado dinamicamente passa a string após um movimento.
+     */
+    applyMove(itemId, to, opts) {
+        const { result, item, from, target } = this.validateMove(itemId, to, opts.enforce);
+        if (!result.ok || !item || !from || !target)
+            return result;
+        const data = { item, from, to: target, index: to.index };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:move', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const fromIndex = this.indexInCell(item);
+        const moved = freezeItem({
+            ...item,
+            [this.columnsAxis.field]: target.column,
+            ...(this.lanesAxis ? { [this.lanesAxis.field]: target.lane } : {}),
+        });
+        const without = this.state.items.filter((i) => i.id !== item.id);
+        const items = this.placeInCell(without, moved, to.index);
+        // no-op (mesma célula, mesma posição): não emite nem entra no histórico
+        if (items.every((it, i) => it.id === this.state.items[i]?.id) && sameCell(from, target)) {
+            return ok();
+        }
+        this.store.set({ items });
+        if (opts.record) {
+            this.pushHistory({
+                undo: {
+                    type: 'moveItem',
+                    itemId,
+                    to: { column: from.column, lane: from.lane, index: fromIndex },
+                },
+                redo: { type: 'moveItem', itemId, to },
+            });
+        }
+        this.emitter.emit('after:move', { ...data, item: moved });
+        return ok();
+    }
+    // ---- Demais comandos de dados ---------------------------------------------
+    applyAdd(item, to, opts) {
+        if (opts.enforce && this.state.readOnly)
+            return fail(MOVE_REASONS.readOnly);
+        if (typeof item.id !== 'string' || item.id === '')
+            return fail('invalid-item');
+        if (this.getItem(item.id))
+            return fail('duplicate-id');
+        if (opts.enforce && this.host.can?.('add', item) === false) {
+            return fail(MOVE_REASONS.forbidden);
+        }
+        let candidate = { ...item };
+        if (to?.column !== undefined) {
+            candidate = { ...candidate, [this.columnsAxis.field]: to.column };
+        }
+        if (this.lanesAxis && to?.lane !== undefined) {
+            candidate = { ...candidate, [this.lanesAxis.field]: to.lane };
+        }
+        const cell = this.cellOf(candidate);
+        if (cell.column !== undefined) {
+            if (!this.groupExists(this.columnsAxis, cell.column)) {
+                return fail(MOVE_REASONS.unknownGroup);
+            }
+            const group = this.groupDef(this.columnsAxis, cell.column);
+            if (opts.enforce && group?.locked)
+                return fail(MOVE_REASONS.locked);
+            if (opts.enforce &&
+                group?.limit !== undefined &&
+                this.countInColumn(cell.column) >= group.limit) {
+                return fail(MOVE_REASONS.wipLimit);
+            }
+        }
+        const data = { item: candidate };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:add', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const frozen = freezeItem(candidate);
+        const items = cell.column === undefined
+            ? [...this.state.items, frozen]
+            : this.placeInCell([...this.state.items], frozen, to?.index);
+        this.store.set({ items });
+        if (opts.record) {
+            this.pushHistory({
+                undo: { type: 'removeItem', itemId: frozen.id },
+                redo: { type: 'addItem', item: frozen, to },
+            });
+        }
+        this.emitter.emit('after:add', { item: frozen });
+        return ok();
+    }
+    applyUpdate(itemId, changes, opts) {
+        if (opts.enforce && this.state.readOnly)
+            return fail(MOVE_REASONS.readOnly);
+        const item = this.getItem(itemId);
+        if (!item)
+            return fail(MOVE_REASONS.notFound);
+        if ('id' in changes && changes['id'] !== itemId)
+            return fail('immutable-id');
+        if (opts.enforce && this.host.can?.('update', item) === false) {
+            return fail(MOVE_REASONS.forbidden);
+        }
+        const next = { ...item, ...changes };
+        const from = this.cellOf(item);
+        const target = this.cellOf(next);
+        // mudança de campo de eixo é um MOVIMENTO lógico: passa pelas regras
+        if (!sameCell(from, target)) {
+            const verdict = this.validateMove(itemId, { column: target.column, lane: target.lane }, opts.enforce).result;
+            if (!verdict.ok)
+                return verdict;
+        }
+        const data = { item: next, previous: item, changes };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:update', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const frozen = freezeItem(next);
+        let items = this.state.items.map((i) => (i.id === itemId ? frozen : i));
+        if (!sameCell(from, target)) {
+            items = this.placeInCell(items.filter((i) => i.id !== itemId), frozen, undefined);
+        }
+        this.store.set({ items });
+        if (opts.record) {
+            const previousValues = {};
+            for (const key of Object.keys(changes))
+                previousValues[key] = item[key];
+            this.pushHistory({
+                undo: { type: 'updateItem', itemId, changes: previousValues },
+                redo: { type: 'updateItem', itemId, changes },
+            });
+        }
+        this.emitter.emit('after:update', data);
+        return ok();
+    }
+    applyRemove(itemId, opts) {
+        if (opts.enforce && this.state.readOnly)
+            return fail(MOVE_REASONS.readOnly);
+        const item = this.getItem(itemId);
+        if (!item)
+            return fail(MOVE_REASONS.notFound);
+        if (opts.enforce && this.host.can?.('remove', item) === false) {
+            return fail(MOVE_REASONS.forbidden);
+        }
+        const data = { item };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:remove', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const globalIndex = this.state.items.findIndex((i) => i.id === itemId);
+        const items = this.state.items.filter((i) => i.id !== itemId);
+        const selection = this.state.selection.filter((id) => id !== itemId);
+        this.store.set({ items, selection });
+        if (opts.record) {
+            this.pushHistory({
+                undo: { type: 'insertItem', item, globalIndex },
+                redo: { type: 'removeItem', itemId },
+            });
+        }
+        this.emitter.emit('after:remove', data);
+        return ok();
+    }
+    // ---- Reordenação de grupos (colunas/lanes) --------------------------------
+    /** O eixo é reordenável? (estático, opt-in `reorderable`, sem sortGroups). */
+    isReorderable(axis) {
+        const norm = axis === 'columns' ? this.columnsAxis : this.lanesAxis;
+        return (!!norm && norm.isStatic && norm.reorderable && norm.sortGroups === undefined);
+    }
+    /** Dry-run do moveGroup — mesma cadeia do commit (preview == commit). */
+    canMoveGroup(axis, groupId, index) {
+        if (this.destroyed)
+            return fail(MOVE_REASONS.destroyed);
+        return this.validateMoveGroup(axis, groupId, index, true).result;
+    }
+    validateMoveGroup(axis, groupId, _index, enforce) {
+        const norm = axis === 'columns' ? this.columnsAxis : this.lanesAxis;
+        if (!norm)
+            return { result: fail(MOVE_REASONS.unknownGroup) };
+        if (enforce && this.state.readOnly)
+            return { result: fail(MOVE_REASONS.readOnly) };
+        if (enforce && !this.isReorderable(axis)) {
+            return { result: fail(MOVE_REASONS.notReorderable) };
+        }
+        const order = [
+            ...(axis === 'columns' ? this.state.columnOrder : this.state.laneOrder),
+        ];
+        const from = order.indexOf(groupId);
+        if (from === -1)
+            return { result: fail(MOVE_REASONS.unknownGroup) };
+        return { result: ok(), order, from };
+    }
+    applyMoveGroup(axis, groupId, index, opts) {
+        const { result, order, from } = this.validateMoveGroup(axis, groupId, index, opts.enforce);
+        if (!result.ok || !order || from === undefined)
+            return result;
+        const to = Math.max(0, Math.min(index, order.length - 1));
+        if (to === from)
+            return ok(); // no-op
+        order.splice(from, 1);
+        order.splice(to, 0, groupId);
+        const data = { axis, groupId, from, to, order };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:group-move', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        this.store.set(axis === 'columns' ? { columnOrder: order } : { laneOrder: order });
+        if (opts.record) {
+            this.pushHistory({
+                undo: { type: 'moveGroup', axis, groupId, index: from },
+                redo: { type: 'moveGroup', axis, groupId, index: to },
+            });
+        }
+        this.emitter.emit('after:group-move', data);
+        return ok();
+    }
+    // ---- Entries (itens internos de card) — docs/02 §7 -------------------------
+    /** Entries de um campo do card ([] quando ausente/malformado). */
+    entries(cardId, field) {
+        const card = this.getItem(cardId);
+        return card ? entriesOf(card, field) : [];
+    }
+    /** Dry-run do moveEntry — mesma cadeia do commit (preview == commit). */
+    canMoveEntry(cmd) {
+        if (this.destroyed)
+            return fail(MOVE_REASONS.destroyed);
+        return this.validateEntryMove(cmd, true).result;
+    }
+    validateEntryMove(cmd, enforce) {
+        const fromCard = this.getItem(cmd.cardId);
+        if (!fromCard)
+            return { result: fail(MOVE_REASONS.notFound) };
+        const found = findEntry(fromCard, cmd.field, cmd.entryId);
+        if (!found)
+            return { result: fail('entry-not-found') };
+        const toCard = this.getItem(cmd.toCardId ?? cmd.cardId);
+        if (!toCard)
+            return { result: fail(MOVE_REASONS.notFound) };
+        const toField = cmd.toField ?? cmd.field;
+        if (enforce && this.state.readOnly)
+            return { result: fail(MOVE_REASONS.readOnly) };
+        if (enforce &&
+            (this.host.can?.('entry-move', fromCard) === false ||
+                this.host.can?.('entry-move', toCard) === false)) {
+            return { result: fail(MOVE_REASONS.forbidden) };
+        }
+        const crossList = toCard.id !== fromCard.id || toField !== cmd.field;
+        if (crossList && findEntry(toCard, toField, cmd.entryId)) {
+            return { result: fail('duplicate-entry') };
+        }
+        const targetList = crossList
+            ? entriesOf(toCard, toField)
+            : entriesOf(fromCard, cmd.field).filter((e) => e.id !== cmd.entryId);
+        const to = {
+            cardId: toCard.id,
+            field: toField,
+            index: Math.max(0, Math.min(cmd.index, targetList.length)),
+        };
+        const from = { cardId: fromCard.id, field: cmd.field, index: found.index };
+        if (enforce) {
+            const ctx = {
+                entry: found.entry,
+                fromCard,
+                toCard,
+                from,
+                to,
+                targetCount: targetList.length,
+                state: this.state,
+            };
+            for (const name of this.config.rules?.entryRules ?? []) {
+                const rule = this.registry.get(name);
+                if (!rule)
+                    return { result: fail(`regra não registrada: ${name}`) };
+                const verdict = rule(ctx);
+                if (verdict !== true)
+                    return { result: fail(verdict) };
+            }
+        }
+        return { result: ok(), entry: found.entry, fromCard, toCard, from, to };
+    }
+    applyEntryMove(cmd, opts) {
+        const { result, entry, fromCard, toCard, from, to } = this.validateEntryMove(cmd, opts.enforce);
+        if (!result.ok || !entry || !fromCard || !toCard || !from || !to)
+            return result;
+        const sameList = from.cardId === to.cardId && from.field === to.field;
+        if (sameList && from.index === to.index)
+            return ok(); // no-op
+        const data = { entry, from, to };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:entry-move', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const sourceWithout = entriesOf(fromCard, from.field).filter((e) => e.id !== entry.id);
+        const patches = new Map();
+        if (sameList) {
+            patches.set(fromCard.id, { [from.field]: insertEntry(sourceWithout, entry, to.index) });
+        }
+        else {
+            const inserted = insertEntry(entriesOf(toCard, to.field), entry, to.index);
+            if (fromCard.id === toCard.id) {
+                // mesmo card, campos diferentes: um patch com os dois campos
+                patches.set(fromCard.id, { [from.field]: sourceWithout, [to.field]: inserted });
+            }
+            else {
+                patches.set(fromCard.id, { [from.field]: sourceWithout });
+                patches.set(toCard.id, { [to.field]: inserted });
+            }
+        }
+        this.patchCards(patches);
+        if (opts.record) {
+            this.pushHistory({
+                undo: {
+                    type: 'moveEntry',
+                    cardId: to.cardId,
+                    field: to.field,
+                    entryId: entry.id,
+                    index: from.index,
+                    toCardId: from.cardId,
+                    toField: from.field,
+                },
+                redo: { type: 'moveEntry', ...cmd },
+            });
+        }
+        this.emitter.emit('after:entry-move', data);
+        return ok();
+    }
+    applyAddEntry(cmd, opts) {
+        const guard = this.entryWriteGuard(cmd.cardId, opts);
+        if (!guard.ok)
+            return guard.result;
+        const card = guard.card;
+        if (typeof cmd.entry.id !== 'string' || cmd.entry.id === '')
+            return fail('invalid-entry');
+        if (findEntry(card, cmd.field, cmd.entry.id))
+            return fail('duplicate-entry');
+        const data = {
+            op: 'add',
+            cardId: card.id,
+            field: cmd.field,
+            entry: cmd.entry,
+        };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:entry-update', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const list = insertEntry(entriesOf(card, cmd.field), cmd.entry, cmd.index);
+        this.patchCards(new Map([[card.id, { [cmd.field]: list }]]));
+        if (opts.record) {
+            this.pushHistory({
+                undo: { type: 'removeEntry', cardId: card.id, field: cmd.field, entryId: cmd.entry.id },
+                redo: { type: 'addEntry', ...cmd },
+            });
+        }
+        this.emitter.emit('after:entry-update', data);
+        return ok();
+    }
+    applyUpdateEntry(cmd, opts) {
+        const guard = this.entryWriteGuard(cmd.cardId, opts);
+        if (!guard.ok)
+            return guard.result;
+        const card = guard.card;
+        const found = findEntry(card, cmd.field, cmd.entryId);
+        if (!found)
+            return fail('entry-not-found');
+        if ('id' in cmd.changes && cmd.changes['id'] !== cmd.entryId)
+            return fail('immutable-id');
+        const next = { ...found.entry, ...cmd.changes };
+        const data = {
+            op: 'update',
+            cardId: card.id,
+            field: cmd.field,
+            entry: next,
+            previous: found.entry,
+            changes: cmd.changes,
+        };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:entry-update', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const list = entriesOf(card, cmd.field).map((e) => (e.id === cmd.entryId ? next : e));
+        this.patchCards(new Map([[card.id, { [cmd.field]: list }]]));
+        if (opts.record) {
+            const previousValues = {};
+            for (const key of Object.keys(cmd.changes))
+                previousValues[key] = found.entry[key];
+            this.pushHistory({
+                undo: {
+                    type: 'updateEntry',
+                    cardId: card.id,
+                    field: cmd.field,
+                    entryId: cmd.entryId,
+                    changes: previousValues,
+                },
+                redo: { type: 'updateEntry', ...cmd },
+            });
+        }
+        this.emitter.emit('after:entry-update', data);
+        return ok();
+    }
+    applyRemoveEntry(cmd, opts) {
+        const guard = this.entryWriteGuard(cmd.cardId, opts);
+        if (!guard.ok)
+            return guard.result;
+        const card = guard.card;
+        const found = findEntry(card, cmd.field, cmd.entryId);
+        if (!found)
+            return fail('entry-not-found');
+        const data = {
+            op: 'remove',
+            cardId: card.id,
+            field: cmd.field,
+            entry: found.entry,
+        };
+        if (opts.cancelable) {
+            const ev = cancelable(data);
+            this.emitter.emit('before:entry-update', ev);
+            if (ev.canceled)
+                return fail(ev.reason ?? MOVE_REASONS.canceled);
+        }
+        const list = entriesOf(card, cmd.field).filter((e) => e.id !== cmd.entryId);
+        this.patchCards(new Map([[card.id, { [cmd.field]: list }]]));
+        if (opts.record) {
+            this.pushHistory({
+                undo: {
+                    type: 'addEntry',
+                    cardId: card.id,
+                    field: cmd.field,
+                    entry: found.entry,
+                    index: found.index,
+                },
+                redo: { type: 'removeEntry', ...cmd },
+            });
+        }
+        this.emitter.emit('after:entry-update', data);
+        return ok();
+    }
+    /** Guardas comuns de escrita de entry (card existe, readOnly, permissão). */
+    entryWriteGuard(cardId, opts) {
+        const card = this.getItem(cardId);
+        if (!card)
+            return { ok: false, result: fail(MOVE_REASONS.notFound) };
+        if (opts.enforce && this.state.readOnly) {
+            return { ok: false, result: fail(MOVE_REASONS.readOnly) };
+        }
+        if (opts.enforce && this.host.can?.('entry-update', card) === false) {
+            return { ok: false, result: fail(MOVE_REASONS.forbidden) };
+        }
+        return { ok: true, card };
+    }
+    /** Aplica patches de campos a um ou mais cards num único snapshot. */
+    patchCards(patches) {
+        const items = this.state.items.map((item) => {
+            const patch = patches.get(item.id);
+            return patch ? freezeItem({ ...item, ...patch }) : item;
+        });
+        this.store.set({ items });
+    }
+    // ---- Infra interna ----------------------------------------------------------
+    pushHistory(entry) {
+        this.undoStack.push(entry);
+        if (this.undoStack.length > MAX_HISTORY)
+            this.undoStack.shift();
+        this.redoStack = [];
+    }
+    cellOf(item) {
+        return {
+            column: str(item[this.columnsAxis.field]),
+            lane: this.lanesAxis ? str(item[this.lanesAxis.field]) : undefined,
+        };
+    }
+    inCell(item, columnId, laneId) {
+        const cell = this.cellOf(item);
+        if (cell.column !== columnId)
+            return false;
+        return laneId === undefined || cell.lane === laneId;
+    }
+    countInCell(cell, excludeId) {
+        return this.state.items.filter((i) => i.id !== excludeId && sameCell(this.cellOf(i), cell)).length;
+    }
+    countInColumn(columnId, excludeId) {
+        return this.state.items.filter((i) => i.id !== excludeId && this.cellOf(i).column === columnId).length;
+    }
+    countInLane(laneId, excludeId) {
+        return this.state.items.filter((i) => i.id !== excludeId && this.cellOf(i).lane === laneId).length;
+    }
+    /** Posição do item entre os itens da própria célula (ordem manual). */
+    indexInCell(item) {
+        const cell = this.cellOf(item);
+        let index = 0;
+        for (const it of this.state.items) {
+            if (it.id === item.id)
+                return index;
+            if (sameCell(this.cellOf(it), cell))
+                index++;
+        }
+        return index;
+    }
+    /** Insere `item` (já com os campos novos) na posição `index` da sua célula,
+     * mapeada para a posição global correspondente. `items` NÃO contém o item. */
+    placeInCell(items, item, index) {
+        const cell = this.cellOf(item);
+        const positions = [];
+        items.forEach((it, i) => {
+            if (sameCell(this.cellOf(it), cell))
+                positions.push(i);
+        });
+        let globalIndex;
+        if (index === undefined || index >= positions.length) {
+            globalIndex = positions.length
+                ? positions[positions.length - 1] + 1
+                : items.length;
+        }
+        else if (index <= 0) {
+            globalIndex = positions.length ? positions[0] : items.length;
+        }
+        else {
+            globalIndex = positions[index];
+        }
+        const next = [...items];
+        next.splice(globalIndex, 0, item);
+        return next;
+    }
+    groupExists(axis, id) {
+        // eixo derivado aceita qualquer valor (o grupo passa a existir ao receber)
+        return !axis.isStatic || axis.groups.some((g) => g.id === id);
+    }
+    groupDef(axis, id) {
+        return id === undefined ? undefined : axis.groups.find((g) => g.id === id);
+    }
+    resolveGroups(axis) {
+        let groups;
+        if (axis.isStatic) {
+            // ordem vem do estado (mutável via moveGroup); grupos novos que não
+            // estejam na ordem entram ao final, na ordem declarada.
+            const order = axis === this.columnsAxis ? this.state.columnOrder : this.state.laneOrder;
+            const byId = new Map(axis.groups.map((g) => [g.id, g]));
+            const ordered = [
+                ...order.filter((id) => byId.has(id)),
+                ...axis.groups.map((g) => g.id).filter((id) => !order.includes(id)),
+            ];
+            groups = ordered.map((id) => ({
+                ...byId.get(id),
+                count: this.countByField(axis.field, id),
+                derived: false,
+            }));
+        }
+        else {
+            const seen = new Map();
+            for (const item of this.state.items) {
+                const value = str(item[axis.field]);
+                if (value === undefined)
+                    continue;
+                seen.set(value, (seen.get(value) ?? 0) + 1);
+            }
+            groups = [...seen.entries()].map(([id, count]) => ({ id, count, derived: true }));
+        }
+        if (axis.sortGroups) {
+            const dir = axis.sortGroups === 'asc' ? 1 : -1;
+            groups = [...groups].sort((a, b) => dir * a.id.localeCompare(b.id));
+        }
+        return groups;
+    }
+    countByField(field, groupId) {
+        return this.state.items.filter((i) => str(i[field]) === groupId).length;
+    }
+    applySort(items) {
+        const sort = this.config.sort;
+        if (!sort)
+            return items;
+        const dir = sort.direction === 'desc' ? -1 : 1;
+        return [...items].sort((a, b) => dir * compare(a[sort.field], b[sort.field]));
+    }
+}
+// ---- Helpers de módulo (puros) ----------------------------------------------
+const ok = () => ({ ok: true });
+const fail = (reason) => ({ ok: false, reason });
+const sameCell = (a, b) => a.column === b.column && a.lane === b.lane;
+function compare(a, b) {
+    if (a === b)
+        return 0;
+    if (a === undefined || a === null)
+        return -1;
+    if (b === undefined || b === null)
+        return 1;
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    return String(a).localeCompare(String(b));
+}
+/**
+ * Cria um board a partir de uma config serializável. Falha RÁPIDO (throw) em
+ * config estruturalmente inválida — para validar sem lançar (ex.: config
+ * vinda do banco), use validateConfig antes.
+ */
+function createBoard(config, options = {}) {
+    const validation = validateConfig(config);
+    if (!validation.valid) {
+        const detail = validation.errors
+            .map((e) => (e.path ? `${e.path}: ${e.message}` : e.message))
+            .join('; ');
+        throw new Error(`BoardConfig inválido — ${detail}`);
+    }
+    return new KanbanBoard(config, options);
+}
+
+/*
+ * @mosaicoo/kanban/core — núcleo HEADLESS do produto.
+ *
+ * REGRA ESTRUTURAL (docs/01-arquitetura.md §2): este entry point é TypeScript
+ * puro, com ZERO dependências — nada de Angular, DOM, RxJS ou browser APIs.
+ * O guard-rail em src/api-surface.spec.ts congela a superfície pública;
+ * mudanças aqui são sempre deliberadas.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { KANBAN_BLOCK_TYPES, KanbanBoard, KanbanRegistry, MKB_VERSION, MOVE_REASONS, createBoard, entriesOf, isFieldBlock, validateConfig };