everymuseum-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zak Krevitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# EveryMuseum MCP server
+
+An [MCP](https://modelcontextprotocol.io) server that puts the **EveryMuseum**
+open-access art archive inside any MCP-capable client (Claude Desktop, Claude
+Code, Cursor, …). Once added, you can *converse* with millions of public-domain
+and openly-licensed artworks from The Met, Rijksmuseum, the Art Institute of
+Chicago, the V&A, Getty, Smithsonian, Harvard, Cleveland, and more:
+
+- **Pull up images** — search by artist, culture, period, medium, or theme and
+  see real artwork images inline in the conversation.
+- **Learn** — get full curatorial detail (description, medium, dimensions,
+  culture, license, source link) and a high-resolution image for any work.
+- **Go deeper** — find visually and thematically similar works.
+- **Build boards** — collect works into persistent local boards (mood boards /
+  reading lists) and export them to a shareable, editorial HTML gallery.
+
+It talks to the live public API at `https://everymuseum.org` — no database,
+API key, or local copy of the app required.
+
+## Add it to Claude
+
+### Claude Desktop
+
+Edit your `claude_desktop_config.json`
+(macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```jsonc
+{
+  "mcpServers": {
+    "everymuseum": {
+      "command": "npx",
+      "args": ["-y", "everymuseum-mcp"]
+    }
+  }
+}
+```
+
+Restart Claude Desktop. You'll see the EveryMuseum tools available.
+
+### Claude Code
+
+```bash
+claude mcp add everymuseum -- npx -y everymuseum-mcp
+```
+
+### Running from a local checkout (before npm publish)
+
+Build once, then point your client at the compiled entrypoint:
+
+```bash
+cd mcp
+npm install
+npm run build
+```
+
+```jsonc
+{
+  "mcpServers": {
+    "everymuseum": {
+      "command": "node",
+      "args": ["/absolute/path/to/CulturalAtlas/mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+Claude Code equivalent:
+
+```bash
+claude mcp add everymuseum -- node /absolute/path/to/CulturalAtlas/mcp/dist/index.js
+```
+
+## Try it
+
+> "Show me some Hokusai prints."
+> "Tell me more about the third one."
+> "Find works similar to it."
+> "Start a board called *Edo seascapes* and add those two."
+> "Export the board and open it."
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `search_artworks` | Free-text search; returns captioned results with images. |
+| `get_artwork` | Full metadata + high-res image for one work (by id). |
+| `find_similar` | Related works for a given artwork id. |
+| `suggest_searches` | Curated ideas drawn from the archive's top facets. |
+| `create_board` | Create a saved board. |
+| `add_to_board` | Add works (by id) to a board. |
+| `view_board` | Show a board's works with images. |
+| `list_boards` | List all saved boards. |
+| `remove_from_board` | Remove works from a board. |
+| `export_board` | Render a board to a shareable HTML gallery (optionally open it). |
+| `delete_board` | Delete a board (requires `confirm: true`). |
+
+## Boards
+
+Boards are stored locally as JSON at `~/.everymuseum/boards.json` and persist
+across conversations. Each added work is snapshotted, so a board still renders
+even if the archive changes. Exported galleries are written to
+`~/.everymuseum/boards/<slug>-<id>.html` — self-contained, offline-friendly, and
+safe to share.
+
+## Configuration
+
+| Env var | Default | Purpose |
+| --- | --- | --- |
+| `EVERYMUSEUM_API_BASE` | `https://everymuseum.org` | Archive to query (set to `http://localhost:3000` for local dev). |
+| `EVERYMUSEUM_DATA_DIR` | `~/.everymuseum` | Where boards and exports are stored. |
+
+## Develop
+
+```bash
+npm install
+npm run build      # tsc → dist/
+npm test           # build + end-to-end stdio smoke test against the live API
+```
+
+The smoke test (`test/smoke.mjs`) spawns the server, speaks JSON-RPC over stdio,
+and exercises every tool against the live archive using a throwaway data dir.
+
+## Attribution & licensing
+
+Images and rights belong to the source institutions. The archive only surfaces
+openly-licensed / public-domain records, but always check the per-work `license`
+field before reuse. This server's own code is MIT-licensed.

package/dist/api.js

@@ -0,0 +1,175 @@
+/**
+ * Base URL of the EveryMuseum deployment to query. Defaults to production.
+ * Override with EVERYMUSEUM_API_BASE (e.g. http://localhost:3000) for local dev.
+ */
+export const API_BASE = (process.env.EVERYMUSEUM_API_BASE || "https://everymuseum.org").replace(/\/+$/, "");
+const REQUEST_TIMEOUT_MS = 20_000;
+const USER_AGENT = "everymuseum-mcp/0.1 (+https://everymuseum.org)";
+// Mirrors SOURCE_LABELS in the app's lib/normalize.ts. Used for human-readable
+// attribution in tool output and board exports.
+const SOURCE_LABELS = {
+    met: "The Met",
+    cleveland: "Cleveland Museum of Art",
+    artic: "Art Institute of Chicago",
+    vam: "Victoria and Albert Museum",
+    wellcome: "Wellcome Collection",
+    walters: "The Walters Art Museum",
+    smithsonian: "Smithsonian Open Access",
+    rijksmuseum: "Rijksmuseum",
+    getty: "Getty",
+    loc: "Library of Congress",
+    harvard: "Harvard Art Museums",
+    "te-papa": "Te Papa Tongarewa",
+    tepapa: "Te Papa Tongarewa",
+    auckland: "Auckland Museum",
+    "cooper-hewitt": "Cooper Hewitt",
+    cooperhewitt: "Cooper Hewitt",
+    mia: "Minneapolis Institute of Art",
+    nga: "National Gallery of Art",
+    smk: "National Gallery of Denmark",
+    ycba: "Yale Center for British Art",
+};
+export function sourceLabel(source) {
+    return SOURCE_LABELS[source] ?? source;
+}
+/** Error carrying an HTTP status so callers can craft friendly messages. */
+export class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+async function apiFetch(path) {
+    const url = path.startsWith("http") ? path : `${API_BASE}${path}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        // The abort signal stays armed across the body read too, so a stalled
+        // response body is bounded by the timeout, not just the header phase.
+        const response = await fetch(url, {
+            headers: { Accept: "application/json", "User-Agent": USER_AGENT },
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        let body = null;
+        if (text) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = null;
+            }
+        }
+        if (!response.ok) {
+            const apiMessage = body && typeof body === "object" && "error" in body
+                ? String(body.error)
+                : `Request failed with status ${response.status}.`;
+            throw new ApiError(apiMessage, response.status);
+        }
+        return body;
+    }
+    catch (error) {
+        if (error instanceof ApiError)
+            throw error;
+        if (controller.signal.aborted) {
+            throw new ApiError(`EveryMuseum request timed out after ${REQUEST_TIMEOUT_MS / 1000}s.`);
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new ApiError(`Could not reach EveryMuseum at ${API_BASE} (${reason}).`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function asArtwork(value) {
+    // The API already returns a normalized shape; we trust it but coerce the
+    // fields we depend on so downstream code never sees `undefined`.
+    const record = (value ?? {});
+    const str = (key) => typeof record[key] === "string" ? record[key] : null;
+    const num = (key) => typeof record[key] === "number" ? record[key] : null;
+    return {
+        id: String(record.id ?? ""),
+        source: String(record.source ?? ""),
+        sourceObjectId: String(record.sourceObjectId ?? ""),
+        title: str("title"),
+        artist: str("artist"),
+        dateDisplay: str("dateDisplay"),
+        dateStart: num("dateStart"),
+        dateEnd: num("dateEnd"),
+        medium: str("medium"),
+        dimensions: str("dimensions"),
+        culture: str("culture"),
+        department: str("department"),
+        classification: str("classification"),
+        description: str("description"),
+        tags: Array.isArray(record.tags)
+            ? record.tags.filter((tag) => typeof tag === "string")
+            : [],
+        imageUrl: str("imageUrl"),
+        thumbnailUrl: str("thumbnailUrl"),
+        iiifUrl: str("iiifUrl"),
+        license: str("license"),
+        sourceUrl: str("sourceUrl"),
+        createdAt: str("createdAt") ?? undefined,
+        updatedAt: str("updatedAt") ?? undefined,
+    };
+}
+/** Search the archive. Always requests totals so callers get paging metadata. */
+export async function searchArtworks(query, options = {}) {
+    const params = new URLSearchParams();
+    const trimmed = query.trim();
+    if (trimmed)
+        params.set("q", trimmed);
+    params.set("limit", String(options.limit ?? 12));
+    if (options.offset)
+        params.set("offset", String(options.offset));
+    params.set("includeTotal", "1");
+    const body = await apiFetch(`/api/search?${params.toString()}`);
+    // includeTotal=1 returns { items, total, limit, offset, nextCursor }.
+    if (body && typeof body === "object" && "items" in body) {
+        const envelope = body;
+        return {
+            items: Array.isArray(envelope.items) ? envelope.items.map(asArtwork) : [],
+            total: typeof envelope.total === "number" ? envelope.total : null,
+            nextCursor: typeof envelope.nextCursor === "string" ? envelope.nextCursor : null,
+        };
+    }
+    // Defensive fallback: a bare array (when includeTotal is ignored).
+    const items = Array.isArray(body) ? body.map(asArtwork) : [];
+    return { items, total: null, nextCursor: null };
+}
+/** Fetch full detail for a single artwork. Throws ApiError(404) if missing. */
+export async function getArtwork(id) {
+    const body = await apiFetch(`/api/artworks/${encodeURIComponent(id)}`);
+    if (!body || typeof body !== "object" || !("id" in body)) {
+        throw new ApiError(`No artwork found for id "${id}".`, 404);
+    }
+    return asArtwork(body);
+}
+/** Works the archive considers similar to the given artwork (up to ~12). */
+export async function findSimilar(id) {
+    try {
+        const body = await apiFetch(`/api/similar/${encodeURIComponent(id)}`);
+        return Array.isArray(body) ? body.map(asArtwork) : [];
+    }
+    catch (error) {
+        // Treat an unknown id (404) as "no neighbors" so the caller can show its
+        // tailored empty-state guidance instead of a generic API error.
+        if (error instanceof ApiError && error.status === 404)
+            return [];
+        throw error;
+    }
+}
+/** Curated search suggestions (artists, cultures, collections, media, sources). */
+export async function getSuggestions() {
+    const body = await apiFetch("/api/search/suggestions");
+    if (body && typeof body === "object" && "suggestions" in body) {
+        const list = body.suggestions;
+        if (Array.isArray(list)) {
+            return list.filter((item) => typeof item === "string");
+        }
+    }
+    return [];
+}

package/dist/board-html.js

@@ -0,0 +1,226 @@
+import { bestDisplayUrl } from "./images.js";
+const HTML_IMAGE_SIZE = 1100; // sharp on retina without bloating the page
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+/** Only allow http(s) URLs into href/src to keep the export safe to open. */
+function safeUrl(value) {
+    if (!value)
+        return null;
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function formatGenerated(iso) {
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime()))
+        return "";
+    return date.toLocaleDateString("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+    });
+}
+function renderCard(item) {
+    const imageUrl = safeUrl(bestDisplayUrl(item, HTML_IMAGE_SIZE));
+    const sourceUrl = safeUrl(item.sourceUrl);
+    const title = escapeHtml(item.title ?? "Untitled");
+    const alt = escapeHtml([item.title, item.artist].filter(Boolean).join(" — ") || "Artwork");
+    const figure = imageUrl
+        ? `<img src="${escapeHtml(imageUrl)}" alt="${alt}" loading="lazy" />`
+        : `<div class="missing">image unavailable</div>`;
+    const metaLines = [];
+    if (item.artist)
+        metaLines.push(`<span class="artist">${escapeHtml(item.artist)}</span>`);
+    const factParts = [item.dateDisplay, item.medium].filter(Boolean).map((part) => escapeHtml(part));
+    if (factParts.length)
+        metaLines.push(`<span class="facts">${factParts.join(" · ")}</span>`);
+    const attribution = [item.sourceLabel, item.license].filter(Boolean).map((part) => escapeHtml(part));
+    if (attribution.length)
+        metaLines.push(`<span class="attr">${attribution.join(" · ")}</span>`);
+    const caption = `
+      <figcaption>
+        <span class="title">${title}</span>
+        ${metaLines.join("\n        ")}
+      </figcaption>`;
+    const inner = `<figure>${figure}${caption}</figure>`;
+    return sourceUrl
+        ? `<article class="card"><a href="${escapeHtml(sourceUrl)}" target="_blank" rel="noreferrer noopener">${inner}</a></article>`
+        : `<article class="card">${inner}</article>`;
+}
+/** Render a board as a self-contained, offline-friendly gallery page. */
+export function renderBoardHtml(board) {
+    const generated = formatGenerated(new Date().toISOString());
+    const count = board.items.length;
+    const countLabel = `${count} ${count === 1 ? "work" : "works"}`;
+    const description = board.description
+        ? `<p class="board-desc">${escapeHtml(board.description)}</p>`
+        : "";
+    const cards = board.items.map(renderCard).join("\n");
+    const body = count
+        ? `<main class="grid">\n${cards}\n</main>`
+        : `<main class="empty"><p>This board is empty. Add works to it with the <code>add_to_board</code> tool.</p></main>`;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${escapeHtml(board.name)} · EveryMuseum board</title>
+<style>
+  :root {
+    --paper: #f7f4ee;
+    --ink: #1a1714;
+    --muted: #6b6358;
+    --hair: #e4ddd0;
+    --accent: #7a2e1d;
+  }
+  * { box-sizing: border-box; }
+  html { -webkit-text-size-adjust: 100%; }
+  body {
+    margin: 0;
+    background: var(--paper);
+    color: var(--ink);
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    line-height: 1.5;
+  }
+  header {
+    max-width: 1280px;
+    margin: 0 auto;
+    padding: 72px 32px 40px;
+    border-bottom: 1px solid var(--hair);
+  }
+  .eyebrow {
+    font-size: 12px;
+    letter-spacing: 0.18em;
+    text-transform: uppercase;
+    color: var(--muted);
+    margin: 0 0 18px;
+  }
+  h1 {
+    font-family: Georgia, "Iowan Old Style", "Palatino Linotype", "Times New Roman", serif;
+    font-weight: 600;
+    font-size: clamp(32px, 5vw, 56px);
+    line-height: 1.05;
+    letter-spacing: -0.01em;
+    margin: 0;
+  }
+  .board-desc {
+    max-width: 60ch;
+    font-size: 18px;
+    color: #3a342d;
+    margin: 18px 0 0;
+  }
+  .meta {
+    margin: 22px 0 0;
+    font-size: 13px;
+    letter-spacing: 0.04em;
+    color: var(--muted);
+  }
+  .grid {
+    max-width: 1280px;
+    margin: 0 auto;
+    padding: 40px 32px 96px;
+    column-gap: 28px;
+    column-count: 1;
+  }
+  @media (min-width: 600px) { .grid { column-count: 2; } }
+  @media (min-width: 960px) { .grid { column-count: 3; } }
+  @media (min-width: 1280px) { .grid { column-count: 4; } }
+  .card {
+    break-inside: avoid;
+    margin: 0 0 36px;
+  }
+  .card a { text-decoration: none; color: inherit; display: block; }
+  figure { margin: 0; }
+  .card img {
+    display: block;
+    width: 100%;
+    height: auto;
+    background: #ece6da;
+    border: 1px solid var(--hair);
+    transition: filter 0.2s ease;
+  }
+  .card a:hover img { filter: brightness(1.04); }
+  .missing {
+    aspect-ratio: 4 / 3;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: #ece6da;
+    color: var(--muted);
+    font-size: 13px;
+    border: 1px solid var(--hair);
+  }
+  figcaption {
+    padding: 12px 2px 0;
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+  }
+  figcaption .title {
+    font-family: Georgia, "Iowan Old Style", "Palatino Linotype", "Times New Roman", serif;
+    font-style: italic;
+    font-size: 16px;
+    line-height: 1.25;
+    color: var(--ink);
+  }
+  figcaption .artist { font-size: 14px; color: #3a342d; }
+  figcaption .facts { font-size: 13px; color: var(--muted); }
+  figcaption .attr {
+    font-size: 11px;
+    letter-spacing: 0.05em;
+    text-transform: uppercase;
+    color: var(--muted);
+    margin-top: 4px;
+  }
+  .card a:hover figcaption .title { color: var(--accent); }
+  .empty {
+    max-width: 1280px;
+    margin: 0 auto;
+    padding: 80px 32px;
+    color: var(--muted);
+  }
+  .empty code {
+    background: #ece6da;
+    padding: 2px 6px;
+    border-radius: 4px;
+    font-size: 0.9em;
+  }
+  footer {
+    max-width: 1280px;
+    margin: 0 auto;
+    padding: 28px 32px 64px;
+    border-top: 1px solid var(--hair);
+    font-size: 12px;
+    letter-spacing: 0.04em;
+    color: var(--muted);
+  }
+  footer a { color: var(--accent); text-decoration: none; }
+</style>
+</head>
+<body>
+  <header>
+    <p class="eyebrow">EveryMuseum · Board</p>
+    <h1>${escapeHtml(board.name)}</h1>
+    ${description}
+    <p class="meta">${countLabel}${generated ? ` · assembled ${escapeHtml(generated)}` : ""}</p>
+  </header>
+  ${body}
+  <footer>
+    Open-access works from museum collections worldwide, curated via
+    <a href="https://everymuseum.org" target="_blank" rel="noreferrer noopener">everymuseum.org</a>.
+    Images and rights belong to their source institutions.
+  </footer>
+</body>
+</html>
+`;
+}

package/dist/boards.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { sourceLabel } from "./api.js";
+/** Root directory for board storage. Override with EVERYMUSEUM_DATA_DIR. */
+export function dataDir() {
+    return process.env.EVERYMUSEUM_DATA_DIR || join(homedir(), ".everymuseum");
+}
+function boardsFile() {
+    return join(dataDir(), "boards.json");
+}
+export function boardsExportDir() {
+    return join(dataDir(), "boards");
+}
+export async function loadBoards() {
+    try {
+        const raw = await readFile(boardsFile(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed && typeof parsed === "object" && Array.isArray(parsed.boards)) {
+            return parsed.boards;
+        }
+        return [];
+    }
+    catch {
+        // Missing or unreadable file → start fresh.
+        return [];
+    }
+}
+export async function saveBoards(boards) {
+    const file = boardsFile();
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    await writeFile(tmp, JSON.stringify(boards, null, 2), "utf8");
+    await rename(tmp, file); // atomic replace
+}
+// An MCP client can dispatch multiple tool calls concurrently, so a naive
+// load → mutate → save sequence can lose updates (the last save wins). Funnel
+// every read-modify-write through this in-process queue so they run serially.
+let boardsLock = Promise.resolve();
+export function withBoards(fn) {
+    const run = boardsLock.then(() => loadBoards().then(fn));
+    // Keep the chain alive whether the operation resolved or threw.
+    boardsLock = run.then(() => undefined, () => undefined);
+    return run;
+}
+export function slugify(value) {
+    return (value
+        .normalize("NFKD")
+        .replace(/[^\w\s-]/g, "")
+        .trim()
+        .replace(/\s+/g, "-")
+        .toLowerCase()
+        .slice(0, 60) || "board");
+}
+/** Resolve a board by id, slug, or case-insensitive name. */
+export function findBoard(boards, identifier) {
+    const needle = identifier.trim().toLowerCase();
+    return (boards.find((board) => board.id.toLowerCase() === needle) ??
+        boards.find((board) => board.slug.toLowerCase() === needle) ??
+        boards.find((board) => board.name.toLowerCase() === needle) ??
+        null);
+}
+export function createBoard(boards, name, description) {
+    const base = slugify(name);
+    let slug = base;
+    let n = 2;
+    const taken = new Set(boards.map((board) => board.slug));
+    while (taken.has(slug))
+        slug = `${base}-${n++}`;
+    const now = new Date().toISOString();
+    const board = {
+        id: randomUUID().slice(0, 8),
+        slug,
+        name: name.trim(),
+        description: description?.trim() || null,
+        createdAt: now,
+        updatedAt: now,
+        items: [],
+    };
+    boards.push(board);
+    return board;
+}
+export function boardItemFromArtwork(artwork) {
+    return {
+        id: artwork.id,
+        title: artwork.title,
+        artist: artwork.artist,
+        dateDisplay: artwork.dateDisplay,
+        source: artwork.source,
+        sourceLabel: sourceLabel(artwork.source),
+        medium: artwork.medium,
+        culture: artwork.culture,
+        imageUrl: artwork.imageUrl,
+        thumbnailUrl: artwork.thumbnailUrl,
+        iiifUrl: artwork.iiifUrl,
+        sourceUrl: artwork.sourceUrl,
+        license: artwork.license,
+        addedAt: new Date().toISOString(),
+    };
+}
+/** Add artworks to a board, skipping ids already present. Returns count added. */
+export function addArtworksToBoard(board, artworks) {
+    const present = new Set(board.items.map((item) => item.id));
+    let added = 0;
+    for (const artwork of artworks) {
+        if (present.has(artwork.id))
+            continue;
+        board.items.push(boardItemFromArtwork(artwork));
+        present.add(artwork.id);
+        added += 1;
+    }
+    if (added > 0)
+        board.updatedAt = new Date().toISOString();
+    return added;
+}
+/** Remove items by artwork id. Returns count removed. */
+export function removeItemsFromBoard(board, ids) {
+    const remove = new Set(ids);
+    const before = board.items.length;
+    board.items = board.items.filter((item) => !remove.has(item.id));
+    const removed = before - board.items.length;
+    if (removed > 0)
+        board.updatedAt = new Date().toISOString();
+    return removed;
+}
+export function deleteBoard(boards, board) {
+    return boards.filter((entry) => entry.id !== board.id);
+}