@industry-theme/repository-composition-panels 0.6.30 → 0.6.32

package/dist/{index-B5obJmUS.js → index-CBrdpzxz.js}

@@ -106176,7 +106176,7 @@ const browserExt = {
   },
   test: () => true,
   load: async () => {
-    await import("./browserAll-B0PE4Ly2.js");
+    await import("./browserAll-DI7lMMAJ.js");
   }
 };
 const webworkerExt = {
@@ -106187,7 +106187,7 @@ const webworkerExt = {
   },
   test: () => typeof self !== "undefined" && self.WorkerGlobalScope !== void 0,
   load: async () => {
-    await import("./webworkerAll-BBVbOe1V.js");
+    await import("./webworkerAll-BDQrDn0n.js");
   }
 };
 class ObservablePoint {
@@ -118430,19 +118430,19 @@ async function autoDetectRenderer(options) {
   for (let i2 = 0; i2 < preferredOrder.length; i2++) {
     const rendererType = preferredOrder[i2];
     if (rendererType === "webgpu" && await isWebGPUSupported()) {
-      const { WebGPURenderer } = await import("./WebGPURenderer-Bjpg8hkG.js");
+      const { WebGPURenderer } = await import("./WebGPURenderer-BcDZvCNz.js");
       RendererClass = WebGPURenderer;
       finalOptions = { ...options, ...options.webgpu };
       break;
     } else if (rendererType === "webgl" && isWebGLSupported(
       options.failIfMajorPerformanceCaveat ?? AbstractRenderer.defaultOptions.failIfMajorPerformanceCaveat
     )) {
-      const { WebGLRenderer } = await import("./WebGLRenderer-9uzpEisE.js");
+      const { WebGLRenderer } = await import("./WebGLRenderer-BSys64oZ.js");
       RendererClass = WebGLRenderer;
       finalOptions = { ...options, ...options.webgl };
       break;
     } else if (rendererType === "canvas") {
-      const { CanvasRenderer } = await import("./CanvasRenderer-ChUHHBzp.js");
+      const { CanvasRenderer } = await import("./CanvasRenderer--e2h72qI.js");
       RendererClass = CanvasRenderer;
       finalOptions = { ...options, ...options.canvasOptions };
       break;
@@ -132920,6 +132920,834 @@ function domEventToGridCoords(clientX, clientY, viewport, canvasElement) {
   const gridCoords = screenToGrid(worldPoint.x, worldPoint.y);
   return gridCoords;
 }
+const TILE_WIDTH = ISO_TILE_WIDTH$1;
+const TILE_HEIGHT = ISO_TILE_HEIGHT$1;
+function calculateFootprint(sizeMultiplier) {
+  const tiles = 4 * sizeMultiplier;
+  return {
+    tiles,
+    width: tiles * TILE_WIDTH / 2,
+    height: tiles * TILE_HEIGHT / 2
+  };
+}
+const COLORS = {
+  // Wood colors
+  woodDark: 6111287,
+  woodMedium: 7951688,
+  woodLight: 9268835,
+  // Flower/vine colors (MIT - welcoming, open)
+  flowerPink: 16738740,
+  flowerPinkDark: 14381203,
+  flowerYellow: 16766720,
+  leafGreen: 2263842,
+  leafGreenLight: 3329330,
+  vineGreen: 3050327,
+  // Grass colors
+  grassLight: 9498256,
+  grassMedium: 3329330,
+  grassDark: 2263842
+};
+function generateMITFlowerArch(config) {
+  const { name: name2, sizeMultiplier, archWidth: customArchWidth } = config;
+  const container = new Container();
+  const footprint = calculateFootprint(sizeMultiplier);
+  const archWidth = customArchWidth ?? footprint.width * 0.5;
+  const scale = archWidth / 80;
+  const postWidth = Math.max(3, 4 * scale);
+  const postHeight = Math.max(25, 35 * scale);
+  const archHeight = postHeight + 4 * scale;
+  const graphics = new Graphics();
+  graphics.rect(-archWidth / 2, -postHeight, postWidth, postHeight);
+  graphics.fill(COLORS.woodMedium);
+  graphics.rect(-archWidth / 2, -postHeight, Math.max(1, scale), postHeight);
+  graphics.fill(COLORS.woodLight);
+  graphics.rect(
+    -archWidth / 2 + postWidth - Math.max(1, scale),
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(COLORS.woodDark);
+  graphics.rect(archWidth / 2 - postWidth, -postHeight, postWidth, postHeight);
+  graphics.fill(COLORS.woodMedium);
+  graphics.rect(
+    archWidth / 2 - postWidth,
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(COLORS.woodLight);
+  graphics.rect(
+    archWidth / 2 - Math.max(1, scale),
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(COLORS.woodDark);
+  const crossbarHeight = Math.max(3, 4 * scale);
+  graphics.rect(-archWidth / 2, -archHeight, archWidth, crossbarHeight);
+  graphics.fill(COLORS.woodMedium);
+  graphics.rect(-archWidth / 2, -archHeight, archWidth, Math.max(1, scale));
+  graphics.fill(COLORS.woodLight);
+  graphics.rect(
+    -archWidth / 2,
+    -archHeight + crossbarHeight - Math.max(1, scale),
+    archWidth,
+    Math.max(1, scale)
+  );
+  graphics.fill(COLORS.woodDark);
+  const flagWidth = archWidth * 0.5;
+  const flagHeight = Math.max(18, 24 * scale);
+  const flagTop = -postHeight + 2 * scale;
+  graphics.rect(-flagWidth / 2, flagTop, flagWidth, flagHeight);
+  graphics.fill(9498256);
+  graphics.rect(-flagWidth / 2, flagTop, flagWidth, Math.max(1, scale));
+  graphics.fill(8244349);
+  graphics.rect(
+    -flagWidth / 2,
+    flagTop + flagHeight - Math.max(1, scale),
+    flagWidth,
+    Math.max(1, scale)
+  );
+  graphics.fill(7059563);
+  graphics.rect(-flagWidth / 2, flagTop, Math.max(1, scale), flagHeight);
+  graphics.fill(8244349);
+  graphics.rect(
+    flagWidth / 2 - Math.max(1, scale),
+    flagTop,
+    Math.max(1, scale),
+    flagHeight
+  );
+  graphics.fill(7059563);
+  const vineSize = Math.max(2, 3 * scale);
+  const vinePositions = [
+    { x: -archWidth / 2 - 2 * scale, y: -postHeight * 0.9 },
+    { x: -archWidth / 2 - 1 * scale, y: -postHeight * 0.6 },
+    { x: -archWidth / 2 + 1 * scale, y: -postHeight * 0.4 },
+    { x: -archWidth / 2 - 2 * scale, y: -postHeight * 0.2 }
+  ];
+  for (const pos of vinePositions) {
+    graphics.rect(pos.x, pos.y, vineSize, vineSize * 0.66);
+    graphics.fill(COLORS.vineGreen);
+  }
+  const rightVinePositions = [
+    { x: archWidth / 2 - 1 * scale, y: -postHeight * 0.8 },
+    { x: archWidth / 2 + 1 * scale, y: -postHeight * 0.5 },
+    { x: archWidth / 2 - 2 * scale, y: -postHeight * 0.3 },
+    { x: archWidth / 2, y: -postHeight * 0.1 }
+  ];
+  for (const pos of rightVinePositions) {
+    graphics.rect(pos.x, pos.y, vineSize, vineSize * 0.66);
+    graphics.fill(COLORS.vineGreen);
+  }
+  const flowerCount = Math.max(4, Math.floor(6 * scale));
+  const flowerSpacing = archWidth / (flowerCount + 1);
+  const flowerSize = Math.max(3, 4 * scale);
+  for (let i2 = 0; i2 < flowerCount; i2++) {
+    const fx = -archWidth / 2 + flowerSpacing * (i2 + 1);
+    const flowerColor = i2 % 2 === 0 ? COLORS.flowerPink : COLORS.flowerYellow;
+    graphics.rect(
+      fx - flowerSize * 0.5,
+      -flowerSize - 2 * scale,
+      flowerSize * 0.5,
+      flowerSize * 0.5
+    );
+    graphics.fill(COLORS.leafGreen);
+    graphics.rect(
+      fx + flowerSize * 0.25,
+      -flowerSize - 1 * scale,
+      flowerSize * 0.5,
+      flowerSize * 0.5
+    );
+    graphics.fill(COLORS.leafGreenLight);
+    graphics.rect(fx - flowerSize * 0.5, -flowerSize, flowerSize, flowerSize);
+    graphics.fill(flowerColor);
+    graphics.rect(
+      fx - flowerSize * 0.25,
+      -flowerSize * 0.75,
+      flowerSize * 0.5,
+      flowerSize * 0.5
+    );
+    graphics.fill(COLORS.flowerYellow);
+  }
+  const cornerFlowerSize = Math.max(4, 5 * scale);
+  graphics.rect(
+    -archWidth / 2 - cornerFlowerSize * 0.3,
+    -cornerFlowerSize,
+    cornerFlowerSize,
+    cornerFlowerSize
+  );
+  graphics.fill(COLORS.flowerPink);
+  graphics.rect(
+    -archWidth / 2 - cornerFlowerSize * 0.1,
+    -cornerFlowerSize * 0.8,
+    cornerFlowerSize * 0.6,
+    cornerFlowerSize * 0.6
+  );
+  graphics.fill(COLORS.flowerPinkDark);
+  graphics.rect(
+    archWidth / 2 - cornerFlowerSize * 0.7,
+    -cornerFlowerSize,
+    cornerFlowerSize,
+    cornerFlowerSize
+  );
+  graphics.fill(COLORS.flowerPink);
+  graphics.rect(
+    archWidth / 2 - cornerFlowerSize * 0.5,
+    -cornerFlowerSize * 0.8,
+    cornerFlowerSize * 0.6,
+    cornerFlowerSize * 0.6
+  );
+  graphics.fill(COLORS.flowerPinkDark);
+  container.addChild(graphics);
+  const mitFontSize = Math.max(10, 14 * scale);
+  const mitText = new Text({
+    text: "MIT",
+    style: {
+      fontSize: mitFontSize,
+      fill: 2263842,
+      // Forest green text
+      fontFamily: "Arial",
+      fontWeight: "bold"
+    },
+    resolution: 2
+  });
+  mitText.anchor.set(0.5, 0.5);
+  mitText.y = flagTop + flagHeight * 0.5;
+  container.addChild(mitText);
+  const signBoard = new Graphics();
+  const fontSize = Math.max(8, 9 * scale);
+  const estimatedTextWidth = name2.length * fontSize * 0.6;
+  const signWidth = Math.min(
+    estimatedTextWidth + 16 * scale,
+    archWidth - 8 * scale
+  );
+  const signHeight = Math.max(8, 10 * scale);
+  const signBoardY = -archHeight - signHeight - 2 * scale;
+  signBoard.rect(-signWidth / 2, signBoardY, signWidth, signHeight);
+  signBoard.fill(COLORS.woodLight);
+  signBoard.rect(-signWidth / 2, signBoardY, signWidth, Math.max(1, scale));
+  signBoard.fill(COLORS.woodMedium);
+  signBoard.rect(
+    -signWidth / 2,
+    signBoardY + signHeight - Math.max(1, scale),
+    signWidth,
+    Math.max(1, scale)
+  );
+  signBoard.fill(COLORS.woodDark);
+  container.addChild(signBoard);
+  const nameText = new Text({
+    text: name2,
+    style: {
+      fontSize,
+      fill: 4073251,
+      // Dark brown text
+      fontFamily: "Arial",
+      fontWeight: "600"
+    },
+    resolution: 2
+  });
+  nameText.anchor.set(0.5, 0.5);
+  nameText.y = signBoardY + signHeight / 2;
+  container.addChild(nameText);
+  return container;
+}
+function generateOpenGrassGround(sizeMultiplier) {
+  const footprint = calculateFootprint(sizeMultiplier);
+  const grass = new Graphics();
+  const halfW = footprint.width;
+  const halfH = footprint.height;
+  grass.moveTo(0, -halfH);
+  grass.lineTo(halfW, 0);
+  grass.lineTo(0, halfH);
+  grass.lineTo(-halfW, 0);
+  grass.closePath();
+  grass.fill(COLORS.grassMedium);
+  const textureCount = Math.max(6, Math.floor(8 * sizeMultiplier));
+  for (let i2 = 0; i2 < textureCount; i2++) {
+    const angle = i2 / textureCount * Math.PI * 2;
+    const radius = 0.3 + i2 % 3 * 0.15;
+    const x2 = Math.cos(angle) * halfW * radius;
+    const y2 = Math.sin(angle) * halfH * radius;
+    const dotSize = Math.max(1.5, 2 * sizeMultiplier);
+    grass.circle(x2, y2, dotSize);
+    grass.fill(i2 % 2 === 0 ? COLORS.grassLight : COLORS.grassDark);
+  }
+  const flowerSize = Math.max(1, 1.5 * sizeMultiplier);
+  const flowerSpots = [
+    { x: -halfW * 0.5, y: -halfH * 0.2 },
+    { x: halfW * 0.4, y: halfH * 0.3 },
+    { x: -halfW * 0.2, y: halfH * 0.4 },
+    { x: halfW * 0.3, y: -halfH * 0.35 }
+  ];
+  for (const spot of flowerSpots) {
+    grass.circle(spot.x, spot.y, flowerSize);
+    grass.fill(COLORS.flowerPink);
+  }
+  return grass;
+}
+function generateApacheSign(config) {
+  const { name: name2, sizeMultiplier, archWidth: customArchWidth } = config;
+  const container = new Container();
+  const footprint = calculateFootprint(sizeMultiplier);
+  const archWidth = customArchWidth ?? footprint.width * 0.5;
+  const scale = archWidth / 80;
+  const graphics = new Graphics();
+  const postWidth = Math.max(3, 4 * scale);
+  const postHeight = Math.max(25, 35 * scale);
+  graphics.rect(-archWidth / 2, -postHeight, postWidth, postHeight);
+  graphics.fill(COLORS.woodMedium);
+  graphics.rect(-archWidth / 2, -postHeight, Math.max(1, scale), postHeight);
+  graphics.fill(COLORS.woodLight);
+  graphics.rect(
+    -archWidth / 2 + postWidth - Math.max(1, scale),
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(COLORS.woodDark);
+  graphics.rect(archWidth / 2 - postWidth, -postHeight, postWidth, postHeight);
+  graphics.fill(COLORS.woodMedium);
+  graphics.rect(
+    archWidth / 2 - postWidth,
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(COLORS.woodLight);
+  graphics.rect(
+    archWidth / 2 - Math.max(1, scale),
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(COLORS.woodDark);
+  const crossbarHeight = Math.max(3, 4 * scale);
+  graphics.rect(
+    -archWidth / 2,
+    -postHeight - crossbarHeight,
+    archWidth,
+    crossbarHeight
+  );
+  graphics.fill(COLORS.woodMedium);
+  graphics.rect(
+    -archWidth / 2,
+    -postHeight - crossbarHeight,
+    archWidth,
+    Math.max(1, scale)
+  );
+  graphics.fill(COLORS.woodLight);
+  const flagWidth = archWidth * 0.5;
+  const flagHeight = Math.max(18, 24 * scale);
+  const flagTop = -postHeight + 2 * scale;
+  graphics.rect(-flagWidth / 2, flagTop, flagWidth, flagHeight);
+  graphics.fill(16777215);
+  graphics.rect(-flagWidth / 2, flagTop, flagWidth, Math.max(1, scale));
+  graphics.fill(14540253);
+  graphics.rect(
+    -flagWidth / 2,
+    flagTop + flagHeight - Math.max(1, scale),
+    flagWidth,
+    Math.max(1, scale)
+  );
+  graphics.fill(13421772);
+  graphics.rect(-flagWidth / 2, flagTop, Math.max(1, scale), flagHeight);
+  graphics.fill(14540253);
+  graphics.rect(
+    flagWidth / 2 - Math.max(1, scale),
+    flagTop,
+    Math.max(1, scale),
+    flagHeight
+  );
+  graphics.fill(13421772);
+  const leafCenterY = flagTop + flagHeight * 0.55;
+  const leafSize = Math.min(flagWidth, flagHeight) * 0.35;
+  const leafColor = 13369344;
+  const leafGraphics = new Graphics();
+  leafGraphics.rect(-scale * 0.5, 0, scale, leafSize * 0.6);
+  leafGraphics.fill(9109504);
+  leafGraphics.beginPath();
+  leafGraphics.moveTo(0, -leafSize * 0.8);
+  leafGraphics.lineTo(leafSize * 0.3, -leafSize * 0.4);
+  leafGraphics.lineTo(leafSize * 0.6, -leafSize * 0.3);
+  leafGraphics.lineTo(leafSize * 0.3, -leafSize * 0.1);
+  leafGraphics.lineTo(leafSize * 0.4, leafSize * 0.2);
+  leafGraphics.lineTo(leafSize * 0.15, leafSize * 0.15);
+  leafGraphics.lineTo(0, leafSize * 0.4);
+  leafGraphics.lineTo(-leafSize * 0.15, leafSize * 0.15);
+  leafGraphics.lineTo(-leafSize * 0.4, leafSize * 0.2);
+  leafGraphics.lineTo(-leafSize * 0.3, -leafSize * 0.1);
+  leafGraphics.lineTo(-leafSize * 0.6, -leafSize * 0.3);
+  leafGraphics.lineTo(-leafSize * 0.3, -leafSize * 0.4);
+  leafGraphics.closePath();
+  leafGraphics.fill(leafColor);
+  leafGraphics.x = 0;
+  leafGraphics.y = leafCenterY;
+  leafGraphics.rotation = 0.3;
+  graphics.addChild(leafGraphics);
+  container.addChild(graphics);
+  const signBoard = new Graphics();
+  const fontSize = Math.max(8, 9 * scale);
+  const estimatedTextWidth = name2.length * fontSize * 0.6;
+  const signBoardWidth = Math.min(
+    estimatedTextWidth + 16 * scale,
+    archWidth - 8 * scale
+  );
+  const signBoardHeight = Math.max(8, 10 * scale);
+  const signBoardY = -postHeight - crossbarHeight + 2 * scale;
+  signBoard.rect(
+    -signBoardWidth / 2,
+    signBoardY,
+    signBoardWidth,
+    signBoardHeight
+  );
+  signBoard.fill(COLORS.woodLight);
+  signBoard.rect(
+    -signBoardWidth / 2,
+    signBoardY,
+    signBoardWidth,
+    Math.max(1, scale)
+  );
+  signBoard.fill(COLORS.woodMedium);
+  signBoard.rect(
+    -signBoardWidth / 2,
+    signBoardY + signBoardHeight - Math.max(1, scale),
+    signBoardWidth,
+    Math.max(1, scale)
+  );
+  signBoard.fill(COLORS.woodDark);
+  container.addChild(signBoard);
+  const nameText = new Text({
+    text: name2,
+    style: {
+      fontSize,
+      fill: 4073251,
+      fontFamily: "Arial",
+      fontWeight: "600"
+    },
+    resolution: 2
+  });
+  nameText.anchor.set(0.5, 0.5);
+  nameText.y = signBoardY + signBoardHeight / 2;
+  container.addChild(nameText);
+  return container;
+}
+function generateGPLSign(config) {
+  const { name: name2, sizeMultiplier, archWidth: customArchWidth } = config;
+  const container = new Container();
+  const footprint = calculateFootprint(sizeMultiplier);
+  const archWidth = customArchWidth ?? footprint.width * 0.5;
+  const scale = archWidth / 80;
+  const graphics = new Graphics();
+  const ironDark = 2763306;
+  const ironMedium = 3815994;
+  const ironLight = 4868682;
+  const ironHighlight = 5921370;
+  const postWidth = Math.max(4, 5 * scale);
+  const postHeight = Math.max(25, 35 * scale);
+  graphics.rect(-archWidth / 2, -postHeight, postWidth, postHeight);
+  graphics.fill(ironMedium);
+  graphics.rect(-archWidth / 2, -postHeight, Math.max(1, scale), postHeight);
+  graphics.fill(ironHighlight);
+  graphics.rect(
+    -archWidth / 2 + postWidth - Math.max(1, scale),
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(ironDark);
+  const finialSize = postWidth * 1.2;
+  graphics.circle(
+    -archWidth / 2 + postWidth / 2,
+    -postHeight - finialSize / 2,
+    finialSize / 2
+  );
+  graphics.fill(ironMedium);
+  graphics.circle(
+    -archWidth / 2 + postWidth / 2 - finialSize * 0.15,
+    -postHeight - finialSize * 0.65,
+    finialSize * 0.15
+  );
+  graphics.fill(ironHighlight);
+  graphics.rect(archWidth / 2 - postWidth, -postHeight, postWidth, postHeight);
+  graphics.fill(ironMedium);
+  graphics.rect(
+    archWidth / 2 - postWidth,
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(ironHighlight);
+  graphics.rect(
+    archWidth / 2 - Math.max(1, scale),
+    -postHeight,
+    Math.max(1, scale),
+    postHeight
+  );
+  graphics.fill(ironDark);
+  graphics.circle(
+    archWidth / 2 - postWidth / 2,
+    -postHeight - finialSize / 2,
+    finialSize / 2
+  );
+  graphics.fill(ironMedium);
+  graphics.circle(
+    archWidth / 2 - postWidth / 2 - finialSize * 0.15,
+    -postHeight - finialSize * 0.65,
+    finialSize * 0.15
+  );
+  graphics.fill(ironHighlight);
+  const crossbarHeight = Math.max(4, 5 * scale);
+  graphics.rect(
+    -archWidth / 2,
+    -postHeight - crossbarHeight,
+    archWidth,
+    crossbarHeight
+  );
+  graphics.fill(ironMedium);
+  graphics.rect(
+    -archWidth / 2,
+    -postHeight - crossbarHeight,
+    archWidth,
+    Math.max(1, scale)
+  );
+  graphics.fill(ironHighlight);
+  graphics.rect(
+    -archWidth / 2,
+    -postHeight - Math.max(1, scale),
+    archWidth,
+    Math.max(1, scale)
+  );
+  graphics.fill(ironDark);
+  const scrollY = -postHeight + 3 * scale;
+  const scrollWidth = archWidth * 0.15;
+  graphics.circle(-archWidth / 4, scrollY, scrollWidth);
+  graphics.stroke({ width: Math.max(2, 2 * scale), color: ironMedium });
+  graphics.circle(archWidth / 4, scrollY, scrollWidth);
+  graphics.stroke({ width: Math.max(2, 2 * scale), color: ironMedium });
+  const flagWidth = archWidth * 0.5;
+  const flagHeight = Math.max(18, 24 * scale);
+  const flagTop = -postHeight + 8 * scale;
+  graphics.rect(-flagWidth / 2, flagTop, flagWidth, flagHeight);
+  graphics.fill(2250154);
+  graphics.rect(-flagWidth / 2, flagTop, flagWidth, Math.max(1, scale));
+  graphics.fill(3368635);
+  graphics.rect(
+    -flagWidth / 2,
+    flagTop + flagHeight - Math.max(1, scale),
+    flagWidth,
+    Math.max(1, scale)
+  );
+  graphics.fill(1131690);
+  graphics.rect(-flagWidth / 2, flagTop, Math.max(1, scale), flagHeight);
+  graphics.fill(3368635);
+  graphics.rect(
+    flagWidth / 2 - Math.max(1, scale),
+    flagTop,
+    Math.max(1, scale),
+    flagHeight
+  );
+  graphics.fill(1131690);
+  container.addChild(graphics);
+  const gplFontSize = Math.max(10, 14 * scale);
+  const gplText = new Text({
+    text: "GPL",
+    style: {
+      fontSize: gplFontSize,
+      fill: 16777215,
+      fontFamily: "Arial",
+      fontWeight: "bold"
+    },
+    resolution: 2
+  });
+  gplText.anchor.set(0.5, 0.5);
+  gplText.y = flagTop + flagHeight * 0.5;
+  container.addChild(gplText);
+  const signBoard = new Graphics();
+  const fontSize = Math.max(8, 9 * scale);
+  const estimatedTextWidth = name2.length * fontSize * 0.6;
+  const signBoardWidth = Math.min(
+    estimatedTextWidth + 16 * scale,
+    archWidth - 8 * scale
+  );
+  const signBoardHeight = Math.max(8, 10 * scale);
+  const signBoardY = -postHeight - crossbarHeight - signBoardHeight - 2 * scale;
+  signBoard.rect(
+    -signBoardWidth / 2,
+    signBoardY,
+    signBoardWidth,
+    signBoardHeight
+  );
+  signBoard.fill(ironLight);
+  signBoard.rect(
+    -signBoardWidth / 2,
+    signBoardY,
+    signBoardWidth,
+    Math.max(1, scale)
+  );
+  signBoard.fill(ironHighlight);
+  signBoard.rect(
+    -signBoardWidth / 2,
+    signBoardY + signBoardHeight - Math.max(1, scale),
+    signBoardWidth,
+    Math.max(1, scale)
+  );
+  signBoard.fill(ironDark);
+  container.addChild(signBoard);
+  const nameText = new Text({
+    text: name2,
+    style: {
+      fontSize,
+      fill: 16777215,
+      fontFamily: "Arial",
+      fontWeight: "600"
+    },
+    resolution: 2
+  });
+  nameText.anchor.set(0.5, 0.5);
+  nameText.y = signBoardY + signBoardHeight / 2;
+  container.addChild(nameText);
+  return container;
+}
+function generatePicketFenceGround(sizeMultiplier) {
+  const footprint = calculateFootprint(sizeMultiplier);
+  const ground = new Graphics();
+  const halfW = footprint.width;
+  const halfH = footprint.height;
+  ground.moveTo(0, -halfH);
+  ground.lineTo(halfW, 0);
+  ground.lineTo(0, halfH);
+  ground.lineTo(-halfW, 0);
+  ground.closePath();
+  ground.fill(COLORS.grassMedium);
+  const textureCount = Math.max(6, Math.floor(8 * sizeMultiplier));
+  for (let i2 = 0; i2 < textureCount; i2++) {
+    const angle = i2 / textureCount * Math.PI * 2;
+    const radius = 0.3 + i2 % 3 * 0.1;
+    const x2 = Math.cos(angle) * halfW * radius;
+    const y2 = Math.sin(angle) * halfH * radius;
+    const dotSize = Math.max(1.5, 2 * sizeMultiplier);
+    ground.circle(x2, y2, dotSize);
+    ground.fill(i2 % 2 === 0 ? COLORS.grassLight : COLORS.grassDark);
+  }
+  const fenceWhite = 16119285;
+  const fenceHighlight = 16777215;
+  const picketWidth = Math.max(2, 3 * sizeMultiplier);
+  const picketHeight = Math.max(8, 12 * sizeMultiplier);
+  const picketSpacing = Math.max(4, 6 * sizeMultiplier);
+  const edgeLength = Math.sqrt(halfW * halfW + halfH * halfH);
+  const picketCount = Math.floor(edgeLength / picketSpacing);
+  const slopeRatio = 0.5;
+  const drawPicket = (px, py, edgeDir) => {
+    const halfW2 = picketWidth / 2;
+    const dx = halfW2 * edgeDir;
+    const dy = halfW2 * slopeRatio;
+    const bottomLeftX = px - dx;
+    const bottomLeftY = py - dy;
+    const bottomRightX = px + dx;
+    const bottomRightY = py + dy;
+    const topLeftX = bottomLeftX;
+    const topLeftY = bottomLeftY - picketHeight;
+    const topRightX = bottomRightX;
+    const topRightY = bottomRightY - picketHeight;
+    ground.beginPath();
+    ground.moveTo(bottomLeftX, bottomLeftY);
+    ground.lineTo(bottomRightX, bottomRightY);
+    ground.lineTo(topRightX, topRightY);
+    ground.lineTo(topLeftX, topLeftY);
+    ground.closePath();
+    ground.fill(fenceWhite);
+    const highlightWidth = Math.max(1, sizeMultiplier * 0.5);
+    ground.beginPath();
+    if (edgeDir > 0) {
+      ground.moveTo(bottomLeftX, bottomLeftY);
+      ground.lineTo(
+        bottomLeftX + highlightWidth * 0.5,
+        bottomLeftY + highlightWidth * 0.25
+      );
+      ground.lineTo(
+        topLeftX + highlightWidth * 0.5,
+        topLeftY + highlightWidth * 0.25
+      );
+      ground.lineTo(topLeftX, topLeftY);
+    } else {
+      ground.moveTo(bottomRightX, bottomRightY);
+      ground.lineTo(
+        bottomRightX - highlightWidth * 0.5,
+        bottomRightY + highlightWidth * 0.25
+      );
+      ground.lineTo(
+        topRightX - highlightWidth * 0.5,
+        topRightY + highlightWidth * 0.25
+      );
+      ground.lineTo(topRightX, topRightY);
+    }
+    ground.closePath();
+    ground.fill(fenceHighlight);
+    ground.beginPath();
+    ground.moveTo(topLeftX, topLeftY);
+    ground.lineTo(px, py - dy * 0 - picketHeight - picketWidth);
+    ground.lineTo(topRightX, topRightY);
+    ground.closePath();
+    ground.fill(fenceWhite);
+  };
+  for (let i2 = 1; i2 < picketCount; i2++) {
+    const t2 = i2 / picketCount;
+    const px = -halfW * t2;
+    const py = -halfH * (1 - t2);
+    drawPicket(px, py, -1);
+  }
+  for (let i2 = 1; i2 < picketCount; i2++) {
+    const t2 = i2 / picketCount;
+    const px = halfW * t2;
+    const py = -halfH * (1 - t2);
+    drawPicket(px, py, 1);
+  }
+  for (let i2 = 1; i2 < picketCount * 0.75; i2++) {
+    const t2 = i2 / picketCount;
+    const px = -halfW * (1 - t2);
+    const py = halfH * t2;
+    drawPicket(px, py, 1);
+  }
+  for (let i2 = 1; i2 < picketCount * 0.75; i2++) {
+    const t2 = i2 / picketCount;
+    const px = halfW * (1 - t2);
+    const py = halfH * t2;
+    drawPicket(px, py, -1);
+  }
+  const cornerPostWidth = picketWidth * 1.5;
+  const cornerPostHeight = picketHeight * 1.2;
+  ground.rect(
+    -cornerPostWidth / 2,
+    -halfH - cornerPostHeight,
+    cornerPostWidth,
+    cornerPostHeight
+  );
+  ground.fill(fenceWhite);
+  ground.rect(
+    -halfW - cornerPostWidth / 2,
+    -cornerPostHeight,
+    cornerPostWidth,
+    cornerPostHeight
+  );
+  ground.fill(fenceWhite);
+  ground.rect(
+    halfW - cornerPostWidth / 2,
+    -cornerPostHeight,
+    cornerPostWidth,
+    cornerPostHeight
+  );
+  ground.fill(fenceWhite);
+  const gatePostT = 0.75;
+  const gatePostLeftX = -halfW * (1 - gatePostT);
+  const gatePostLeftY = halfH * gatePostT;
+  const gatePostRightX = halfW * (1 - gatePostT);
+  const gatePostRightY = halfH * gatePostT;
+  ground.rect(
+    gatePostLeftX - cornerPostWidth / 2,
+    gatePostLeftY - cornerPostHeight,
+    cornerPostWidth,
+    cornerPostHeight
+  );
+  ground.fill(fenceWhite);
+  ground.rect(
+    gatePostRightX - cornerPostWidth / 2,
+    gatePostRightY - cornerPostHeight,
+    cornerPostWidth,
+    cornerPostHeight
+  );
+  ground.fill(fenceWhite);
+  return ground;
+}
+function generateCobblestoneGround(sizeMultiplier) {
+  const footprint = calculateFootprint(sizeMultiplier);
+  const ground = new Graphics();
+  const halfW = footprint.width;
+  const halfH = footprint.height;
+  ground.moveTo(0, -halfH);
+  ground.lineTo(halfW, 0);
+  ground.lineTo(0, halfH);
+  ground.lineTo(-halfW, 0);
+  ground.closePath();
+  ground.fill(COLORS.grassMedium);
+  const textureCount = Math.max(6, Math.floor(8 * sizeMultiplier));
+  for (let i2 = 0; i2 < textureCount; i2++) {
+    const angle = i2 / textureCount * Math.PI * 2;
+    const radius = 0.4 + i2 % 3 * 0.15;
+    const x2 = Math.cos(angle) * halfW * radius;
+    const y2 = Math.sin(angle) * halfH * radius;
+    if (Math.abs(x2) > halfW * 0.15 || Math.abs(y2) < halfH * 0.3) {
+      const dotSize = Math.max(1.5, 2 * sizeMultiplier);
+      ground.circle(x2, y2, dotSize);
+      ground.fill(i2 % 2 === 0 ? COLORS.grassLight : COLORS.grassDark);
+    }
+  }
+  const stoneSize = Math.max(3, 5 * sizeMultiplier);
+  const stoneColors = [8421504, 9474192, 7368816, 8947848];
+  const pathSteps = Math.max(4, Math.floor(6 * sizeMultiplier));
+  for (let i2 = 0; i2 < pathSteps; i2++) {
+    const progress = i2 / (pathSteps - 1);
+    const y2 = -halfH * 0.5 + progress * halfH * 1.2;
+    for (let j2 = -1; j2 <= 1; j2 += 2) {
+      const offsetX = j2 * stoneSize * 0.6;
+      const offsetY = i2 % 2 * stoneSize * 0.3;
+      const color2 = stoneColors[(i2 + j2 + 10) % stoneColors.length];
+      ground.roundRect(
+        offsetX - stoneSize / 2,
+        y2 + offsetY - stoneSize / 2,
+        stoneSize,
+        stoneSize * 0.7,
+        stoneSize * 0.2
+      );
+      ground.fill(color2);
+    }
+    if (i2 < pathSteps - 1) {
+      const centerY = y2 + stoneSize * 0.5;
+      const color2 = stoneColors[(i2 + 2) % stoneColors.length];
+      ground.roundRect(
+        -stoneSize / 2,
+        centerY - stoneSize / 2,
+        stoneSize,
+        stoneSize * 0.7,
+        stoneSize * 0.2
+      );
+      ground.fill(color2);
+    }
+  }
+  return ground;
+}
+function generateLicenseSign(license, config) {
+  switch (license) {
+    case "MIT":
+    case "BSD":
+    case "ISC":
+    case "Unlicense":
+      return generateMITFlowerArch(config);
+    case "Apache-2.0":
+      return generateApacheSign(config);
+    case "GPL-3.0":
+    case "LGPL-3.0":
+      return generateGPLSign(config);
+    default:
+      return generateMITFlowerArch(config);
+  }
+}
+function generateLicenseGround(license, sizeMultiplier) {
+  switch (license) {
+    case "MIT":
+    case "BSD":
+    case "ISC":
+    case "Unlicense":
+      return generateOpenGrassGround(sizeMultiplier);
+    case "Apache-2.0":
+      return generateCobblestoneGround(sizeMultiplier);
+    case "GPL-3.0":
+    case "LGPL-3.0":
+      return generatePicketFenceGround(sizeMultiplier);
+    default:
+      return generateOpenGrassGround(sizeMultiplier);
+  }
+}
 const ISO_TILE_WIDTH = 64;
 const ISO_TILE_HEIGHT = 32;
 class IsometricRenderer {
@@ -132958,9 +133786,11 @@ class IsometricRenderer {
   renderScene(mapData, showGrid = true) {
     const background = new Container();
     const tiles = new Container();
+    const licenseGrounds = new Container();
     const bridges = new Container();
     const paths = new Container();
     const nodes = new Container();
+    licenseGrounds.sortableChildren = true;
     if (showGrid) {
       const grid = this.renderGrid(
         mapData.width,
@@ -132981,11 +133811,17 @@ class IsometricRenderer {
     }
     const spriteInstances = this.renderSprites(mapData.nodes);
     for (const instance of spriteInstances.values()) {
+      if (instance.licenseGround) {
+        licenseGrounds.addChild(instance.licenseGround);
+      }
       nodes.addChild(instance.highlight);
       nodes.addChild(instance.sprite);
       if (instance.weathering) {
         nodes.addChild(instance.weathering);
       }
+      if (instance.licenseSign) {
+        nodes.addChild(instance.licenseSign);
+      }
       nodes.addChild(instance.label);
       if (instance.hoverLabel) {
         nodes.addChild(instance.hoverLabel);
@@ -132994,6 +133830,7 @@ class IsometricRenderer {
     return {
       background,
       tiles,
+      licenseGrounds,
       bridges,
       paths,
       nodes,
@@ -133253,22 +134090,6 @@ class IsometricRenderer {
         (_a = this.onPackageClick) == null ? void 0 : _a.call(this, nodeId, packageName);
       });
       container.addChild(sprite);
-      if (subCount <= 5) {
-        const subLabel = new Text({
-          text: sub.name,
-          style: {
-            fontSize: 10,
-            fill: 16777215,
-            fontFamily: "Arial",
-            fontWeight: "400"
-          },
-          resolution: 2
-        });
-        subLabel.x = offset.x;
-        subLabel.y = offset.y + sprite.height * 0.15 + 4;
-        subLabel.anchor.set(0.5, 0);
-        container.addChild(subLabel);
-      }
     }
     const decorationBaseY = footprintHeight * 0.5;
     if (node2.stars && node2.stars > 0) {
@@ -133386,6 +134207,24 @@ class IsometricRenderer {
       );
       weathering.zIndex = container.zIndex + 0.1;
     }
+    let licenseGround;
+    let licenseSign;
+    if (node2.license) {
+      const licenseType = node2.license;
+      const footprint = calculateFootprint(sizeMultiplier);
+      licenseGround = generateLicenseGround(licenseType, sizeMultiplier);
+      licenseGround.x = screenX;
+      licenseGround.y = screenY;
+      licenseGround.zIndex = screenY;
+      licenseSign = generateLicenseSign(licenseType, {
+        name: node2.label,
+        sizeMultiplier
+      });
+      licenseSign.x = screenX;
+      licenseSign.y = screenY + footprint.height * 0.75;
+      licenseSign.zIndex = container.zIndex + 0.15;
+      label.visible = false;
+    }
     const instance = {
       sprite: container,
       // Container acts as the sprite
@@ -133393,8 +134232,12 @@ class IsometricRenderer {
       label,
       hoverLabel,
       weathering,
+      licenseGround,
+      licenseSign,
       gridPosition: { gridX: node2.gridX, gridY: node2.gridY },
       size: sizeMultiplier,
+      spriteKey: node2.sprite,
+      // Store for diffing - allows detecting visual changes
       update: (gridX, gridY) => {
         const pos = gridToScreen(gridX, gridY);
         container.x = pos.screenX;
@@ -133421,6 +134264,17 @@ class IsometricRenderer {
           weathering.x = pos.screenX;
           weathering.y = pos.screenY;
         }
+        if (licenseGround) {
+          licenseGround.x = pos.screenX;
+          licenseGround.y = pos.screenY;
+          licenseGround.zIndex = pos.screenY;
+        }
+        if (licenseSign) {
+          const footprint = calculateFootprint(sizeMultiplier);
+          licenseSign.x = pos.screenX;
+          licenseSign.y = pos.screenY + footprint.height * 0.75;
+          licenseSign.zIndex = getIsometricZIndex(gridX, gridY) + 0.15;
+        }
         instance.gridPosition = { gridX, gridY };
       },
       destroy: () => {
@@ -133429,6 +134283,8 @@ class IsometricRenderer {
         label.destroy();
         hoverLabel.destroy();
         weathering == null ? void 0 : weathering.destroy();
+        licenseGround == null ? void 0 : licenseGround.destroy();
+        licenseSign == null ? void 0 : licenseSign.destroy();
       }
     };
     return instance;
@@ -133502,13 +134358,35 @@ class IsometricRenderer {
       label.y = screenY + sprite.height * 0.15 + 8;
       label.anchor.set(0.5, 0);
       label.zIndex = sprite.zIndex + 0.2;
+      let licenseGround;
+      let licenseSign;
+      if (node2.license) {
+        const licenseType = node2.license;
+        const footprint = calculateFootprint(sizeMultiplier);
+        licenseGround = generateLicenseGround(licenseType, sizeMultiplier);
+        licenseGround.x = screenX;
+        licenseGround.y = screenY;
+        licenseGround.zIndex = screenY;
+        licenseSign = generateLicenseSign(licenseType, {
+          name: node2.label,
+          sizeMultiplier
+        });
+        licenseSign.x = screenX;
+        licenseSign.y = screenY + footprint.height * 0.75;
+        licenseSign.zIndex = sprite.zIndex + 0.15;
+        label.visible = false;
+      }
       const instance = {
         sprite,
         highlight,
         label,
         weathering,
+        licenseGround,
+        licenseSign,
         gridPosition: { gridX: node2.gridX, gridY: node2.gridY },
         size: sizeMultiplier,
+        spriteKey: node2.sprite,
+        // Store for diffing - allows detecting visual changes
         update: (gridX, gridY) => {
           const pos = gridToScreen(gridX, gridY);
           sprite.x = pos.screenX;
@@ -133533,6 +134411,17 @@ class IsometricRenderer {
             weathering.x = pos.screenX;
             weathering.y = pos.screenY;
           }
+          if (licenseGround) {
+            licenseGround.x = pos.screenX;
+            licenseGround.y = pos.screenY;
+            licenseGround.zIndex = pos.screenY;
+          }
+          if (licenseSign) {
+            const footprint = calculateFootprint(sizeMultiplier);
+            licenseSign.x = pos.screenX;
+            licenseSign.y = pos.screenY + footprint.height * 0.75;
+            licenseSign.zIndex = getIsometricZIndex(gridX, gridY) + 0.15;
+          }
           instance.gridPosition = { gridX, gridY };
         },
         destroy: () => {
@@ -133540,6 +134429,8 @@ class IsometricRenderer {
           highlight.destroy();
           label.destroy();
           weathering == null ? void 0 : weathering.destroy();
+          licenseGround == null ? void 0 : licenseGround.destroy();
+          licenseSign == null ? void 0 : licenseSign.destroy();
         }
       };
       spriteInstances.set(node2.id, instance);
@@ -134732,7 +135623,8 @@ function nodesToUnifiedOverworldMap(nodes, options = {}) {
       aging: node2.aging,
       subdivisions,
       stars: node2.stars,
-      collaborators: node2.collaborators
+      collaborators: node2.collaborators,
+      license: node2.license
     };
   });
   const paths = [];
@@ -134906,6 +135798,7 @@ const OverworldMapPanelContent = ({
       if (sceneContainersRef.current) {
         viewport.removeChild(sceneContainersRef.current.background);
         viewport.removeChild(sceneContainersRef.current.tiles);
+        viewport.removeChild(sceneContainersRef.current.licenseGrounds);
         viewport.removeChild(sceneContainersRef.current.bridges);
         viewport.removeChild(sceneContainersRef.current.paths);
         viewport.removeChild(sceneContainersRef.current.nodes);
@@ -134913,6 +135806,7 @@ const OverworldMapPanelContent = ({
       const scene = renderer.renderScene(mapData, true);
       viewport.addChild(scene.background);
       viewport.addChild(scene.tiles);
+      viewport.addChild(scene.licenseGrounds);
       viewport.addChild(scene.bridges);
       viewport.addChild(scene.paths);
       viewport.addChild(scene.nodes);
@@ -135004,6 +135898,7 @@ const OverworldMapPanelContent = ({
       const scene = renderer.renderScene(mapData, true);
       viewport.addChild(scene.background);
       viewport.addChild(scene.tiles);
+      viewport.addChild(scene.licenseGrounds);
       viewport.addChild(scene.bridges);
       viewport.addChild(scene.paths);
       viewport.addChild(scene.nodes);
@@ -135354,7 +136249,7 @@ const OverworldMapPanelContent = ({
     };
   }, [stableCollectionKey, width, height]);
   useEffect(() => {
-    var _a;
+    var _a, _b;
     if (!isInitializedRef.current) {
       return;
     }
@@ -135397,14 +136292,57 @@ const OverworldMapPanelContent = ({
         buildingGraphics.destroy();
       }
     }
+    const currentSprites = (_b = sceneContainersRef.current) == null ? void 0 : _b.spriteInstances;
+    if (currentSprites && currentSprites.size > 0) {
+      const newNodeMap = new Map(mapData.nodes.map((n2) => [n2.id, n2]));
+      const currentIds = new Set(currentSprites.keys());
+      const newIds = new Set(newNodeMap.keys());
+      const toRemove = [...currentIds].filter((id2) => !newIds.has(id2));
+      const toAdd = [...newIds].filter((id2) => !currentIds.has(id2));
+      const toRecreate = [...newIds].filter((id2) => {
+        if (!currentIds.has(id2)) return false;
+        const node2 = newNodeMap.get(id2);
+        const sprite = currentSprites.get(id2);
+        return node2.sprite !== sprite.spriteKey;
+      });
+      const toUpdatePosition = [...newIds].filter((id2) => {
+        if (!currentIds.has(id2)) return false;
+        const node2 = newNodeMap.get(id2);
+        const sprite = currentSprites.get(id2);
+        return node2.sprite === sprite.spriteKey && (node2.gridX !== sprite.gridPosition.gridX || node2.gridY !== sprite.gridPosition.gridY);
+      });
+      if (toRemove.length === 0 && toAdd.length === 0 && toRecreate.length === 0) {
+        for (const id2 of toUpdatePosition) {
+          const node2 = newNodeMap.get(id2);
+          const sprite = currentSprites.get(id2);
+          sprite.update(node2.gridX, node2.gridY);
+        }
+        if (toUpdatePosition.length > 0 && pathManagerRef.current) {
+          for (const id2 of toUpdatePosition) {
+            const node2 = newNodeMap.get(id2);
+            pathManagerRef.current.updateNodePosition(id2, node2.gridX, node2.gridY);
+          }
+        }
+        return;
+      }
+      if (toRemove.length > 0 || toAdd.length > 0 || toRecreate.length > 0) {
+        console.log("[OverworldMapPanel] Full recreation needed:", {
+          toRemove: toRemove.length,
+          toAdd: toAdd.length,
+          toRecreate: toRecreate.length
+        });
+      }
+    }
     if (sceneContainersRef.current) {
       viewport.removeChild(sceneContainersRef.current.background);
       viewport.removeChild(sceneContainersRef.current.tiles);
+      viewport.removeChild(sceneContainersRef.current.licenseGrounds);
       viewport.removeChild(sceneContainersRef.current.bridges);
       viewport.removeChild(sceneContainersRef.current.paths);
       viewport.removeChild(sceneContainersRef.current.nodes);
       sceneContainersRef.current.background.destroy({ children: true });
       sceneContainersRef.current.tiles.destroy({ children: true });
+      sceneContainersRef.current.licenseGrounds.destroy({ children: true });
       sceneContainersRef.current.bridges.destroy({ children: true });
       sceneContainersRef.current.paths.destroy({ children: true });
       sceneContainersRef.current.nodes.destroy({ children: true });
@@ -135412,6 +136350,7 @@ const OverworldMapPanelContent = ({
     const scene = renderer.renderScene(mapData, true);
     viewport.addChild(scene.background);
     viewport.addChild(scene.tiles);
+    viewport.addChild(scene.licenseGrounds);
     viewport.addChild(scene.bridges);
     viewport.addChild(scene.paths);
     viewport.addChild(scene.nodes);
@@ -136010,7 +136949,7 @@ This indicates a sprite was rendered without valid backing data.`
   });
   const nodes = useMemo(() => {
     const memberNodes = collection.members.map((membership) => {
-      var _a2, _b, _c, _d, _e2, _f, _g;
+      var _a2, _b, _c, _d, _e2, _f, _g, _h;
       const repo = repositories.find((r2) => {
         var _a3;
         const repoId = ((_a3 = r2.github) == null ? void 0 : _a3.id) || r2.name;
@@ -136047,6 +136986,7 @@ This indicates a sprite was rendered without valid backing data.`
         const decorationBonus = getCollaboratorDecorationSizeBonus(collaborators);
         size = size + decorationBonus;
       }
+      const license = (_e2 = repo.github) == null ? void 0 : _e2.license;
       const node2 = {
         id: membership.repositoryId,
         name: repo.name,
@@ -136063,11 +137003,13 @@ This indicates a sprite was rendered without valid backing data.`
         // GitHub star count for decorations
         collaborators,
         // Contributor count for community space decorations
+        license,
+        // License identifier for sign/ground treatment
         dependencies: dependencies[membership.repositoryId] || [],
-        isRoot: ((_e2 = membership.metadata) == null ? void 0 : _e2.pinned) || false,
-        regionId: (_f = membership.metadata) == null ? void 0 : _f.regionId,
+        isRoot: ((_f = membership.metadata) == null ? void 0 : _f.pinned) || false,
+        regionId: (_g = membership.metadata) == null ? void 0 : _g.regionId,
         // Preserve region assignment
-        layout: (_g = membership.metadata) == null ? void 0 : _g.layout
+        layout: (_h = membership.metadata) == null ? void 0 : _h.layout
         // Pass saved position data
       };
       return node2;
@@ -137555,4 +138497,4 @@ export {
   UPDATE_PRIORITY as y,
   removeItems as z
 };
-//# sourceMappingURL=index-B5obJmUS.js.map
+//# sourceMappingURL=index-CBrdpzxz.js.map