@pixi-board/board-plugin-canvas 0.1.0

package/dist/index.js

@@ -0,0 +1,1131 @@
+// ../board-domain/src/geometry.ts
+function nodeBounds(node) {
+  const corners = nodeWorldCorners(node);
+  return {
+    id: node.id,
+    minX: Math.min(...corners.map((point) => point.x)),
+    minY: Math.min(...corners.map((point) => point.y)),
+    maxX: Math.max(...corners.map((point) => point.x)),
+    maxY: Math.max(...corners.map((point) => point.y))
+  };
+}
+function nodeWorldCorners(node) {
+  const localCorners = [
+    { x: 0, y: 0 },
+    { x: node.width, y: 0 },
+    { x: node.width, y: node.height },
+    { x: 0, y: node.height }
+  ];
+  if (node.rotation === 0) {
+    return localCorners.map((point) => ({
+      x: node.x + point.x,
+      y: node.y + point.y
+    }));
+  }
+  const cos = Math.cos(node.rotation);
+  const sin = Math.sin(node.rotation);
+  return localCorners.map((point) => ({
+    x: node.x + point.x * cos - point.y * sin,
+    y: node.y + point.x * sin + point.y * cos
+  }));
+}
+
+// ../board-domain/src/nodeNames.ts
+var UNNAMED_NODE_NAME = "\u672A\u547D\u540D\u8282\u70B9";
+function displayNodeName(name) {
+  const trimmed = name?.trim();
+  return trimmed ? trimmed : UNNAMED_NODE_NAME;
+}
+
+// src/dto.ts
+import path from "path";
+function toNodeDto(node) {
+  const bounds = nodeBounds(node);
+  return {
+    id: node.id,
+    type: node.type,
+    name: node.name,
+    displayName: displayNodeName(node.name),
+    x: node.x,
+    y: node.y,
+    width: node.width,
+    height: node.height,
+    rotation: node.rotation,
+    zIndex: node.zIndex,
+    locked: node.locked ?? false,
+    assetId: node.assetId,
+    options: node.options,
+    bounds: {
+      minX: bounds.minX,
+      minY: bounds.minY,
+      maxX: bounds.maxX,
+      maxY: bounds.maxY
+    }
+  };
+}
+function toAssetDto(projectRoot, asset) {
+  return {
+    id: asset.id,
+    kind: asset.kind,
+    fileName: asset.fileName,
+    mimeType: asset.mimeType,
+    size: asset.size,
+    original: asset.localPath ? {
+      localPath: asset.localPath,
+      absolutePath: path.resolve(projectRoot, asset.localPath),
+      sourceUrl: asset.sourceUrl,
+      webLink: asset.webLink
+    } : void 0,
+    derivatives: Object.entries(asset.derivatives ?? {}).map(([variant, derivative]) => ({
+      variant,
+      localPath: derivative.localPath,
+      absolutePath: path.resolve(projectRoot, derivative.localPath),
+      extension: derivative.extension,
+      updatedAt: derivative.updatedAt
+    })),
+    metadata: {
+      width: asset.width,
+      height: asset.height,
+      duration: asset.duration,
+      format: asset.format,
+      hash: asset.hash,
+      metadata: asset.metadata,
+      createdAt: asset.createdAt,
+      updatedAt: asset.updatedAt
+    }
+  };
+}
+function toProjectInfo(projectRoot) {
+  return {
+    name: path.basename(projectRoot),
+    rootPath: projectRoot,
+    boardPath: path.join(projectRoot, "board.json"),
+    assetsPath: path.join(projectRoot, "assets.json")
+  };
+}
+function toSnapshotDto(projectRoot, snapshot) {
+  return {
+    project: toProjectInfo(projectRoot),
+    viewport: snapshot.viewport ?? null,
+    nodes: snapshot.nodes.map(toNodeDto),
+    assets: snapshot.assets.map((asset) => ({
+      id: asset.id,
+      kind: asset.kind,
+      fileName: asset.fileName,
+      mimeType: asset.mimeType,
+      size: asset.size,
+      metadata: asset.metadata,
+      width: asset.width,
+      height: asset.height,
+      duration: asset.duration,
+      updatedAt: asset.updatedAt
+    }))
+  };
+}
+
+// src/errors.ts
+var BoardToolUserError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BoardToolUserError";
+  }
+};
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// src/filter.ts
+var NODE_TYPE_VALUES = ["image", "video", "audio", "model", "text", "markdown", "html", "importing", "generating"];
+function filterNodes(nodes, filter) {
+  const parsed = parseFilter(filter);
+  return nodes.filter((node) => matchesType(node, parsed) && matchesKeyword(node, parsed) && matchesBounds(node, parsed));
+}
+function parseFilter(filter) {
+  if (!filter || typeof filter !== "object" || Array.isArray(filter)) {
+    return {};
+  }
+  const source = filter;
+  const parsed = {};
+  if (typeof source.type === "string" && NODE_TYPE_VALUES.includes(source.type)) {
+    parsed.type = source.type;
+  }
+  if (typeof source.keyword === "string") {
+    parsed.keyword = source.keyword;
+  } else if (typeof source.name === "string") {
+    parsed.keyword = source.name;
+  } else if (typeof source.text === "string") {
+    parsed.keyword = source.text;
+  }
+  if (source.bounds && typeof source.bounds === "object" && !Array.isArray(source.bounds)) {
+    parsed.bounds = source.bounds;
+  }
+  return parsed;
+}
+function matchesType(node, filter) {
+  return !filter.type || node.type === filter.type;
+}
+function matchesKeyword(node, filter) {
+  const keyword = filter.keyword?.trim().toLowerCase();
+  if (!keyword) return true;
+  const haystack = [node.id, node.type, node.name ?? "", node.assetId].join("\n").toLowerCase();
+  return haystack.includes(keyword);
+}
+function matchesBounds(node, filter) {
+  if (!filter.bounds) return true;
+  const bounds = normalizeBounds(filter.bounds);
+  if (!bounds) return true;
+  const current = nodeBounds(node);
+  return current.maxX >= bounds.minX && current.minX <= bounds.maxX && current.maxY >= bounds.minY && current.minY <= bounds.maxY;
+}
+function normalizeBounds(bounds) {
+  if (typeof bounds.minX === "number" && typeof bounds.minY === "number" && typeof bounds.maxX === "number" && typeof bounds.maxY === "number") {
+    return {
+      minX: bounds.minX,
+      minY: bounds.minY,
+      maxX: bounds.maxX,
+      maxY: bounds.maxY
+    };
+  }
+  if (typeof bounds.x === "number" && typeof bounds.y === "number" && typeof bounds.width === "number" && typeof bounds.height === "number") {
+    return {
+      minX: bounds.x,
+      minY: bounds.y,
+      maxX: bounds.x + bounds.width,
+      maxY: bounds.y + bounds.height
+    };
+  }
+  return null;
+}
+
+// src/reader.ts
+import { promises as fs2 } from "fs";
+import path3 from "path";
+
+// src/projects.ts
+import { promises as fs } from "fs";
+import net from "net";
+import os from "os";
+import path2 from "path";
+var APP_IDENTIFIER = "com.codex.pixi-board";
+var ACTIVE_PROJECT = "active";
+var LAST_PROJECT_FILE = ".last-canvas";
+var KNOWN_PROJECTS_FILE = ".known-canvas-projects.json";
+var BRIDGE_FILE = ".canvas-mcp-bridge.json";
+var BRIDGE_CONNECT_TIMEOUT_MS = 250;
+async function resolveProjectRoot(projectRoot, options) {
+  if (typeof projectRoot !== "string" || projectRoot.trim() === "") {
+    throw new BoardToolUserError('projectRoot must be a non-empty string or "active"');
+  }
+  if (projectRoot.trim() === ACTIVE_PROJECT) {
+    return resolveActiveProjectRoot(options);
+  }
+  return realpathForProject(projectRoot);
+}
+async function listKnownProjects(options) {
+  const appRoot = resolveAppRoot(options);
+  const roots = await readKnownProjectRoots(appRoot);
+  roots.sort((left, right) => projectDisplayName(left).localeCompare(projectDisplayName(right), void 0, {
+    sensitivity: "accent"
+  }));
+  const bridgeAvailability = await Promise.all(
+    roots.map(async (root) => ({
+      root,
+      bridgeAvailable: await isBridgeAvailable(root)
+    }))
+  );
+  return bridgeAvailability.map(({ root, bridgeAvailable }) => ({
+    ...toProjectInfo(root),
+    bridgeAvailable
+  }));
+}
+async function resolveActiveProjectRoot(options) {
+  const appRoot = resolveAppRoot(options);
+  const root = await readLastProject(appRoot);
+  if (!root) {
+    throw new BoardToolUserError("No active canvas project. Open a project in the desktop app first.");
+  }
+  return root;
+}
+async function readKnownProjectRoots(appRoot) {
+  const registryPath = path2.join(appRoot, KNOWN_PROJECTS_FILE);
+  let parsed = [];
+  try {
+    parsed = JSON.parse(await fs.readFile(registryPath, "utf8"));
+  } catch (error) {
+    if (!isMissing(error)) {
+      await writeKnownProjectRoots(registryPath, []);
+    }
+    return [];
+  }
+  if (!Array.isArray(parsed)) {
+    await writeKnownProjectRoots(registryPath, []);
+    return [];
+  }
+  const validRoots = [];
+  for (const entry of parsed) {
+    if (typeof entry !== "string" || entry.trim() === "") continue;
+    try {
+      const root = await fs.realpath(entry);
+      if (await isCanvasProject(root)) {
+        validRoots.push(root);
+      }
+    } catch {
+    }
+  }
+  const dedupedRoots = dedupeProjectRoots(validRoots);
+  const rawRoots = parsed.filter((entry) => typeof entry === "string" && entry.trim() !== "");
+  if (!sameProjectLists(rawRoots, dedupedRoots)) {
+    await writeKnownProjectRoots(registryPath, dedupedRoots);
+  }
+  return dedupedRoots;
+}
+async function readLastProject(appRoot) {
+  const lastProjectPath = path2.join(appRoot, LAST_PROJECT_FILE);
+  let stored;
+  try {
+    stored = await fs.readFile(lastProjectPath, "utf8");
+  } catch (error) {
+    if (isMissing(error)) return null;
+    throw error;
+  }
+  const candidate = stored.trim();
+  if (!candidate) return null;
+  try {
+    const root = await fs.realpath(candidate);
+    return await isCanvasProject(root) ? root : null;
+  } catch {
+    return null;
+  }
+}
+async function writeKnownProjectRoots(registryPath, roots) {
+  await fs.mkdir(path2.dirname(registryPath), { recursive: true });
+  await fs.writeFile(`${registryPath}.tmp`, `${JSON.stringify(roots, null, 2)}
+`, "utf8");
+  await fs.rename(`${registryPath}.tmp`, registryPath);
+}
+async function isCanvasProject(projectRoot) {
+  try {
+    const [board, assets] = await Promise.all([
+      fs.stat(path2.join(projectRoot, "board.json")),
+      fs.stat(path2.join(projectRoot, "assets.json"))
+    ]);
+    return board.isFile() && assets.isFile();
+  } catch {
+    return false;
+  }
+}
+async function realpathForProject(projectRoot) {
+  try {
+    const root = await fs.realpath(projectRoot);
+    const stat = await fs.stat(root);
+    if (!stat.isDirectory()) {
+      throw new BoardToolUserError(`projectRoot is not a directory: ${projectRoot}`);
+    }
+    if (!await isCanvasProject(root)) {
+      throw new BoardToolUserError(`invalid canvas project: ${projectRoot}`);
+    }
+    return root;
+  } catch (error) {
+    if (error instanceof BoardToolUserError) throw error;
+    throw new BoardToolUserError(`Cannot access projectRoot ${projectRoot}: ${String(error)}`);
+  }
+}
+async function isBridgeAvailable(projectRoot) {
+  const bridgePath = path2.join(projectRoot, BRIDGE_FILE);
+  let value;
+  try {
+    value = JSON.parse(await fs.readFile(bridgePath, "utf8"));
+  } catch {
+    return false;
+  }
+  if (!isEndpoint(value)) return false;
+  return canConnectToBridge(value.host, value.port);
+}
+function canConnectToBridge(host, port) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host, port });
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(result);
+    };
+    const timer = setTimeout(() => settle(false), BRIDGE_CONNECT_TIMEOUT_MS);
+    socket.once("connect", () => {
+      clearTimeout(timer);
+      settle(true);
+    });
+    socket.once("error", () => {
+      clearTimeout(timer);
+      settle(false);
+    });
+    socket.once("close", () => {
+      clearTimeout(timer);
+      settle(false);
+    });
+  });
+}
+function resolveAppRoot(options) {
+  if (options?.appRoot) {
+    return path2.resolve(options.appRoot);
+  }
+  if (process.platform === "darwin") {
+    return path2.join(os.homedir(), "Library", "Application Support", APP_IDENTIFIER);
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA;
+    if (!appData) {
+      throw new BoardToolUserError("APPDATA is not set; cannot resolve the desktop app project root");
+    }
+    return path2.join(appData, APP_IDENTIFIER);
+  }
+  const baseDir = process.env.XDG_DATA_HOME ?? path2.join(os.homedir(), ".local", "share");
+  return path2.join(baseDir, APP_IDENTIFIER);
+}
+function dedupeProjectRoots(roots) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const root of roots) {
+    const key = normalizeRootKey(root);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(root);
+  }
+  return deduped;
+}
+function sameProjectLists(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => normalizeRootKey(value) === normalizeRootKey(right[index]));
+}
+function normalizeRootKey(root) {
+  return process.platform === "win32" ? root.toLowerCase() : root;
+}
+function projectDisplayName(projectRoot) {
+  return path2.basename(projectRoot).toLowerCase();
+}
+function isMissing(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+function isEndpoint(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const endpoint = value;
+  return endpoint.version === 1 && endpoint.host === "127.0.0.1" && typeof endpoint.port === "number" && Number.isInteger(endpoint.port) && endpoint.port > 0 && typeof endpoint.token === "string" && endpoint.token.length > 0 && typeof endpoint.updatedAt === "number";
+}
+
+// src/reader.ts
+async function resolveProjectFiles(projectRoot) {
+  const root = await resolveProjectRoot(projectRoot);
+  const boardPath = path3.join(root, "board.json");
+  const assetsPath = path3.join(root, "assets.json");
+  await assertReadableFile(boardPath, "board.json");
+  await assertReadableFile(assetsPath, "assets.json");
+  return { root, boardPath, assetsPath };
+}
+async function loadProject(projectRoot) {
+  const files = await resolveProjectFiles(projectRoot);
+  const [boardResult, assetsResult] = await Promise.all([
+    readJsonFile(files.boardPath, "board.json"),
+    readJsonFile(files.assetsPath, "assets.json")
+  ]);
+  const board = parseBoardFile(boardResult.value, files.boardPath);
+  const assets = parseAssetFile(assetsResult.value, files.assetsPath);
+  return {
+    ...files,
+    boardUpdatedAt: board.updatedAt ?? boardResult.mtimeMs,
+    assetsUpdatedAt: assets.updatedAt ?? assetsResult.mtimeMs,
+    snapshot: {
+      nodes: board.nodes,
+      assets: assets.assets,
+      viewport: board.viewport ?? null
+    }
+  };
+}
+function getNodeOrThrow(snapshot, nodeId) {
+  if (typeof nodeId !== "string" || nodeId.trim() === "") {
+    throw new BoardToolUserError("nodeId must be a non-empty string");
+  }
+  const node = snapshot.nodes.find((entry) => entry.id === nodeId);
+  if (!node) {
+    throw new BoardToolUserError(`Node not found: ${nodeId}`);
+  }
+  return node;
+}
+function getAssetOrThrow(snapshot, assetId) {
+  if (typeof assetId !== "string" || assetId.trim() === "") {
+    throw new BoardToolUserError("assetId must be a non-empty string");
+  }
+  const asset = snapshot.assets.find((entry) => entry.id === assetId);
+  if (!asset) {
+    throw new BoardToolUserError(`Asset not found: ${assetId}`);
+  }
+  return asset;
+}
+function getOriginAssetForNode(snapshot, nodeId) {
+  const node = getNodeOrThrow(snapshot, nodeId);
+  const asset = getAssetOrThrow(snapshot, node.assetId);
+  if (!asset.localPath) {
+    throw new BoardToolUserError(`Asset has no original file: ${asset.id}`);
+  }
+  return asset;
+}
+async function assertReadableFile(filePath, label) {
+  try {
+    const stat = await fs2.stat(filePath);
+    if (!stat.isFile()) {
+      throw new BoardToolUserError(`${label} is not a file: ${filePath}`);
+    }
+  } catch (error) {
+    if (error instanceof BoardToolUserError) throw error;
+    throw new BoardToolUserError(`Cannot read ${label} at ${filePath}: ${errorMessage(error)}`);
+  }
+}
+async function readJsonFile(filePath, label) {
+  let text;
+  let mtimeMs = 0;
+  try {
+    const [content, stat] = await Promise.all([fs2.readFile(filePath, "utf8"), fs2.stat(filePath)]);
+    text = content;
+    mtimeMs = Math.trunc(stat.mtimeMs);
+  } catch (error) {
+    throw new BoardToolUserError(`Failed to read ${label} at ${filePath}: ${errorMessage(error)}`);
+  }
+  try {
+    return { value: JSON.parse(text), mtimeMs };
+  } catch (error) {
+    throw new BoardToolUserError(
+      `Failed to parse ${label} at ${filePath}: ${errorMessage(error)}. The file may be mid-write; retry the read.`
+    );
+  }
+}
+function parseBoardFile(value, filePath) {
+  if (!isRecord(value)) {
+    throw new BoardToolUserError(`Invalid board.json at ${filePath}: expected an object`);
+  }
+  if (!Array.isArray(value.nodes)) {
+    throw new BoardToolUserError(`Invalid board.json at ${filePath}: missing nodes array`);
+  }
+  return {
+    schemaVersion: numberOrUndefined(value.schemaVersion),
+    updatedAt: numberOrUndefined(value.updatedAt),
+    viewport: parseViewport(value.viewport),
+    nodes: value.nodes
+  };
+}
+function parseAssetFile(value, filePath) {
+  if (!isRecord(value)) {
+    throw new BoardToolUserError(`Invalid assets.json at ${filePath}: expected an object`);
+  }
+  if (!Array.isArray(value.assets)) {
+    throw new BoardToolUserError(`Invalid assets.json at ${filePath}: missing assets array`);
+  }
+  return {
+    schemaVersion: numberOrUndefined(value.schemaVersion),
+    updatedAt: numberOrUndefined(value.updatedAt),
+    assets: value.assets
+  };
+}
+function parseViewport(value) {
+  if (value === null || value === void 0) return null;
+  if (!isRecord(value) || typeof value.scale !== "number" || !isRecord(value.offset)) {
+    return null;
+  }
+  if (typeof value.offset.x !== "number" || typeof value.offset.y !== "number") {
+    return null;
+  }
+  return {
+    scale: value.scale,
+    offset: {
+      x: value.offset.x,
+      y: value.offset.y
+    }
+  };
+}
+function numberOrUndefined(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/writerClient.ts
+import { promises as fs3 } from "fs";
+import net2 from "net";
+import path4 from "path";
+var BRIDGE_FILE2 = ".canvas-mcp-bridge.json";
+var CONNECT_TIMEOUT_MS = 1500;
+var RESPONSE_TIMEOUT_MS = 3e4;
+async function sendWriteCommand(command) {
+  const files = await resolveProjectFiles(command.projectRoot);
+  const endpoint = await readBridgeEndpoint(files.root);
+  const response = await sendJsonLine(endpoint, {
+    token: endpoint.token,
+    request: {
+      ...command,
+      projectRoot: files.root
+    }
+  });
+  if (!response.ok) {
+    throw new BoardToolUserError(response.error);
+  }
+  return response.data;
+}
+async function readBridgeEndpoint(projectRoot) {
+  const bridgePath = path4.join(projectRoot, BRIDGE_FILE2);
+  let value;
+  try {
+    value = JSON.parse(await fs3.readFile(bridgePath, "utf8"));
+  } catch (error) {
+    throw new BoardToolUserError(
+      `Desktop app is not available for writes: cannot read ${BRIDGE_FILE2} in ${projectRoot}. Start the desktop app and open this project. Details: ${errorMessage(error)}`
+    );
+  }
+  if (!isEndpoint2(value)) {
+    throw new BoardToolUserError(`Desktop app bridge file is invalid: ${bridgePath}`);
+  }
+  return value;
+}
+function sendJsonLine(endpoint, payload) {
+  return new Promise((resolve, reject) => {
+    const socket = net2.createConnection({ host: endpoint.host, port: endpoint.port });
+    let buffer = "";
+    let settled = false;
+    const connectTimer = setTimeout(() => {
+      socket.destroy();
+      reject(new BoardToolUserError("Desktop app is not available for writes: bridge connection timed out"));
+    }, CONNECT_TIMEOUT_MS);
+    const responseTimer = setTimeout(() => {
+      socket.destroy();
+      reject(new BoardToolUserError("Desktop app did not finish the write command before the timeout"));
+    }, RESPONSE_TIMEOUT_MS);
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(connectTimer);
+      clearTimeout(responseTimer);
+      fn();
+    };
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      clearTimeout(connectTimer);
+      socket.write(`${JSON.stringify(payload)}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newline = buffer.indexOf("\n");
+      if (newline < 0) return;
+      const line = buffer.slice(0, newline);
+      settle(() => {
+        socket.end();
+        try {
+          const parsed = JSON.parse(line);
+          if (isBridgeResponse(parsed)) {
+            resolve(parsed);
+          } else {
+            reject(new BoardToolUserError("Desktop app returned an invalid bridge response"));
+          }
+        } catch (error) {
+          reject(new BoardToolUserError(`Desktop app returned invalid JSON: ${errorMessage(error)}`));
+        }
+      });
+    });
+    socket.on("error", (error) => {
+      settle(() => {
+        reject(
+          new BoardToolUserError(
+            `Desktop app is not available for writes: failed to connect to bridge ${endpoint.host}:${endpoint.port}. Details: ${error.message}`
+          )
+        );
+      });
+    });
+    socket.on("close", () => {
+      if (settled) return;
+      settle(() => {
+        reject(new BoardToolUserError("Desktop app bridge closed before returning a write result"));
+      });
+    });
+  });
+}
+function isEndpoint2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const endpoint = value;
+  return endpoint.version === 1 && endpoint.host === "127.0.0.1" && typeof endpoint.port === "number" && Number.isInteger(endpoint.port) && endpoint.port > 0 && typeof endpoint.token === "string" && endpoint.token.length > 0 && typeof endpoint.updatedAt === "number";
+}
+function isBridgeResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const response = value;
+  if (response.ok === true) return typeof response.data === "object" && response.data !== null;
+  if (response.ok === false) return typeof response.error === "string";
+  return false;
+}
+
+// src/index.ts
+var PROJECT_ROOT_DESCRIPTION = 'Canvas project root absolute path, or "active" for the current canvas';
+var ASSET_KIND_VALUES = ["image", "video", "audio", "model", "text", "markdown", "html", "importing", "generating"];
+var NODE_TYPE_VALUES2 = ASSET_KIND_VALUES;
+var MODEL_FORMAT_VALUES = [
+  "glb",
+  "gltf",
+  "obj",
+  "fbx",
+  "stl",
+  "ply",
+  "dae",
+  "3mf",
+  "3ds",
+  "vrml",
+  "wrl",
+  "zip"
+];
+var anyOutputSchema = {
+  type: "object",
+  additionalProperties: true
+};
+var canvasPlugin = {
+  name: "@pixi-board/board-plugin-canvas",
+  version: "0.1.0",
+  register(api) {
+    for (const tool2 of canvasTools) {
+      api.registerTool(tool2);
+    }
+  }
+};
+var plugin = canvasPlugin;
+var canvasTools = [
+  tool({
+    name: "canvas.get_project_list",
+    description: "List known canvas projects from the shared canvas project registry.",
+    inputSchema: objectSchema({}, []),
+    async run() {
+      return {
+        projects: await listKnownProjects()
+      };
+    }
+  }),
+  tool({
+    name: "canvas.get_board_snapshot",
+    description: "Read a compact board snapshot from local project files. Does not require the desktop app.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION)
+    }),
+    async run(input) {
+      const project = await loadProject(readString(input, "projectRoot"));
+      return toSnapshotDto(project.root, project.snapshot);
+    }
+  }),
+  tool({
+    name: "canvas.list_nodes",
+    description: "List compact board nodes, optionally filtered by bounds or keyword.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      filter: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          type: { type: "string", enum: NODE_TYPE_VALUES2 },
+          keyword: { type: "string" },
+          name: { type: "string" },
+          text: { type: "string" },
+          bounds: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              x: { type: "number" },
+              y: { type: "number" },
+              width: { type: "number" },
+              height: { type: "number" },
+              minX: { type: "number" },
+              minY: { type: "number" },
+              maxX: { type: "number" },
+              maxY: { type: "number" }
+            }
+          }
+        }
+      }
+    }),
+    async run(input) {
+      const args = asRecord(input);
+      const project = await loadProject(readString(args, "projectRoot"));
+      return {
+        nodes: filterNodes(project.snapshot.nodes, args.filter).map(toNodeDto)
+      };
+    }
+  }),
+  tool({
+    name: "canvas.get_node",
+    description: "Read compact details for one board node from local project files.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      nodeId: stringSchema("Node id")
+    }, ["projectRoot", "nodeId"]),
+    async run(input) {
+      const args = asRecord(input);
+      const project = await loadProject(readString(args, "projectRoot"));
+      return {
+        node: toNodeDto(getNodeOrThrow(project.snapshot, args.nodeId))
+      };
+    }
+  }),
+  tool({
+    name: "canvas.create_nodes",
+    description: "Ask the running desktop app to create asset-driven BoardNode entries from local files, then save through desktop logic. Pass a file path unless kind is generating. Write text, markdown, or html content to a source file first and pass that path. Do not provide x/y; the desktop canvas chooses placement and returns the created node coordinates.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      nodes: {
+        type: "array",
+        minItems: 1,
+        items: {
+          type: "object",
+          additionalProperties: true,
+          properties: {
+            path: { type: "string" },
+            kind: {
+              type: "string",
+              description: "Optional compatibility hint. Use generating to create a lightweight placeholder without a path; otherwise the desktop importer determines the actual asset kind from the file.",
+              enum: ASSET_KIND_VALUES
+            },
+            width: { type: "number" },
+            height: { type: "number" },
+            options: {
+              type: "object",
+              description: "Renderer parameters only. Do not put text, markdown, or html document content here.",
+              additionalProperties: true
+            },
+            name: { type: "string" }
+          }
+        }
+      }
+    }, ["projectRoot", "nodes"]),
+    async run(input) {
+      const args = asRecord(input);
+      const command = {
+        kind: "create_nodes",
+        projectRoot: readString(args, "projectRoot"),
+        nodes: readCreateNodes(args.nodes)
+      };
+      const result = await sendWriteCommand(command);
+      const project = await loadProject(command.projectRoot);
+      return {
+        nodes: result.nodes.map(toNodeDto),
+        assets: (result.assets ?? []).map((asset) => toAssetDto(project.root, asset))
+      };
+    }
+  }),
+  tool({
+    name: "canvas.generating_node_install",
+    description: "Replace an existing generating placeholder node with a real local file asset. The desktop app imports the file, updates the node type/asset/name, and resizes the node to the real asset dimensions.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      nodeId: stringSchema("Generating board node id"),
+      path: stringSchema("Local file path to install into the generating node")
+    }, ["projectRoot", "nodeId", "path"]),
+    async run(input) {
+      const args = asRecord(input);
+      const command = {
+        kind: "generating_node_install",
+        projectRoot: readString(args, "projectRoot"),
+        nodeId: readString(args, "nodeId"),
+        path: readString(args, "path")
+      };
+      const result = await sendWriteCommand(command);
+      const project = await loadProject(command.projectRoot);
+      return {
+        nodes: result.nodes.map(toNodeDto),
+        assets: (result.assets ?? []).map((asset) => toAssetDto(project.root, asset))
+      };
+    }
+  }),
+  tool({
+    name: "canvas.update_nodes",
+    description: "Ask the running desktop app to merge node geometry, name, and node option updates, then save through desktop logic. Do not send text, markdown, or html content here; edit the source file for content changes.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      updates: {
+        type: "array",
+        minItems: 1,
+        items: {
+          type: "object",
+          additionalProperties: true,
+          required: ["id"],
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            options: {
+              type: "object",
+              description: "Renderer parameters only. Do not put text, markdown, or html document content here.",
+              additionalProperties: true
+            },
+            x: { type: "number" },
+            y: { type: "number" },
+            width: { type: "number" },
+            height: { type: "number" },
+            rotation: { type: "number" },
+            zIndex: { type: "number" },
+            locked: { type: "boolean" }
+          }
+        }
+      }
+    }, ["projectRoot", "updates"]),
+    async run(input) {
+      const args = asRecord(input);
+      const command = {
+        kind: "update_nodes",
+        projectRoot: readString(args, "projectRoot"),
+        updates: readUpdates(args.updates)
+      };
+      const result = await sendWriteCommand(command);
+      return {
+        nodes: result.nodes.map(toNodeDto)
+      };
+    }
+  }),
+  tool({
+    name: "canvas.update_assets",
+    description: "Ask the running desktop app to replace asset metadata and media dimensions, then save through desktop logic. Do not use this to write text, markdown, or html content; edit the source file instead.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      assets: {
+        type: "array",
+        minItems: 1,
+        items: {
+          type: "object",
+          additionalProperties: true,
+          required: ["id"],
+          properties: {
+            id: { type: "string" },
+            metadata: { type: "object", additionalProperties: true },
+            width: { type: "number" },
+            height: { type: "number" },
+            duration: { type: "number" },
+            format: {
+              type: "string",
+              enum: MODEL_FORMAT_VALUES
+            }
+          }
+        }
+      }
+    }, ["projectRoot", "assets"]),
+    async run(input) {
+      const args = asRecord(input);
+      const command = {
+        kind: "update_assets",
+        projectRoot: readString(args, "projectRoot"),
+        assets: readAssetUpdates(args.assets)
+      };
+      const result = await sendWriteCommand(command);
+      const project = await loadProject(command.projectRoot);
+      return {
+        assets: (result.assets ?? []).map((asset) => toAssetDto(project.root, asset))
+      };
+    }
+  }),
+  tool({
+    name: "canvas.refresh_node_preview",
+    description: "Ask the running desktop app to regenerate a text, markdown, or html node preview from its source file using the node's current bounds.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      nodeId: stringSchema("Text, markdown, or html board node id")
+    }, ["projectRoot", "nodeId"]),
+    async run(input) {
+      const args = asRecord(input);
+      const command = {
+        kind: "refresh_node_preview",
+        projectRoot: readString(args, "projectRoot"),
+        nodeId: readString(args, "nodeId")
+      };
+      const result = await sendWriteCommand(command);
+      const project = await loadProject(command.projectRoot);
+      return {
+        nodes: result.nodes.map(toNodeDto),
+        assets: (result.assets ?? []).map((asset) => toAssetDto(project.root, asset))
+      };
+    }
+  }),
+  tool({
+    name: "canvas.get_origin_asset_by_node",
+    description: "Return original asset information for a file-backed board node.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      nodeId: stringSchema("Board node id")
+    }, ["projectRoot", "nodeId"]),
+    async run(input) {
+      const args = asRecord(input);
+      const project = await loadProject(readString(args, "projectRoot"));
+      const node = getNodeOrThrow(project.snapshot, args.nodeId);
+      const asset = getOriginAssetForNode(project.snapshot, args.nodeId);
+      return {
+        node: toNodeDto(node),
+        asset: {
+          ...toAssetDto(project.root, asset),
+          accessibleUrl: asset.webLink ?? asset.sourceUrl ?? null
+        }
+      };
+    }
+  }),
+  tool({
+    name: "canvas.get_asset",
+    description: "Return compact asset details including original, derivatives, and metadata.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION),
+      assetId: stringSchema("Asset id")
+    }, ["projectRoot", "assetId"]),
+    async run(input) {
+      const args = asRecord(input);
+      const project = await loadProject(readString(args, "projectRoot"));
+      return {
+        asset: toAssetDto(project.root, getAssetOrThrow(project.snapshot, args.assetId))
+      };
+    }
+  }),
+  tool({
+    name: "canvas.read_project_info",
+    description: "Read compact project info, counts, viewport, and update timestamps.",
+    inputSchema: objectSchema({
+      projectRoot: stringSchema(PROJECT_ROOT_DESCRIPTION)
+    }),
+    async run(input) {
+      const project = await loadProject(readString(input, "projectRoot"));
+      return {
+        projectRoot: project.root,
+        boardPath: project.boardPath,
+        assetsPath: project.assetsPath,
+        nodeCount: project.snapshot.nodes.length,
+        assetCount: project.snapshot.assets.length,
+        viewport: project.snapshot.viewport ?? null,
+        updatedAt: Math.max(project.boardUpdatedAt ?? 0, project.assetsUpdatedAt ?? 0),
+        boardUpdatedAt: project.boardUpdatedAt,
+        assetsUpdatedAt: project.assetsUpdatedAt
+      };
+    }
+  })
+];
+function tool(definition) {
+  return {
+    kind: "builtin",
+    outputSchema: definition.outputSchema ?? anyOutputSchema,
+    ...definition
+  };
+}
+function objectSchema(properties, required = ["projectRoot"]) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required,
+    properties
+  };
+}
+function stringSchema(description) {
+  return { type: "string", description };
+}
+function readCreateNodes(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new BoardToolUserError("nodes must be a non-empty array");
+  }
+  return value.map((entry, index) => {
+    const node = asRecord(entry, `nodes[${index}]`);
+    if (node.x !== void 0 || node.y !== void 0) {
+      throw new BoardToolUserError(`nodes[${index}].x/y is not supported; the desktop canvas chooses placement`);
+    }
+    if (node.kind !== void 0 && !isAssetKind(node.kind)) {
+      throw new BoardToolUserError(`nodes[${index}].kind must be one of ${ASSET_KIND_VALUES.join(", ")}`);
+    }
+    const kind = node.kind;
+    const hasPath = typeof node.path === "string" && node.path.trim() !== "";
+    if (kind === "generating") {
+      if (node.path !== void 0 && !hasPath) {
+        throw new BoardToolUserError(`nodes[${index}].path must be a non-empty string when provided`);
+      }
+    } else if (!hasPath) {
+      throw new BoardToolUserError(`nodes[${index}].path must be a non-empty string unless kind is generating`);
+    }
+    if (node.metadata !== void 0) {
+      throw new BoardToolUserError(`nodes[${index}].metadata is not supported; write content to a source file and pass path`);
+    }
+    if (node.text !== void 0) {
+      throw new BoardToolUserError(`nodes[${index}].text is not supported; write content to a source file and pass path`);
+    }
+    if (node.options !== void 0) {
+      asRecord(node.options, `nodes[${index}].options`);
+    }
+    return node;
+  });
+}
+function isAssetKind(value) {
+  return typeof value === "string" && ASSET_KIND_VALUES.includes(value);
+}
+function readAssetUpdates(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new BoardToolUserError("assets must be a non-empty array");
+  }
+  return value.map((entry, index) => {
+    const update = asRecord(entry, `assets[${index}]`);
+    readString(update, "id");
+    readOptionalNumber(update, "width", `assets[${index}]`);
+    readOptionalNumber(update, "height", `assets[${index}]`);
+    readOptionalNumber(update, "duration", `assets[${index}]`);
+    if (update.format !== void 0 && !MODEL_FORMAT_VALUES.includes(update.format)) {
+      throw new BoardToolUserError(`assets[${index}].format must be a supported model format`);
+    }
+    if (update.metadata !== void 0) {
+      const metadata = asRecord(update.metadata, `assets[${index}].metadata`);
+      assertNoContentMetadata(metadata, `assets[${index}].metadata`);
+    }
+    return update;
+  });
+}
+function assertNoContentMetadata(metadata, label) {
+  for (const key of ["html", "markdown", "text", "content"]) {
+    if (metadata[key] !== void 0) {
+      throw new BoardToolUserError(`${label}.${key} is not supported; edit the source file instead`);
+    }
+  }
+}
+function readUpdates(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new BoardToolUserError("updates must be a non-empty array");
+  }
+  return value.map((entry, index) => {
+    const update = asRecord(entry, `updates[${index}]`);
+    readString(update, "id");
+    if ("text" in update) {
+      throw new BoardToolUserError(`updates[${index}].text is not supported; edit the source file instead`);
+    }
+    readOptionalNumber(update, "x", `updates[${index}]`);
+    readOptionalNumber(update, "y", `updates[${index}]`);
+    readOptionalNumber(update, "width", `updates[${index}]`);
+    readOptionalNumber(update, "height", `updates[${index}]`);
+    readOptionalNumber(update, "rotation", `updates[${index}]`);
+    readOptionalNumber(update, "zIndex", `updates[${index}]`);
+    if (update.options !== void 0) {
+      asRecord(update.options, `updates[${index}].options`);
+    }
+    return update;
+  });
+}
+function readString(input, key) {
+  const record = asRecord(input);
+  const value = record[key];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new BoardToolUserError(`${key} must be a non-empty string`);
+  }
+  return value;
+}
+function readOptionalNumber(input, key, label) {
+  const value = input[key];
+  if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value))) {
+    throw new BoardToolUserError(`${label}.${key} must be a finite number`);
+  }
+}
+function asRecord(input, label = "input") {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new BoardToolUserError(`${label} must be an object`);
+  }
+  return input;
+}
+export {
+  canvasPlugin,
+  canvasTools,
+  plugin
+};