@genart-dev/plugin-symbols 0.1.0

package/README.md

@@ -0,0 +1,83 @@
+# @genart-dev/plugin-symbols
+
+Vector symbol library plugin for [genart.dev](https://genart.dev) — design layer rendering, Iconify integration, and symbol management tools. Renders SVG path data as non-destructive canvas layers with fill/stroke overrides and aspect ratio control.
+
+Part of [genart.dev](https://genart.dev) — a generative art platform with an MCP server, desktop app, and IDE extensions.
+
+## Install
+
+```bash
+npm install @genart-dev/plugin-symbols
+```
+
+## Usage
+
+```typescript
+import symbolsPlugin from "@genart-dev/plugin-symbols";
+import { createDefaultRegistry } from "@genart-dev/core";
+
+const registry = createDefaultRegistry();
+registry.registerPlugin(symbolsPlugin);
+
+// Or access individual exports
+import {
+  symbolLayerType,
+  symbolMcpTools,
+} from "@genart-dev/plugin-symbols";
+```
+
+## Layer Types (1)
+
+### Symbol (`symbols:symbol`, image)
+
+Renders SVG path data as a canvas layer. Paths are stored as JSON and drawn via Path2D with viewBox-to-bounds coordinate transformation.
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `symbolId` | string | `""` | Symbol ID (e.g. `"ph-cat"`) |
+| `iconifyId` | string | `""` | Original Iconify ID (e.g. `"ph:cat"`) |
+| `viewBox` | string | `"0 0 24 24"` | SVG viewBox |
+| `paths` | string | `"[]"` | SVG path data (JSON array of `{ d, fill?, stroke?, strokeWidth?, role? }`) |
+| `fillOverride` | string | `""` | Override fill color for all paths |
+| `strokeOverride` | string | `""` | Override stroke color for all paths |
+| `preserveAspect` | boolean | `true` | Maintain aspect ratio (letterbox) or stretch to fill |
+
+## Test Render
+
+![Symbol layer montage](test-renders/symbol-layer.png)
+
+24-panel montage showing the symbol layer type rendering real Iconify icons:
+- **Row 1**: Phosphor icons (fill style) — cat, tree, sun, heart, star, mountains
+- **Row 2**: Lucide icons (stroke style) — anchor, house, flower, cloud, waves, arrow-left
+- **Row 3**: Tabler icons (stroke style) — butterfly, planet, campfire, sailboat, kayak, wave-square
+- **Row 4**: Layer features — fill override (red), stroke override (green), no-aspect-preserve, fill override (blue), stroke override (gold), fill override (purple)
+
+Regenerate with `node render-test-symbols.cjs` (requires `canvas` dev dependency and network access).
+
+## MCP Tools (7)
+
+| Tool | Description |
+|------|-------------|
+| `search_symbols` | Search the symbol registry by keyword, category, and/or style |
+| `list_symbol_categories` | List all symbol categories with counts |
+| `add_symbol` | Add a registry symbol to a sketch with symbol-draw component |
+| `remove_symbol` | Remove a symbol from a sketch |
+| `create_symbol` | Create a custom symbol with SVG path data and validate it |
+| `fetch_symbol` | Search Iconify or embed an icon into a sketch (275k+ icons) |
+| `place_symbol` | Place a symbol as a `symbols:symbol` design layer on the canvas |
+
+## Related Packages
+
+| Package | Purpose |
+|---------|---------|
+| [`@genart-dev/symbols`](https://github.com/genart-dev/symbols) | Symbol data registry and Iconify integration (dependency) |
+| [`@genart-dev/core`](https://github.com/genart-dev/core) | Plugin host, layer system (dependency) |
+| [`@genart-dev/mcp-server`](https://github.com/genart-dev/mcp-server) | MCP server that surfaces plugin tools to AI agents |
+
+## Support
+
+Questions, bugs, or feedback — [support@genart.dev](mailto:support@genart.dev) or [open an issue](https://github.com/genart-dev/plugin-symbols/issues).
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,566 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  symbolLayerType: () => symbolLayerType,
+  symbolMcpTools: () => symbolMcpTools,
+  symbolsPlugin: () => symbolsPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/symbol-layer.ts
+var SYMBOL_PROPERTIES = [
+  { key: "symbolId", label: "Symbol ID", type: "string", default: "", group: "symbol" },
+  { key: "iconifyId", label: "Iconify ID", type: "string", default: "", group: "symbol" },
+  { key: "viewBox", label: "ViewBox", type: "string", default: "0 0 24 24", group: "symbol" },
+  { key: "paths", label: "Paths (JSON)", type: "string", default: "[]", group: "data" },
+  { key: "fillOverride", label: "Fill Override", type: "string", default: "", group: "appearance" },
+  { key: "strokeOverride", label: "Stroke Override", type: "string", default: "", group: "appearance" },
+  { key: "preserveAspect", label: "Preserve Aspect", type: "boolean", default: true, group: "layout" }
+];
+var symbolLayerType = {
+  typeId: "symbols:symbol",
+  displayName: "Symbol",
+  icon: "symbol",
+  category: "image",
+  properties: SYMBOL_PROPERTIES,
+  propertyEditorId: "symbols:symbol-editor",
+  createDefault() {
+    return {
+      symbolId: "",
+      iconifyId: "",
+      viewBox: "0 0 24 24",
+      paths: "[]",
+      fillOverride: "",
+      strokeOverride: "",
+      preserveAspect: true
+    };
+  },
+  render(properties, ctx, bounds, _resources) {
+    const pathsJson = String(properties.paths ?? "[]");
+    let paths;
+    try {
+      paths = JSON.parse(pathsJson);
+    } catch {
+      return;
+    }
+    if (paths.length === 0) return;
+    const viewBoxStr = String(properties.viewBox ?? "0 0 24 24");
+    const vb = viewBoxStr.split(/\s+/).map(Number);
+    const vbX = vb[0] ?? 0;
+    const vbY = vb[1] ?? 0;
+    const vbW = vb[2] ?? 24;
+    const vbH = vb[3] ?? 24;
+    const preserveAspect = Boolean(properties.preserveAspect ?? true);
+    const fillOverride = String(properties.fillOverride ?? "") || void 0;
+    const strokeOverride = String(properties.strokeOverride ?? "") || void 0;
+    let scaleX = bounds.width / vbW;
+    let scaleY = bounds.height / vbH;
+    let offsetX = 0;
+    let offsetY = 0;
+    if (preserveAspect) {
+      const uniformScale = Math.min(scaleX, scaleY);
+      offsetX = (bounds.width - vbW * uniformScale) / 2;
+      offsetY = (bounds.height - vbH * uniformScale) / 2;
+      scaleX = uniformScale;
+      scaleY = uniformScale;
+    }
+    ctx.save();
+    ctx.translate(bounds.x + offsetX - vbX * scaleX, bounds.y + offsetY - vbY * scaleY);
+    ctx.scale(scaleX, scaleY);
+    for (const p of paths) {
+      const path = new Path2D(p.d);
+      if (p.fill !== "none") {
+        ctx.fillStyle = fillOverride ?? p.fill ?? "#000000";
+        ctx.fill(path);
+      }
+      if (p.stroke || strokeOverride) {
+        ctx.strokeStyle = strokeOverride ?? p.stroke ?? "#000000";
+        ctx.lineWidth = (p.strokeWidth ?? 1) / Math.max(scaleX, scaleY);
+        ctx.stroke(path);
+      }
+    }
+    ctx.restore();
+  },
+  validate() {
+    return null;
+  }
+};
+
+// src/symbol-tools.ts
+var import_core = require("@genart-dev/core");
+var import_symbols = require("@genart-dev/symbols");
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+var VALID_STYLES = ["geometric", "organic", "silhouette", "sketch"];
+var JS_RENDERERS = /* @__PURE__ */ new Set(["p5", "three", "canvas2d", "svg"]);
+var ICONIFY_NOTICES = {
+  ph: {
+    name: "Phosphor Icons",
+    license: "MIT",
+    copyright: "Copyright (c) 2023 Phosphor Icons",
+    url: "https://github.com/phosphor-icons/core"
+  },
+  lucide: {
+    name: "Lucide",
+    license: "ISC",
+    copyright: "Copyright (c) 2022 Lucide Contributors",
+    url: "https://github.com/lucide-icons/lucide"
+  },
+  tabler: {
+    name: "Tabler Icons",
+    license: "MIT",
+    copyright: "Copyright (c) 2020-2024 Pawe\u0142 Kuna",
+    url: "https://github.com/tabler/tabler-icons"
+  },
+  heroicons: {
+    name: "Heroicons",
+    license: "MIT",
+    copyright: "Copyright (c) 2020 Tailwind Labs, Inc.",
+    url: "https://github.com/tailwindlabs/heroicons"
+  },
+  bi: {
+    name: "Bootstrap Icons",
+    license: "MIT",
+    copyright: "Copyright (c) 2019-2024 The Bootstrap Authors",
+    url: "https://github.com/twbs/icons"
+  },
+  mdi: {
+    name: "Material Design Icons",
+    license: "Apache-2.0",
+    copyright: "Copyright (c) Google LLC",
+    url: "https://github.com/google/material-design-icons"
+  },
+  ri: {
+    name: "Remix Icon",
+    license: "Remix Icon License v1.0",
+    copyright: "Copyright (c) 2017-2024 Remix Design",
+    url: "https://github.com/Remix-Design/RemixIcon"
+  },
+  carbon: {
+    name: "Carbon Icons",
+    license: "Apache-2.0",
+    copyright: "Copyright (c) 2015 IBM Corp.",
+    url: "https://github.com/carbon-design-system/carbon"
+  },
+  fluent: {
+    name: "Fluent UI System Icons",
+    license: "MIT",
+    copyright: "Copyright (c) 2020 Microsoft Corporation",
+    url: "https://github.com/microsoft/fluentui-system-icons"
+  }
+};
+var searchSymbolsTool = {
+  name: "search_symbols",
+  description: "Search the symbol registry by keyword, category, and/or style. Returns symbols with their IDs, tags, and available styles.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Keyword to match against symbol name, tags, and description" },
+      category: { type: "string", enum: ["nature", "architecture", "people", "vehicles", "objects", "animals", "abstract", "celestial", "flora", "weather"], description: "Filter by category" },
+      style: { type: "string", enum: ["geometric", "organic", "silhouette", "sketch"], description: "Filter by available style" },
+      limit: { type: "number", description: "Maximum results to return (default: 20)" }
+    }
+  },
+  async handler(input, _context) {
+    const results = (0, import_symbols.searchSymbols)({
+      query: input["query"],
+      category: input["category"],
+      style: input["style"],
+      limit: input["limit"] ?? 20
+    });
+    return textResult(JSON.stringify({ count: results.length, symbols: results }));
+  }
+};
+var listSymbolCategoriesTool = {
+  name: "list_symbol_categories",
+  description: "List all symbol categories with symbol counts. Use this to browse the symbol library before searching.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  },
+  async handler(_input, _context) {
+    const categories = (0, import_symbols.listCategories)();
+    const total = Object.keys(import_symbols.SYMBOL_REGISTRY).length;
+    const breakdown = categories.map((cat) => ({
+      category: cat,
+      count: Object.values(import_symbols.SYMBOL_REGISTRY).filter((s) => s.category === cat).length
+    }));
+    return textResult(JSON.stringify({ categories: breakdown, total }));
+  }
+};
+var addSymbolTool = {
+  name: "add_symbol",
+  description: "Add a symbol from the registry to a sketch. Resolves the symbol's SVG path data and caches it in the sketch file. Automatically adds the symbol-draw component if not already present.",
+  inputSchema: {
+    type: "object",
+    required: ["symbol"],
+    properties: {
+      symbol: { type: "string", description: "Symbol ID (e.g. 'pine-tree', 'sailboat', 'mountain')" },
+      style: { type: "string", enum: ["geometric", "organic", "silhouette", "sketch"], description: "Style variant to use (default: 'geometric')" }
+    }
+  },
+  async handler(input, context) {
+    const symbolName = input["symbol"];
+    const renderer = context.sketch.getRenderer();
+    if (!JS_RENDERERS.has(renderer)) {
+      return errorResult(
+        `Symbols require a JS-based renderer (p5, canvas2d, svg, three). Renderer "${renderer}" does not support symbols.`
+      );
+    }
+    const style = input["style"] ?? "geometric";
+    if (!VALID_STYLES.includes(style)) {
+      return errorResult(`Unknown style "${style}". Valid styles: ${VALID_STYLES.join(", ")}`);
+    }
+    const resolved = (0, import_symbols.resolveSymbol)(symbolName, style);
+    const existing = context.sketch.getSymbols();
+    if (existing[symbolName]) {
+      return errorResult(`Symbol "${symbolName}" is already present in the sketch`);
+    }
+    const newSymbols = { ...existing, [symbolName]: resolved };
+    const existingComponents = context.sketch.getComponents();
+    if (!existingComponents["symbol-draw"]) {
+      const compMap = {};
+      for (const [name, value] of Object.entries(existingComponents)) {
+        if (typeof value === "string") {
+          compMap[name] = value;
+        } else if (value && typeof value === "object" && "version" in value) {
+          compMap[name] = value.version;
+        }
+      }
+      compMap["symbol-draw"] = "^1.0.0";
+      const resolved2 = (0, import_core.resolveComponents)(compMap, renderer);
+      const resolvedRecord = {};
+      for (const rc of resolved2) {
+        resolvedRecord[rc.name] = { version: rc.version, code: rc.code, exports: [...rc.exports] };
+      }
+      context.sketch.setComponents(resolvedRecord);
+    }
+    context.sketch.setSymbols(newSymbols);
+    context.sketch.setGenartVersion("1.3");
+    context.emitChange("sketch-updated");
+    const added = Object.keys(newSymbols).filter((k) => !existing[k]);
+    return textResult(JSON.stringify({
+      success: true,
+      added,
+      symbolCount: Object.keys(newSymbols).length
+    }));
+  }
+};
+var removeSymbolTool = {
+  name: "remove_symbol",
+  description: "Remove a symbol from a sketch. Warns if the algorithm references the symbol ID.",
+  inputSchema: {
+    type: "object",
+    required: ["symbol"],
+    properties: {
+      symbol: { type: "string", description: "Symbol ID to remove" }
+    }
+  },
+  async handler(input, context) {
+    const symbolName = input["symbol"];
+    const existing = context.sketch.getSymbols();
+    if (!existing[symbolName]) {
+      return errorResult(`Symbol "${symbolName}" is not present in the sketch`);
+    }
+    const newSymbols = { ...existing };
+    delete newSymbols[symbolName];
+    context.sketch.setSymbols(
+      Object.keys(newSymbols).length > 0 ? newSymbols : void 0
+    );
+    context.emitChange("sketch-updated");
+    return textResult(JSON.stringify({
+      success: true,
+      removed: symbolName,
+      symbolCount: Object.keys(newSymbols).length
+    }));
+  }
+};
+var createSymbolTool = {
+  name: "create_symbol",
+  description: "Create a custom AI-generated symbol with SVG path data. Validates path syntax and enforces a 10KB size limit. Caches it in the sketch file for use with drawSymbol().",
+  inputSchema: {
+    type: "object",
+    required: ["name", "category", "tags", "description", "paths", "viewBox", "style"],
+    properties: {
+      name: { type: "string", description: "Human-readable symbol name (e.g. 'Weeping Willow')" },
+      id: { type: "string", description: "Symbol ID (kebab-case, auto-generated from name if omitted)" },
+      category: { type: "string", enum: ["nature", "architecture", "people", "vehicles", "objects", "animals", "abstract", "celestial", "flora", "weather"], description: "Symbol category" },
+      tags: { type: "array", items: { type: "string" }, description: "Search tags (e.g. ['tree', 'weeping', 'willow', 'nature'])" },
+      description: { type: "string", description: "Short description of the symbol" },
+      paths: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            d: { type: "string", description: "SVG path d attribute" },
+            fill: { type: "string" },
+            stroke: { type: "string" },
+            strokeWidth: { type: "number" },
+            role: { type: "string", description: "Semantic role (e.g. 'trunk', 'canopy')" }
+          },
+          required: ["d"]
+        },
+        description: "Array of SVG path objects"
+      },
+      viewBox: { type: "string", description: "SVG viewBox (e.g. '0 0 100 100')" },
+      style: { type: "string", enum: ["geometric", "organic", "silhouette", "sketch"], description: "Visual style of these paths" }
+    }
+  },
+  async handler(input, context) {
+    const paths = input["paths"];
+    const viewBox = input["viewBox"];
+    const errors = (0, import_symbols.validateSymbol)(paths, viewBox);
+    if (errors.length > 0) {
+      return errorResult(`Symbol validation failed:
+${errors.join("\n")}`);
+    }
+    const style = input["style"] ?? "geometric";
+    if (!VALID_STYLES.includes(style)) {
+      return errorResult(`Unknown style "${style}". Valid styles: ${VALID_STYLES.join(", ")}`);
+    }
+    const name = input["name"];
+    const id = input["id"] ?? name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    const symbolDef = {
+      id,
+      name,
+      style,
+      paths,
+      viewBox,
+      custom: true
+    };
+    const renderer = context.sketch.getRenderer();
+    if (!JS_RENDERERS.has(renderer)) {
+      return errorResult(
+        `Symbols require a JS-based renderer. Renderer "${renderer}" does not support symbols.`
+      );
+    }
+    const existing = context.sketch.getSymbols();
+    const newSymbols = { ...existing, [id]: symbolDef };
+    context.sketch.setSymbols(newSymbols);
+    context.sketch.setGenartVersion("1.3");
+    context.emitChange("sketch-updated");
+    return textResult(JSON.stringify({
+      success: true,
+      symbol: symbolDef,
+      tip: `Use drawSymbol(ctx, "${id}", x, y, width, height) to render this symbol in your algorithm.`
+    }));
+  }
+};
+var fetchSymbolTool = {
+  name: "fetch_symbol",
+  description: "Search Iconify for professional icons (275k+ from Phosphor, Lucide, Tabler, MDI, etc.) or embed one into a sketch. Two modes: (1) Search \u2014 provide query to get a list of iconifyIds; (2) Embed \u2014 provide iconifyId (e.g. 'ph:cat') to fetch SVG, parse paths, and embed as a SketchSymbolDef. Approved prefixes: ph, lucide, tabler, heroicons, bi, mdi, ri, carbon, fluent.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Keyword to search Iconify (e.g. 'cat', 'arrow left', 'sun'). Returns a list of iconifyIds \u2014 no SVG fetched yet." },
+      iconifyId: { type: "string", description: "Iconify icon ID to embed (e.g. 'ph:cat', 'lucide:arrow-left'). Fetches SVG, parses paths, embeds in sketch." },
+      prefix: { type: "string", description: "Limit search to a specific icon set (e.g. 'ph', 'lucide', 'tabler'). Ignored when using iconifyId." },
+      limit: { type: "number", description: "Maximum search results to return (default: 10)" }
+    }
+  },
+  async handler(input, context) {
+    const query = input["query"];
+    const iconifyId = input["iconifyId"];
+    if (query && !iconifyId) {
+      const prefixes = input["prefix"] ? [input["prefix"]] : void 0;
+      const results = await (0, import_symbols.searchIconify)(query, input["limit"] ?? 10, prefixes);
+      return textResult(JSON.stringify({
+        mode: "search",
+        results,
+        tip: "Call fetch_symbol with iconifyId to embed one of these icons into a sketch"
+      }));
+    }
+    if (!iconifyId) {
+      return errorResult(
+        "Provide either query (to search) or iconifyId (to embed). Approved prefixes: " + Object.keys(import_symbols.SAFE_PREFIXES).join(", ")
+      );
+    }
+    let iconData;
+    try {
+      iconData = await (0, import_symbols.fetchAndParseIcon)(iconifyId);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("not in the approved list")) {
+        return textResult(JSON.stringify({ warning: msg }));
+      }
+      return errorResult(msg);
+    }
+    const symbolId = iconData.iconifyId.replace(":", "-");
+    const symbolDef = {
+      id: symbolId,
+      name: iconData.name,
+      paths: iconData.paths,
+      viewBox: iconData.viewBox,
+      iconifyId: iconData.iconifyId,
+      license: iconData.license
+    };
+    const renderer = context.sketch.getRenderer();
+    if (!JS_RENDERERS.has(renderer)) {
+      return errorResult(
+        `Symbols require a JS-based renderer. Renderer "${renderer}" does not support symbols.`
+      );
+    }
+    const existing = context.sketch.getSymbols();
+    const newSymbols = { ...existing, [symbolId]: symbolDef };
+    context.sketch.setSymbols(newSymbols);
+    const notice = ICONIFY_NOTICES[iconData.prefix];
+    const existingNotices = context.sketch.getThirdParty();
+    const alreadyPresent = existingNotices.some(
+      (n) => n.name === notice?.name
+    );
+    if (notice && !alreadyPresent) {
+      context.sketch.setThirdParty([
+        ...existingNotices,
+        notice
+      ]);
+    }
+    context.sketch.setGenartVersion("1.3");
+    context.emitChange("sketch-updated");
+    return textResult(JSON.stringify({
+      mode: "embedded",
+      symbolId,
+      iconifyId: iconData.iconifyId,
+      license: iconData.license,
+      viewBox: iconData.viewBox,
+      pathCount: iconData.paths.length,
+      tip: `drawSymbol(ctx, "${symbolId}", x, y, width, height)`
+    }));
+  }
+};
+var placeSymbolTool = {
+  name: "place_symbol",
+  description: "Place a symbol as a design layer on the canvas. Creates a symbols:symbol layer with embedded SVG path data for visual composition.",
+  inputSchema: {
+    type: "object",
+    required: ["symbolId", "viewBox", "paths"],
+    properties: {
+      symbolId: { type: "string", description: "Symbol ID (e.g. 'ph-cat')" },
+      iconifyId: { type: "string", description: "Original Iconify ID (e.g. 'ph:cat')" },
+      viewBox: { type: "string", description: "SVG viewBox (e.g. '0 0 256 256')" },
+      paths: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            d: { type: "string", description: "SVG path d attribute" },
+            fill: { type: "string" },
+            stroke: { type: "string" },
+            strokeWidth: { type: "number" },
+            role: { type: "string" }
+          },
+          required: ["d"]
+        },
+        description: "Array of SVG path objects"
+      },
+      x: { type: "number", description: "X position (default: 0)" },
+      y: { type: "number", description: "Y position (default: 0)" },
+      width: { type: "number", description: "Layer width (default: 100)" },
+      height: { type: "number", description: "Layer height (default: 100)" }
+    }
+  },
+  async handler(input, context) {
+    const symbolId = input["symbolId"];
+    const iconifyId = input["iconifyId"] ?? "";
+    const viewBox = input["viewBox"];
+    const paths = input["paths"];
+    const x = input["x"] ?? 0;
+    const y = input["y"] ?? 0;
+    const width = input["width"] ?? 100;
+    const height = input["height"] ?? 100;
+    const id = `symbol-${symbolId}-${Date.now()}`;
+    context.layers.add({
+      id,
+      type: "symbols:symbol",
+      name: symbolId,
+      visible: true,
+      locked: false,
+      opacity: 1,
+      blendMode: "normal",
+      transform: {
+        x,
+        y,
+        width,
+        height,
+        rotation: 0,
+        scaleX: 1,
+        scaleY: 1,
+        anchorX: 0.5,
+        anchorY: 0.5
+      },
+      properties: {
+        symbolId,
+        iconifyId,
+        viewBox,
+        paths: JSON.stringify(paths),
+        fillOverride: "",
+        strokeOverride: "",
+        preserveAspect: true
+      }
+    });
+    context.emitChange("layer-added");
+    return textResult(JSON.stringify({
+      layerId: id,
+      symbolId,
+      position: { x, y },
+      size: { width, height }
+    }));
+  }
+};
+var symbolMcpTools = [
+  searchSymbolsTool,
+  listSymbolCategoriesTool,
+  addSymbolTool,
+  removeSymbolTool,
+  createSymbolTool,
+  fetchSymbolTool,
+  placeSymbolTool
+];
+
+// src/index.ts
+var symbolsPlugin = {
+  id: "symbols",
+  name: "Symbols & Icons",
+  version: "0.1.0",
+  tier: "free",
+  description: "Vector symbol library with Iconify integration. Search, fetch, and place symbols on the design canvas or embed in algorithms.",
+  layerTypes: [symbolLayerType],
+  tools: [],
+  exportHandlers: [],
+  mcpTools: symbolMcpTools,
+  async initialize(_context) {
+  },
+  dispose() {
+  }
+};
+var index_default = symbolsPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  symbolLayerType,
+  symbolMcpTools,
+  symbolsPlugin
+});
+//# sourceMappingURL=index.cjs.map