@genart-dev/plugin-distribution 0.1.0

package/dist/index.cjs

@@ -0,0 +1,903 @@
+"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,
+  densityLayerType: () => densityLayerType,
+  distributionMcpTools: () => distributionMcpTools,
+  distributionPlugin: () => distributionPlugin,
+  previewLayerType: () => previewLayerType,
+  voronoiLayerType: () => voronoiLayerType
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/preview-layer.ts
+var PREVIEW_PROPERTIES = [
+  { key: "algorithm", label: "Algorithm", type: "string", default: "poisson-disk", group: "distribution" },
+  { key: "params", label: "Parameters (JSON)", type: "string", default: "{}", group: "distribution" },
+  { key: "dotSize", label: "Dot Size", type: "number", default: 3, min: 0.5, max: 20, step: 0.5, group: "style" },
+  { key: "dotColor", label: "Dot Color", type: "color", default: "#0088ff", group: "style" },
+  { key: "opacity", label: "Opacity", type: "number", default: 0.6, min: 0, max: 1, step: 0.01, group: "style" },
+  { key: "_points", label: "Points (JSON)", type: "string", default: "[]", group: "data" }
+];
+var previewLayerType = {
+  typeId: "distribution:preview",
+  displayName: "Distribution Preview",
+  icon: "scatter_plot",
+  category: "guide",
+  properties: PREVIEW_PROPERTIES,
+  propertyEditorId: "distribution:preview-editor",
+  createDefault() {
+    return {
+      algorithm: "poisson-disk",
+      params: "{}",
+      dotSize: 3,
+      dotColor: "#0088ff",
+      opacity: 0.6,
+      _points: "[]"
+    };
+  },
+  render(properties, ctx, bounds, _resources) {
+    const points = JSON.parse(String(properties._points || "[]"));
+    if (points.length === 0) return;
+    const dotSize = Number(properties.dotSize ?? 3);
+    const dotColor = String(properties.dotColor ?? "#0088ff");
+    const opacity = Number(properties.opacity ?? 0.6);
+    ctx.save();
+    ctx.globalAlpha = opacity;
+    ctx.fillStyle = dotColor;
+    const scaleX = bounds.width;
+    const scaleY = bounds.height;
+    for (const pt of points) {
+      const x = bounds.x + pt.x * scaleX;
+      const y = bounds.y + pt.y * scaleY;
+      ctx.beginPath();
+      ctx.arc(x, y, dotSize, 0, Math.PI * 2);
+      ctx.fill();
+    }
+    ctx.restore();
+  },
+  validate() {
+    return null;
+  }
+};
+
+// src/voronoi-layer.ts
+var VORONOI_PROPERTIES = [
+  { key: "strokeColor", label: "Edge Color", type: "color", default: "#333333", group: "style" },
+  { key: "strokeWidth", label: "Edge Width", type: "number", default: 1, min: 0.5, max: 5, step: 0.5, group: "style" },
+  { key: "fillColor", label: "Fill Color", type: "color", default: "transparent", group: "style" },
+  { key: "opacity", label: "Opacity", type: "number", default: 0.7, min: 0, max: 1, step: 0.01, group: "style" },
+  { key: "_cells", label: "Cells (JSON)", type: "string", default: "[]", group: "data" }
+];
+var voronoiLayerType = {
+  typeId: "distribution:voronoi",
+  displayName: "Voronoi Overlay",
+  icon: "hexagon",
+  category: "guide",
+  properties: VORONOI_PROPERTIES,
+  propertyEditorId: "distribution:voronoi-editor",
+  createDefault() {
+    return {
+      strokeColor: "#333333",
+      strokeWidth: 1,
+      fillColor: "transparent",
+      opacity: 0.7,
+      _cells: "[]"
+    };
+  },
+  render(properties, ctx, bounds, _resources) {
+    const cells = JSON.parse(String(properties._cells || "[]"));
+    if (cells.length === 0) return;
+    const strokeColor = String(properties.strokeColor ?? "#333333");
+    const strokeWidth = Number(properties.strokeWidth ?? 1);
+    const fillColor = String(properties.fillColor ?? "transparent");
+    const opacity = Number(properties.opacity ?? 0.7);
+    ctx.save();
+    ctx.globalAlpha = opacity;
+    ctx.strokeStyle = strokeColor;
+    ctx.lineWidth = strokeWidth;
+    for (const cell of cells) {
+      const verts = cell.vertices;
+      if (verts.length < 3) continue;
+      ctx.beginPath();
+      ctx.moveTo(bounds.x + verts[0].x, bounds.y + verts[0].y);
+      for (let i = 1; i < verts.length; i++) {
+        ctx.lineTo(bounds.x + verts[i].x, bounds.y + verts[i].y);
+      }
+      ctx.closePath();
+      if (fillColor !== "transparent") {
+        ctx.fillStyle = fillColor;
+        ctx.fill();
+      }
+      ctx.stroke();
+    }
+    ctx.restore();
+  },
+  validate() {
+    return null;
+  }
+};
+
+// src/density-layer.ts
+var DENSITY_PROPERTIES = [
+  { key: "radius", label: "Kernel Radius", type: "number", default: 30, min: 5, max: 100, step: 5, group: "density" },
+  { key: "colormap", label: "Color Map", type: "string", default: "viridis", group: "style" },
+  { key: "opacity", label: "Opacity", type: "number", default: 0.65, min: 0, max: 1, step: 0.01, group: "style" },
+  { key: "_points", label: "Points (JSON)", type: "string", default: "[]", group: "data" }
+];
+var COLORMAPS = {
+  viridis: [[68, 1, 84], [59, 82, 139], [33, 144, 141], [93, 201, 99], [253, 231, 37]],
+  plasma: [[13, 8, 135], [156, 23, 158], [237, 121, 83], [240, 249, 33], [252, 230, 25]],
+  inferno: [[0, 0, 4], [120, 28, 109], [238, 125, 51], [252, 225, 31], [252, 255, 164]],
+  hot: [[0, 0, 0], [160, 0, 0], [255, 80, 0], [255, 200, 0], [255, 255, 255]],
+  cool: [[0, 255, 255], [64, 191, 255], [128, 128, 255], [191, 64, 255], [255, 0, 255]]
+};
+function colormapLookup(name, t) {
+  const stops = COLORMAPS[name] ?? COLORMAPS["viridis"];
+  const scaled = t * (stops.length - 1);
+  const lo = Math.floor(scaled), hi = Math.min(lo + 1, stops.length - 1);
+  const f = scaled - lo;
+  const slo = stops[lo];
+  const shi = stops[hi];
+  return [
+    Math.round(slo[0] + f * (shi[0] - slo[0])),
+    Math.round(slo[1] + f * (shi[1] - slo[1])),
+    Math.round(slo[2] + f * (shi[2] - slo[2]))
+  ];
+}
+var densityLayerType = {
+  typeId: "distribution:density",
+  displayName: "Density Map",
+  icon: "gradient",
+  category: "guide",
+  properties: DENSITY_PROPERTIES,
+  propertyEditorId: "distribution:density-editor",
+  createDefault() {
+    return { radius: 30, colormap: "viridis", opacity: 0.65, _points: "[]" };
+  },
+  render(properties, ctx, bounds, _resources) {
+    const points = JSON.parse(String(properties._points || "[]"));
+    if (points.length === 0) return;
+    const radius = Number(properties.radius ?? 30);
+    const colormap = String(properties.colormap ?? "viridis");
+    const opacity = Number(properties.opacity ?? 0.65);
+    const w = Math.floor(bounds.width);
+    const h = Math.floor(bounds.height);
+    if (w <= 0 || h <= 0) return;
+    const scale = 0.25;
+    const gw = Math.max(1, Math.floor(w * scale));
+    const gh = Math.max(1, Math.floor(h * scale));
+    const density = new Float32Array(gw * gh);
+    const gr = radius * scale;
+    const gr2 = gr * gr;
+    for (const pt of points) {
+      const px = pt.x * gw;
+      const py = pt.y * gh;
+      const minX = Math.max(0, Math.floor(px - gr));
+      const maxX = Math.min(gw - 1, Math.ceil(px + gr));
+      const minY = Math.max(0, Math.floor(py - gr));
+      const maxY = Math.min(gh - 1, Math.ceil(py + gr));
+      for (let gy = minY; gy <= maxY; gy++) {
+        for (let gx = minX; gx <= maxX; gx++) {
+          const dx = gx - px, dy = gy - py;
+          const d2 = dx * dx + dy * dy;
+          if (d2 < gr2) {
+            const idx2 = gy * gw + gx;
+            density[idx2] = (density[idx2] ?? 0) + (1 - d2 / gr2);
+          }
+        }
+      }
+    }
+    let maxD = 0;
+    for (let i = 0; i < density.length; i++) if ((density[i] ?? 0) > maxD) maxD = density[i] ?? 0;
+    if (maxD === 0) return;
+    const imgData = ctx.createImageData(gw, gh);
+    for (let i = 0; i < gw * gh; i++) {
+      const t = (density[i] ?? 0) / maxD;
+      const [r, g, b] = colormapLookup(colormap, t);
+      imgData.data[i * 4] = r;
+      imgData.data[i * 4 + 1] = g;
+      imgData.data[i * 4 + 2] = b;
+      imgData.data[i * 4 + 3] = t > 0 ? Math.round(t * 200) : 0;
+    }
+    const offscreen = new OffscreenCanvas(gw, gh);
+    const octx = offscreen.getContext("2d");
+    octx.putImageData(imgData, 0, 0);
+    ctx.save();
+    ctx.globalAlpha = opacity;
+    ctx.imageSmoothingEnabled = true;
+    ctx.drawImage(offscreen, bounds.x, bounds.y, bounds.width, bounds.height);
+    ctx.restore();
+  },
+  validate() {
+    return null;
+  }
+};
+
+// src/distribution-tools.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function makePrng(seed) {
+  let s = (seed | 0) >>> 0;
+  return function rng() {
+    s += 1831565813;
+    let t = s;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function poissonDisk(rng, width, height, minDist, maxAttempts = 30) {
+  const cellSize = minDist / Math.SQRT2;
+  const cols = Math.ceil(width / cellSize);
+  const rows = Math.ceil(height / cellSize);
+  const grid = new Array(cols * rows).fill(-1);
+  const pts = [];
+  const active = [];
+  function addPt(x, y) {
+    const i = pts.length;
+    pts.push([x, y]);
+    active.push(i);
+    grid[Math.floor(y / cellSize) * cols + Math.floor(x / cellSize)] = i;
+  }
+  addPt(rng() * width, rng() * height);
+  while (active.length > 0) {
+    const ri = Math.floor(rng() * active.length);
+    const pi = active[ri];
+    const p = pts[pi];
+    let found = false;
+    for (let a = 0; a < maxAttempts; a++) {
+      const angle = rng() * Math.PI * 2;
+      const dist = minDist + rng() * minDist;
+      const nx = p[0] + Math.cos(angle) * dist;
+      const ny = p[1] + Math.sin(angle) * dist;
+      if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
+      const gx = Math.floor(nx / cellSize);
+      const gy = Math.floor(ny / cellSize);
+      let ok = true;
+      for (let dx = -2; dx <= 2 && ok; dx++) {
+        for (let dy = -2; dy <= 2 && ok; dy++) {
+          const ngx = gx + dx, ngy = gy + dy;
+          if (ngx < 0 || ngx >= cols || ngy < 0 || ngy >= rows) continue;
+          const ni = grid[ngy * cols + ngx];
+          if (ni === void 0 || ni === -1) continue;
+          const q = pts[ni];
+          const ddx = q[0] - nx, ddy = q[1] - ny;
+          if (ddx * ddx + ddy * ddy < minDist * minDist) ok = false;
+        }
+      }
+      if (ok) {
+        addPt(nx, ny);
+        found = true;
+        break;
+      }
+    }
+    if (!found) active.splice(ri, 1);
+  }
+  return pts.map(([x, y]) => ({ x, y }));
+}
+var distributePointsTool = {
+  name: "distribute_points",
+  description: "Generate a spatial distribution of points using a named algorithm (poisson-disk, phyllotaxis, hex-grid, jittered-grid, and more). Returns the point array and count.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      algorithm: {
+        type: "string",
+        enum: [
+          "poisson-disk",
+          "phyllotaxis",
+          "hex-grid",
+          "tri-grid",
+          "jittered-grid",
+          "r2-sequence",
+          "halton",
+          "best-candidate",
+          "latin-hypercube",
+          "lloyd-relax"
+        ],
+        description: "Distribution algorithm"
+      },
+      width: { type: "number", description: "Canvas width in pixels" },
+      height: { type: "number", description: "Canvas height in pixels" },
+      params: {
+        type: "object",
+        description: "Algorithm-specific parameters (minDist, count, size, jitter, etc.)",
+        additionalProperties: true
+      },
+      seed: { type: "number", description: "PRNG seed for reproducibility" }
+    },
+    required: ["algorithm", "width", "height"]
+  },
+  async handler(input, _context) {
+    const algorithm = String(input.algorithm);
+    const width = Number(input.width);
+    const height = Number(input.height);
+    const params = input.params ?? {};
+    const rng = makePrng(Number(input.seed ?? 0));
+    let points = [];
+    switch (algorithm) {
+      case "poisson-disk": {
+        const minDist = params.minDist ?? 20;
+        const raw = poissonDisk(rng, width, height, minDist, params.maxAttempts ?? 30);
+        points = raw.map((p, i) => ({ ...p, size: 1, index: i }));
+        break;
+      }
+      case "phyllotaxis": {
+        const n = params.count ?? 200;
+        const PHI = Math.PI * (3 - Math.sqrt(5));
+        const scale = params.scale ?? Math.min(width, height) / 2;
+        for (let i = 0; i < n; i++) {
+          const r = Math.sqrt(i / n) * scale;
+          const theta = i * PHI;
+          points.push({ x: width / 2 + r * Math.cos(theta), y: height / 2 + r * Math.sin(theta), size: 1, index: i });
+        }
+        break;
+      }
+      case "hex-grid": {
+        const size = params.size ?? 20;
+        const colW = size * 1.5, rowH = size * Math.sqrt(3);
+        let idx = 0;
+        for (let col = 0; col <= Math.ceil(width / colW); col++) {
+          for (let row = 0; row <= Math.ceil(height / rowH); row++) {
+            const x = col * colW;
+            const y = row * rowH + (col % 2 === 1 ? rowH / 2 : 0);
+            if (x <= width && y <= height) points.push({ x, y, size, index: idx++ });
+          }
+        }
+        break;
+      }
+      case "tri-grid": {
+        const size = params.size ?? 20;
+        const rowH = size * Math.sqrt(3) / 2;
+        let idx = 0;
+        for (let row = 0; row * rowH <= height; row++) {
+          const offset = row % 2 === 1 ? size / 2 : 0;
+          for (let col = 0; col * size + offset <= width; col++) {
+            points.push({ x: col * size + offset, y: row * rowH, size, index: idx++ });
+          }
+        }
+        break;
+      }
+      case "jittered-grid": {
+        const size = params.size ?? 30;
+        const jitter = params.jitter ?? 0.5;
+        let idx = 0;
+        for (let row = 0; row * size < height; row++) {
+          for (let col = 0; col * size < width; col++) {
+            points.push({
+              x: (col + 0.5 + (rng() - 0.5) * jitter) * size,
+              y: (row + 0.5 + (rng() - 0.5) * jitter) * size,
+              size: 1,
+              index: idx++
+            });
+          }
+        }
+        break;
+      }
+      case "r2-sequence": {
+        const n = params.count ?? 100;
+        const g = 1.324717957244746;
+        const a1 = 1 / g, a2 = 1 / (g * g);
+        for (let i = 0; i < n; i++) {
+          points.push({ x: (0.5 + a1 * i) % 1 * width, y: (0.5 + a2 * i) % 1 * height, size: 1, index: i });
+        }
+        break;
+      }
+      case "halton": {
+        let haltonBase2 = function(i, base) {
+          let f = 1, r = 0;
+          while (i > 0) {
+            f /= base;
+            r += f * (i % base);
+            i = Math.floor(i / base);
+          }
+          return r;
+        };
+        var haltonBase = haltonBase2;
+        const n = params.count ?? 100;
+        for (let i = 0; i < n; i++) {
+          points.push({ x: haltonBase2(i + 1, 2) * width, y: haltonBase2(i + 1, 3) * height, size: 1, index: i });
+        }
+        break;
+      }
+      case "best-candidate": {
+        const n = params.count ?? 100;
+        const k = params.candidates ?? 10;
+        for (let i = 0; i < n; i++) {
+          let bestX = 0, bestY = 0, bestDist = -1;
+          for (let c = 0; c < k; c++) {
+            const cx = rng() * width, cy = rng() * height;
+            let minD = Infinity;
+            for (const pt of points) {
+              const dx = cx - pt.x, dy = cy - (pt.y ?? 0);
+              const d = dx * dx + dy * dy;
+              if (d < minD) minD = d;
+            }
+            if (points.length === 0) minD = Infinity;
+            if (minD > bestDist) {
+              bestDist = minD;
+              bestX = cx;
+              bestY = cy;
+            }
+          }
+          points.push({ x: bestX, y: bestY, size: 1, index: i });
+        }
+        break;
+      }
+      case "latin-hypercube": {
+        const n = params.count ?? 100;
+        const xs = Array.from({ length: n }, (_, i) => i);
+        const ys = Array.from({ length: n }, (_, i) => i);
+        for (let i = n - 1; i > 0; i--) {
+          const j = Math.floor(rng() * (i + 1));
+          [xs[i], xs[j]] = [xs[j], xs[i]];
+          const k2 = Math.floor(rng() * (i + 1));
+          [ys[i], ys[k2]] = [ys[k2], ys[i]];
+        }
+        const cellW = width / n, cellH = height / n;
+        for (let i = 0; i < n; i++) {
+          points.push({ x: (xs[i] + rng()) * cellW, y: (ys[i] + rng()) * cellH, size: 1, index: i });
+        }
+        break;
+      }
+      default: {
+        const n = params.count ?? 100;
+        for (let i = 0; i < n; i++) {
+          points.push({ x: rng() * width, y: rng() * height, size: 1, index: i });
+        }
+      }
+    }
+    return textResult(JSON.stringify({
+      points,
+      count: points.length,
+      bounds: { x: 0, y: 0, width, height }
+    }));
+  }
+};
+var packCirclesTool = {
+  name: "pack_circles",
+  description: "Pack non-overlapping circles within a region using trial-and-reject sampling. Returns (x, y, radius) tuples and coverage percentage.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      width: { type: "number" },
+      height: { type: "number" },
+      minRadius: { type: "number", default: 5 },
+      maxRadius: { type: "number", default: 50 },
+      count: { type: "number", default: 100 },
+      padding: { type: "number", default: 2 },
+      seed: { type: "number", default: 0 }
+    },
+    required: ["width", "height"]
+  },
+  async handler(input, _context) {
+    const width = Number(input.width);
+    const height = Number(input.height);
+    const minRadius = Number(input.minRadius ?? 5);
+    const maxRadius = Number(input.maxRadius ?? 50);
+    const count = Number(input.count ?? 100);
+    const padding = Number(input.padding ?? 2);
+    const rng = makePrng(Number(input.seed ?? 0));
+    const circles = [];
+    const maxAttempts = 500;
+    for (let c = 0; c < count; c++) {
+      for (let a = 0; a < maxAttempts; a++) {
+        const r = minRadius + rng() * (maxRadius - minRadius);
+        const x = r + padding + rng() * (width - 2 * r - 2 * padding);
+        const y = r + padding + rng() * (height - 2 * r - 2 * padding);
+        if (x < 0 || y < 0) continue;
+        let ok = true;
+        for (const ci of circles) {
+          const dx = x - ci.x, dy = y - ci.y;
+          if (dx * dx + dy * dy < (r + ci.radius + padding) ** 2) {
+            ok = false;
+            break;
+          }
+        }
+        if (ok) {
+          circles.push({ x, y, radius: r, index: circles.length });
+          break;
+        }
+      }
+    }
+    const area = circles.reduce((acc, c) => acc + Math.PI * c.radius * c.radius, 0);
+    return textResult(JSON.stringify({
+      circles,
+      count: circles.length,
+      coverage: area / (width * height)
+    }));
+  }
+};
+var packRectsTool = {
+  name: "pack_rects",
+  description: "Pack rectangles into a bin using the guillotine algorithm. Returns placements with x, y, width, height, and rotated flag.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      rects: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { w: { type: "number" }, h: { type: "number" }, id: { type: "string" } },
+          required: ["w", "h"]
+        }
+      },
+      width: { type: "number" },
+      height: { type: "number" },
+      padding: { type: "number", default: 2 },
+      allowRotation: { type: "boolean", default: false }
+    },
+    required: ["rects", "width", "height"]
+  },
+  async handler(input, _context) {
+    const rects = input.rects;
+    const width = Number(input.width);
+    const height = Number(input.height);
+    const padding = Number(input.padding ?? 2);
+    const allowRotation = Boolean(input.allowRotation ?? false);
+    const sorted = rects.slice().sort((a, b) => b.h * b.w - a.h * a.w);
+    const free = [{ x: 0, y: 0, w: width, h: height }];
+    const placements = [];
+    for (const rect of sorted) {
+      const rw = rect.w + padding, rh = rect.h + padding;
+      let bestScore = Infinity, bestFi = -1, bestRot = false;
+      for (let fi = 0; fi < free.length; fi++) {
+        const f = free[fi];
+        if (f.w >= rw && f.h >= rh) {
+          const score = Math.min(f.w - rw, f.h - rh);
+          if (score < bestScore) {
+            bestScore = score;
+            bestFi = fi;
+            bestRot = false;
+          }
+        }
+        if (allowRotation && f.w >= rh && f.h >= rw) {
+          const score = Math.min(f.w - rh, f.h - rw);
+          if (score < bestScore) {
+            bestScore = score;
+            bestFi = fi;
+            bestRot = true;
+          }
+        }
+      }
+      if (bestFi >= 0) {
+        const f = free[bestFi];
+        const pw = bestRot ? rh : rw, ph = bestRot ? rw : rh;
+        placements.push({ x: f.x, y: f.y, w: rect.w, h: rect.h, id: rect.id, rotated: bestRot });
+        free.splice(bestFi, 1);
+        if (f.w - pw > 0 && ph > 0) free.push({ x: f.x + pw, y: f.y, w: f.w - pw, h: ph });
+        if (f.w > 0 && f.h - ph > 0) free.push({ x: f.x, y: f.y + ph, w: f.w, h: f.h - ph });
+      } else {
+        placements.push(null);
+      }
+    }
+    const result = new Array(rects.length).fill(null);
+    for (let i = 0; i < sorted.length; i++) {
+      result[rects.indexOf(sorted[i])] = placements[i];
+    }
+    const packed = result.filter(Boolean).length;
+    const utilization = result.filter(Boolean).reduce((acc, p) => {
+      const pl = p;
+      return acc + pl.w * pl.h;
+    }, 0) / (width * height);
+    return textResult(JSON.stringify({ placements: result, packed, total: rects.length, utilization }));
+  }
+};
+var previewDistributionTool = {
+  name: "preview_distribution",
+  description: "Generate a distribution and add a distribution:preview guide layer to visualize it non-destructively.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      algorithm: { type: "string" },
+      width: { type: "number" },
+      height: { type: "number" },
+      params: { type: "object", additionalProperties: true },
+      dotSize: { type: "number", default: 3 },
+      dotColor: { type: "string", default: "#0088ff" },
+      layerName: { type: "string" },
+      seed: { type: "number", default: 0 }
+    },
+    required: ["algorithm"]
+  },
+  async handler(input, context) {
+    const algorithm = String(input.algorithm);
+    const canvasW = Number(input.width ?? context.canvasWidth);
+    const canvasH = Number(input.height ?? context.canvasHeight);
+    const ptResult = await distributePointsTool.handler(
+      { ...input, algorithm, width: canvasW, height: canvasH },
+      context
+    );
+    const ptText = ptResult.content[0];
+    if (!ptText || ptText.type !== "text" || ptResult.isError) {
+      return errorResult(`Failed to generate distribution for algorithm "${algorithm}".`);
+    }
+    const data = JSON.parse(ptText.text);
+    const layerId = `dist-preview-${Date.now().toString(36)}`;
+    context.layers.add({
+      id: layerId,
+      type: "distribution:preview",
+      name: input.layerName ?? `${algorithm} preview`,
+      visible: true,
+      locked: false,
+      opacity: 1,
+      blendMode: "normal",
+      transform: { x: 0, y: 0, width: canvasW, height: canvasH, rotation: 0, scaleX: 1, scaleY: 1, anchorX: 0.5, anchorY: 0.5 },
+      properties: {
+        algorithm,
+        params: JSON.stringify(input.params ?? {}),
+        dotSize: Number(input.dotSize ?? 3),
+        dotColor: String(input.dotColor ?? "#0088ff"),
+        opacity: 0.6,
+        _points: JSON.stringify(data.points)
+      }
+    });
+    context.emitChange("layer-added");
+    return textResult(`Added distribution preview layer '${layerId}' with ${data.count} points (algorithm: ${algorithm}).`);
+  }
+};
+var clearDistributionPreviewTool = {
+  name: "clear_distribution_preview",
+  description: "Remove distribution:preview or distribution:voronoi guide layers from the document.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      layerId: { type: "string", description: "Specific layer ID to remove; omit to remove all distribution guide layers" }
+    }
+  },
+  async handler(input, context) {
+    const layerId = input.layerId;
+    const allLayers = context.layers.getAll();
+    const toRemove = layerId ? allLayers.filter((l) => l.id === layerId) : allLayers.filter((l) => l.type.startsWith("distribution:"));
+    if (toRemove.length === 0) {
+      return textResult("No distribution guide layers found to remove.");
+    }
+    for (const l of toRemove) {
+      context.layers.remove(l.id);
+    }
+    context.emitChange("layer-removed");
+    return textResult(`Removed ${toRemove.length} distribution guide layer(s).`);
+  }
+};
+var growPatternTool = {
+  name: "grow_pattern",
+  description: "Run a growth algorithm (DLA, differential-growth, substrate) and return the resulting point set and/or paths.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      algorithm: {
+        type: "string",
+        enum: ["dla", "differential-growth", "substrate"]
+      },
+      width: { type: "number" },
+      height: { type: "number" },
+      iterations: { type: "number", default: 100 },
+      seeds: {
+        type: "array",
+        items: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } }
+      },
+      params: { type: "object", additionalProperties: true },
+      seed: { type: "number", default: 0 }
+    },
+    required: ["algorithm", "width", "height"]
+  },
+  async handler(input, _context) {
+    const algorithm = String(input.algorithm);
+    const width = Number(input.width);
+    const height = Number(input.height);
+    const iterations = Number(input.iterations ?? 100);
+    const rng = makePrng(Number(input.seed ?? 0));
+    if (algorithm === "dla") {
+      const attached = [{ x: width / 2, y: height / 2 }];
+      const grid = new Uint8Array(width * height);
+      grid[Math.floor(height / 2) * width + Math.floor(width / 2)] = 1;
+      for (let w = 0; w < iterations * 10; w++) {
+        let wx = Math.floor(rng() * width);
+        let wy = Math.floor(rng() * height);
+        for (let step = 0; step < 500; step++) {
+          wx += Math.round(rng() * 2 - 1);
+          wy += Math.round(rng() * 2 - 1);
+          if (wx < 0 || wx >= width || wy < 0 || wy >= height) break;
+          let hasN = false;
+          for (let dx = -1; dx <= 1 && !hasN; dx++) {
+            for (let dy = -1; dy <= 1 && !hasN; dy++) {
+              const nx = wx + dx, ny = wy + dy;
+              if (nx >= 0 && nx < width && ny >= 0 && ny < height && grid[ny * width + nx]) hasN = true;
+            }
+          }
+          if (hasN) {
+            grid[wy * width + wx] = 1;
+            attached.push({ x: wx, y: wy });
+            break;
+          }
+        }
+      }
+      return textResult(JSON.stringify({ points: attached.map((p, i) => ({ ...p, index: i })), count: attached.length }));
+    }
+    return textResult(JSON.stringify({
+      message: `Growth algorithm "${algorithm}" with ${iterations} iterations. Use the ${algorithm} component in sketch code for full control.`,
+      algorithm,
+      dimensions: { width, height },
+      iterations
+    }));
+  }
+};
+var tileRegionTool = {
+  name: "tile_region",
+  description: "Tile a region using Wave Function Collapse. Returns a 2D grid of tile IDs.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      tileSet: {
+        type: "object",
+        description: "Tile set: {tiles: [{id, weight?}], adjacency: {[id]: {up, down, left, right}: string[]}}"
+      },
+      width: { type: "number", description: "Grid width in tiles" },
+      height: { type: "number", description: "Grid height in tiles" },
+      seed: { type: "number", default: 0 }
+    },
+    required: ["tileSet", "width", "height"]
+  },
+  async handler(input, _context) {
+    const tileSet = input.tileSet;
+    const width = Number(input.width);
+    const height = Number(input.height);
+    const rng = makePrng(Number(input.seed ?? 0));
+    const tiles = tileSet.tiles;
+    const adj = tileSet.adjacency;
+    const tileIds = tiles.map((t) => t.id);
+    const weights = {};
+    tiles.forEach((t) => {
+      weights[t.id] = t.weight ?? 1;
+    });
+    const wave = [];
+    for (let r = 0; r < height; r++) {
+      wave.push([]);
+      for (let c = 0; c < width; c++) {
+        const wRow = wave[r];
+        wRow.push(tileIds[Math.floor(rng() * tileIds.length)] ?? tileIds[0] ?? "");
+      }
+    }
+    for (let r = 0; r < height; r++) {
+      for (let c = 0; c < width; c++) {
+        const tid = wave[r][c];
+        const nbrs = [[-1, 0, "down"], [1, 0, "up"], [0, -1, "right"], [0, 1, "left"]];
+        for (const [dr, dc, opp] of nbrs) {
+          const nr = r + dr, nc = c + dc;
+          if (nr < 0 || nr >= height || nc < 0 || nc >= width) continue;
+          const allowed = adj[tid]?.[opp] ?? tileIds;
+          if (!allowed.includes(wave[nr][nc])) {
+            wave[nr][nc] = allowed[Math.floor(rng() * allowed.length)] ?? wave[nr][nc];
+          }
+        }
+      }
+    }
+    return textResult(JSON.stringify({
+      grid: wave,
+      width,
+      height,
+      tiles: wave.flat().map((id, i) => ({ id, col: i % width, row: Math.floor(i / width) }))
+    }));
+  }
+};
+var distributeAlongPathTool = {
+  name: "distribute_along_path",
+  description: "Distribute points along a polyline using arc-length parameterization.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "array",
+        items: { type: "object", properties: { x: { type: "number" }, y: { type: "number" } } },
+        description: "Polyline points [{x, y}]"
+      },
+      count: { type: "number", default: 20 },
+      spacing: { type: "number", description: "Fixed spacing in pixels (overrides count)" },
+      offset: { type: "number", default: 0, description: "Start offset [0..1]" },
+      closed: { type: "boolean", default: false }
+    },
+    required: ["path"]
+  },
+  async handler(input, _context) {
+    const path = input.path;
+    const count = Number(input.count ?? 20);
+    const spacing = input.spacing != null ? Number(input.spacing) : null;
+    const offset = Number(input.offset ?? 0);
+    const closed = Boolean(input.closed ?? false);
+    if (path.length < 2) return textResult(JSON.stringify({ points: [], count: 0 }));
+    const lens = [0];
+    const pts = closed ? [...path, path[0]] : path;
+    for (let i = 1; i < pts.length; i++) {
+      const dx = pts[i].x - pts[i - 1].x;
+      const dy = pts[i].y - pts[i - 1].y;
+      lens.push(lens[i - 1] + Math.sqrt(dx * dx + dy * dy));
+    }
+    const totalLen = lens[lens.length - 1] ?? 0;
+    if (totalLen === 0) return textResult(JSON.stringify({ points: [], count: 0 }));
+    const n = spacing != null ? Math.floor((totalLen - offset * totalLen) / spacing) : count;
+    const step = spacing ?? totalLen / (closed ? n : Math.max(1, n - 1));
+    const result = [];
+    for (let i = 0; i < n; i++) {
+      const targetLen = offset * totalLen + i * step;
+      if (targetLen > totalLen) break;
+      let lo = 0, hi = lens.length - 2;
+      while (lo < hi) {
+        const mid = lo + hi >> 1;
+        if ((lens[mid + 1] ?? 0) < targetLen) lo = mid + 1;
+        else hi = mid;
+      }
+      const segLen = lens[lo + 1] - lens[lo];
+      const t = segLen > 0 ? (targetLen - lens[lo]) / segLen : 0;
+      const p0 = pts[lo], p1 = pts[lo + 1];
+      result.push({
+        x: p0.x + t * (p1.x - p0.x),
+        y: p0.y + t * (p1.y - p0.y),
+        t: targetLen / totalLen,
+        angle: Math.atan2(p1.y - p0.y, p1.x - p0.x),
+        index: i
+      });
+    }
+    return textResult(JSON.stringify({ points: result, count: result.length, pathLength: totalLen }));
+  }
+};
+var distributionMcpTools = [
+  distributePointsTool,
+  packCirclesTool,
+  packRectsTool,
+  previewDistributionTool,
+  clearDistributionPreviewTool,
+  growPatternTool,
+  tileRegionTool,
+  distributeAlongPathTool
+];
+
+// src/index.ts
+var distributionPlugin = {
+  id: "distribution",
+  name: "Distribution & Packing",
+  version: "0.1.0",
+  tier: "free",
+  description: "Spatial distribution algorithms (Poisson disk, phyllotaxis, hex grid, DLA, WFC, and more) plus circle/rect packing. Includes guide layers for non-destructive distribution previews.",
+  layerTypes: [previewLayerType, voronoiLayerType, densityLayerType],
+  tools: [],
+  exportHandlers: [],
+  mcpTools: distributionMcpTools,
+  async initialize(_context) {
+  },
+  dispose() {
+  }
+};
+var index_default = distributionPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  densityLayerType,
+  distributionMcpTools,
+  distributionPlugin,
+  previewLayerType,
+  voronoiLayerType
+});
+//# sourceMappingURL=index.cjs.map