@listen1954/board 0.1.0

package/lib/domain.js

@@ -0,0 +1,669 @@
+import { randomBytes } from 'node:crypto';
+export const SCHEMA_VERSION = 1;
+export class BoardNotFoundError extends Error {
+    code = 'BOARD_NOT_FOUND';
+    constructor() {
+        super('board not found');
+        this.name = 'BoardNotFoundError';
+    }
+}
+export class BoardOpError extends Error {
+    code = 'BOARD_OP';
+    constructor(message) {
+        super(message);
+        this.name = 'BoardOpError';
+    }
+}
+export class BoardRevisionError extends Error {
+    code = 'BOARD_REVISION';
+    constructor(expected, actual) {
+        super(`board revision mismatch (got ${String(actual)}, expected ${String(expected)})`);
+        this.name = 'BoardRevisionError';
+    }
+}
+const SESSION_ID_RE = /^[A-Za-z0-9._-]+$/;
+const REMINDER_STATUSES = new Set(['scheduled', 'fired', 'cancelled']);
+export function isSessionId(value) {
+    return SESSION_ID_RE.test(value);
+}
+export function assertSessionId(sessionId) {
+    if (!isSessionId(sessionId))
+        throw new BoardNotFoundError();
+}
+export function newId(kind) {
+    return `${kind}_${randomBytes(6).toString('hex')}`;
+}
+export function emptyBoard(scope, sessionId, now = new Date()) {
+    const updatedAt = now.toISOString();
+    if (scope === 'session') {
+        if (sessionId === undefined)
+            throw new BoardOpError('session board requires a session id');
+        assertSessionId(sessionId);
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            id: `session:${sessionId}`,
+            scope: 'session',
+            sessionId,
+            title: 'Session',
+            columns: [],
+            cards: [],
+            revision: 0,
+            updatedAt,
+            sessionColumnsMigrated: false,
+        };
+    }
+    return {
+        schemaVersion: SCHEMA_VERSION,
+        id: 'global',
+        scope: 'global',
+        title: 'Global',
+        columns: [],
+        cards: [],
+        revision: 0,
+        updatedAt,
+        sessionColumnsMigrated: false,
+    };
+}
+export function isEmptyBoard(board) {
+    return board.columns.length === 0;
+}
+export function assertReadable(callerSessionId, board) {
+    if (board.scope === 'global')
+        return;
+    if (board.sessionId === callerSessionId)
+        return;
+    throw new BoardNotFoundError();
+}
+export function summarizeBoard(board) {
+    const columns = [...board.columns]
+        .sort((a, b) => a.order - b.order)
+        .map((column) => ({
+        id: column.id,
+        title: column.title,
+        ...(column.sessionId === undefined ? {} : { sessionId: column.sessionId }),
+        cards: board.cards
+            .filter((card) => card.columnId === column.id && card.archivedAt === null)
+            .sort((a, b) => a.order - b.order)
+            .map((card) => ({
+            id: card.id,
+            title: card.title,
+            reminderStatus: card.reminder?.status ?? null,
+        })),
+    }));
+    return {
+        scope: board.scope,
+        id: board.id,
+        title: board.title,
+        revision: board.revision,
+        updatedAt: board.updatedAt,
+        empty: isEmptyBoard(board),
+        reminderFiredCount: board.cards.filter((card) => card.archivedAt === null && card.reminder?.status === 'fired').length,
+        archivedCount: board.cards.filter((card) => card.archivedAt !== null).length,
+        columns,
+    };
+}
+export function parseBoard(raw) {
+    if (!isRecord(raw))
+        throw new BoardOpError('invalid board: expected an object');
+    if (raw.schemaVersion !== SCHEMA_VERSION) {
+        throw new BoardOpError(`unsupported board schemaVersion: ${String(raw.schemaVersion)}`);
+    }
+    if (raw.scope !== 'global' && raw.scope !== 'session') {
+        throw new BoardOpError('invalid board scope');
+    }
+    if (typeof raw.id !== 'string' || raw.id.length === 0) {
+        throw new BoardOpError('invalid board id');
+    }
+    if (typeof raw.title !== 'string')
+        throw new BoardOpError('invalid board title');
+    const revision = asSafeInt(raw.revision, 'invalid board revision');
+    if (revision < 0)
+        throw new BoardOpError('invalid board revision');
+    if (typeof raw.updatedAt !== 'string' || Number.isNaN(Date.parse(raw.updatedAt))) {
+        throw new BoardOpError('invalid board updatedAt');
+    }
+    if (!Array.isArray(raw.columns))
+        throw new BoardOpError('invalid board columns');
+    if (!Array.isArray(raw.cards))
+        throw new BoardOpError('invalid board cards');
+    if (raw.sessionColumnsMigrated !== undefined && typeof raw.sessionColumnsMigrated !== 'boolean') {
+        throw new BoardOpError('invalid board sessionColumnsMigrated');
+    }
+    const columns = raw.columns.map((item, index) => parseColumn(item, index));
+    const columnIds = new Set(columns.map((column) => column.id));
+    if (columnIds.size !== columns.length)
+        throw new BoardOpError('duplicate column id');
+    const linkedSessionIds = columns.flatMap((column) => column.sessionId === undefined ? [] : [column.sessionId]);
+    if (new Set(linkedSessionIds).size !== linkedSessionIds.length)
+        throw new BoardOpError('duplicate session task column');
+    const cards = raw.cards.map((item, index) => parseCard(item, index, new Map(columns.map((column) => [column.id, column]))));
+    const cardIds = new Set(cards.map((card) => card.id));
+    if (cardIds.size !== cards.length)
+        throw new BoardOpError('duplicate card id');
+    if (raw.scope === 'global') {
+        if (raw.id !== 'global')
+            throw new BoardOpError('global board id must be "global"');
+        if (raw.sessionId !== undefined)
+            throw new BoardOpError('global board must not have sessionId');
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            id: 'global',
+            scope: 'global',
+            title: raw.title,
+            columns,
+            cards,
+            revision,
+            updatedAt: raw.updatedAt,
+            sessionColumnsMigrated: raw.sessionColumnsMigrated === true,
+        };
+    }
+    if (typeof raw.sessionId !== 'string' || !isSessionId(raw.sessionId)) {
+        throw new BoardOpError('invalid sessionId');
+    }
+    if (raw.id !== `session:${raw.sessionId}`) {
+        throw new BoardOpError('session board id must be session:<sessionId>');
+    }
+    return {
+        schemaVersion: SCHEMA_VERSION,
+        id: raw.id,
+        scope: 'session',
+        sessionId: raw.sessionId,
+        title: raw.title,
+        columns,
+        cards,
+        revision,
+        updatedAt: raw.updatedAt,
+        sessionColumnsMigrated: false,
+    };
+}
+export function applyMutate(board, op, now = new Date(), createId = newId) {
+    const next = structuredClone(board);
+    const at = now.toISOString();
+    switch (op.type) {
+        case 'addColumn': {
+            const title = requireTitle(op.title, 'column');
+            next.columns.push({ id: createId('col'), title, order: nextOrder(next.columns) });
+            break;
+        }
+        case 'renameColumn': {
+            const column = requireColumn(next, op.columnId);
+            column.title = requireTitle(op.title, 'column');
+            break;
+        }
+        case 'reorderColumns': {
+            reorderColumns(next, op.columnIds);
+            break;
+        }
+        case 'deleteColumn': {
+            if (op.confirm !== true)
+                throw new BoardOpError('deleteColumn requires confirm: true');
+            requireColumn(next, op.columnId);
+            next.columns = next.columns.filter((column) => column.id !== op.columnId);
+            next.cards = next.cards.filter((card) => card.columnId !== op.columnId || card.archivedAt !== null);
+            reindex(next.columns);
+            break;
+        }
+        case 'addCard': {
+            requireColumn(next, op.columnId);
+            const title = requireTitle(op.title, 'card');
+            const siblings = cardsIn(next, op.columnId);
+            const startAt = op.startAt === undefined ? null : requireIso(op.startAt);
+            const endAt = op.endAt === undefined ? null : requireIso(op.endAt);
+            requireValidTimeRange(startAt, endAt);
+            next.cards.push({
+                id: createId('card'),
+                columnId: op.columnId,
+                title,
+                body: op.body ?? '',
+                order: nextOrder(siblings),
+                startAt,
+                endAt,
+                reminder: op.reminder === undefined ? null : {
+                    at: requireIso(op.reminder.at),
+                    text: op.reminder.text ?? '',
+                    status: 'scheduled',
+                },
+                timeReminder: createTimeReminder(op.timeReminder === true, startAt, endAt, at),
+                logs: [],
+                archivedAt: null,
+                archivedColumn: null,
+                createdAt: at,
+                updatedAt: at,
+            });
+            break;
+        }
+        case 'updateCard': {
+            const card = requireCard(next, op.cardId);
+            if (op.title === undefined && op.body === undefined && op.startAt === undefined && op.endAt === undefined && op.timeReminder === undefined && op.reminder === undefined) {
+                throw new BoardOpError('updateCard requires title, body, time range, or reminder');
+            }
+            const previousStartAt = card.startAt;
+            const previousEndAt = card.endAt;
+            if (op.title !== undefined)
+                card.title = requireTitle(op.title, 'card');
+            if (op.body !== undefined)
+                card.body = op.body;
+            if (op.startAt !== undefined)
+                card.startAt = op.startAt === null ? null : requireIso(op.startAt);
+            if (op.endAt !== undefined)
+                card.endAt = op.endAt === null ? null : requireIso(op.endAt);
+            requireValidTimeRange(card.startAt, card.endAt);
+            if (op.timeReminder !== undefined || card.startAt !== previousStartAt || card.endAt !== previousEndAt) {
+                card.timeReminder = updateTimeReminder(card.timeReminder, op.timeReminder ?? card.timeReminder.enabled, previousStartAt, previousEndAt, card.startAt, card.endAt, at);
+            }
+            if (op.reminder !== undefined) {
+                if (op.reminder === null) {
+                    card.reminder = null;
+                }
+                else {
+                    const at = requireIso(op.reminder.at);
+                    const text = op.reminder.text ?? '';
+                    if (card.reminder?.at !== at || card.reminder.text !== text) {
+                        card.reminder = { at, text, status: 'scheduled' };
+                    }
+                }
+            }
+            card.updatedAt = at;
+            break;
+        }
+        case 'addLog': {
+            const card = requireCard(next, op.cardId);
+            const text = op.text.trim();
+            const attachments = (op.attachments ?? []).map(validateLogAttachment);
+            if (text.length === 0 && attachments.length === 0)
+                throw new BoardOpError('log requires text or attachments');
+            card.logs.push({ id: createId('log'), text, createdAt: at, attachments });
+            card.updatedAt = at;
+            break;
+        }
+        case 'moveCard': {
+            moveCard(next, op.cardId, op.columnId, op.index);
+            requireCard(next, op.cardId).updatedAt = at;
+            break;
+        }
+        case 'archiveCard': {
+            const card = requireCard(next, op.cardId);
+            if (card.archivedAt !== null)
+                throw new BoardOpError('card is already archived');
+            const column = requireColumn(next, card.columnId);
+            const columnId = card.columnId;
+            card.archivedAt = at;
+            card.archivedColumn = { id: column.id, title: column.title, ...(column.sessionId === undefined ? {} : { sessionId: column.sessionId }) };
+            card.updatedAt = at;
+            reindex(cardsIn(next, columnId));
+            break;
+        }
+        case 'restoreCard': {
+            const card = requireCard(next, op.cardId);
+            requireColumn(next, op.columnId);
+            if (card.archivedAt === null)
+                throw new BoardOpError('card is not archived');
+            card.columnId = op.columnId;
+            card.order = nextOrder(cardsIn(next, op.columnId));
+            card.archivedAt = null;
+            card.archivedColumn = null;
+            card.updatedAt = at;
+            break;
+        }
+        case 'restoreCards': {
+            if (op.cards.length === 0)
+                throw new BoardOpError('cards must not be empty');
+            const seen = new Set();
+            for (const item of op.cards) {
+                if (seen.has(item.cardId))
+                    throw new BoardOpError('card ids must be unique');
+                seen.add(item.cardId);
+                const card = requireCard(next, item.cardId);
+                requireColumn(next, item.columnId);
+                if (card.archivedAt === null)
+                    throw new BoardOpError('card is not archived');
+            }
+            for (const item of op.cards) {
+                const card = requireCard(next, item.cardId);
+                card.columnId = item.columnId;
+                card.order = nextOrder(cardsIn(next, item.columnId));
+                card.archivedAt = null;
+                card.archivedColumn = null;
+                card.updatedAt = at;
+            }
+            break;
+        }
+        case 'deleteCard': {
+            requireCard(next, op.cardId);
+            const columnId = requireCard(next, op.cardId).columnId;
+            next.cards = next.cards.filter((card) => card.id !== op.cardId);
+            reindex(cardsIn(next, columnId));
+            break;
+        }
+        case 'deleteCards': {
+            if (op.cardIds.length === 0)
+                throw new BoardOpError('cardIds must not be empty');
+            const ids = new Set(op.cardIds);
+            if (ids.size !== op.cardIds.length)
+                throw new BoardOpError('card ids must be unique');
+            const columnIds = new Set(op.cardIds.map((cardId) => requireCard(next, cardId).columnId));
+            next.cards = next.cards.filter((card) => !ids.has(card.id));
+            for (const columnId of columnIds)
+                reindex(cardsIn(next, columnId));
+            break;
+        }
+        case 'setReminder': {
+            const card = requireCard(next, op.cardId);
+            card.reminder = {
+                at: requireIso(op.at),
+                text: op.text ?? '',
+                status: 'scheduled',
+            };
+            card.updatedAt = at;
+            break;
+        }
+        case 'clearReminder': {
+            const card = requireCard(next, op.cardId);
+            card.reminder = null;
+            card.updatedAt = at;
+            break;
+        }
+        default: {
+            const neverOp = op;
+            throw new BoardOpError(`unknown mutate op: ${JSON.stringify(neverOp)}`);
+        }
+    }
+    next.revision += 1;
+    next.updatedAt = at;
+    return next;
+}
+export function fireDueReminders(board, now = new Date()) {
+    const at = now.toISOString();
+    const nowMs = now.getTime();
+    const next = structuredClone(board);
+    const fired = [];
+    for (const card of next.cards) {
+        if (card.archivedAt !== null || !card.timeReminder.enabled)
+            continue;
+        const previousCount = fired.length;
+        if (card.startAt !== null && card.timeReminder.startFiredAt === undefined && Date.parse(card.startAt) <= nowMs) {
+            card.timeReminder.startFiredAt = at;
+            fired.push({ cardId: card.id, title: card.title, kind: 'start', at: card.startAt, firedAt: at });
+        }
+        if (card.endAt !== null && card.timeReminder.endFiredAt === undefined && Date.parse(card.endAt) <= nowMs) {
+            card.timeReminder.endFiredAt = at;
+            fired.push({ cardId: card.id, title: card.title, kind: 'end', at: card.endAt, firedAt: at });
+        }
+        if (fired.length > previousCount)
+            card.updatedAt = at;
+    }
+    if (fired.length > 0) {
+        next.revision += 1;
+        next.updatedAt = at;
+    }
+    return { board: next, fired };
+}
+function parseColumn(raw, index) {
+    if (!isRecord(raw))
+        throw new BoardOpError(`invalid column at ${String(index)}`);
+    if (typeof raw.id !== 'string' || !raw.id.startsWith('col_')) {
+        throw new BoardOpError(`invalid column id at ${String(index)}`);
+    }
+    if (typeof raw.title !== 'string')
+        throw new BoardOpError(`invalid column title at ${String(index)}`);
+    if (raw.sessionId !== undefined && (typeof raw.sessionId !== 'string' || !isSessionId(raw.sessionId))) {
+        throw new BoardOpError(`invalid column sessionId at ${String(index)}`);
+    }
+    return { id: raw.id, title: raw.title, order: asSafeInt(raw.order, `invalid column order at ${String(index)}`), ...(raw.sessionId === undefined ? {} : { sessionId: raw.sessionId }) };
+}
+function parseCard(raw, index, columns) {
+    if (!isRecord(raw))
+        throw new BoardOpError(`invalid card at ${String(index)}`);
+    if (typeof raw.id !== 'string' || !raw.id.startsWith('card_')) {
+        throw new BoardOpError(`invalid card id at ${String(index)}`);
+    }
+    if (typeof raw.columnId !== 'string')
+        throw new BoardOpError(`invalid card columnId at ${String(index)}`);
+    if (typeof raw.title !== 'string' || raw.title.trim().length === 0) {
+        throw new BoardOpError(`invalid card title at ${String(index)}`);
+    }
+    if (typeof raw.body !== 'string')
+        throw new BoardOpError(`invalid card body at ${String(index)}`);
+    const order = asSafeInt(raw.order, `invalid card order at ${String(index)}`);
+    if (typeof raw.createdAt !== 'string' || Number.isNaN(Date.parse(raw.createdAt))) {
+        throw new BoardOpError(`invalid card createdAt at ${String(index)}`);
+    }
+    if (typeof raw.updatedAt !== 'string' || Number.isNaN(Date.parse(raw.updatedAt))) {
+        throw new BoardOpError(`invalid card updatedAt at ${String(index)}`);
+    }
+    let archivedAt = null;
+    if (raw.archivedAt !== undefined && raw.archivedAt !== null) {
+        if (typeof raw.archivedAt !== 'string' || Number.isNaN(Date.parse(raw.archivedAt))) {
+            throw new BoardOpError(`invalid card archivedAt at ${String(index)}`);
+        }
+        archivedAt = new Date(raw.archivedAt).toISOString();
+    }
+    const currentColumn = columns.get(raw.columnId);
+    if (archivedAt === null && currentColumn === undefined)
+        throw new BoardOpError(`card ${raw.id} references a missing column`);
+    const archivedColumn = archivedAt === null ? null : parseArchivedColumn(raw.archivedColumn, raw.columnId, currentColumn, raw.id);
+    const startAt = parseOptionalIso(raw.startAt, `invalid card startAt at ${String(index)}`);
+    const endAt = parseOptionalIso(raw.endAt, `invalid card endAt at ${String(index)}`);
+    requireValidTimeRange(startAt, endAt);
+    return {
+        id: raw.id,
+        columnId: raw.columnId,
+        title: raw.title,
+        body: raw.body,
+        order,
+        startAt,
+        endAt,
+        reminder: parseReminder(raw.reminder, raw.id),
+        timeReminder: parseTimeReminder(raw.timeReminder, raw.id),
+        logs: raw.logs === undefined ? [] : parseLogs(raw.logs, raw.id),
+        archivedAt,
+        archivedColumn,
+        createdAt: raw.createdAt,
+        updatedAt: raw.updatedAt,
+    };
+}
+function parseArchivedColumn(raw, columnId, current, cardId) {
+    if (raw === undefined || raw === null) {
+        if (current === undefined)
+            throw new BoardOpError(`archived card ${cardId} has no column snapshot`);
+        return { id: current.id, title: current.title, ...(current.sessionId === undefined ? {} : { sessionId: current.sessionId }) };
+    }
+    if (!isRecord(raw) || raw.id !== columnId || typeof raw.title !== 'string') {
+        throw new BoardOpError(`invalid archived column on ${cardId}`);
+    }
+    if (raw.sessionId !== undefined && (typeof raw.sessionId !== 'string' || !isSessionId(raw.sessionId))) {
+        throw new BoardOpError(`invalid archived column sessionId on ${cardId}`);
+    }
+    const sessionId = raw.sessionId ?? current?.sessionId;
+    return { id: columnId, title: raw.title, ...(sessionId === undefined ? {} : { sessionId }) };
+}
+function parseTimeReminder(raw, cardId) {
+    if (raw === undefined)
+        return { enabled: false };
+    if (!isRecord(raw) || typeof raw.enabled !== 'boolean')
+        throw new BoardOpError(`invalid timeReminder on ${cardId}`);
+    const value = { enabled: raw.enabled };
+    for (const key of ['startFiredAt', 'endFiredAt']) {
+        const item = raw[key];
+        if (item === undefined)
+            continue;
+        if (typeof item !== 'string' || Number.isNaN(Date.parse(item)))
+            throw new BoardOpError(`invalid timeReminder.${key} on ${cardId}`);
+        value[key] = new Date(item).toISOString();
+    }
+    return value;
+}
+function createTimeReminder(enabled, startAt, endAt, now) {
+    const value = { enabled };
+    if (!enabled)
+        return value;
+    if (startAt !== null && Date.parse(startAt) <= Date.parse(now))
+        value.startFiredAt = now;
+    if (endAt !== null && Date.parse(endAt) <= Date.parse(now))
+        value.endFiredAt = now;
+    return value;
+}
+function updateTimeReminder(current, enabled, previousStartAt, previousEndAt, startAt, endAt, now) {
+    const value = createTimeReminder(enabled, startAt, endAt, now);
+    if (!enabled)
+        return value;
+    if (startAt !== null && startAt === previousStartAt && current.startFiredAt !== undefined)
+        value.startFiredAt = current.startFiredAt;
+    if (endAt !== null && endAt === previousEndAt && current.endFiredAt !== undefined)
+        value.endFiredAt = current.endFiredAt;
+    return value;
+}
+export function defaultGlobalBoard(now = new Date(), createId = newId, titles = ['To do', 'In progress', 'Uncategorized']) {
+    const board = emptyBoard('global', undefined, now);
+    board.columns = titles.map((title, order) => ({ id: createId('col'), title, order }));
+    return board;
+}
+function parseLogs(raw, cardId) {
+    if (!Array.isArray(raw))
+        throw new BoardOpError(`invalid logs on ${cardId}`);
+    return raw.map((item, index) => {
+        if (!isRecord(item) || typeof item.id !== 'string' || !item.id.startsWith('log_'))
+            throw new BoardOpError(`invalid log at ${String(index)} on ${cardId}`);
+        if (typeof item.text !== 'string')
+            throw new BoardOpError(`invalid log text at ${String(index)} on ${cardId}`);
+        if (typeof item.createdAt !== 'string' || Number.isNaN(Date.parse(item.createdAt)))
+            throw new BoardOpError(`invalid log createdAt at ${String(index)} on ${cardId}`);
+        if (!Array.isArray(item.attachments))
+            throw new BoardOpError(`invalid log attachments at ${String(index)} on ${cardId}`);
+        return { id: item.id, text: item.text, createdAt: new Date(item.createdAt).toISOString(), attachments: item.attachments.map(validateLogAttachment) };
+    });
+}
+function validateLogAttachment(raw) {
+    if (!isRecord(raw) || typeof raw.id !== 'string' || !raw.id.startsWith('attachment_'))
+        throw new BoardOpError('invalid log attachment id');
+    if (typeof raw.name !== 'string' || raw.name.trim().length === 0)
+        throw new BoardOpError('invalid log attachment name');
+    if (typeof raw.type !== 'string')
+        throw new BoardOpError('invalid log attachment type');
+    if (typeof raw.size !== 'number' || !Number.isSafeInteger(raw.size) || raw.size < 0)
+        throw new BoardOpError('invalid log attachment size');
+    if (raw.preview !== undefined && (typeof raw.preview !== 'string' || !/^data:image\/(?:jpeg|png|webp);base64,/.test(raw.preview)))
+        throw new BoardOpError('invalid log attachment preview');
+    return { id: raw.id, name: raw.name, type: raw.type, size: raw.size, ...(raw.preview === undefined ? {} : { preview: raw.preview }) };
+}
+function parseReminder(raw, cardId) {
+    if (raw === null || raw === undefined)
+        return null;
+    if (!isRecord(raw))
+        throw new BoardOpError(`invalid reminder on ${cardId}`);
+    if (typeof raw.at !== 'string' || Number.isNaN(Date.parse(raw.at))) {
+        throw new BoardOpError(`invalid reminder.at on ${cardId}`);
+    }
+    if (typeof raw.text !== 'string')
+        throw new BoardOpError(`invalid reminder.text on ${cardId}`);
+    if (typeof raw.status !== 'string' || !REMINDER_STATUSES.has(raw.status)) {
+        throw new BoardOpError(`invalid reminder.status on ${cardId}`);
+    }
+    const reminder = {
+        at: new Date(raw.at).toISOString(),
+        text: raw.text,
+        status: raw.status,
+    };
+    if (raw.firedAt !== undefined) {
+        if (typeof raw.firedAt !== 'string' || Number.isNaN(Date.parse(raw.firedAt))) {
+            throw new BoardOpError(`invalid reminder.firedAt on ${cardId}`);
+        }
+        reminder.firedAt = new Date(raw.firedAt).toISOString();
+    }
+    return reminder;
+}
+function requireTitle(value, kind) {
+    const title = value.trim();
+    if (title.length === 0)
+        throw new BoardOpError(`${kind} title must be non-empty`);
+    return title;
+}
+function requireIso(value) {
+    const ms = Date.parse(value);
+    if (Number.isNaN(ms))
+        throw new BoardOpError('reminder.at must be an ISO-8601 datetime');
+    return new Date(ms).toISOString();
+}
+function parseOptionalIso(value, message) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value !== 'string' || Number.isNaN(Date.parse(value)))
+        throw new BoardOpError(message);
+    return new Date(value).toISOString();
+}
+function requireValidTimeRange(startAt, endAt) {
+    if (startAt !== null && endAt !== null && Date.parse(startAt) >= Date.parse(endAt)) {
+        throw new BoardOpError('card startAt must be before endAt');
+    }
+}
+function requireColumn(board, columnId) {
+    const column = board.columns.find((item) => item.id === columnId);
+    if (column === undefined)
+        throw new BoardOpError(`column not found: ${columnId}`);
+    return column;
+}
+function requireCard(board, cardId) {
+    const card = board.cards.find((item) => item.id === cardId);
+    if (card === undefined)
+        throw new BoardOpError(`card not found: ${cardId}`);
+    return card;
+}
+function cardsIn(board, columnId) {
+    return board.cards.filter((card) => card.columnId === columnId && card.archivedAt === null);
+}
+function nextOrder(items) {
+    if (items.length === 0)
+        return 0;
+    return Math.max(...items.map((item) => item.order)) + 1;
+}
+function reindex(items) {
+    const sorted = [...items].sort((a, b) => a.order - b.order);
+    sorted.forEach((item, index) => {
+        item.order = index;
+    });
+}
+function reorderColumns(board, columnIds) {
+    if (columnIds.length !== board.columns.length) {
+        throw new BoardOpError('reorderColumns must list every column exactly once');
+    }
+    const seen = new Set();
+    for (const id of columnIds) {
+        if (seen.has(id))
+            throw new BoardOpError('reorderColumns has a duplicate column id');
+        seen.add(id);
+        requireColumn(board, id);
+    }
+    columnIds.forEach((id, index) => {
+        requireColumn(board, id).order = index;
+    });
+}
+function moveCard(board, cardId, columnId, index) {
+    requireColumn(board, columnId);
+    const card = requireCard(board, cardId);
+    if (card.archivedAt !== null)
+        throw new BoardOpError('archived card cannot be moved');
+    if (!Number.isSafeInteger(index) || index < 0) {
+        throw new BoardOpError('moveCard index must be a non-negative integer');
+    }
+    const fromId = card.columnId;
+    const dest = cardsIn(board, columnId)
+        .filter((item) => item.id !== cardId)
+        .sort((a, b) => a.order - b.order);
+    if (index > dest.length)
+        throw new BoardOpError('moveCard index is out of range');
+    dest.splice(index, 0, card);
+    card.columnId = columnId;
+    dest.forEach((item, order) => {
+        item.order = order;
+    });
+    if (fromId !== columnId)
+        reindex(cardsIn(board, fromId));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asSafeInt(value, message) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        throw new BoardOpError(message);
+    return value;
+}

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+export declare const name = "board";
+export declare const inject: string[];
+export interface Config {
+    wakeOnGlobalReminder: boolean;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config?: Config): void;
+export type { AttachmentDownload, AttachmentUpload, ArchivedColumn, Board, BoardScope, CardLog, Card, Column, LogAttachment, MutateOp, Reminder, } from './domain.js';
+export { BoardNotFoundError, BoardOpError, BoardRevisionError } from './domain.js';
+export { BoardModel, BoardService } from './service.js';
+export { BoardStore, resolveBoardRoot, resolveDshHome } from './store.js';