@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-HCFPELPY.js

@@ -0,0 +1,919 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/procedural/index.ts
+var procedural_exports = {};
+__export(procedural_exports, {
+  BuildingGenerator: () => BuildingGenerator,
+  DungeonGenerator: () => DungeonGenerator,
+  LSystemGenerator: () => LSystemGenerator,
+  NoiseGenerator: () => NoiseGenerator,
+  WaveFunction: () => WaveFunction
+});
+
+// src/procedural/NoiseGenerator.ts
+var DEFAULT_CONFIG = {
+  seed: 42,
+  octaves: 6,
+  lacunarity: 2,
+  gain: 0.5,
+  scale: 0.01
+};
+var NoiseGenerator = class {
+  config;
+  perm;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.perm = this.buildPermutationTable(this.config.seed);
+  }
+  // ---------------------------------------------------------------------------
+  // Base Noise
+  // ---------------------------------------------------------------------------
+  /**
+   * 2D value noise (smooth random values at integer lattice).
+   */
+  value2D(x, y) {
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const fx = x - ix;
+    const fy = y - iy;
+    const sx = this.fade(fx);
+    const sy = this.fade(fy);
+    const n00 = this.hash2D(ix, iy);
+    const n10 = this.hash2D(ix + 1, iy);
+    const n01 = this.hash2D(ix, iy + 1);
+    const n11 = this.hash2D(ix + 1, iy + 1);
+    return this.lerp(this.lerp(n00, n10, sx), this.lerp(n01, n11, sx), sy);
+  }
+  /**
+   * 2D gradient noise (Perlin-like).
+   */
+  perlin2D(x, y) {
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const fx = x - ix;
+    const fy = y - iy;
+    const u = this.fade(fx);
+    const v = this.fade(fy);
+    const g00 = this.grad2D(this.permAt(ix, iy), fx, fy);
+    const g10 = this.grad2D(this.permAt(ix + 1, iy), fx - 1, fy);
+    const g01 = this.grad2D(this.permAt(ix, iy + 1), fx, fy - 1);
+    const g11 = this.grad2D(this.permAt(ix + 1, iy + 1), fx - 1, fy - 1);
+    return this.lerp(this.lerp(g00, g10, u), this.lerp(g01, g11, u), v) * 0.5 + 0.5;
+  }
+  /**
+   * 3D value noise.
+   */
+  value3D(x, y, z) {
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const iz = Math.floor(z);
+    const fx = x - ix;
+    const fy = y - iy;
+    const fz = z - iz;
+    const sx = this.fade(fx);
+    const sy = this.fade(fy);
+    const sz = this.fade(fz);
+    const n000 = this.hash3D(ix, iy, iz);
+    const n100 = this.hash3D(ix + 1, iy, iz);
+    const n010 = this.hash3D(ix, iy + 1, iz);
+    const n110 = this.hash3D(ix + 1, iy + 1, iz);
+    const n001 = this.hash3D(ix, iy, iz + 1);
+    const n101 = this.hash3D(ix + 1, iy, iz + 1);
+    const n011 = this.hash3D(ix, iy + 1, iz + 1);
+    const n111 = this.hash3D(ix + 1, iy + 1, iz + 1);
+    return this.lerp(
+      this.lerp(this.lerp(n000, n100, sx), this.lerp(n010, n110, sx), sy),
+      this.lerp(this.lerp(n001, n101, sx), this.lerp(n011, n111, sx), sy),
+      sz
+    );
+  }
+  /**
+   * Worley (cellular) noise — distance to nearest feature point.
+   */
+  worley2D(x, y, density = 1) {
+    let minDist = Infinity;
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const cx = ix + dx;
+        const cy = iy + dy;
+        const hash = this.perm[(cx & 255) + this.perm[cy & 255] & 511];
+        const px = cx + hash / 255 * density;
+        const py = cy + this.perm[hash + 1 & 511] / 255 * density;
+        const dist = Math.sqrt((x - px) ** 2 + (y - py) ** 2);
+        if (dist < minDist) minDist = dist;
+      }
+    }
+    return Math.min(1, minDist);
+  }
+  // ---------------------------------------------------------------------------
+  // Fractal Noise
+  // ---------------------------------------------------------------------------
+  /**
+   * Fractal Brownian Motion (FBM) — layered octaves of noise.
+   */
+  fbm2D(x, y, type = "value") {
+    const { octaves, lacunarity, gain, scale } = this.config;
+    let value = 0;
+    let amplitude = 1;
+    let frequency = scale;
+    let maxValue = 0;
+    for (let i = 0; i < octaves; i++) {
+      const n = type === "perlin" ? this.perlin2D(x * frequency, y * frequency) : this.value2D(x * frequency, y * frequency);
+      value += n * amplitude;
+      maxValue += amplitude;
+      amplitude *= gain;
+      frequency *= lacunarity;
+    }
+    return value / maxValue;
+  }
+  /**
+   * Ridged multifractal noise — sharp ridges from inverted absolute values.
+   */
+  ridged2D(x, y) {
+    const { octaves, lacunarity, gain, scale } = this.config;
+    let value = 0;
+    let amplitude = 1;
+    let frequency = scale;
+    let weight = 1;
+    for (let i = 0; i < octaves; i++) {
+      let n = this.perlin2D(x * frequency, y * frequency);
+      n = 1 - Math.abs(n * 2 - 1);
+      n = n * n * weight;
+      weight = Math.min(1, n);
+      value += n * amplitude;
+      frequency *= lacunarity;
+      amplitude *= gain;
+    }
+    return value;
+  }
+  /**
+   * Domain-warped noise — distorts input coordinates for organic shapes.
+   */
+  warped2D(x, y, warpStrength = 4) {
+    const { scale } = this.config;
+    const qx = this.fbm2D(x, y);
+    const qy = this.fbm2D(x + 5.2, y + 1.3);
+    return this.fbm2D(x + qx * warpStrength / scale, y + qy * warpStrength / scale);
+  }
+  // ---------------------------------------------------------------------------
+  // Multi-purpose Sample
+  // ---------------------------------------------------------------------------
+  /**
+   * Sample noise at a point using the specified type.
+   */
+  sample2D(x, y, type = "value") {
+    switch (type) {
+      case "value":
+        return this.fbm2D(x, y, "value");
+      case "perlin":
+        return this.fbm2D(x, y, "perlin");
+      case "ridged":
+        return this.ridged2D(x, y);
+      case "warped":
+        return this.warped2D(x, y);
+      case "worley":
+        return this.worley2D(x, y);
+    }
+  }
+  /**
+   * Generate a 2D noise map.
+   */
+  generateMap(width, height, type = "value") {
+    const map = new Float32Array(width * height);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        map[y * width + x] = this.sample2D(x, y, type);
+      }
+    }
+    return map;
+  }
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setSeed(seed) {
+    this.config.seed = seed;
+    this.perm = this.buildPermutationTable(seed);
+  }
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (config.seed !== void 0) {
+      this.perm = this.buildPermutationTable(config.seed);
+    }
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  // ---------------------------------------------------------------------------
+  // Internal Utilities
+  // ---------------------------------------------------------------------------
+  fade(t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+  lerp(a, b, t) {
+    return a + (b - a) * t;
+  }
+  hash2D(x, y) {
+    const idx = this.perm[x & 255] + y & 255;
+    return this.perm[idx] / 255;
+  }
+  hash3D(x, y, z) {
+    const idx = this.perm[this.perm[x & 255] + y & 255] + z & 255;
+    return this.perm[idx] / 255;
+  }
+  permAt(x, y) {
+    return this.perm[this.perm[x & 255] + y & 255];
+  }
+  grad2D(hash, x, y) {
+    const h = hash & 3;
+    switch (h) {
+      case 0:
+        return x + y;
+      case 1:
+        return -x + y;
+      case 2:
+        return x - y;
+      case 3:
+        return -x - y;
+      default:
+        return 0;
+    }
+  }
+  buildPermutationTable(seed) {
+    const table = new Uint8Array(512);
+    for (let i = 0; i < 256; i++) table[i] = i;
+    let s = seed;
+    for (let i = 255; i > 0; i--) {
+      s = s * 1103515245 + 12345 & 2147483647;
+      const j = s % (i + 1);
+      [table[i], table[j]] = [table[j], table[i]];
+    }
+    for (let i = 0; i < 256; i++) table[i + 256] = table[i];
+    return table;
+  }
+};
+
+// src/procedural/LSystemGenerator.ts
+var LSystemGenerator = class {
+  seed;
+  rng;
+  constructor(seed = 42) {
+    this.seed = seed;
+    this.rng = this.createRng(seed);
+  }
+  // ---------------------------------------------------------------------------
+  // String Generation
+  // ---------------------------------------------------------------------------
+  /**
+   * Apply production rules to expand the axiom.
+   */
+  expand(config) {
+    let current = config.axiom;
+    for (let i = 0; i < config.iterations; i++) {
+      let next = "";
+      for (const char of current) {
+        const matching = config.rules.filter((r) => r.symbol === char);
+        if (matching.length === 0) {
+          next += char;
+          continue;
+        }
+        if (matching.length === 1 && (matching[0].probability === void 0 || matching[0].probability >= 1)) {
+          next += matching[0].replacement;
+        } else {
+          const roll = this.rng();
+          let cumulative = 0;
+          let chosen = matching[0].replacement;
+          for (const rule of matching) {
+            cumulative += rule.probability ?? 1;
+            if (roll <= cumulative) {
+              chosen = rule.replacement;
+              break;
+            }
+          }
+          next += chosen;
+        }
+      }
+      current = next;
+    }
+    return current;
+  }
+  // ---------------------------------------------------------------------------
+  // Turtle Interpretation
+  // ---------------------------------------------------------------------------
+  /**
+   * Interpret the L-system string using 3D turtle graphics.
+   */
+  interpret(lString, config) {
+    const segments = [];
+    const leaves = [];
+    const stack = [];
+    let state = {
+      position: { x: 0, y: 0, z: 0 },
+      direction: { x: 0, y: 1, z: 0 },
+      // Growing upward
+      up: { x: 0, y: 0, z: 1 },
+      length: config.length,
+      depth: 0
+    };
+    const angleRad = config.angle * Math.PI / 180;
+    const minBound = { x: 0, y: 0, z: 0 };
+    const maxBound = { x: 0, y: 0, z: 0 };
+    for (const char of lString) {
+      switch (char) {
+        case "F": {
+          const start = { ...state.position };
+          const end = {
+            x: state.position.x + state.direction.x * state.length,
+            y: state.position.y + state.direction.y * state.length,
+            z: state.position.z + state.direction.z * state.length
+          };
+          segments.push({
+            start,
+            end,
+            depth: state.depth,
+            radius: Math.max(0.02, 0.1 * Math.pow(config.lengthScale, state.depth))
+          });
+          state.position = end;
+          this.updateBounds(end, minBound, maxBound);
+          break;
+        }
+        case "+":
+          state.direction = this.rotateY(state.direction, angleRad);
+          break;
+        case "-":
+          state.direction = this.rotateY(state.direction, -angleRad);
+          break;
+        case "&":
+          state.direction = this.rotateX(state.direction, angleRad);
+          break;
+        case "^":
+          state.direction = this.rotateX(state.direction, -angleRad);
+          break;
+        case "[":
+          stack.push({
+            position: { ...state.position },
+            direction: { ...state.direction },
+            up: { ...state.up },
+            length: state.length * config.lengthScale,
+            depth: state.depth + 1
+          });
+          break;
+        case "]":
+          if (stack.length > 0) {
+            leaves.push({
+              position: { ...state.position },
+              normal: { ...state.direction },
+              size: 0.3 * Math.pow(config.lengthScale, state.depth)
+            });
+            state = stack.pop();
+          }
+          break;
+        case "X":
+          break;
+      }
+    }
+    return {
+      segments,
+      leaves,
+      boundingBox: { min: minBound, max: maxBound }
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // High-Level API
+  // ---------------------------------------------------------------------------
+  /**
+   * Generate a complete L-system tree/plant.
+   */
+  generate(config) {
+    const lString = this.expand(config);
+    return this.interpret(lString, config);
+  }
+  // ---------------------------------------------------------------------------
+  // Internal Utilities
+  // ---------------------------------------------------------------------------
+  rotateY(dir, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return {
+      x: dir.x * cos - dir.z * sin,
+      y: dir.y,
+      z: dir.x * sin + dir.z * cos
+    };
+  }
+  rotateX(dir, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return {
+      x: dir.x,
+      y: dir.y * cos - dir.z * sin,
+      z: dir.y * sin + dir.z * cos
+    };
+  }
+  updateBounds(p, min, max) {
+    min.x = Math.min(min.x, p.x);
+    min.y = Math.min(min.y, p.y);
+    min.z = Math.min(min.z, p.z);
+    max.x = Math.max(max.x, p.x);
+    max.y = Math.max(max.y, p.y);
+    max.z = Math.max(max.z, p.z);
+  }
+  createRng(seed) {
+    let s = seed;
+    return () => {
+      s = s * 1103515245 + 12345 & 2147483647;
+      return s / 2147483647;
+    };
+  }
+};
+
+// src/procedural/BuildingGenerator.ts
+var STYLE_PARAMS = {
+  residential: {
+    roomCountRange: [3, 6],
+    windowDensity: 0.6,
+    hasLobby: false,
+    roofType: "pitched",
+    wallThickness: 0.2
+  },
+  commercial: {
+    roomCountRange: [4, 10],
+    windowDensity: 0.8,
+    hasLobby: true,
+    roofType: "flat",
+    wallThickness: 0.15
+  },
+  industrial: {
+    roomCountRange: [1, 3],
+    windowDensity: 0.2,
+    hasLobby: false,
+    roofType: "flat",
+    wallThickness: 0.3
+  },
+  tower: {
+    roomCountRange: [2, 4],
+    windowDensity: 0.9,
+    hasLobby: true,
+    roofType: "flat",
+    wallThickness: 0.2
+  },
+  warehouse: {
+    roomCountRange: [1, 2],
+    windowDensity: 0.1,
+    hasLobby: false,
+    roofType: "pitched",
+    wallThickness: 0.25
+  }
+};
+var BuildingGenerator = class {
+  rng;
+  constructor(seed = 42) {
+    this.rng = this.createRng(seed);
+  }
+  // ---------------------------------------------------------------------------
+  // Generation
+  // ---------------------------------------------------------------------------
+  generate(config) {
+    this.rng = this.createRng(config.seed);
+    const style = STYLE_PARAMS[config.style];
+    const floorPlans = [];
+    for (let floor = 0; floor < config.floors; floor++) {
+      const plan = this.generateFloor(config, floor, style);
+      floorPlans.push(plan);
+    }
+    const meshData = this.generateMesh(config, floorPlans);
+    const halfW = config.footprint.width / 2;
+    const halfD = config.footprint.depth / 2;
+    return {
+      config,
+      floorPlans,
+      meshData,
+      boundingBox: {
+        min: { x: -halfW, y: 0, z: -halfD },
+        max: { x: halfW, y: config.floors * config.floorHeight, z: halfD }
+      }
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Floor Plan Generation
+  // ---------------------------------------------------------------------------
+  generateFloor(config, floorIndex, style) {
+    const rooms = [];
+    const walls = [];
+    const openings = [];
+    const w = config.footprint.width;
+    const d = config.footprint.depth;
+    const h = config.floorHeight;
+    if (floorIndex === 0 && style.hasLobby) {
+      rooms.push({
+        id: `lobby_${floorIndex}`,
+        type: "lobby",
+        bounds: { x: 0, z: 0, width: w, depth: d * 0.3 },
+        height: h
+      });
+    }
+    const roomCount = style.roomCountRange[0] + Math.floor(this.rng() * (style.roomCountRange[1] - style.roomCountRange[0] + 1));
+    const cols = Math.ceil(Math.sqrt(roomCount));
+    const rows = Math.ceil(roomCount / cols);
+    const roomW = w / cols;
+    const roomD = d / rows;
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        if (rooms.length >= roomCount) break;
+        const jitterX = (this.rng() - 0.5) * roomW * 0.1;
+        const jitterZ = (this.rng() - 0.5) * roomD * 0.1;
+        rooms.push({
+          id: `room_${floorIndex}_${r}_${c}`,
+          type: "room",
+          bounds: {
+            x: c * roomW + jitterX,
+            z: r * roomD + jitterZ,
+            width: roomW,
+            depth: roomD
+          },
+          height: h
+        });
+      }
+    }
+    rooms.push({
+      id: `stairwell_${floorIndex}`,
+      type: "stairwell",
+      bounds: { x: w - 2, z: d - 2, width: 2, depth: 2 },
+      height: h
+    });
+    const wallThick = style.wallThickness;
+    const _baseY = floorIndex * h;
+    walls.push({
+      start: { x: 0, z: 0 },
+      end: { x: w, z: 0 },
+      height: h,
+      thickness: wallThick,
+      isExterior: true
+    });
+    walls.push({
+      start: { x: 0, z: d },
+      end: { x: w, z: d },
+      height: h,
+      thickness: wallThick,
+      isExterior: true
+    });
+    walls.push({
+      start: { x: 0, z: 0 },
+      end: { x: 0, z: d },
+      height: h,
+      thickness: wallThick,
+      isExterior: true
+    });
+    walls.push({
+      start: { x: w, z: 0 },
+      end: { x: w, z: d },
+      height: h,
+      thickness: wallThick,
+      isExterior: true
+    });
+    for (let wi = 0; wi < walls.length; wi++) {
+      const wall = walls[wi];
+      if (!wall.isExterior) continue;
+      const wallLen = Math.sqrt(
+        Math.pow(wall.end.x - wall.start.x, 2) + Math.pow(wall.end.z - wall.start.z, 2)
+      );
+      const windowCount = Math.floor(wallLen * style.windowDensity);
+      for (let wn = 0; wn < windowCount; wn++) {
+        openings.push({
+          type: "window",
+          wall: wi,
+          position: (wn + 0.5) / windowCount,
+          width: 1,
+          height: 1.2,
+          sillHeight: 0.9
+        });
+      }
+    }
+    if (floorIndex === 0) {
+      openings.push({
+        type: "door",
+        wall: 0,
+        position: 0.5,
+        width: 1.2,
+        height: 2.2
+      });
+    }
+    return { floor: floorIndex, rooms, walls, openings };
+  }
+  // ---------------------------------------------------------------------------
+  // Mesh Generation (simplified box geometry)
+  // ---------------------------------------------------------------------------
+  generateMesh(config, _floorPlans) {
+    const vertices = [];
+    const faces = [];
+    const w = config.footprint.width;
+    const d = config.footprint.depth;
+    const h = config.floors * config.floorHeight;
+    const hw = w / 2;
+    const hd = d / 2;
+    const base = vertices.length;
+    vertices.push(
+      { x: -hw, y: 0, z: -hd },
+      // 0: bottom-front-left
+      { x: hw, y: 0, z: -hd },
+      // 1: bottom-front-right
+      { x: hw, y: 0, z: hd },
+      // 2: bottom-back-right
+      { x: -hw, y: 0, z: hd },
+      // 3: bottom-back-left
+      { x: -hw, y: h, z: -hd },
+      // 4: top-front-left
+      { x: hw, y: h, z: -hd },
+      // 5: top-front-right
+      { x: hw, y: h, z: hd },
+      // 6: top-back-right
+      { x: -hw, y: h, z: hd }
+      // 7: top-back-left
+    );
+    faces.push(base + 0, base + 1, base + 5, base + 0, base + 5, base + 4);
+    faces.push(base + 2, base + 3, base + 7, base + 2, base + 7, base + 6);
+    faces.push(base + 3, base + 0, base + 4, base + 3, base + 4, base + 7);
+    faces.push(base + 1, base + 2, base + 6, base + 1, base + 6, base + 5);
+    faces.push(base + 4, base + 5, base + 6, base + 4, base + 6, base + 7);
+    faces.push(base + 0, base + 3, base + 2, base + 0, base + 2, base + 1);
+    return { vertices, faces };
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  createRng(seed) {
+    let s = seed;
+    return () => {
+      s = s * 1103515245 + 12345 & 2147483647;
+      return s / 2147483647;
+    };
+  }
+};
+
+// src/procedural/DungeonGenerator.ts
+var DungeonGenerator = class {
+  config;
+  rooms = [];
+  corridors = [];
+  nextRoomId = 0;
+  rng;
+  constructor(config) {
+    this.config = {
+      width: config?.width ?? 64,
+      height: config?.height ?? 64,
+      minRoomSize: config?.minRoomSize ?? 4,
+      maxRoomSize: config?.maxRoomSize ?? 12,
+      maxRooms: config?.maxRooms ?? 15,
+      corridorWidth: config?.corridorWidth ?? 1,
+      seed: config?.seed ?? 42
+    };
+    let s = this.config.seed;
+    this.rng = () => {
+      s = s * 16807 % 2147483647;
+      return (s - 1) / 2147483646;
+    };
+  }
+  /**
+   * Generate a full dungeon
+   */
+  generate() {
+    this.rooms = [];
+    this.corridors = [];
+    this.nextRoomId = 0;
+    for (let i = 0; i < this.config.maxRooms * 3; i++) {
+      if (this.rooms.length >= this.config.maxRooms) break;
+      const w = this.randInt(this.config.minRoomSize, this.config.maxRoomSize);
+      const h = this.randInt(this.config.minRoomSize, this.config.maxRoomSize);
+      const x = this.randInt(1, this.config.width - w - 1);
+      const y = this.randInt(1, this.config.height - h - 1);
+      if (!this.overlaps(x, y, w, h)) {
+        this.rooms.push({ id: this.nextRoomId++, x, y, width: w, height: h, connected: [] });
+      }
+    }
+    for (let i = 1; i < this.rooms.length; i++) {
+      this.connectRooms(this.rooms[i - 1], this.rooms[i]);
+    }
+    return { rooms: [...this.rooms], corridors: [...this.corridors] };
+  }
+  overlaps(x, y, w, h) {
+    for (const room of this.rooms) {
+      if (x < room.x + room.width + 1 && x + w + 1 > room.x && y < room.y + room.height + 1 && y + h + 1 > room.y)
+        return true;
+    }
+    return false;
+  }
+  connectRooms(a, b) {
+    const ax = Math.floor(a.x + a.width / 2);
+    const ay = Math.floor(a.y + a.height / 2);
+    const bx = Math.floor(b.x + b.width / 2);
+    const by = Math.floor(b.y + b.height / 2);
+    const points = [];
+    if (this.rng() > 0.5) {
+      for (let x = Math.min(ax, bx); x <= Math.max(ax, bx); x++) points.push({ x, y: ay });
+      for (let y = Math.min(ay, by); y <= Math.max(ay, by); y++) points.push({ x: bx, y });
+    } else {
+      for (let y = Math.min(ay, by); y <= Math.max(ay, by); y++) points.push({ x: ax, y });
+      for (let x = Math.min(ax, bx); x <= Math.max(ax, bx); x++) points.push({ x, y: by });
+    }
+    a.connected.push(b.id);
+    b.connected.push(a.id);
+    this.corridors.push({ from: a.id, to: b.id, points });
+  }
+  randInt(min, max) {
+    return Math.floor(this.rng() * (max - min + 1)) + min;
+  }
+  /**
+   * Check if all rooms are connected
+   */
+  isFullyConnected() {
+    if (this.rooms.length === 0) return true;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [this.rooms[0].id];
+    visited.add(this.rooms[0].id);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const room = this.rooms.find((r) => r.id === current);
+      for (const neighbor of room.connected) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    return visited.size === this.rooms.length;
+  }
+  getRooms() {
+    return [...this.rooms];
+  }
+  getCorridors() {
+    return [...this.corridors];
+  }
+  getRoomCount() {
+    return this.rooms.length;
+  }
+};
+
+// src/procedural/WaveFunction.ts
+var WaveFunction = class {
+  tiles = /* @__PURE__ */ new Map();
+  grid = [];
+  width;
+  height;
+  rng;
+  contradictions = 0;
+  constructor(width, height, seed = 42) {
+    this.width = width;
+    this.height = height;
+    let s = seed;
+    this.rng = () => {
+      s = s * 16807 % 2147483647;
+      return (s - 1) / 2147483646;
+    };
+  }
+  /**
+   * Register a tile type
+   */
+  addTile(tile) {
+    this.tiles.set(tile.id, tile);
+  }
+  /**
+   * Initialize the grid with all options
+   */
+  initialize() {
+    const allIds = [...this.tiles.keys()];
+    this.grid = [];
+    for (let y = 0; y < this.height; y++) {
+      this.grid[y] = [];
+      for (let x = 0; x < this.width; x++) {
+        this.grid[y][x] = { x, y, collapsed: false, tileId: null, options: [...allIds] };
+      }
+    }
+    this.contradictions = 0;
+  }
+  /**
+   * Get the cell with lowest entropy (fewest options)
+   */
+  getLowestEntropy() {
+    let minEntropy = Infinity;
+    const candidates = [];
+    for (const row of this.grid) {
+      for (const cell of row) {
+        if (cell.collapsed) continue;
+        if (cell.options.length < minEntropy) {
+          minEntropy = cell.options.length;
+          candidates.length = 0;
+          candidates.push(cell);
+        } else if (cell.options.length === minEntropy) {
+          candidates.push(cell);
+        }
+      }
+    }
+    if (candidates.length === 0) return null;
+    return candidates[Math.floor(this.rng() * candidates.length)];
+  }
+  /**
+   * Collapse a cell to a single tile
+   */
+  collapse(cell) {
+    if (cell.options.length === 0) {
+      this.contradictions++;
+      return false;
+    }
+    let totalWeight = 0;
+    for (const tileId of cell.options) {
+      totalWeight += this.tiles.get(tileId)?.weight ?? 1;
+    }
+    let rand = this.rng() * totalWeight;
+    for (const tileId of cell.options) {
+      rand -= this.tiles.get(tileId)?.weight ?? 1;
+      if (rand <= 0) {
+        cell.tileId = tileId;
+        cell.options = [tileId];
+        cell.collapsed = true;
+        return true;
+      }
+    }
+    cell.tileId = cell.options[0];
+    cell.options = [cell.tileId];
+    cell.collapsed = true;
+    return true;
+  }
+  /**
+   * Propagate constraints from a collapsed cell
+   */
+  propagate(cell) {
+    const stack = [cell];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      const neighbors = this.getNeighbors(current.x, current.y);
+      for (const [dir, neighbor] of neighbors) {
+        if (neighbor.collapsed) continue;
+        const validOptions = /* @__PURE__ */ new Set();
+        for (const optionId of current.options) {
+          const tile = this.tiles.get(optionId);
+          if (tile) {
+            const allowed = tile.adjacency[dir];
+            for (const a of allowed) validOptions.add(a);
+          }
+        }
+        const before = neighbor.options.length;
+        neighbor.options = neighbor.options.filter((o) => validOptions.has(o));
+        if (neighbor.options.length < before) {
+          stack.push(neighbor);
+        }
+      }
+    }
+  }
+  /**
+   * Solve the entire grid
+   */
+  solve(maxIterations = 1e4) {
+    this.initialize();
+    let iterations = 0;
+    while (iterations < maxIterations) {
+      const cell = this.getLowestEntropy();
+      if (!cell) return true;
+      if (!this.collapse(cell)) return false;
+      this.propagate(cell);
+      iterations++;
+    }
+    return false;
+  }
+  getNeighbors(x, y) {
+    const result = [];
+    if (y > 0) result.push(["up", this.grid[y - 1][x]]);
+    if (y < this.height - 1) result.push(["down", this.grid[y + 1][x]]);
+    if (x > 0) result.push(["left", this.grid[y][x - 1]]);
+    if (x < this.width - 1) result.push(["right", this.grid[y][x + 1]]);
+    return result;
+  }
+  getCell(x, y) {
+    return this.grid[y]?.[x];
+  }
+  getGrid() {
+    return this.grid.map((row) => row.map((c) => ({ ...c })));
+  }
+  isComplete() {
+    return this.grid.every((row) => row.every((c) => c.collapsed));
+  }
+  getContradictions() {
+    return this.contradictions;
+  }
+  getWidth() {
+    return this.width;
+  }
+  getHeight() {
+    return this.height;
+  }
+};
+
+export {
+  NoiseGenerator,
+  LSystemGenerator,
+  BuildingGenerator,
+  DungeonGenerator,
+  WaveFunction,
+  procedural_exports
+};