figram 1.0.0

package/dist/index.js

@@ -0,0 +1,1274 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname5, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { Command } from "commander";
+
+// src/commands/build.ts
+import { writeFile } from "fs/promises";
+import { extname } from "path";
+
+// src/lib/diagram.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+
+// ../core/dist/index.js
+function diff(prev, next) {
+  const ops = [];
+  const prevNodes = prev?.nodes ?? {};
+  const prevEdges = prev?.edges ?? {};
+  const nextNodes = next.nodes;
+  const nextEdges = next.edges;
+  for (const id of Object.keys(prevEdges)) {
+    if (!(id in nextEdges)) {
+      ops.push({ op: "removeEdge", id });
+    }
+  }
+  const removedNodeIds = Object.keys(prevNodes).filter((id) => !(id in nextNodes));
+  const sortedRemovedNodes = sortNodesChildFirst(removedNodeIds, prevNodes);
+  for (const id of sortedRemovedNodes) {
+    ops.push({ op: "removeNode", id });
+  }
+  const upsertNodeIds = Object.keys(nextNodes).filter((id) => {
+    if (!(id in prevNodes))
+      return true;
+    return !nodesEqual(prevNodes[id], nextNodes[id]);
+  });
+  const sortedUpsertNodes = sortNodesParentFirst(upsertNodeIds, nextNodes);
+  for (const id of sortedUpsertNodes) {
+    ops.push({ op: "upsertNode", node: nextNodes[id] });
+  }
+  for (const id of Object.keys(nextEdges)) {
+    if (!(id in prevEdges) || !edgesEqual(prevEdges[id], nextEdges[id])) {
+      ops.push({ op: "upsertEdge", edge: nextEdges[id] });
+    }
+  }
+  return ops;
+}
+function sortNodesParentFirst(ids, nodes) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const idSet = new Set(ids);
+  function visit(id) {
+    if (visited.has(id) || !idSet.has(id))
+      return;
+    const node = nodes[id];
+    if (node.parent && idSet.has(node.parent)) {
+      visit(node.parent);
+    }
+    visited.add(id);
+    result.push(id);
+  }
+  for (const id of ids) {
+    visit(id);
+  }
+  return result;
+}
+function sortNodesChildFirst(ids, nodes) {
+  return sortNodesParentFirst(ids, nodes).reverse();
+}
+function nodesEqual(a, b) {
+  return a.id === b.id && a.provider === b.provider && a.kind === b.kind && a.label === b.label && a.parent === b.parent && a.layout.x === b.layout.x && a.layout.y === b.layout.y && a.layout.w === b.layout.w && a.layout.h === b.layout.h;
+}
+function edgesEqual(a, b) {
+  return a.id === b.id && a.from === b.from && a.to === b.to && a.label === b.label && a.color === b.color;
+}
+function normalizeIcons(icons) {
+  return icons ?? {};
+}
+function iconsEqual(a, b) {
+  const aRegistry = a ?? {};
+  const bRegistry = b ?? {};
+  const aProviders = Object.keys(aRegistry);
+  const bProviders = Object.keys(bRegistry);
+  if (aProviders.length !== bProviders.length)
+    return false;
+  for (const provider of aProviders) {
+    const aKinds = aRegistry[provider];
+    const bKinds = bRegistry[provider];
+    if (!bKinds)
+      return false;
+    const aKindKeys = Object.keys(aKinds);
+    const bKindKeys = Object.keys(bKinds);
+    if (aKindKeys.length !== bKindKeys.length)
+      return false;
+    for (const kind of aKindKeys) {
+      if (aKinds[kind] !== bKinds[kind])
+        return false;
+    }
+  }
+  return true;
+}
+function countIcons(registry) {
+  if (!registry)
+    return 0;
+  let count = 0;
+  for (const mapping of Object.values(registry)) {
+    count += Object.keys(mapping).length;
+  }
+  return count;
+}
+function mergeIconRegistries(...registries) {
+  const result = {};
+  for (const registry of registries) {
+    if (!registry)
+      continue;
+    for (const [provider, mapping] of Object.entries(registry)) {
+      if (!result[provider]) {
+        result[provider] = {};
+      }
+      Object.assign(result[provider], mapping);
+    }
+  }
+  return result;
+}
+var DEFAULT_EDGE_COLOR = "#666666";
+function normalizeHexColor(color) {
+  if (color.length === 4) {
+    const r = color[1];
+    const g = color[2];
+    const b = color[3];
+    return `#${r}${r}${g}${g}${b}${b}`.toUpperCase();
+  }
+  return color.toUpperCase();
+}
+var RESOURCE_LAYOUT = {
+  PADDING: 50,
+  ITEM_WIDTH: 160,
+  ITEM_HEIGHT: 140,
+  COLS: 2
+};
+var SUBNET_LAYOUT = {
+  PADDING: 40,
+  GAP: 40,
+  DEFAULT_WIDTH: 450,
+  DEFAULT_HEIGHT: 400,
+  COLS: 3
+};
+function isSubnet(kind) {
+  return kind === "network.subnet";
+}
+function normalize(dsl) {
+  const nodes = {};
+  const edges = {};
+  const subnetCounts = /* @__PURE__ */ new Map();
+  const resourceCounts = /* @__PURE__ */ new Map();
+  for (const node of dsl.nodes) {
+    const layout = node.layout ?? {};
+    let x = layout.x;
+    let y = layout.y;
+    let w = layout.w;
+    let h = layout.h;
+    if (node.parent && x === void 0 && y === void 0) {
+      if (isSubnet(node.kind)) {
+        const subnetIndex = subnetCounts.get(node.parent) ?? 0;
+        subnetCounts.set(node.parent, subnetIndex + 1);
+        const col = subnetIndex % SUBNET_LAYOUT.COLS;
+        const row = Math.floor(subnetIndex / SUBNET_LAYOUT.COLS);
+        x = SUBNET_LAYOUT.PADDING + col * (SUBNET_LAYOUT.DEFAULT_WIDTH + SUBNET_LAYOUT.GAP);
+        y = SUBNET_LAYOUT.PADDING + row * (SUBNET_LAYOUT.DEFAULT_HEIGHT + SUBNET_LAYOUT.GAP);
+        if (w === void 0)
+          w = SUBNET_LAYOUT.DEFAULT_WIDTH;
+        if (h === void 0)
+          h = SUBNET_LAYOUT.DEFAULT_HEIGHT;
+      } else {
+        const resourceIndex = resourceCounts.get(node.parent) ?? 0;
+        resourceCounts.set(node.parent, resourceIndex + 1);
+        const col = resourceIndex % RESOURCE_LAYOUT.COLS;
+        const row = Math.floor(resourceIndex / RESOURCE_LAYOUT.COLS);
+        x = RESOURCE_LAYOUT.PADDING + col * (RESOURCE_LAYOUT.ITEM_WIDTH + RESOURCE_LAYOUT.PADDING);
+        y = RESOURCE_LAYOUT.PADDING + row * (RESOURCE_LAYOUT.ITEM_HEIGHT + RESOURCE_LAYOUT.PADDING);
+      }
+    }
+    if (x === void 0 || y === void 0) {
+      throw new Error(`Node ${node.id} requires layout.x and layout.y`);
+    }
+    nodes[node.id] = {
+      id: node.id,
+      provider: node.provider,
+      kind: node.kind,
+      label: node.label ?? node.id,
+      parent: node.parent ?? null,
+      layout: {
+        x,
+        y,
+        w: w ?? null,
+        h: h ?? null
+      }
+    };
+  }
+  if (dsl.edges) {
+    for (const edge of dsl.edges) {
+      edges[edge.id] = {
+        id: edge.id,
+        from: edge.from,
+        to: edge.to,
+        label: edge.label ?? "",
+        color: edge.color ? normalizeHexColor(edge.color) : DEFAULT_EDGE_COLOR
+      };
+    }
+  }
+  return {
+    version: dsl.version,
+    docId: dsl.docId,
+    title: dsl.title ?? dsl.docId,
+    nodes,
+    edges
+  };
+}
+var HEX_COLOR_REGEX = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/;
+function validate(doc) {
+  const errors = [];
+  if (!doc || typeof doc !== "object") {
+    return { ok: false, errors: [{ path: "", message: "Document must be an object" }] };
+  }
+  const d = doc;
+  const nodeIds = /* @__PURE__ */ new Set();
+  let nodes = null;
+  if (typeof d.version !== "number") {
+    errors.push({ path: "version", message: "version is required and must be a number" });
+  }
+  if (typeof d.docId !== "string" || d.docId.trim() === "") {
+    errors.push({ path: "docId", message: "docId is required and must be a non-empty string" });
+  }
+  if (!Array.isArray(d.nodes)) {
+    errors.push({ path: "nodes", message: "nodes must be an array" });
+  } else {
+    nodes = d.nodes;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const path = `nodes[${i}]`;
+      if (typeof node.id !== "string" || node.id.trim() === "") {
+        errors.push({ path: `${path}.id`, message: "node id is required" });
+      } else if (nodeIds.has(node.id)) {
+        errors.push({ path: `${path}.id`, message: `duplicate node id: ${node.id}` });
+      } else {
+        nodeIds.add(node.id);
+      }
+      if (typeof node.provider !== "string") {
+        errors.push({ path: `${path}.provider`, message: "provider is required" });
+      }
+      if (typeof node.kind !== "string") {
+        errors.push({ path: `${path}.kind`, message: "kind is required" });
+      }
+      const hasParent = !!node.parent;
+      const layout = node.layout;
+      if (!hasParent && (!layout || typeof layout !== "object")) {
+        errors.push({ path: `${path}.layout`, message: "layout is required for top-level nodes" });
+      }
+      if (layout && typeof layout === "object") {
+        const hasX = layout.x !== void 0;
+        const hasY = layout.y !== void 0;
+        if (hasX !== hasY) {
+          errors.push({
+            path: `${path}.layout`,
+            message: "layout.x and layout.y must be both specified or both omitted"
+          });
+        }
+        if (!hasParent && !hasX) {
+          errors.push({
+            path: `${path}.layout.x`,
+            message: "layout.x is required for top-level nodes"
+          });
+        }
+        if (!hasParent && !hasY) {
+          errors.push({
+            path: `${path}.layout.y`,
+            message: "layout.y is required for top-level nodes"
+          });
+        }
+        if (hasX && typeof layout.x !== "number") {
+          errors.push({ path: `${path}.layout.x`, message: "layout.x must be a number" });
+        }
+        if (hasY && typeof layout.y !== "number") {
+          errors.push({ path: `${path}.layout.y`, message: "layout.y must be a number" });
+        }
+        if (layout.w !== void 0 && typeof layout.w !== "number") {
+          errors.push({ path: `${path}.layout.w`, message: "layout.w must be a number" });
+        }
+        if (layout.h !== void 0 && typeof layout.h !== "number") {
+          errors.push({ path: `${path}.layout.h`, message: "layout.h must be a number" });
+        }
+      }
+    }
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.parent && !nodeIds.has(node.parent)) {
+        errors.push({
+          path: `nodes[${i}].parent`,
+          message: `parent '${node.parent}' does not exist`
+        });
+      }
+    }
+    const cycleErrors = detectCycles(nodes);
+    errors.push(...cycleErrors);
+  }
+  if (d.edges !== void 0) {
+    if (!Array.isArray(d.edges)) {
+      errors.push({ path: "edges", message: "edges must be an array" });
+    } else {
+      const edgeIds = /* @__PURE__ */ new Set();
+      const edges = d.edges;
+      for (let i = 0; i < edges.length; i++) {
+        const edge = edges[i];
+        const path = `edges[${i}]`;
+        if (typeof edge.id !== "string" || edge.id.trim() === "") {
+          errors.push({ path: `${path}.id`, message: "edge id is required" });
+        } else if (edgeIds.has(edge.id)) {
+          errors.push({ path: `${path}.id`, message: `duplicate edge id: ${edge.id}` });
+        } else {
+          edgeIds.add(edge.id);
+        }
+        if (typeof edge.from !== "string") {
+          errors.push({ path: `${path}.from`, message: "from is required" });
+        } else if (!nodeIds.has(edge.from)) {
+          errors.push({ path: `${path}.from`, message: `from '${edge.from}' does not exist` });
+        }
+        if (typeof edge.to !== "string") {
+          errors.push({ path: `${path}.to`, message: "to is required" });
+        } else if (!nodeIds.has(edge.to)) {
+          errors.push({ path: `${path}.to`, message: `to '${edge.to}' does not exist` });
+        }
+        if (edge.color !== void 0) {
+          if (typeof edge.color !== "string") {
+            errors.push({ path: `${path}.color`, message: "color must be a string" });
+          } else if (!HEX_COLOR_REGEX.test(edge.color)) {
+            errors.push({
+              path: `${path}.color`,
+              message: "color must be a valid HEX color (#RGB or #RRGGBB)"
+            });
+          }
+        }
+      }
+    }
+  }
+  if (d.icons !== void 0) {
+    if (typeof d.icons !== "object" || d.icons === null || Array.isArray(d.icons)) {
+      errors.push({ path: "icons", message: "icons must be an object" });
+    } else {
+      const icons = d.icons;
+      for (const [provider, mapping] of Object.entries(icons)) {
+        const providerPath = `icons.${provider}`;
+        if (typeof mapping !== "object" || mapping === null || Array.isArray(mapping)) {
+          errors.push({ path: providerPath, message: "icon mapping must be an object" });
+          continue;
+        }
+        const kindMapping = mapping;
+        for (const [kind, iconPath] of Object.entries(kindMapping)) {
+          if (typeof iconPath !== "string" || iconPath.trim() === "") {
+            errors.push({
+              path: `${providerPath}.${kind}`,
+              message: "icon path must be a non-empty string"
+            });
+          }
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return { ok: true, document: doc };
+}
+function detectCycles(nodes) {
+  const errors = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.id) {
+      nodeMap.set(node.id, node);
+    }
+  }
+  for (const node of nodes) {
+    if (!node.parent)
+      continue;
+    const visited = /* @__PURE__ */ new Set();
+    let current = node.id;
+    while (current) {
+      if (visited.has(current)) {
+        errors.push({
+          path: `nodes`,
+          message: `cycle detected involving node '${node.id}'`
+        });
+        break;
+      }
+      visited.add(current);
+      const currentNode = nodeMap.get(current);
+      current = currentNode?.parent;
+    }
+  }
+  return errors;
+}
+
+// src/lib/diagram.ts
+import { parse as parseYaml } from "yaml";
+
+// src/errors.ts
+var CliError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+};
+var FileNotFoundError = class extends CliError {
+  constructor(path) {
+    super(`File not found: ${path}`, 1);
+    this.name = "FileNotFoundError";
+  }
+};
+var FileExistsError = class extends CliError {
+  constructor(path) {
+    super(`${path} already exists`, 1);
+    this.name = "FileExistsError";
+  }
+};
+var YamlParseError = class extends CliError {
+  constructor(message) {
+    super(`Failed to parse YAML: ${message}`, 1);
+    this.name = "YamlParseError";
+  }
+};
+var ValidationError = class extends CliError {
+  constructor(errors) {
+    const formatted = errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n");
+    super(`Validation errors:
+${formatted}`, 1);
+    this.name = "ValidationError";
+  }
+};
+
+// src/lib/diagram.ts
+function ensureFileExists(path) {
+  if (!existsSync(path)) {
+    throw new FileNotFoundError(path);
+  }
+}
+async function readDiagramFile(path) {
+  return readFile(path, "utf-8");
+}
+function parseDiagramYaml(content) {
+  try {
+    return parseYaml(content);
+  } catch (err) {
+    throw new YamlParseError(err.message);
+  }
+}
+function validateDiagram(parsed) {
+  const result = validate(parsed);
+  if (!result.ok) {
+    throw new ValidationError(result.errors);
+  }
+  return result.document;
+}
+function toIR(dsl) {
+  return normalize(dsl);
+}
+async function loadIRFromYamlFile(inputFile) {
+  ensureFileExists(inputFile);
+  const content = await readDiagramFile(inputFile);
+  const parsed = parseDiagramYaml(content);
+  const dsl = validateDiagram(parsed);
+  const ir = toIR(dsl);
+  return { ir };
+}
+async function tryLoadDiagram(inputFile) {
+  try {
+    const { ir } = await loadIRFromYamlFile(inputFile);
+    return { ir, error: null };
+  } catch (err) {
+    return { ir: null, error: err.message };
+  }
+}
+
+// src/commands/build.ts
+async function buildCommand(inputFile, outputFile) {
+  const { ir } = await loadIRFromYamlFile(inputFile);
+  const ext = extname(inputFile);
+  const output = outputFile ?? (inputFile.match(/\.ya?ml$/) ? inputFile.replace(/\.ya?ml$/, ".json") : ext ? `${inputFile.slice(0, -ext.length)}.json` : `${inputFile}.json`);
+  await writeFile(output, JSON.stringify(ir, null, 2));
+  console.log(`Built: ${inputFile} -> ${output}`);
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+async function initCommand() {
+  const filename = "diagram.yaml";
+  if (existsSync2(filename)) {
+    throw new FileExistsError(filename);
+  }
+  const templatePath = join(__dirname, "..", "templates", "diagram.yaml");
+  const template = await readFile2(templatePath, "utf-8");
+  await writeFile2(filename, template);
+  console.log(`Created ${filename}`);
+}
+
+// src/commands/serve.ts
+import { readFileSync } from "fs";
+import { createServer } from "http";
+import { dirname as dirname3, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/lib/icons.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname2, extname as extname2, isAbsolute, resolve } from "path";
+import { parse } from "yaml";
+var SUPPORTED_FORMATS = [".png", ".jpg", ".jpeg", ".gif", ".webp"];
+async function loadIconAsBase64(iconPath, basePath) {
+  const fullPath = isAbsolute(iconPath) ? iconPath : resolve(dirname2(basePath), iconPath);
+  const ext = extname2(fullPath).toLowerCase();
+  if (ext === ".svg") {
+    throw new Error(
+      "Unsupported image format: .svg. FigJam only supports PNG, JPG/JPEG, GIF, or WebP."
+    );
+  }
+  if (!SUPPORTED_FORMATS.includes(ext)) {
+    throw new Error(`Unsupported image format: ${ext}. Supported: ${SUPPORTED_FORMATS.join(", ")}`);
+  }
+  const buffer = await readFile3(fullPath);
+  return buffer.toString("base64");
+}
+async function resolveIcons(dslIcons, basePath) {
+  const result = {};
+  for (const [provider, mapping] of Object.entries(dslIcons)) {
+    result[provider] = {};
+    for (const [kind, iconPath] of Object.entries(mapping)) {
+      try {
+        result[provider][kind] = await loadIconAsBase64(iconPath, basePath);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.warn(`[icons] Failed to load ${provider}:${kind} from ${iconPath}: ${message}`);
+      }
+    }
+  }
+  return result;
+}
+function findIconsFile(diagramPath) {
+  const dir = dirname2(diagramPath);
+  const candidates = ["figram-icons.yaml", "figram-icons.yml"];
+  for (const candidate of candidates) {
+    const fullPath = resolve(dir, candidate);
+    if (existsSync3(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function loadIconsFile(iconsFilePath) {
+  try {
+    const content = await readFile3(iconsFilePath, "utf-8");
+    const parsed = parse(content);
+    if (!parsed || typeof parsed !== "object") {
+      return { icons: null, error: "Icons file must be a YAML object" };
+    }
+    if (!parsed.icons || typeof parsed.icons !== "object") {
+      return { icons: null, error: "Icons file must have an 'icons' field" };
+    }
+    const resolved = await resolveIcons(parsed.icons, iconsFilePath);
+    return { icons: resolved, error: null };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { icons: null, error: message };
+  }
+}
+
+// src/commands/serve/messages.ts
+var INVALID_MESSAGE_ERROR = "Invalid message format";
+function sendMessage(ws, message) {
+  ws.send(JSON.stringify(message));
+}
+function sendError(ws, message) {
+  sendMessage(ws, { type: "error", message });
+}
+function sendErrorAndClose(ws, message) {
+  ws.send(JSON.stringify({ type: "error", message }), () => {
+    try {
+      ws.close();
+    } catch {
+    }
+  });
+}
+function sendWelcome(ws, cliVersion, protocolVersion) {
+  sendMessage(ws, {
+    type: "welcome",
+    cliVersion,
+    protocolVersion
+  });
+}
+function sendFull(ws, ir, rev) {
+  sendMessage(ws, { type: "full", rev, ir });
+}
+function sendIcons(ws, icons) {
+  sendMessage(ws, { type: "icons", icons });
+}
+
+// src/commands/serve/patch.ts
+function computePatchMessage(prevIR, baseRev, nextIR) {
+  const ops = diff(prevIR, nextIR);
+  if (ops.length === 0) return null;
+  return { type: "patch", baseRev, nextRev: baseRev + 1, ops };
+}
+
+// src/commands/serve/watcher.ts
+import { watch } from "fs";
+var FileWatcher = class {
+  watcher = null;
+  debounceTimer = null;
+  debounceMs;
+  constructor(options = {}) {
+    this.debounceMs = options.debounceMs ?? 200;
+  }
+  watch(filePath, onChange) {
+    this.close();
+    try {
+      this.watcher = watch(filePath, () => {
+        this.scheduleCallback(onChange);
+      });
+      console.log(`Watching: ${filePath}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`Warning: failed to watch ${filePath}: ${message}`);
+    }
+  }
+  scheduleCallback(callback) {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(callback, this.debounceMs);
+  }
+  close() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  isWatching() {
+    return this.watcher !== null;
+  }
+};
+var IconsWatcher = class {
+  watcher = null;
+  debounceTimer = null;
+  currentPath = null;
+  debounceMs;
+  constructor(options = {}) {
+    this.debounceMs = options.debounceMs ?? 200;
+  }
+  update(filePath, onChange) {
+    const shouldReset = this.currentPath !== filePath;
+    this.currentPath = filePath;
+    if (!shouldReset && this.watcher) return;
+    this.close();
+    if (!filePath) return;
+    try {
+      this.watcher = watch(filePath, () => {
+        this.scheduleCallback(onChange);
+      });
+      console.log(`Watching icons: ${filePath}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`[icons] Warning: failed to watch ${filePath}: ${message}`);
+    }
+  }
+  scheduleCallback(callback) {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(callback, this.debounceMs);
+  }
+  close() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.currentPath = null;
+  }
+  getCurrentPath() {
+    return this.currentPath;
+  }
+};
+
+// src/commands/serve/websocket.ts
+import { WebSocketServer } from "ws";
+function isValidClientMessage(msg) {
+  return typeof msg === "object" && msg !== null && typeof msg.type === "string";
+}
+var WebSocketManager = class {
+  wss;
+  clients = /* @__PURE__ */ new Map();
+  options;
+  state;
+  constructor(httpServer, options, state) {
+    this.wss = new WebSocketServer({ server: httpServer });
+    this.options = options;
+    this.state = state;
+    this.setupConnectionHandler();
+  }
+  setupConnectionHandler() {
+    this.wss.on("connection", (ws, _req) => {
+      this.clients.set(ws, {
+        docId: null,
+        authenticated: !this.options.secret
+      });
+      console.log("Client connected");
+      ws.on("message", (data) => this.handleMessage(ws, data));
+      ws.on("close", () => this.handleClose(ws));
+    });
+  }
+  handleMessage(ws, data) {
+    const clientState = this.clients.get(ws);
+    if (!clientState) return;
+    try {
+      const raw = JSON.parse(String(data));
+      if (!isValidClientMessage(raw)) {
+        sendError(ws, INVALID_MESSAGE_ERROR);
+        return;
+      }
+      const msgType = raw.type;
+      if (msgType === "hello") {
+        this.handleHello(ws, clientState, raw);
+      } else if (msgType === "requestFull") {
+        this.handleRequestFull(ws, clientState, raw);
+      }
+    } catch {
+      sendError(ws, INVALID_MESSAGE_ERROR);
+    }
+  }
+  handleHello(ws, clientState, raw) {
+    if (this.options.secret && raw.secret !== this.options.secret) {
+      sendErrorAndClose(ws, "Invalid secret");
+      return;
+    }
+    clientState.authenticated = true;
+    clientState.docId = raw.docId ?? null;
+    sendWelcome(ws, this.options.getCliVersion(), this.options.protocolVersion);
+    const currentIR = this.state.getCurrentIR();
+    const currentIcons = this.state.getCurrentIcons();
+    const currentRev = this.state.getCurrentRev();
+    if (currentIR && currentIR.docId === raw.docId) {
+      if (currentIcons && Object.keys(currentIcons).length > 0) {
+        sendIcons(ws, currentIcons);
+        console.log(`Sent ${countIcons(currentIcons)} custom icons to client`);
+      }
+      sendFull(ws, currentIR, currentRev);
+      console.log(`Sent full IR to client (rev ${currentRev})`);
+    } else {
+      sendError(ws, `docId mismatch: expected ${raw.docId}, got ${currentIR?.docId}`);
+    }
+  }
+  handleRequestFull(ws, clientState, raw) {
+    if (this.options.secret && !clientState.authenticated) {
+      sendError(ws, "Authentication required");
+      return;
+    }
+    const currentIR = this.state.getCurrentIR();
+    const currentIcons = this.state.getCurrentIcons();
+    const currentRev = this.state.getCurrentRev();
+    if (currentIR && currentIR.docId === raw.docId) {
+      if (currentIcons && Object.keys(currentIcons).length > 0) {
+        sendIcons(ws, currentIcons);
+      }
+      sendFull(ws, currentIR, currentRev);
+    }
+  }
+  handleClose(ws) {
+    this.clients.delete(ws);
+    console.log("Client disconnected");
+  }
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    const currentIR = this.state.getCurrentIR();
+    for (const [ws, clientState] of this.clients.entries()) {
+      if (clientState.authenticated && clientState.docId === currentIR?.docId) {
+        try {
+          ws.send(data);
+        } catch {
+        }
+      }
+    }
+  }
+  onError(callback) {
+    this.wss.once("error", callback);
+  }
+  async close() {
+    return new Promise((resolve3) => this.wss.close(() => resolve3()));
+  }
+};
+
+// src/commands/serve.ts
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var PROTOCOL_VERSION = 1;
+function getCliVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join2(__dirname2, "..", "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function serveCommand(inputFile, options) {
+  ensureFileExists(inputFile);
+  let currentIR = null;
+  let currentIcons = null;
+  let currentRev = 0;
+  const diagramWatcher = new FileWatcher();
+  const iconsWatcher = new IconsWatcher();
+  function resolveIconsFilePath() {
+    return options.iconsFile ?? findIconsFile(inputFile);
+  }
+  async function loadIcons() {
+    let inlineIcons = null;
+    let fileIcons = null;
+    try {
+      const content = await readDiagramFile(inputFile);
+      const parsed = parseDiagramYaml(content);
+      const dsl = validateDiagram(parsed);
+      if (dsl.icons && Object.keys(dsl.icons).length > 0) {
+        inlineIcons = await resolveIcons(dsl.icons, inputFile);
+      }
+    } catch {
+    }
+    const resolvedIconsFilePath = resolveIconsFilePath();
+    if (options.watch) {
+      iconsWatcher.update(resolvedIconsFilePath, handleIconsChange);
+    }
+    if (resolvedIconsFilePath) {
+      const result = await loadIconsFile(resolvedIconsFilePath);
+      if (result.error) {
+        console.warn(`[icons] Warning: ${result.error}`);
+      } else {
+        fileIcons = result.icons;
+        console.log(`Loaded icons: ${resolvedIconsFilePath}`);
+      }
+    }
+    const merged = mergeIconRegistries(fileIcons, inlineIcons);
+    const iconCount = countIcons(merged);
+    if (iconCount > 0) {
+      console.log(`Custom icons: ${iconCount} icons loaded`);
+      return merged;
+    }
+    return null;
+  }
+  async function updateIcons() {
+    const nextIcons = await loadIcons();
+    if (iconsEqual(currentIcons, nextIcons)) {
+      return false;
+    }
+    currentIcons = nextIcons;
+    const payload = normalizeIcons(nextIcons);
+    wsManager.broadcast({ type: "icons", icons: payload });
+    const iconCount = countIcons(payload);
+    if (iconCount > 0) {
+      console.log(`[icons] Synced ${iconCount} custom icons`);
+    } else {
+      console.log("[icons] Cleared custom icons");
+    }
+    return true;
+  }
+  async function handleIconsChange() {
+    const path = iconsWatcher.getCurrentPath();
+    if (path) {
+      console.log(`[icons] File changed: ${path}`);
+    }
+    await updateIcons();
+  }
+  async function handleFileChange() {
+    console.log(`File changed: ${inputFile}`);
+    const { ir: ir2, error: error2 } = await tryLoadDiagram(inputFile);
+    if (error2) {
+      console.error(`Parse error: ${error2}`);
+      wsManager.broadcast({ type: "error", message: error2 });
+      return;
+    }
+    if (!ir2) return;
+    const patch = computePatchMessage(currentIR, currentRev, ir2);
+    currentIR = ir2;
+    const iconsUpdated = await updateIcons();
+    if (!patch) {
+      if (!iconsUpdated) {
+        console.log(`[rev ${currentRev}] No changes`);
+      }
+      return;
+    }
+    currentRev = patch.nextRev;
+    console.log(`[rev ${currentRev}] ${patch.ops.length} changes`);
+    wsManager.broadcast(patch);
+  }
+  const { ir, error } = await tryLoadDiagram(inputFile);
+  if (error) {
+    throw new Error(error);
+  }
+  currentIR = ir;
+  console.log(`Loaded: ${inputFile} (docId: ${ir?.docId})`);
+  currentIcons = await loadIcons();
+  const bindHost = options.allowRemote ? "0.0.0.0" : options.host;
+  const httpServer = createServer((_req, res) => {
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end("figram WebSocket server");
+  });
+  const wsManager = new WebSocketManager(
+    httpServer,
+    {
+      secret: options.secret,
+      getCliVersion,
+      protocolVersion: PROTOCOL_VERSION
+    },
+    {
+      getCurrentIR: () => currentIR,
+      getCurrentIcons: () => currentIcons,
+      getCurrentRev: () => currentRev
+    }
+  );
+  let actualPort = options.port;
+  const wssErrorPromise = new Promise((_, reject) => {
+    wsManager.onError(reject);
+  });
+  try {
+    await Promise.race([
+      new Promise((resolve3, reject) => {
+        httpServer.once("error", reject);
+        httpServer.listen(options.port, bindHost, () => {
+          const address = httpServer.address();
+          if (address && typeof address === "object") {
+            actualPort = address.port;
+          }
+          resolve3();
+        });
+      }),
+      wssErrorPromise
+    ]);
+  } catch (err) {
+    const e = err;
+    const code = e?.code;
+    if (code === "EADDRINUSE") {
+      throw new CliError(
+        `Port ${options.port} is already in use (try --port ${options.port + 1})`,
+        1
+      );
+    }
+    if (code === "EACCES" || code === "EPERM") {
+      throw new CliError(
+        `Permission denied listening on ${bindHost}:${options.port} (try a different --port)`,
+        1
+      );
+    }
+    throw e;
+  }
+  const connectHost = bindHost === "0.0.0.0" ? "127.0.0.1" : bindHost;
+  console.log(`WebSocket server listening on ws://${connectHost}:${actualPort}`);
+  if (bindHost === "0.0.0.0") {
+    console.log("Tip: for LAN clients, use this machine's IP address (not 0.0.0.0).");
+  }
+  if (options.watch) {
+    diagramWatcher.watch(inputFile, handleFileChange);
+    iconsWatcher.update(resolveIconsFilePath(), handleIconsChange);
+  }
+  const sigintHandler = () => {
+    console.log("\nShutting down...");
+    wsManager.close();
+    httpServer.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", sigintHandler);
+  return {
+    port: actualPort,
+    close: async () => {
+      process.off("SIGINT", sigintHandler);
+      diagramWatcher.close();
+      iconsWatcher.close();
+      await wsManager.close();
+      await new Promise((resolve3) => httpServer.close(() => resolve3()));
+    }
+  };
+}
+
+// src/commands/version.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname4, join as join3, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = dirname4(fileURLToPath3(import.meta.url));
+function findMonorepoRoot() {
+  let dir = resolve2(__dirname3, "..", "..");
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = join3(dir, "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        if (pkg.workspaces) {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    dir = dirname4(dir);
+  }
+  throw new CliError("Could not find monorepo root", 1);
+}
+function getPackages() {
+  const root = findMonorepoRoot();
+  const packagesDir = join3(root, "packages");
+  const packages = [];
+  const packageNames = ["core", "cli", "plugin"];
+  for (const name of packageNames) {
+    const pkgPath = join3(packagesDir, name, "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        packages.push({
+          name: packageJson.name,
+          path: join3(packagesDir, name),
+          version: packageJson.version,
+          packageJson
+        });
+      } catch (err) {
+        throw new CliError(`Failed to read ${pkgPath}: ${err}`, 1);
+      }
+    }
+  }
+  return packages;
+}
+function parseVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) {
+    throw new CliError(`Invalid version format: ${version}`, 1);
+  }
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+function bumpVersion(version, type) {
+  const parsed = parseVersion(version);
+  switch (type) {
+    case "major":
+      return `${parsed.major + 1}.0.0`;
+    case "minor":
+      return `${parsed.major}.${parsed.minor + 1}.0`;
+    case "patch":
+      return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+  }
+}
+async function versionShowCommand() {
+  const packages = getPackages();
+  console.log("\nFigram Package Versions\n");
+  console.log("Package              Version");
+  console.log("\u2500".repeat(40));
+  for (const pkg of packages) {
+    const name = pkg.name.padEnd(20);
+    console.log(`${name} ${pkg.version}`);
+  }
+  console.log();
+}
+async function versionCheckCommand() {
+  const packages = getPackages();
+  const issues = [];
+  console.log("\nChecking version consistency...\n");
+  const versions = new Set(packages.map((p) => p.version));
+  if (versions.size > 1) {
+    console.log("Package versions differ (this may be intentional):");
+    for (const pkg of packages) {
+      console.log(`  ${pkg.name}: ${pkg.version}`);
+    }
+    console.log();
+  }
+  const corePackage = packages.find((p) => p.name === "@figram/core");
+  if (corePackage) {
+    for (const pkg of packages) {
+      if (pkg.name === "@figram/core") continue;
+      const deps = { ...pkg.packageJson.dependencies, ...pkg.packageJson.devDependencies };
+      const coreDep = deps["@figram/core"];
+      if (coreDep && coreDep !== "workspace:*") {
+        issues.push(`${pkg.name} has non-workspace dependency on @figram/core: ${coreDep}`);
+      }
+    }
+  }
+  for (const pkg of packages) {
+    try {
+      parseVersion(pkg.version);
+    } catch {
+      issues.push(`${pkg.name} has invalid version: ${pkg.version}`);
+    }
+  }
+  if (issues.length > 0) {
+    console.log("Issues found:");
+    for (const issue of issues) {
+      console.log(`  \u26A0 ${issue}`);
+    }
+    console.log();
+    throw new CliError("Version check failed", 1);
+  }
+  console.log("\u2713 All version checks passed\n");
+}
+async function versionBumpCommand(type, options) {
+  const allPackages = getPackages();
+  let packagesToUpdate;
+  if (options.packages) {
+    const requestedNames = options.packages.split(",").map((n) => n.trim());
+    packagesToUpdate = allPackages.filter((p) => {
+      const shortName = p.name.replace("@figram/", "");
+      return requestedNames.includes(p.name) || requestedNames.includes(shortName);
+    });
+    if (packagesToUpdate.length === 0) {
+      throw new CliError(`No matching packages found for: ${options.packages}`, 1);
+    }
+  } else {
+    packagesToUpdate = allPackages;
+  }
+  console.log(`
+Version bump: ${type}
+`);
+  const updates = [];
+  for (const pkg of packagesToUpdate) {
+    const oldVersion = pkg.version;
+    const newVersion = bumpVersion(oldVersion, type);
+    updates.push({ pkg, oldVersion, newVersion });
+  }
+  console.log("Planned changes:");
+  console.log("\u2500".repeat(50));
+  for (const { pkg, oldVersion, newVersion } of updates) {
+    console.log(`  ${pkg.name}: ${oldVersion} \u2192 ${newVersion}`);
+  }
+  console.log();
+  if (options.dryRun) {
+    console.log("Dry run - no changes made\n");
+    return;
+  }
+  for (const { pkg, newVersion } of updates) {
+    const pkgJsonPath = join3(pkg.path, "package.json");
+    const content = readFileSync2(pkgJsonPath, "utf-8");
+    const updatedContent = content.replace(/"version":\s*"[^"]+"/, `"version": "${newVersion}"`);
+    writeFileSync(pkgJsonPath, updatedContent);
+    console.log(`  \u2713 Updated ${pkg.name}`);
+  }
+  console.log("\nVersion bump complete!\n");
+  console.log("Next steps:");
+  console.log("  1. Update CHANGELOG.md for each package");
+  console.log("  2. Run: bun run build && bun run check && bun test");
+  console.log("  3. Commit: git commit -am 'chore: bump version to X.Y.Z'");
+  console.log(`  4. Tag: git tag v${updates[0]?.newVersion ?? "X.Y.Z"}`);
+  console.log();
+}
+async function versionSyncCommand(targetVersion, options) {
+  try {
+    parseVersion(targetVersion);
+  } catch {
+    throw new CliError(`Invalid target version: ${targetVersion}`, 1);
+  }
+  const packages = getPackages();
+  console.log(`
+Syncing all packages to version ${targetVersion}
+`);
+  const updates = [];
+  for (const pkg of packages) {
+    if (pkg.version !== targetVersion) {
+      updates.push({ pkg, oldVersion: pkg.version });
+    }
+  }
+  if (updates.length === 0) {
+    console.log("All packages already at target version\n");
+    return;
+  }
+  console.log("Planned changes:");
+  console.log("\u2500".repeat(50));
+  for (const { pkg, oldVersion } of updates) {
+    console.log(`  ${pkg.name}: ${oldVersion} \u2192 ${targetVersion}`);
+  }
+  console.log();
+  if (options.dryRun) {
+    console.log("Dry run - no changes made\n");
+    return;
+  }
+  for (const { pkg } of updates) {
+    const pkgJsonPath = join3(pkg.path, "package.json");
+    const content = readFileSync2(pkgJsonPath, "utf-8");
+    const updatedContent = content.replace(/"version":\s*"[^"]+"/, `"version": "${targetVersion}"`);
+    writeFileSync(pkgJsonPath, updatedContent);
+    console.log(`  \u2713 Updated ${pkg.name}`);
+  }
+  console.log("\nVersion sync complete!\n");
+}
+
+// src/index.ts
+var __dirname4 = dirname5(fileURLToPath4(import.meta.url));
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync3(join4(__dirname4, "..", "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function createProgram() {
+  const program = new Command();
+  program.name("figram").description("YAML-driven architecture diagrams for FigJam").version(getVersion(), "-v, --version", "Show version").showHelpAfterError().showSuggestionAfterError();
+  program.command("init").description("Create a diagram.yaml template").action(async () => {
+    await initCommand();
+  });
+  program.command("build").description("Build YAML to IR JSON").argument("[file]", "Input YAML file", "diagram.yaml").option("-o, --output <file>", "Output file path (default: input file with .json extension)").action(async (file, options) => {
+    await buildCommand(file, options.output);
+  });
+  program.command("serve").description("Start WebSocket server with watch").argument("[file]", "Input YAML file", "diagram.yaml").option("-p, --port <port>", "WebSocket server port", "3456").option("--host <host>", "Host to bind", "127.0.0.1").option("--no-watch", "Disable file watching").option("--allow-remote", "Allow connections from remote hosts").option("--secret <secret>", "Require secret for connection").option("--icons <path>", "Path to icons configuration file (figram-icons.yaml)").action(
+    async (file, options) => {
+      const port = parseInt(options.port ?? "3456", 10);
+      if (!Number.isFinite(port) || port < 1 || port > 65535) {
+        throw new CliError(`Invalid port: ${options.port}. Use a value between 1 and 65535.`, 1);
+      }
+      await serveCommand(file, {
+        port,
+        host: options.host ?? "127.0.0.1",
+        watch: options.watch ?? true,
+        allowRemote: options.allowRemote ?? false,
+        secret: options.secret,
+        iconsFile: options.icons
+      });
+    }
+  );
+  const versionCmd = program.command("version").description("Manage package versions across the monorepo");
+  versionCmd.command("show", { isDefault: true }).description("Show versions of all packages").action(async () => {
+    await versionShowCommand();
+  });
+  versionCmd.command("check").description("Check version consistency across packages").action(async () => {
+    await versionCheckCommand();
+  });
+  versionCmd.command("bump <type>").description("Bump versions (major, minor, or patch)").option("-p, --packages <names>", "Comma-separated package names to update (default: all)").option("-n, --dry-run", "Show what would be changed without making changes").action(async (type, options) => {
+    if (!["major", "minor", "patch"].includes(type)) {
+      throw new CliError(`Invalid bump type: ${type}. Use major, minor, or patch.`, 1);
+    }
+    await versionBumpCommand(type, options);
+  });
+  versionCmd.command("sync <version>").description("Sync all packages to a specific version").option("-n, --dry-run", "Show what would be changed without making changes").action(async (version, options) => {
+    await versionSyncCommand(version, options);
+  });
+  return program;
+}
+async function main() {
+  const program = createProgram();
+  if (process.argv.slice(2).length === 0) {
+    program.outputHelp();
+    return;
+  }
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  if (err instanceof CliError) {
+    console.error(`Error: ${err.message}`);
+    process.exit(err.exitCode);
+  }
+  console.error("Error:", err.message);
+  process.exit(1);
+});