@pinepaper.studio/mcp-server 1.6.27 → 1.6.29

package/dist/vendor/design/textile-weave-generator.js

@@ -31,58 +31,58 @@ export function generatePlainWeaveCode(opts = {}) {
     const slubJitter = opts.slubJitter ?? 0;
     const opacity = opts.opacity ?? 0.85;
     const prefix = opts.idPrefix ?? "plain_weave";
-    return `// Plain Weave / Tabby Vector Generator
-(function() {
-  const items = [];
-  const x0 = ${x}, y0 = ${y}, x1 = ${x + w}, y1 = ${y + h};
-  const pitch = ${pitch};
-  const strokeWidth = ${threadWidth};
-  const slubJitter = ${slubJitter};
-
-  // Vertical Warp threads
-  let colIdx = 0;
-  for (let vx = x0; vx <= x1; vx += pitch) {
-    const jitterX = slubJitter ? (Math.sin(colIdx * 1.7) * slubJitter * 2) : 0;
-    const warp = new paper.Path.Line({
-      from: [vx + jitterX, y0],
-      to: [vx + jitterX, y1],
-      strokeColor: "${warpColor}",
-      strokeWidth: strokeWidth,
-      strokeCap: "round",
-      dashArray: [pitch, pitch],
-      dashOffset: (colIdx % 2 === 0) ? 0 : pitch,
-      opacity: ${opacity}
-    });
-    const id = "${prefix}_warp_" + colIdx;
-    if (typeof app.registerItem === "function") app.registerItem(warp, id, { source: "weave_generator", weave: "plain", role: "warp" });
-    items.push(warp);
-    colIdx++;
-  }
-
-  // Horizontal Weft threads
-  let rowIdx = 0;
-  for (let vy = y0; vy <= y1; vy += pitch) {
-    const jitterY = slubJitter ? (Math.cos(rowIdx * 1.7) * slubJitter * 2) : 0;
-    const weft = new paper.Path.Line({
-      from: [x0, vy + jitterY],
-      to: [x1, vy + jitterY],
-      strokeColor: "${weftColor}",
-      strokeWidth: strokeWidth,
-      strokeCap: "round",
-      dashArray: [pitch, pitch],
-      dashOffset: (rowIdx % 2 === 0) ? pitch : 0,
-      opacity: ${opacity}
-    });
-    const id = "${prefix}_weft_" + rowIdx;
-    if (typeof app.registerItem === "function") app.registerItem(weft, id, { source: "weave_generator", weave: "plain", role: "weft" });
-    items.push(weft);
-    rowIdx++;
-  }
-
-  const group = new paper.Group(items);
-  if (typeof app.registerItem === "function") app.registerItem(group, "${prefix}_group", { source: "weave_generator", weave: "plain" });
-  return group;
-})();`;
+    return ("// Plain Weave / Tabby Vector Generator\n(function() {\n  const items = [];\n  const x0 = " +
+String(x) +
+", y0 = " +
+String(y) +
+", x1 = " +
+String(x + w) +
+", y1 = " +
+String(y + h) +
+";\n  const pitch = " +
+String(pitch) +
+";\n  const strokeWidth = " +
+String(threadWidth) +
+";\n  const slubJitter = " +
+String(slubJitter) +
+";\n\n  // Vertical Warp threads\n  let colIdx = 0;\n  for (let vx = x0; vx <= x1; vx += pitch) {\n    const jitterX = slubJitter ? (Math.sin(colIdx * 1.7) * slubJitter * 2) : 0;\n    const warp = new paper.Path.Line({\n      from: [vx + jitterX, y0],\n      to: [vx + jitterX, y1],\n      strokeColor: \"" +
+String(warpColor) +
+"\",\n      strokeWidth: strokeWidth,\n      strokeCap: \"round\",\n      dashArray: [pitch, pitch],\n      dashOffset: (colIdx % 2 === 0) ? 0 : pitch,\n      opacity: " +
+String(opacity) +
+"\n    });\n    const id = \"" +
+String(prefix) +
+"_warp_\" + colIdx;\n    if (typeof app.registerItem === \"function\") app.registerItem(warp, id, { source: \"weave_generator\", weave: \"plain\", role: \"warp\" });\n    items.push(warp);\n    colIdx++;\n  }\n\n  // Horizontal Weft threads\n  let rowIdx = 0;\n  for (let vy = y0; vy <= y1; vy += pitch) {\n    const jitterY = slubJitter ? (Math.cos(rowIdx * 1.7) * slubJitter * 2) : 0;\n    const weft = new paper.Path.Line({\n      from: [x0, vy + jitterY],\n      to: [x1, vy + jitterY],\n      strokeColor: \"" +
+String(weftColor) +
+"\",\n      strokeWidth: strokeWidth,\n      strokeCap: \"round\",\n      dashArray: [pitch, pitch],\n      dashOffset: (rowIdx % 2 === 0) ? pitch : 0,\n      opacity: " +
+String(opacity) +
+"\n    });\n    const id = \"" +
+String(prefix) +
+"_weft_\" + rowIdx;\n    if (typeof app.registerItem === \"function\") app.registerItem(weft, id, { source: \"weave_generator\", weave: \"plain\", role: \"weft\" });\n    items.push(weft);\n    rowIdx++;\n  }\n\n  const group = new paper.Group(items);\n  if (typeof app.registerItem === \"function\") app.registerItem(group, \"" +
+String(prefix) +
+"_group\", { source: \"weave_generator\", weave: \"plain\" });\n  return group;\n})();"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+);
 }
 /**
  * Generate Paper.js code for a Twill / Herringbone Weave.
@@ -103,80 +103,80 @@ export function generateTwillWeaveCode(opts = {}) {
     const weftColor = opts.weftColor ?? "rgba(203, 213, 225, 0.5)";
     const opacity = opts.opacity ?? 0.9;
     const prefix = opts.idPrefix ?? (isHerringbone ? "herringbone_weave" : "twill_weave");
-    return `// Twill Weave & Herringbone Vector Generator
-(function() {
-  const items = [];
-  const x0 = ${x}, y0 = ${y}, x1 = ${x + w}, y1 = ${y + h};
-  const pitch = ${pitch};
-  const floatLen = pitch * ${floatRatio};
-  const isHerringbone = ${isHerringbone};
-  const chevronWidth = ${chevronW};
-
-  // Warp lines (base grid)
-  let colIdx = 0;
-  for (let vx = x0; vx <= x1; vx += pitch) {
-    const warp = new paper.Path.Line({
-      from: [vx, y0],
-      to: [vx, y1],
-      strokeColor: "${warpColor}",
-      strokeWidth: ${threadWidth},
-      strokeCap: "round",
-      opacity: ${opacity * 0.7}
-    });
-    const id = "${prefix}_warp_" + colIdx;
-    if (typeof app.registerItem === "function") app.registerItem(warp, id, { source: "weave_generator", weave: "twill", role: "warp" });
-    items.push(warp);
-    colIdx++;
-  }
-
-  // Weft float lines with diagonal stepped offsets
-  let rowIdx = 0;
-  for (let vy = y0; vy <= y1; vy += pitch) {
-    if (isHerringbone) {
-      // Split into chevron blocks with reversing slants
-      for (let bx = x0; bx < x1; bx += chevronWidth) {
-        const segEnd = Math.min(x1, bx + chevronWidth);
-        const blockIdx = Math.floor((bx - x0) / chevronWidth);
-        const dir = (blockIdx % 2 === 0) ? 1 : -1;
-        const phase = dir === 1 ? ((rowIdx * pitch) % (floatLen * 2)) : (((1000 - rowIdx) * pitch) % (floatLen * 2));
-        const weftSeg = new paper.Path.Line({
-          from: [bx, vy],
-          to: [segEnd, vy],
-          strokeColor: "${weftColor}",
-          strokeWidth: ${threadWidth},
-          strokeCap: "round",
-          dashArray: [floatLen, pitch],
-          dashOffset: phase,
-          opacity: ${opacity}
-        });
-        const id = "${prefix}_weft_" + rowIdx + "_" + blockIdx;
-        if (typeof app.registerItem === "function") app.registerItem(weftSeg, id, { source: "weave_generator", weave: "herringbone", role: "weft" });
-        items.push(weftSeg);
-      }
-    } else {
-      // Classic diagonal twill
-      const phase = (rowIdx * pitch) % (floatLen * 2);
-      const weft = new paper.Path.Line({
-        from: [x0, vy],
-        to: [x1, vy],
-        strokeColor: "${weftColor}",
-        strokeWidth: ${threadWidth},
-        strokeCap: "round",
-        dashArray: [floatLen, pitch],
-        dashOffset: phase,
-        opacity: ${opacity}
-      });
-      const id = "${prefix}_weft_" + rowIdx;
-      if (typeof app.registerItem === "function") app.registerItem(weft, id, { source: "weave_generator", weave: "twill", role: "weft" });
-      items.push(weft);
-    }
-    rowIdx++;
-  }
+    return ("// Twill Weave & Herringbone Vector Generator\n(function() {\n  const items = [];\n  const x0 = " +
+String(x) +
+", y0 = " +
+String(y) +
+", x1 = " +
+String(x + w) +
+", y1 = " +
+String(y + h) +
+";\n  const pitch = " +
+String(pitch) +
+";\n  const floatLen = pitch * " +
+String(floatRatio) +
+";\n  const isHerringbone = " +
+String(isHerringbone) +
+";\n  const chevronWidth = " +
+String(chevronW) +
+";\n\n  // Warp lines (base grid)\n  let colIdx = 0;\n  for (let vx = x0; vx <= x1; vx += pitch) {\n    const warp = new paper.Path.Line({\n      from: [vx, y0],\n      to: [vx, y1],\n      strokeColor: \"" +
+String(warpColor) +
+"\",\n      strokeWidth: " +
+String(threadWidth) +
+",\n      strokeCap: \"round\",\n      opacity: " +
+String(opacity * 0.7) +
+"\n    });\n    const id = \"" +
+String(prefix) +
+"_warp_\" + colIdx;\n    if (typeof app.registerItem === \"function\") app.registerItem(warp, id, { source: \"weave_generator\", weave: \"twill\", role: \"warp\" });\n    items.push(warp);\n    colIdx++;\n  }\n\n  // Weft float lines with diagonal stepped offsets\n  let rowIdx = 0;\n  for (let vy = y0; vy <= y1; vy += pitch) {\n    if (isHerringbone) {\n      // Split into chevron blocks with reversing slants\n      for (let bx = x0; bx < x1; bx += chevronWidth) {\n        const segEnd = Math.min(x1, bx + chevronWidth);\n        const blockIdx = Math.floor((bx - x0) / chevronWidth);\n        const dir = (blockIdx % 2 === 0) ? 1 : -1;\n        const phase = dir === 1 ? ((rowIdx * pitch) % (f" +
+"loatLen * 2)) : (((1000 - rowIdx) * pitch) % (floatLen * 2));\n        const weftSeg = new paper.Path.Line({\n          from: [bx, vy],\n          to: [segEnd, vy],\n          strokeColor: \"" +
+String(weftColor) +
+"\",\n          strokeWidth: " +
+String(threadWidth) +
+",\n          strokeCap: \"round\",\n          dashArray: [floatLen, pitch],\n          dashOffset: phase,\n          opacity: " +
+String(opacity) +
+"\n        });\n        const id = \"" +
+String(prefix) +
+"_weft_\" + rowIdx + \"_\" + blockIdx;\n        if (typeof app.registerItem === \"function\") app.registerItem(weftSeg, id, { source: \"weave_generator\", weave: \"herringbone\", role: \"weft\" });\n        items.push(weftSeg);\n      }\n    } else {\n      // Classic diagonal twill\n      const phase = (rowIdx * pitch) % (floatLen * 2);\n      const weft = new paper.Path.Line({\n        from: [x0, vy],\n        to: [x1, vy],\n        strokeColor: \"" +
+String(weftColor) +
+"\",\n        strokeWidth: " +
+String(threadWidth) +
+",\n        strokeCap: \"round\",\n        dashArray: [floatLen, pitch],\n        dashOffset: phase,\n        opacity: " +
+String(opacity) +
+"\n      });\n      const id = \"" +
+String(prefix) +
+"_weft_\" + rowIdx;\n      if (typeof app.registerItem === \"function\") app.registerItem(weft, id, { source: \"weave_generator\", weave: \"twill\", role: \"weft\" });\n      items.push(weft);\n    }\n    rowIdx++;\n  }\n\n  const group = new paper.Group(items);\n  if (typeof app.registerItem === \"function\") app.registerItem(group, \"" +
+String(prefix) +
+"_group\", { source: \"weave_generator\", weave: isHerringbone ? \"herringbone\" : \"twill\" });\n  return group;\n})();"
+
+
+
+
+
+
+
+
+
+
+
 
-  const group = new paper.Group(items);
-  if (typeof app.registerItem === "function") app.registerItem(group, "${prefix}_group", { source: "weave_generator", weave: isHerringbone ? "herringbone" : "twill" });
-  return group;
-})();`;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+);
 }
 /**
  * Generate Paper.js code for a Basketweave (Panama) pattern.
@@ -195,54 +195,54 @@ export function generateBasketWeaveCode(opts = {}) {
     const colorB = opts.colorB ?? opts.weftColor ?? "rgba(217, 119, 6, 0.6)";
     const opacity = opts.opacity ?? 0.85;
     const prefix = opts.idPrefix ?? "basket_weave";
-    return `// Basketweave Vector Generator
-(function() {
-  const items = [];
-  const x0 = ${x}, y0 = ${y}, x1 = ${x + w}, y1 = ${y + h};
-  const pitch = ${pitch};
-  const bundleSize = ${bundleSize};
-  const bundleGap = ${bundleGap};
-  const blockSize = (bundleSize * pitch) + bundleGap;
-  const threadWidth = ${threadWidth};
-
-  let rIdx = 0;
-  for (let vy = y0; vy <= y1; vy += blockSize) {
-    let cIdx = 0;
-    for (let vx = x0; vx <= x1; vx += blockSize) {
-      const isHorizontal = (rIdx + cIdx) % 2 === 0;
-      for (let t = 0; t < bundleSize; t++) {
-        const offset = t * pitch + pitch / 2;
-        let line;
-        if (isHorizontal) {
-          line = new paper.Path.Line({
-            from: [vx, vy + offset],
-            to: [Math.min(x1, vx + blockSize - bundleGap), vy + offset],
-            strokeColor: "${colorA}",
-            strokeWidth: threadWidth,
-            strokeCap: "round",
-            opacity: ${opacity}
-          });
-        } else {
-          line = new paper.Path.Line({
-            from: [vx + offset, vy],
-            to: [vx + offset, Math.min(y1, vy + blockSize - bundleGap)],
-            strokeColor: "${colorB}",
-            strokeWidth: threadWidth,
-            strokeCap: "round",
-            opacity: ${opacity}
-          });
-        }
-        items.push(line);
-      }
-      cIdx++;
-    }
-    rIdx++;
-  }
+    return ("// Basketweave Vector Generator\n(function() {\n  const items = [];\n  const x0 = " +
+String(x) +
+", y0 = " +
+String(y) +
+", x1 = " +
+String(x + w) +
+", y1 = " +
+String(y + h) +
+";\n  const pitch = " +
+String(pitch) +
+";\n  const bundleSize = " +
+String(bundleSize) +
+";\n  const bundleGap = " +
+String(bundleGap) +
+";\n  const blockSize = (bundleSize * pitch) + bundleGap;\n  const threadWidth = " +
+String(threadWidth) +
+";\n\n  let rIdx = 0;\n  for (let vy = y0; vy <= y1; vy += blockSize) {\n    let cIdx = 0;\n    for (let vx = x0; vx <= x1; vx += blockSize) {\n      const isHorizontal = (rIdx + cIdx) % 2 === 0;\n      for (let t = 0; t < bundleSize; t++) {\n        const offset = t * pitch + pitch / 2;\n        let line;\n        if (isHorizontal) {\n          line = new paper.Path.Line({\n            from: [vx, vy + offset],\n            to: [Math.min(x1, vx + blockSize - bundleGap), vy + offset],\n            strokeColor: \"" +
+String(colorA) +
+"\",\n            strokeWidth: threadWidth,\n            strokeCap: \"round\",\n            opacity: " +
+String(opacity) +
+"\n          });\n        } else {\n          line = new paper.Path.Line({\n            from: [vx + offset, vy],\n            to: [vx + offset, Math.min(y1, vy + blockSize - bundleGap)],\n            strokeColor: \"" +
+String(colorB) +
+"\",\n            strokeWidth: threadWidth,\n            strokeCap: \"round\",\n            opacity: " +
+String(opacity) +
+"\n          });\n        }\n        items.push(line);\n      }\n      cIdx++;\n    }\n    rIdx++;\n  }\n\n  const group = new paper.Group(items);\n  if (typeof app.registerItem === \"function\") app.registerItem(group, \"" +
+String(prefix) +
+"_group\", { source: \"weave_generator\", weave: \"basket\" });\n  return group;\n})();"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-  const group = new paper.Group(items);
-  if (typeof app.registerItem === "function") app.registerItem(group, "${prefix}_group", { source: "weave_generator", weave: "basket" });
-  return group;
-})();`;
+
+
+
+
+);
 }
 /**
  * Generate Paper.js code for tactile 3D Embroidered Knots (French knots, bullion coils, knot anchors).
@@ -256,130 +256,130 @@ export function generateKnotCode(opts = {}) {
     const defaultShadow = opts.shadowColor ?? opts.defaultShadow ?? "rgba(15, 23, 42, 0.4)";
     const prefix = opts.idPrefix ?? "embroidery_knot";
     const serializedKnots = JSON.stringify(knots);
-    return `// Embroidered Knots & Anchor Relief Vector Generator
-(function() {
-  const items = [];
-  const knotList = ${serializedKnots};
-  const knotType = "${knotType}";
-  const defR = ${defaultRadius};
-  const defCol = "${defaultColor}";
-  const defHi = "${defaultHighlight}";
-  const defShadow = "${defaultShadow}";
-
-  knotList.forEach((k, idx) => {
-    const kx = k.x, ky = k.y;
-    const kr = k.radius || defR;
-    const col = k.color || defCol;
-    const hi = k.highlightColor || defHi;
-    const sh = k.shadowColor || defShadow;
-    const knotParts = [];
-
-    if (knotType === "bullion_roll") {
-      // Bullion roll coils along directional vector
-      const len = k.length || (kr * 4);
-      const angRad = ((k.angle || 0) * Math.PI) / 180;
-      const dx = Math.cos(angRad);
-      const dy = Math.sin(angRad);
-      const steps = Math.max(3, Math.round(len / (kr * 0.8)));
-
-      // Base shadow line
-      const baseShadow = new paper.Path.Line({
-        from: [kx + 1, ky + 1.5],
-        to: [kx + dx * len + 1, ky + dy * len + 1.5],
-        strokeColor: sh,
-        strokeWidth: kr * 1.8,
-        strokeCap: "round"
-      });
-      knotParts.push(baseShadow);
-
-      // Overlapping coil loops
-      for (let s = 0; s < steps; s++) {
-        const t = s / steps;
-        const cx = kx + dx * (len * t);
-        const cy = ky + dy * (len * t);
-        const coil = new paper.Path.Circle({
-          center: [cx, cy],
-          radius: kr,
-          fillColor: col,
-          strokeColor: hi,
-          strokeWidth: 0.8
-        });
-        knotParts.push(coil);
-      }
-    } else if (knotType === "knot_anchor") {
-      // Anchor tack cross stitches
-      const tackLen = kr * 1.5;
-      const line1 = new paper.Path.Line({
-        from: [kx - tackLen, ky - tackLen],
-        to: [kx + tackLen, ky + tackLen],
-        strokeColor: col,
-        strokeWidth: Math.max(1, kr * 0.4),
-        strokeCap: "round"
-      });
-      const line2 = new paper.Path.Line({
-        from: [kx - tackLen, ky + tackLen],
-        to: [kx + tackLen, ky - tackLen],
-        strokeColor: col,
-        strokeWidth: Math.max(1, kr * 0.4),
-        strokeCap: "round"
-      });
-      const centerDot = new paper.Path.Circle({
-        center: [kx, ky],
-        radius: kr * 0.6,
-        fillColor: hi
-      });
-      knotParts.push(line1, line2, centerDot);
-    } else {
-      // Standard tactile French knot relief
-      // 1. French knot shadow crescent anchor beneath knot
-      const shadow = new paper.Path.Circle({
-        center: [kx + 1, ky + 1.5],
-        radius: kr,
-        fillColor: sh,
-        strokeColor: null
-      });
-      knotParts.push(shadow);
-
-      // 2. French knot coil body outer thread
-      const body = new paper.Path.Circle({
-        center: [kx, ky],
-        radius: kr,
-        fillColor: col,
-        strokeColor: "#f8fafc",
-        strokeWidth: 1
-      });
-      knotParts.push(body);
-
-      // 3. Inner coiled thread wrap
-      const innerCoil = new paper.Path.Circle({
-        center: [kx + kr * 0.1, ky + kr * 0.1],
-        radius: Math.max(1, kr * 0.55),
-        fillColor: null,
-        strokeColor: col,
-        strokeWidth: Math.max(0.8, kr * 0.28)
-      });
-      knotParts.push(innerCoil);
-
-      // 4. Specular glint highlight
-      const glint = new paper.Path.Circle({
-        center: [kx - kr * 0.32, ky - kr * 0.32],
-        radius: Math.max(0.8, kr * 0.3),
-        fillColor: hi,
-        strokeColor: null
-      });
-      knotParts.push(glint);
-    }
+    return ("// Embroidered Knots & Anchor Relief Vector Generator\n(function() {\n  const items = [];\n  const knotList = " +
+String(serializedKnots) +
+";\n  const knotType = \"" +
+String(knotType) +
+"\";\n  const defR = " +
+String(defaultRadius) +
+";\n  const defCol = \"" +
+String(defaultColor) +
+"\";\n  const defHi = \"" +
+String(defaultHighlight) +
+"\";\n  const defShadow = \"" +
+String(defaultShadow) +
+"\";\n\n  knotList.forEach((k, idx) => {\n    const kx = k.x, ky = k.y;\n    const kr = k.radius || defR;\n    const col = k.color || defCol;\n    const hi = k.highlightColor || defHi;\n    const sh = k.shadowColor || defShadow;\n    const knotParts = [];\n\n    if (knotType === \"bullion_roll\") {\n      // Bullion roll coils along directional vector\n      const len = k.length || (kr * 4);\n      const angRad = ((k.angle || 0) * Math.PI) / 180;\n      const dx = Math.cos(angRad);\n      const dy = Math.sin(angRad);\n      const steps = Math.max(3, Math.round(len / (kr * 0.8)));\n\n      // Base shadow line\n      const baseShadow = new paper.Path.Line({\n        from: [kx + 1, ky + 1.5]," +
+"\n        to: [kx + dx * len + 1, ky + dy * len + 1.5],\n        strokeColor: sh,\n        strokeWidth: kr * 1.8,\n        strokeCap: \"round\"\n      });\n      knotParts.push(baseShadow);\n\n      // Overlapping coil loops\n      for (let s = 0; s < steps; s++) {\n        const t = s / steps;\n        const cx = kx + dx * (len * t);\n        const cy = ky + dy * (len * t);\n        const coil = new paper.Path.Circle({\n          center: [cx, cy],\n          radius: kr,\n          fillColor: col,\n          strokeColor: hi,\n          strokeWidth: 0.8\n        });\n        knotParts.push(coil);\n      }\n    } else if (knotType === \"knot_anchor\") {\n      // Anchor tack cross stitches\n" +
+"      const tackLen = kr * 1.5;\n      const line1 = new paper.Path.Line({\n        from: [kx - tackLen, ky - tackLen],\n        to: [kx + tackLen, ky + tackLen],\n        strokeColor: col,\n        strokeWidth: Math.max(1, kr * 0.4),\n        strokeCap: \"round\"\n      });\n      const line2 = new paper.Path.Line({\n        from: [kx - tackLen, ky + tackLen],\n        to: [kx + tackLen, ky - tackLen],\n        strokeColor: col,\n        strokeWidth: Math.max(1, kr * 0.4),\n        strokeCap: \"round\"\n      });\n      const centerDot = new paper.Path.Circle({\n        center: [kx, ky],\n        radius: kr * 0.6,\n        fillColor: hi\n      });\n      knotParts.push(line1, line2, cente" +
+"rDot);\n    } else {\n      // Standard tactile French knot relief\n      // 1. French knot shadow crescent anchor beneath knot\n      const shadow = new paper.Path.Circle({\n        center: [kx + 1, ky + 1.5],\n        radius: kr,\n        fillColor: sh,\n        strokeColor: null\n      });\n      knotParts.push(shadow);\n\n      // 2. French knot coil body outer thread\n      const body = new paper.Path.Circle({\n        center: [kx, ky],\n        radius: kr,\n        fillColor: col,\n        strokeColor: \"#f8fafc\",\n        strokeWidth: 1\n      });\n      knotParts.push(body);\n\n      // 3. Inner coiled thread wrap\n      const innerCoil = new paper.Path.Circle({\n        center: [" +
+"kx + kr * 0.1, ky + kr * 0.1],\n        radius: Math.max(1, kr * 0.55),\n        fillColor: null,\n        strokeColor: col,\n        strokeWidth: Math.max(0.8, kr * 0.28)\n      });\n      knotParts.push(innerCoil);\n\n      // 4. Specular glint highlight\n      const glint = new paper.Path.Circle({\n        center: [kx - kr * 0.32, ky - kr * 0.32],\n        radius: Math.max(0.8, kr * 0.3),\n        fillColor: hi,\n        strokeColor: null\n      });\n      knotParts.push(glint);\n    }\n\n    const knotGroup = new paper.Group(knotParts);\n    const id = \"" +
+String(prefix) +
+"_\" + idx;\n    if (typeof app.registerItem === \"function\") app.registerItem(knotGroup, id, { source: \"knot_generator\", x: kx, y: ky, radius: kr });\n    items.push(knotGroup);\n  });\n\n  const masterGroup = new paper.Group(items);\n  if (typeof app.registerItem === \"function\") app.registerItem(masterGroup, \"" +
+String(prefix) +
+"_collection\", { source: \"knot_generator\", count: items.length });\n  return masterGroup;\n})();"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-    const knotGroup = new paper.Group(knotParts);
-    const id = "${prefix}_" + idx;
-    if (typeof app.registerItem === "function") app.registerItem(knotGroup, id, { source: "knot_generator", x: kx, y: ky, radius: kr });
-    items.push(knotGroup);
-  });
 
-  const masterGroup = new paper.Group(items);
-  if (typeof app.registerItem === "function") app.registerItem(masterGroup, "${prefix}_collection", { source: "knot_generator", count: items.length });
-  return masterGroup;
-})();`;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+);
 }
 /**
  * Generate Paper.js code for Japanese Sashiko geometric folk embroidery.
@@ -401,141 +401,141 @@ export function generateSashikoCode(opts = {}) {
     const concentricArcs = Math.max(1, opts.concentricArcs ?? 3);
     const opacity = opts.opacity ?? 0.92;
     const prefix = opts.idPrefix ?? `sashiko_${pattern}`;
-    return `// Sashiko Geometric Folk Embroidery Generator (${pattern})
-(function() {
-  const items = [];
-  const x0 = ${x}, y0 = ${y}, x1 = ${x + w}, y1 = ${y + h};
-  const threadColor = "${threadColor}";
-  const threadWidth = ${threadWidth};
-  const stitchLen = ${stitchLen};
-  const gapLen = ${gapLen};
-  const vertexGap = ${vertexGap};
-  const scale = ${scale};
-  const concentricArcs = ${concentricArcs};
-  const opacity = ${opacity};
-
-  // 0. Ground cloth plate
-  const bgPlate = new paper.Path.Rectangle({
-    point: [x0, y0],
-    size: [x1 - x0, y1 - y0],
-    fillColor: "${groundColor}",
-    strokeColor: null
-  });
-  items.push(bgPlate);
-
-  if ("${pattern}" === "seigaiha") {
-    // Seigaiha: Overlapping concentric ocean wave arcs with staggered centers
-    const R = scale;
-    const dy = R * 0.55;
-    let row = 0;
-    for (let cy = y0 + R * 0.4; cy <= y1 + R; cy += dy) {
-      const offsetX = (row % 2 === 0) ? 0 : R;
-      let col = 0;
-      for (let cx = x0 - R + offsetX; cx <= x1 + R; cx += R * 2) {
-        for (let a = 1; a <= concentricArcs; a++) {
-          const arcR = (R * a) / concentricArcs;
-          const fromPt = [cx - arcR + vertexGap * 0.5, cy - vertexGap * 0.2];
-          const throughPt = [cx, cy - arcR];
-          const toPt = [cx + arcR - vertexGap * 0.5, cy - vertexGap * 0.2];
-          const arc = new paper.Path.Arc(fromPt, throughPt, toPt);
-          arc.strokeColor = threadColor;
-          arc.strokeWidth = threadWidth;
-          arc.strokeCap = "round";
-          arc.dashArray = [stitchLen, gapLen];
-          arc.opacity = opacity;
-          items.push(arc);
-        }
-        col++;
-      }
-      row++;
-    }
-  } else if ("${pattern}" === "asanoha") {
-    // Asanoha: Hexagonal star / hemp-leaf isometric lattice with vertex gap clearance
-    const S = scale;
-    const H = S * Math.sqrt(3) / 2;
-    let rIdx = 0;
-    for (let py = y0; py <= y1 + H; py += H) {
-      const offX = (rIdx % 2 === 0) ? 0 : S * 0.5;
-      for (let px = x0 - S + offX; px <= x1 + S; px += S) {
-        const mx = px;
-        const my = py;
-        const angles = [0, 60, 120, 180, 240, 300];
-        angles.forEach(angDeg => {
-          const rad = (angDeg * Math.PI) / 180;
-          const targetX = mx + Math.cos(rad) * S * 0.55;
-          const targetY = my + Math.sin(rad) * S * 0.55;
-
-          const startX = mx + Math.cos(rad) * vertexGap;
-          const startY = my + Math.sin(rad) * vertexGap;
-          const endX = targetX - Math.cos(rad) * vertexGap;
-          const endY = targetY - Math.sin(rad) * vertexGap;
-
-          const spoke = new paper.Path.Line({
-            from: [startX, startY],
-            to: [endX, endY],
-            strokeColor: threadColor,
-            strokeWidth: threadWidth,
-            strokeCap: "round",
-            dashArray: [stitchLen, gapLen],
-            opacity: opacity
-          });
-          items.push(spoke);
-        });
-      }
-      rIdx++;
-    }
-  } else {
-    // Hishi / Kaki no Hana: Diamond grid with vertex gap junctions
-    const P = scale;
-    for (let diag = -Math.max(w, h); diag <= w + h; diag += P) {
-      for (let t = 0; t <= w + h; t += P) {
-        const p1x = t + vertexGap;
-        const p1y = t + diag + vertexGap;
-        const p2x = t + P - vertexGap;
-        const p2y = t + P + diag - vertexGap;
-        if (p1x >= x0 - P && p1x <= x1 + P && p1y >= y0 - P && p1y <= y1 + P) {
-          const seg1 = new paper.Path.Line({
-            from: [p1x, p1y],
-            to: [p2x, p2y],
-            strokeColor: threadColor,
-            strokeWidth: threadWidth,
-            strokeCap: "round",
-            dashArray: [stitchLen, gapLen],
-            opacity: opacity
-          });
-          items.push(seg1);
-        }
-
-        const q1x = t + vertexGap;
-        const q1y = -t + diag + vertexGap;
-        const q2x = t + P - vertexGap;
-        const q2y = -(t + P) + diag - vertexGap;
-        if (q1x >= x0 - P && q1x <= x1 + P && q1y >= y0 - P && q1y <= y1 + P) {
-          const seg2 = new paper.Path.Line({
-            from: [q1x, q1y],
-            to: [q2x, q2y],
-            strokeColor: threadColor,
-            strokeWidth: threadWidth,
-            strokeCap: "round",
-            dashArray: [stitchLen, gapLen],
-            opacity: opacity
-          });
-          items.push(seg2);
-        }
-      }
-    }
-  }
-
-  const group = new paper.Group(items);
-  if (typeof app.registerItem === "function") {
-    app.registerItem(group, "${prefix}_group", {
-      source: "sashiko_generator",
-      pattern: "${pattern}",
-      stitchCount: items.length
-    });
-  }
-  return group;
-})();`;
+    return ("// Sashiko Geometric Folk Embroidery Generator (" +
+String(pattern) +
+")\n(function() {\n  const items = [];\n  const x0 = " +
+String(x) +
+", y0 = " +
+String(y) +
+", x1 = " +
+String(x + w) +
+", y1 = " +
+String(y + h) +
+";\n  const threadColor = \"" +
+String(threadColor) +
+"\";\n  const threadWidth = " +
+String(threadWidth) +
+";\n  const stitchLen = " +
+String(stitchLen) +
+";\n  const gapLen = " +
+String(gapLen) +
+";\n  const vertexGap = " +
+String(vertexGap) +
+";\n  const scale = " +
+String(scale) +
+";\n  const concentricArcs = " +
+String(concentricArcs) +
+";\n  const opacity = " +
+String(opacity) +
+";\n\n  // 0. Ground cloth plate\n  const bgPlate = new paper.Path.Rectangle({\n    point: [x0, y0],\n    size: [x1 - x0, y1 - y0],\n    fillColor: \"" +
+String(groundColor) +
+"\",\n    strokeColor: null\n  });\n  items.push(bgPlate);\n\n  if (\"" +
+String(pattern) +
+"\" === \"seigaiha\") {\n    // Seigaiha: Overlapping concentric ocean wave arcs with staggered centers\n    const R = scale;\n    const dy = R * 0.55;\n    let row = 0;\n    for (let cy = y0 + R * 0.4; cy <= y1 + R; cy += dy) {\n      const offsetX = (row % 2 === 0) ? 0 : R;\n      let col = 0;\n      for (let cx = x0 - R + offsetX; cx <= x1 + R; cx += R * 2) {\n        for (let a = 1; a <= concentricArcs; a++) {\n          const arcR = (R * a) / concentricArcs;\n          const fromPt = [cx - arcR + vertexGap * 0.5, cy - vertexGap * 0.2];\n          const throughPt = [cx, cy - arcR];\n          const toPt = [cx + arcR - vertexGap * 0.5, cy - vertexGap * 0.2];\n          const arc = new pa" +
+"per.Path.Arc(fromPt, throughPt, toPt);\n          arc.strokeColor = threadColor;\n          arc.strokeWidth = threadWidth;\n          arc.strokeCap = \"round\";\n          arc.dashArray = [stitchLen, gapLen];\n          arc.opacity = opacity;\n          items.push(arc);\n        }\n        col++;\n      }\n      row++;\n    }\n  } else if (\"" +
+String(pattern) +
+"\" === \"asanoha\") {\n    // Asanoha: Hexagonal star / hemp-leaf isometric lattice with vertex gap clearance\n    const S = scale;\n    const H = S * Math.sqrt(3) / 2;\n    let rIdx = 0;\n    for (let py = y0; py <= y1 + H; py += H) {\n      const offX = (rIdx % 2 === 0) ? 0 : S * 0.5;\n      for (let px = x0 - S + offX; px <= x1 + S; px += S) {\n        const mx = px;\n        const my = py;\n        const angles = [0, 60, 120, 180, 240, 300];\n        angles.forEach(angDeg => {\n          const rad = (angDeg * Math.PI) / 180;\n          const targetX = mx + Math.cos(rad) * S * 0.55;\n          const targetY = my + Math.sin(rad) * S * 0.55;\n\n          const startX = mx + Math.cos(rad) " +
+"* vertexGap;\n          const startY = my + Math.sin(rad) * vertexGap;\n          const endX = targetX - Math.cos(rad) * vertexGap;\n          const endY = targetY - Math.sin(rad) * vertexGap;\n\n          const spoke = new paper.Path.Line({\n            from: [startX, startY],\n            to: [endX, endY],\n            strokeColor: threadColor,\n            strokeWidth: threadWidth,\n            strokeCap: \"round\",\n            dashArray: [stitchLen, gapLen],\n            opacity: opacity\n          });\n          items.push(spoke);\n        });\n      }\n      rIdx++;\n    }\n  } else {\n    // Hishi / Kaki no Hana: Diamond grid with vertex gap junctions\n    const P = scale;\n    for" +
+" (let diag = -Math.max(w, h); diag <= w + h; diag += P) {\n      for (let t = 0; t <= w + h; t += P) {\n        const p1x = t + vertexGap;\n        const p1y = t + diag + vertexGap;\n        const p2x = t + P - vertexGap;\n        const p2y = t + P + diag - vertexGap;\n        if (p1x >= x0 - P && p1x <= x1 + P && p1y >= y0 - P && p1y <= y1 + P) {\n          const seg1 = new paper.Path.Line({\n            from: [p1x, p1y],\n            to: [p2x, p2y],\n            strokeColor: threadColor,\n            strokeWidth: threadWidth,\n            strokeCap: \"round\",\n            dashArray: [stitchLen, gapLen],\n            opacity: opacity\n          });\n          items.push(seg1);\n        }" +
+"\n\n        const q1x = t + vertexGap;\n        const q1y = -t + diag + vertexGap;\n        const q2x = t + P - vertexGap;\n        const q2y = -(t + P) + diag - vertexGap;\n        if (q1x >= x0 - P && q1x <= x1 + P && q1y >= y0 - P && q1y <= y1 + P) {\n          const seg2 = new paper.Path.Line({\n            from: [q1x, q1y],\n            to: [q2x, q2y],\n            strokeColor: threadColor,\n            strokeWidth: threadWidth,\n            strokeCap: \"round\",\n            dashArray: [stitchLen, gapLen],\n            opacity: opacity\n          });\n          items.push(seg2);\n        }\n      }\n    }\n  }\n\n  const group = new paper.Group(items);\n  if (typeof app.registerItem " +
+"=== \"function\") {\n    app.registerItem(group, \"" +
+String(prefix) +
+"_group\", {\n      source: \"sashiko_generator\",\n      pattern: \"" +
+String(pattern) +
+"\",\n      stitchCount: items.length\n    });\n  }\n  return group;\n})();"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+);
 }
 /**
  * Master dispatcher for textile and embroidery vector code generation.