@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-ROLFT4CJ.js

@@ -0,0 +1,1693 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/simulation/index.ts
+var simulation_exports = {};
+__export(simulation_exports, {
+  CouplingManager: () => CouplingManager,
+  HydraulicSolver: () => HydraulicSolver,
+  RegularGrid3D: () => RegularGrid3D,
+  SaturationManager: () => SaturationManager,
+  StructuralSolver: () => StructuralSolver,
+  ThermalSolver: () => ThermalSolver,
+  applyBoundaryConditions: () => applyBoundaryConditions,
+  conjugateGradient: () => conjugateGradient,
+  findMaterial: () => findMaterial,
+  getMaterial: () => getMaterial,
+  jacobiIteration: () => jacobiIteration,
+  listMaterials: () => listMaterials,
+  registerMaterial: () => registerMaterial,
+  thermalDiffusivity: () => thermalDiffusivity
+});
+
+// src/simulation/RegularGrid3D.ts
+var RegularGrid3D = class _RegularGrid3D {
+  nx;
+  ny;
+  nz;
+  components;
+  dx;
+  dy;
+  dz;
+  data;
+  constructor(resolution, domainSize, components = 1) {
+    this.nx = resolution[0];
+    this.ny = resolution[1];
+    this.nz = resolution[2];
+    this.components = components;
+    this.dx = domainSize[0] / (this.nx - 1);
+    this.dy = domainSize[1] / (this.ny - 1);
+    this.dz = domainSize[2] / (this.nz - 1);
+    this.data = new Float32Array(this.nx * this.ny * this.nz * components);
+  }
+  /** Flat index for cell (i, j, k) component c */
+  idx(i, j, k, c = 0) {
+    return ((k * this.ny + j) * this.nx + i) * this.components + c;
+  }
+  get(i, j, k, component = 0) {
+    return this.data[this.idx(i, j, k, component)];
+  }
+  set(i, j, k, value, component = 0) {
+    this.data[this.idx(i, j, k, component)] = value;
+  }
+  /** Total number of cells */
+  get cellCount() {
+    return this.nx * this.ny * this.nz;
+  }
+  // ── Stencil Operations ──────────────────────────────────────────────────
+  /**
+   * Discrete Laplacian ∇²f at (i,j,k) using 2nd-order central differences.
+   * Returns 0 at boundaries (Neumann-like default).
+   */
+  laplacian(i, j, k, component = 0) {
+    const c = this.get(i, j, k, component);
+    let lap = 0;
+    if (i > 0 && i < this.nx - 1) {
+      lap += (this.get(i + 1, j, k, component) - 2 * c + this.get(i - 1, j, k, component)) / (this.dx * this.dx);
+    }
+    if (j > 0 && j < this.ny - 1) {
+      lap += (this.get(i, j + 1, k, component) - 2 * c + this.get(i, j - 1, k, component)) / (this.dy * this.dy);
+    }
+    if (k > 0 && k < this.nz - 1) {
+      lap += (this.get(i, j, k + 1, component) - 2 * c + this.get(i, j, k - 1, component)) / (this.dz * this.dz);
+    }
+    return lap;
+  }
+  /**
+   * Gradient ∇f at (i,j,k) using central differences.
+   * Falls back to one-sided differences at boundaries.
+   */
+  gradient(i, j, k, component = 0) {
+    let gx, gy, gz;
+    if (i <= 0) {
+      gx = (this.get(i + 1, j, k, component) - this.get(i, j, k, component)) / this.dx;
+    } else if (i >= this.nx - 1) {
+      gx = (this.get(i, j, k, component) - this.get(i - 1, j, k, component)) / this.dx;
+    } else {
+      gx = (this.get(i + 1, j, k, component) - this.get(i - 1, j, k, component)) / (2 * this.dx);
+    }
+    if (j <= 0) {
+      gy = (this.get(i, j + 1, k, component) - this.get(i, j, k, component)) / this.dy;
+    } else if (j >= this.ny - 1) {
+      gy = (this.get(i, j, k, component) - this.get(i, j - 1, k, component)) / this.dy;
+    } else {
+      gy = (this.get(i, j + 1, k, component) - this.get(i, j - 1, k, component)) / (2 * this.dy);
+    }
+    if (k <= 0) {
+      gz = (this.get(i, j, k + 1, component) - this.get(i, j, k, component)) / this.dz;
+    } else if (k >= this.nz - 1) {
+      gz = (this.get(i, j, k, component) - this.get(i, j, k - 1, component)) / this.dz;
+    } else {
+      gz = (this.get(i, j, k + 1, component) - this.get(i, j, k - 1, component)) / (2 * this.dz);
+    }
+    return [gx, gy, gz];
+  }
+  /**
+   * Divergence ∇·F for a 3-component vector field at (i,j,k).
+   * Components 0,1,2 = x,y,z.
+   */
+  divergence(i, j, k) {
+    if (this.components < 3) return 0;
+    const [gx] = this.gradient(i, j, k, 0);
+    const gy = this.gradient(i, j, k, 1)[1];
+    const gz = this.gradient(i, j, k, 2)[2];
+    return gx + gy + gz;
+  }
+  // ── Bulk Operations ─────────────────────────────────────────────────────
+  fill(value) {
+    this.data.fill(value);
+  }
+  copy(other) {
+    this.data.set(other.data);
+  }
+  /** this.data += scale * other.data (element-wise) */
+  addScaled(other, scale) {
+    const d = this.data;
+    const o = other.data;
+    for (let n = 0; n < d.length; n++) {
+      d[n] += scale * o[n];
+    }
+  }
+  /** L∞ norm (max absolute value) */
+  maxAbs() {
+    let m = 0;
+    for (let n = 0; n < this.data.length; n++) {
+      const a = Math.abs(this.data[n]);
+      if (a > m) m = a;
+    }
+    return m;
+  }
+  /** L2 norm */
+  norm2() {
+    let s = 0;
+    for (let n = 0; n < this.data.length; n++) {
+      s += this.data[n] * this.data[n];
+    }
+    return Math.sqrt(s);
+  }
+  // ── Export for Rendering ─────────────────────────────────────────────────
+  /** Direct reference to the flat data buffer (for ScalarFieldOverlay) */
+  toFloat32Array() {
+    return this.data;
+  }
+  /**
+   * Sample grid values at mesh vertex positions via trilinear interpolation.
+   * @param positions Flat xyz vertex positions [x0,y0,z0, x1,y1,z1, ...]
+   * @param domainOrigin World-space origin of the grid domain
+   * @param component Which component to sample (default 0)
+   */
+  sampleAtPositions(positions, domainOrigin = [0, 0, 0], component = 0) {
+    const vertexCount = positions.length / 3;
+    const out = new Float32Array(vertexCount);
+    for (let v = 0; v < vertexCount; v++) {
+      const wx = positions[v * 3] - domainOrigin[0];
+      const wy = positions[v * 3 + 1] - domainOrigin[1];
+      const wz = positions[v * 3 + 2] - domainOrigin[2];
+      const fx = wx / this.dx;
+      const fy = wy / this.dy;
+      const fz = wz / this.dz;
+      const i0 = Math.max(0, Math.min(this.nx - 2, Math.floor(fx)));
+      const j0 = Math.max(0, Math.min(this.ny - 2, Math.floor(fy)));
+      const k0 = Math.max(0, Math.min(this.nz - 2, Math.floor(fz)));
+      const tx = Math.max(0, Math.min(1, fx - i0));
+      const ty = Math.max(0, Math.min(1, fy - j0));
+      const tz = Math.max(0, Math.min(1, fz - k0));
+      const c000 = this.get(i0, j0, k0, component);
+      const c100 = this.get(i0 + 1, j0, k0, component);
+      const c010 = this.get(i0, j0 + 1, k0, component);
+      const c110 = this.get(i0 + 1, j0 + 1, k0, component);
+      const c001 = this.get(i0, j0, k0 + 1, component);
+      const c101 = this.get(i0 + 1, j0, k0 + 1, component);
+      const c011 = this.get(i0, j0 + 1, k0 + 1, component);
+      const c111 = this.get(i0 + 1, j0 + 1, k0 + 1, component);
+      const c00 = c000 * (1 - tx) + c100 * tx;
+      const c10 = c010 * (1 - tx) + c110 * tx;
+      const c01 = c001 * (1 - tx) + c101 * tx;
+      const c11 = c011 * (1 - tx) + c111 * tx;
+      const c0 = c00 * (1 - ty) + c10 * ty;
+      const c1 = c01 * (1 - ty) + c11 * ty;
+      out[v] = c0 * (1 - tz) + c1 * tz;
+    }
+    return out;
+  }
+  /**
+   * Create a deep clone of this grid.
+   */
+  clone() {
+    const g = new _RegularGrid3D(
+      [this.nx, this.ny, this.nz],
+      [this.dx * (this.nx - 1), this.dy * (this.ny - 1), this.dz * (this.nz - 1)],
+      this.components
+    );
+    g.data.set(this.data);
+    return g;
+  }
+};
+
+// src/simulation/BoundaryConditions.ts
+var VALID_FACES = /* @__PURE__ */ new Set(["x-", "x+", "y-", "y+", "z-", "z+"]);
+function applyBoundaryConditions(grid, bcs, dt, component = 0) {
+  for (const bc of bcs) {
+    for (const face of bc.faces) {
+      if (!VALID_FACES.has(face)) continue;
+      applyToFace(grid, face, bc, dt, component);
+    }
+  }
+}
+function applyToFace(grid, face, bc, _dt, c) {
+  const { nx, ny, nz } = grid;
+  switch (face) {
+    case "x-":
+      for (let k = 0; k < nz; k++)
+        for (let j = 0; j < ny; j++) applyAtCell(grid, 0, j, k, face, bc, c);
+      break;
+    case "x+":
+      for (let k = 0; k < nz; k++)
+        for (let j = 0; j < ny; j++)
+          applyAtCell(grid, nx - 1, j, k, face, bc, c);
+      break;
+    case "y-":
+      for (let k = 0; k < nz; k++)
+        for (let i = 0; i < nx; i++) applyAtCell(grid, i, 0, k, face, bc, c);
+      break;
+    case "y+":
+      for (let k = 0; k < nz; k++)
+        for (let i = 0; i < nx; i++)
+          applyAtCell(grid, i, ny - 1, k, face, bc, c);
+      break;
+    case "z-":
+      for (let j = 0; j < ny; j++)
+        for (let i = 0; i < nx; i++) applyAtCell(grid, i, j, 0, face, bc, c);
+      break;
+    case "z+":
+      for (let j = 0; j < ny; j++)
+        for (let i = 0; i < nx; i++)
+          applyAtCell(grid, i, j, nz - 1, face, bc, c);
+      break;
+  }
+}
+function applyAtCell(grid, i, j, k, face, bc, c) {
+  switch (bc.type) {
+    case "dirichlet":
+      grid.set(i, j, k, bc.value, c);
+      break;
+    case "neumann": {
+      const [ni, nj, nk] = interiorNeighbor(i, j, k, face, grid);
+      const dn = normalSpacing(face, grid);
+      grid.set(i, j, k, grid.get(ni, nj, nk, c) + bc.value * dn, c);
+      break;
+    }
+    case "convection": {
+      const h = bc.coefficient ?? 10;
+      const Tamb = bc.ambient ?? bc.value;
+      const [ni, nj, nk] = interiorNeighbor(i, j, k, face, grid);
+      const dn = normalSpacing(face, grid);
+      const Bi = h * dn / 1;
+      const Tinterior = grid.get(ni, nj, nk, c);
+      grid.set(i, j, k, (Tinterior + Bi * Tamb) / (1 + Bi), c);
+      break;
+    }
+    case "robin": {
+      const alpha = bc.coefficient ?? 1;
+      const [ni, nj, nk] = interiorNeighbor(i, j, k, face, grid);
+      const dn = normalSpacing(face, grid);
+      const Tinterior = grid.get(ni, nj, nk, c);
+      grid.set(i, j, k, (bc.value + Tinterior / dn) / (alpha + 1 / dn), c);
+      break;
+    }
+  }
+}
+function interiorNeighbor(i, j, k, face, grid) {
+  switch (face) {
+    case "x-":
+      return [Math.min(i + 1, grid.nx - 1), j, k];
+    case "x+":
+      return [Math.max(i - 1, 0), j, k];
+    case "y-":
+      return [i, Math.min(j + 1, grid.ny - 1), k];
+    case "y+":
+      return [i, Math.max(j - 1, 0), k];
+    case "z-":
+      return [i, j, Math.min(k + 1, grid.nz - 1)];
+    case "z+":
+      return [i, j, Math.max(k - 1, 0)];
+  }
+}
+function normalSpacing(face, grid) {
+  switch (face) {
+    case "x-":
+    case "x+":
+      return grid.dx;
+    case "y-":
+    case "y+":
+      return grid.dy;
+    case "z-":
+    case "z+":
+      return grid.dz;
+  }
+}
+
+// src/simulation/MaterialDatabase.ts
+var MATERIAL_DB = {
+  // From hvac-building.hsplus
+  concrete: { conductivity: 1.7, specific_heat: 880, density: 2300 },
+  glass: { conductivity: 1, specific_heat: 840, density: 2500 },
+  air: { conductivity: 0.026, specific_heat: 1005, density: 1.225 },
+  insulation: { conductivity: 0.04, specific_heat: 840, density: 50 },
+  // From bridge-load-test.hsplus
+  steel_a36: {
+    conductivity: 50,
+    specific_heat: 490,
+    density: 7850,
+    youngs_modulus: 2e11,
+    poisson_ratio: 0.3,
+    yield_strength: 25e7
+  },
+  structural_steel: {
+    conductivity: 50,
+    specific_heat: 490,
+    density: 7850,
+    youngs_modulus: 2e11,
+    poisson_ratio: 0.3,
+    yield_strength: 25e7
+  },
+  // From water-network.hsplus
+  ductile_iron: {
+    conductivity: 36,
+    specific_heat: 460,
+    density: 7100,
+    roughness: 0.015
+  },
+  pvc: {
+    conductivity: 0.16,
+    specific_heat: 900,
+    density: 1400,
+    roughness: 7e-3
+  },
+  // Common simulation materials
+  water: { conductivity: 0.6, specific_heat: 4186, density: 998 },
+  copper: {
+    conductivity: 385,
+    specific_heat: 385,
+    density: 8960,
+    youngs_modulus: 11e10,
+    poisson_ratio: 0.34,
+    yield_strength: 21e7
+  },
+  aluminum: {
+    conductivity: 205,
+    specific_heat: 900,
+    density: 2700,
+    youngs_modulus: 69e9,
+    poisson_ratio: 0.33,
+    yield_strength: 27e7
+  },
+  wood_oak: { conductivity: 0.17, specific_heat: 2e3, density: 700 },
+  brick: { conductivity: 0.72, specific_heat: 840, density: 1920 },
+  soil_dry: { conductivity: 0.25, specific_heat: 800, density: 1500 },
+  soil_wet: { conductivity: 1.5, specific_heat: 1480, density: 1800 },
+  granite: {
+    conductivity: 2.8,
+    specific_heat: 790,
+    density: 2750,
+    youngs_modulus: 5e10,
+    poisson_ratio: 0.25,
+    yield_strength: 13e7
+  }
+};
+var customMaterials = /* @__PURE__ */ new Map();
+function getMaterial(name) {
+  const custom = customMaterials.get(name);
+  if (custom) return custom;
+  const builtin = MATERIAL_DB[name];
+  if (builtin) return builtin;
+  throw new Error(
+    `Unknown material: "${name}". Available: ${listMaterials().join(", ")}`
+  );
+}
+function findMaterial(name) {
+  return customMaterials.get(name) ?? MATERIAL_DB[name];
+}
+function registerMaterial(name, props) {
+  customMaterials.set(name, props);
+}
+function listMaterials() {
+  return [
+    .../* @__PURE__ */ new Set([...Object.keys(MATERIAL_DB), ...customMaterials.keys()])
+  ];
+}
+function thermalDiffusivity(mat) {
+  return mat.conductivity / (mat.density * mat.specific_heat);
+}
+
+// src/simulation/ConvergenceControl.ts
+function conjugateGradient(applyA, b, x, maxIter, tol) {
+  const n = b.length;
+  const r = new Float32Array(n);
+  const p = new Float32Array(n);
+  const Ap = new Float32Array(n);
+  applyA(x, Ap);
+  for (let i = 0; i < n; i++) r[i] = b[i] - Ap[i];
+  p.set(r);
+  let rDotR = dot(r, r);
+  const bNorm = Math.sqrt(dot(b, b));
+  const threshold = Math.max(tol * bNorm, tol);
+  let maxChange = 0;
+  let iter = 0;
+  for (iter = 0; iter < maxIter; iter++) {
+    const rNorm = Math.sqrt(rDotR);
+    if (rNorm < threshold) {
+      return { converged: true, iterations: iter, residual: rNorm, maxChange };
+    }
+    applyA(p, Ap);
+    const pAp = dot(p, Ap);
+    if (Math.abs(pAp) < 1e-30) break;
+    const alpha = rDotR / pAp;
+    maxChange = 0;
+    for (let i = 0; i < n; i++) {
+      const dx = alpha * p[i];
+      x[i] += dx;
+      r[i] -= alpha * Ap[i];
+      if (Math.abs(dx) > maxChange) maxChange = Math.abs(dx);
+    }
+    const rDotRNew = dot(r, r);
+    const beta = rDotRNew / rDotR;
+    rDotR = rDotRNew;
+    for (let i = 0; i < n; i++) {
+      p[i] = r[i] + beta * p[i];
+    }
+  }
+  return {
+    converged: false,
+    iterations: iter,
+    residual: Math.sqrt(rDotR),
+    maxChange
+  };
+}
+function jacobiIteration(grid, rhs, alpha, beta, maxIter, tol, omega = 0.6667) {
+  const { nx, ny, nz } = grid;
+  const temp = grid.clone();
+  let maxChange = 0;
+  let iter = 0;
+  for (iter = 0; iter < maxIter; iter++) {
+    maxChange = 0;
+    for (let k = 1; k < nz - 1; k++) {
+      for (let j = 1; j < ny - 1; j++) {
+        for (let i = 1; i < nx - 1; i++) {
+          const neighbors = temp.get(i - 1, j, k) + temp.get(i + 1, j, k) + temp.get(i, j - 1, k) + temp.get(i, j + 1, k) + temp.get(i, j, k - 1) + temp.get(i, j, k + 1);
+          const newVal = (alpha * rhs.get(i, j, k) + neighbors) / beta;
+          const oldVal = temp.get(i, j, k);
+          const relaxed = oldVal + omega * (newVal - oldVal);
+          grid.set(i, j, k, relaxed);
+          const change = Math.abs(relaxed - oldVal);
+          if (change > maxChange) maxChange = change;
+        }
+      }
+    }
+    if (maxChange < tol) {
+      return { converged: true, iterations: iter + 1, residual: maxChange, maxChange };
+    }
+    temp.copy(grid);
+  }
+  return { converged: false, iterations: iter, residual: maxChange, maxChange };
+}
+function dot(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+
+// src/simulation/ThermalSolver.ts
+var ThermalSolver = class {
+  temperature;
+  tempPrev;
+  sourceField;
+  config;
+  material;
+  alpha;
+  // thermal diffusivity
+  simulationTime = 0;
+  stepCount = 0;
+  useImplicit = false;
+  lastStepMs = 0;
+  constructor(config) {
+    this.config = config;
+    const matName = config.defaultMaterial;
+    const matOverride = config.materials[matName];
+    const matBase = getMaterial(matName);
+    this.material = { ...matBase, ...matOverride };
+    this.alpha = thermalDiffusivity(this.material);
+    this.temperature = new RegularGrid3D(config.gridResolution, config.domainSize);
+    this.tempPrev = new RegularGrid3D(config.gridResolution, config.domainSize);
+    this.sourceField = new RegularGrid3D(config.gridResolution, config.domainSize);
+    const T0 = config.initialTemperature ?? 20;
+    this.temperature.fill(T0);
+    this.tempPrev.fill(T0);
+    this.rebuildSourceField();
+    const dx = this.temperature.dx;
+    const dy = this.temperature.dy;
+    const dz = this.temperature.dz;
+    const dxMin = Math.min(dx, dy, dz);
+    const dtStable = dxMin * dxMin / (6 * this.alpha);
+    if (config.timeStep > dtStable) {
+      this.useImplicit = true;
+    }
+  }
+  /**
+   * Advance the thermal field by dt seconds.
+   */
+  step(dt) {
+    const t0 = performance.now();
+    const effectiveDt = dt > 0 ? dt : this.config.timeStep;
+    applyBoundaryConditions(
+      this.temperature,
+      this.config.boundaryConditions,
+      effectiveDt
+    );
+    if (this.useImplicit) {
+      this.stepImplicit(effectiveDt);
+    } else {
+      this.stepExplicit(effectiveDt);
+    }
+    this.simulationTime += effectiveDt;
+    this.stepCount++;
+    this.lastStepMs = performance.now() - t0;
+  }
+  /**
+   * Explicit forward Euler: T(n+1) = T(n) + dt * (α∇²T + Q/(ρcₚ))
+   */
+  stepExplicit(dt) {
+    const { nx, ny, nz } = this.temperature;
+    const rhoCp = this.material.density * this.material.specific_heat;
+    this.tempPrev.copy(this.temperature);
+    for (let k = 1; k < nz - 1; k++) {
+      for (let j = 1; j < ny - 1; j++) {
+        for (let i = 1; i < nx - 1; i++) {
+          const lap = this.tempPrev.laplacian(i, j, k);
+          const source = this.sourceField.get(i, j, k);
+          const dT = dt * (this.alpha * lap + source / rhoCp);
+          this.temperature.set(
+            i,
+            j,
+            k,
+            this.tempPrev.get(i, j, k) + dT
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Implicit Jacobi: solve (I - dt·α·∇²)T(n+1) = T(n) + dt·Q/(ρcₚ)
+   */
+  stepImplicit(dt) {
+    const { nx, ny, nz } = this.temperature;
+    const rhoCp = this.material.density * this.material.specific_heat;
+    const rhs = this.tempPrev.clone();
+    for (let k = 0; k < nz; k++) {
+      for (let j = 0; j < ny; j++) {
+        for (let i = 0; i < nx; i++) {
+          const src = this.sourceField.get(i, j, k);
+          rhs.set(i, j, k, this.temperature.get(i, j, k) + dt * src / rhoCp);
+        }
+      }
+    }
+    const dx2 = this.temperature.dx * this.temperature.dx;
+    const alphaCoeff = dx2 / (dt * this.alpha);
+    const beta = 6 + alphaCoeff;
+    jacobiIteration(
+      this.temperature,
+      rhs,
+      alphaCoeff,
+      beta,
+      this.config.maxImplicitIterations ?? 100,
+      this.config.implicitTolerance ?? 1e-4
+    );
+  }
+  /**
+   * Rebuild the volumetric source field from config sources.
+   */
+  rebuildSourceField() {
+    this.sourceField.fill(0);
+    const { dx, dy, dz } = this.temperature;
+    const cellVolume = dx * dy * dz;
+    for (const src of this.config.sources) {
+      if (src.active === false) continue;
+      const [px, py, pz] = src.position;
+      const gi = Math.max(0, Math.min(this.temperature.nx - 1, Math.round(px / dx)));
+      const gj = Math.max(0, Math.min(this.temperature.ny - 1, Math.round(py / dy)));
+      const gk = Math.max(0, Math.min(this.temperature.nz - 1, Math.round(pz / dz)));
+      if (src.type === "point" || !src.radius) {
+        if (this.inBounds(gi, gj, gk)) {
+          this.sourceField.set(
+            gi,
+            gj,
+            gk,
+            this.sourceField.get(gi, gj, gk) + src.heat_output / cellVolume
+          );
+        }
+      } else {
+        const r = src.radius;
+        let totalCells = 0;
+        for (let dk = -r; dk <= r; dk++) {
+          for (let dj = -r; dj <= r; dj++) {
+            for (let di = -r; di <= r; di++) {
+              if (di * di + dj * dj + dk * dk <= r * r) {
+                if (this.inBounds(gi + di, gj + dj, gk + dk)) {
+                  totalCells++;
+                }
+              }
+            }
+          }
+        }
+        if (totalCells === 0) continue;
+        const heatPerCell = src.heat_output / (totalCells * cellVolume);
+        for (let dk = -r; dk <= r; dk++) {
+          for (let dj = -r; dj <= r; dj++) {
+            for (let di = -r; di <= r; di++) {
+              if (di * di + dj * dj + dk * dk <= r * r) {
+                const ci = gi + di, cj = gj + dj, ck = gk + dk;
+                if (this.inBounds(ci, cj, ck)) {
+                  this.sourceField.set(
+                    ci,
+                    cj,
+                    ck,
+                    this.sourceField.get(ci, cj, ck) + heatPerCell
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  inBounds(i, j, k) {
+    return i >= 0 && i < this.temperature.nx && j >= 0 && j < this.temperature.ny && k >= 0 && k < this.temperature.nz;
+  }
+  // ── Public API ──────────────────────────────────────────────────────────
+  /** Get the temperature field as Float32Array for ScalarFieldOverlay */
+  getTemperatureField() {
+    return this.temperature.toFloat32Array();
+  }
+  /** Get the underlying grid for coupling with other solvers */
+  getTemperatureGrid() {
+    return this.temperature;
+  }
+  /** Point query: temperature at world position via trilinear interpolation */
+  getTemperatureAt(x, y, z) {
+    const result = this.temperature.sampleAtPositions(
+      new Float32Array([x, y, z])
+    );
+    return result[0];
+  }
+  /** Update a heat source at runtime (e.g., HVAC on/off) */
+  setSource(id, heatOutput, active) {
+    const src = this.config.sources.find((s) => s.id === id);
+    if (src) {
+      src.heat_output = heatOutput;
+      if (active !== void 0) src.active = active;
+      this.rebuildSourceField();
+    }
+  }
+  /** Update boundary temperature (e.g., exterior weather change) */
+  setBoundaryValue(faceOrIndex, value) {
+    if (typeof faceOrIndex === "number") {
+      const bc = this.config.boundaryConditions[faceOrIndex];
+      if (bc) {
+        if (bc.type === "convection") bc.ambient = value;
+        else bc.value = value;
+      }
+    }
+  }
+  getStats() {
+    let min = Infinity, max = -Infinity, sum = 0;
+    const d = this.temperature.data;
+    for (let i = 0; i < d.length; i++) {
+      if (d[i] < min) min = d[i];
+      if (d[i] > max) max = d[i];
+      sum += d[i];
+    }
+    return {
+      minTemperature: min,
+      maxTemperature: max,
+      avgTemperature: sum / d.length,
+      simulationTime: this.simulationTime,
+      stepCount: this.stepCount,
+      isImplicit: this.useImplicit,
+      lastStepMs: this.lastStepMs
+    };
+  }
+  dispose() {
+  }
+};
+
+// src/simulation/StructuralSolver.ts
+var StructuralSolver = class {
+  config;
+  material;
+  nodeCount;
+  elementCount;
+  dofCount;
+  // 3 DOF per node
+  displacements;
+  forces;
+  vonMisesStress;
+  // per-element
+  safetyFactors;
+  // per-element
+  constrainedDofs;
+  // Sparse stiffness: CSR-like via element assembly
+  elementStiffness;
+  // 12×12 per element
+  solveResult = null;
+  solveTimeMs = 0;
+  constructor(config) {
+    this.config = config;
+    this.material = typeof config.material === "string" ? getMaterial(config.material) : config.material;
+    this.nodeCount = config.vertices.length / 3;
+    this.elementCount = config.tetrahedra.length / 4;
+    this.dofCount = this.nodeCount * 3;
+    this.displacements = new Float32Array(this.dofCount);
+    this.forces = new Float32Array(this.dofCount);
+    this.vonMisesStress = new Float32Array(this.elementCount);
+    this.safetyFactors = new Float32Array(this.elementCount);
+    this.elementStiffness = [];
+    this.constrainedDofs = /* @__PURE__ */ new Set();
+    for (const c of config.constraints) {
+      for (const n of c.nodes) {
+        if (c.type === "fixed") {
+          this.constrainedDofs.add(n * 3);
+          this.constrainedDofs.add(n * 3 + 1);
+          this.constrainedDofs.add(n * 3 + 2);
+        } else if (c.type === "pinned") {
+          this.constrainedDofs.add(n * 3);
+          this.constrainedDofs.add(n * 3 + 1);
+          this.constrainedDofs.add(n * 3 + 2);
+        }
+      }
+    }
+    this.assembleStiffness();
+    this.assembleForces();
+  }
+  /**
+   * Solve the static equilibrium Ku = f.
+   */
+  solve() {
+    const t0 = performance.now();
+    const applyK = (x, out) => {
+      out.fill(0);
+      const tets = this.config.tetrahedra;
+      for (let e = 0; e < this.elementCount; e++) {
+        const ke = this.elementStiffness[e];
+        const nodes = [tets[e * 4], tets[e * 4 + 1], tets[e * 4 + 2], tets[e * 4 + 3]];
+        for (let a = 0; a < 4; a++) {
+          for (let ai = 0; ai < 3; ai++) {
+            const globalI = nodes[a] * 3 + ai;
+            const localI = a * 3 + ai;
+            let sum = 0;
+            for (let b = 0; b < 4; b++) {
+              for (let bi = 0; bi < 3; bi++) {
+                const globalJ = nodes[b] * 3 + bi;
+                const localJ = b * 3 + bi;
+                sum += ke[localI * 12 + localJ] * x[globalJ];
+              }
+            }
+            out[globalI] += sum;
+          }
+        }
+      }
+      for (const dof of this.constrainedDofs) {
+        out[dof] = x[dof];
+      }
+    };
+    const rhs = new Float32Array(this.forces);
+    for (const dof of this.constrainedDofs) {
+      rhs[dof] = 0;
+    }
+    this.displacements.fill(0);
+    this.solveResult = conjugateGradient(
+      applyK,
+      rhs,
+      this.displacements,
+      this.config.maxIterations ?? 1e3,
+      this.config.tolerance ?? 1e-8
+    );
+    for (const dof of this.constrainedDofs) {
+      this.displacements[dof] = 0;
+    }
+    this.recoverStress();
+    this.solveTimeMs = performance.now() - t0;
+    return this.solveResult;
+  }
+  /**
+   * Assemble element stiffness matrices using linear tetrahedral elements.
+   * Ke = V * Bᵀ * D * B where B is the strain-displacement matrix.
+   */
+  assembleStiffness() {
+    const verts = this.config.vertices;
+    const tets = this.config.tetrahedra;
+    const { youngs_modulus: E, poisson_ratio: nu } = this.material;
+    const lambda = E * nu / ((1 + nu) * (1 - 2 * nu));
+    const mu = E / (2 * (1 + nu));
+    const D = new Float64Array(36);
+    D[0] = D[7] = D[14] = lambda + 2 * mu;
+    D[1] = D[2] = D[6] = D[8] = D[12] = D[13] = lambda;
+    D[21] = D[28] = D[35] = mu;
+    this.elementStiffness = new Array(this.elementCount);
+    for (let e = 0; e < this.elementCount; e++) {
+      const n0 = tets[e * 4], n1 = tets[e * 4 + 1];
+      const n2 = tets[e * 4 + 2], n3 = tets[e * 4 + 3];
+      const x0 = verts[n0 * 3], y0 = verts[n0 * 3 + 1], z0 = verts[n0 * 3 + 2];
+      const x1 = verts[n1 * 3], y1 = verts[n1 * 3 + 1], z1 = verts[n1 * 3 + 2];
+      const x2 = verts[n2 * 3], y2 = verts[n2 * 3 + 1], z2 = verts[n2 * 3 + 2];
+      const x3 = verts[n3 * 3], y3 = verts[n3 * 3 + 1], z3 = verts[n3 * 3 + 2];
+      const J = [
+        x1 - x0,
+        y1 - y0,
+        z1 - z0,
+        x2 - x0,
+        y2 - y0,
+        z2 - z0,
+        x3 - x0,
+        y3 - y0,
+        z3 - z0
+      ];
+      const detJ = J[0] * (J[4] * J[8] - J[5] * J[7]) - J[1] * (J[3] * J[8] - J[5] * J[6]) + J[2] * (J[3] * J[7] - J[4] * J[6]);
+      const V = Math.abs(detJ) / 6;
+      if (V < 1e-20) {
+        this.elementStiffness[e] = new Float64Array(144);
+        continue;
+      }
+      const invDetJ = 1 / detJ;
+      const Ji = [
+        (J[4] * J[8] - J[5] * J[7]) * invDetJ,
+        (J[2] * J[7] - J[1] * J[8]) * invDetJ,
+        (J[1] * J[5] - J[2] * J[4]) * invDetJ,
+        (J[5] * J[6] - J[3] * J[8]) * invDetJ,
+        (J[0] * J[8] - J[2] * J[6]) * invDetJ,
+        (J[2] * J[3] - J[0] * J[5]) * invDetJ,
+        (J[3] * J[7] - J[4] * J[6]) * invDetJ,
+        (J[1] * J[6] - J[0] * J[7]) * invDetJ,
+        (J[0] * J[4] - J[1] * J[3]) * invDetJ
+      ];
+      const dN = new Float64Array(12);
+      dN[3] = Ji[0];
+      dN[4] = Ji[1];
+      dN[5] = Ji[2];
+      dN[6] = Ji[3];
+      dN[7] = Ji[4];
+      dN[8] = Ji[5];
+      dN[9] = Ji[6];
+      dN[10] = Ji[7];
+      dN[11] = Ji[8];
+      dN[0] = -(dN[3] + dN[6] + dN[9]);
+      dN[1] = -(dN[4] + dN[7] + dN[10]);
+      dN[2] = -(dN[5] + dN[8] + dN[11]);
+      const B = new Float64Array(72);
+      for (let a = 0; a < 4; a++) {
+        const dnx = dN[a * 3], dny = dN[a * 3 + 1], dnz = dN[a * 3 + 2];
+        const col = a * 3;
+        B[0 * 12 + col] = dnx;
+        B[1 * 12 + col + 1] = dny;
+        B[2 * 12 + col + 2] = dnz;
+        B[3 * 12 + col] = dny;
+        B[3 * 12 + col + 1] = dnx;
+        B[4 * 12 + col + 1] = dnz;
+        B[4 * 12 + col + 2] = dny;
+        B[5 * 12 + col] = dnz;
+        B[5 * 12 + col + 2] = dnx;
+      }
+      const ke = new Float64Array(144);
+      const DB = new Float64Array(72);
+      for (let i = 0; i < 6; i++) {
+        for (let j = 0; j < 12; j++) {
+          let sum = 0;
+          for (let k = 0; k < 6; k++) {
+            sum += D[i * 6 + k] * B[k * 12 + j];
+          }
+          DB[i * 12 + j] = sum;
+        }
+      }
+      for (let i = 0; i < 12; i++) {
+        for (let j = 0; j < 12; j++) {
+          let sum = 0;
+          for (let k = 0; k < 6; k++) {
+            sum += B[k * 12 + i] * DB[k * 12 + j];
+          }
+          ke[i * 12 + j] = V * sum;
+        }
+      }
+      this.elementStiffness[e] = ke;
+    }
+  }
+  /**
+   * Assemble the global force vector from loads.
+   */
+  assembleForces() {
+    this.forces.fill(0);
+    const { density } = this.material;
+    for (const load of this.config.loads) {
+      switch (load.type) {
+        case "gravity": {
+          const [ax, ay, az] = load.acceleration ?? [0, -9.81, 0];
+          const tets = this.config.tetrahedra;
+          const verts = this.config.vertices;
+          for (let e = 0; e < this.elementCount; e++) {
+            const nodes = [tets[e * 4], tets[e * 4 + 1], tets[e * 4 + 2], tets[e * 4 + 3]];
+            const n0 = nodes[0], n1 = nodes[1], n2 = nodes[2], n3 = nodes[3];
+            const dx1 = verts[n1 * 3] - verts[n0 * 3], dy1 = verts[n1 * 3 + 1] - verts[n0 * 3 + 1], dz1 = verts[n1 * 3 + 2] - verts[n0 * 3 + 2];
+            const dx2 = verts[n2 * 3] - verts[n0 * 3], dy2 = verts[n2 * 3 + 1] - verts[n0 * 3 + 1], dz2 = verts[n2 * 3 + 2] - verts[n0 * 3 + 2];
+            const dx3 = verts[n3 * 3] - verts[n0 * 3], dy3 = verts[n3 * 3 + 1] - verts[n0 * 3 + 1], dz3 = verts[n3 * 3 + 2] - verts[n0 * 3 + 2];
+            const vol = Math.abs(
+              dx1 * (dy2 * dz3 - dz2 * dy3) - dy1 * (dx2 * dz3 - dz2 * dx3) + dz1 * (dx2 * dy3 - dy2 * dx3)
+            ) / 6;
+            const massPerNode = density * vol / 4;
+            for (const n of nodes) {
+              this.forces[n * 3] += massPerNode * ax;
+              this.forces[n * 3 + 1] += massPerNode * ay;
+              this.forces[n * 3 + 2] += massPerNode * az;
+            }
+          }
+          break;
+        }
+        case "point": {
+          if (load.nodeIndex !== void 0 && load.force) {
+            const n = load.nodeIndex;
+            this.forces[n * 3] += load.force[0];
+            this.forces[n * 3 + 1] += load.force[1];
+            this.forces[n * 3 + 2] += load.force[2];
+          }
+          break;
+        }
+        case "distributed": {
+          if (load.surfaceElements && load.pressure) {
+            for (const faceIdx of load.surfaceElements) {
+              const tets = this.config.tetrahedra;
+              const verts = this.config.vertices;
+              const n0 = tets[faceIdx * 4], n1 = tets[faceIdx * 4 + 1], n2 = tets[faceIdx * 4 + 2];
+              const ax = verts[n1 * 3] - verts[n0 * 3], ay = verts[n1 * 3 + 1] - verts[n0 * 3 + 1], az = verts[n1 * 3 + 2] - verts[n0 * 3 + 2];
+              const bx = verts[n2 * 3] - verts[n0 * 3], by = verts[n2 * 3 + 1] - verts[n0 * 3 + 1], bz = verts[n2 * 3 + 2] - verts[n0 * 3 + 2];
+              const nx = ay * bz - az * by, ny = az * bx - ax * bz, nz = ax * by - ay * bx;
+              const area = 0.5 * Math.sqrt(nx * nx + ny * ny + nz * nz);
+              if (area < 1e-20) continue;
+              const scale = load.pressure * area / (3 * Math.sqrt(nx * nx + ny * ny + nz * nz));
+              for (const n of [n0, n1, n2]) {
+                this.forces[n * 3] += scale * nx;
+                this.forces[n * 3 + 1] += scale * ny;
+                this.forces[n * 3 + 2] += scale * nz;
+              }
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * Recover Von Mises stress from displacements.
+   * σ = D * B * u → Von Mises = √(σxx²+σyy²+σzz²-σxx·σyy-σyy·σzz-σzz·σxx+3(τxy²+τyz²+τxz²))
+   */
+  recoverStress() {
+    const tets = this.config.tetrahedra;
+    const verts = this.config.vertices;
+    const { youngs_modulus: E, poisson_ratio: nu, yield_strength: Sy } = this.material;
+    const lambda = E * nu / ((1 + nu) * (1 - 2 * nu));
+    const mu = E / (2 * (1 + nu));
+    const D = new Float64Array(36);
+    D[0] = D[7] = D[14] = lambda + 2 * mu;
+    D[1] = D[2] = D[6] = D[8] = D[12] = D[13] = lambda;
+    D[21] = D[28] = D[35] = mu;
+    for (let e = 0; e < this.elementCount; e++) {
+      const n0 = tets[e * 4], n1 = tets[e * 4 + 1];
+      const n2 = tets[e * 4 + 2], n3 = tets[e * 4 + 3];
+      const x0 = verts[n0 * 3], y0 = verts[n0 * 3 + 1], z0 = verts[n0 * 3 + 2];
+      const J = [
+        verts[n1 * 3] - x0,
+        verts[n1 * 3 + 1] - y0,
+        verts[n1 * 3 + 2] - z0,
+        verts[n2 * 3] - x0,
+        verts[n2 * 3 + 1] - y0,
+        verts[n2 * 3 + 2] - z0,
+        verts[n3 * 3] - x0,
+        verts[n3 * 3 + 1] - y0,
+        verts[n3 * 3 + 2] - z0
+      ];
+      const detJ = J[0] * (J[4] * J[8] - J[5] * J[7]) - J[1] * (J[3] * J[8] - J[5] * J[6]) + J[2] * (J[3] * J[7] - J[4] * J[6]);
+      if (Math.abs(detJ) < 1e-20) {
+        this.vonMisesStress[e] = 0;
+        this.safetyFactors[e] = Sy > 0 ? Infinity : 0;
+        continue;
+      }
+      const invDetJ = 1 / detJ;
+      const Ji = [
+        (J[4] * J[8] - J[5] * J[7]) * invDetJ,
+        (J[2] * J[7] - J[1] * J[8]) * invDetJ,
+        (J[1] * J[5] - J[2] * J[4]) * invDetJ,
+        (J[5] * J[6] - J[3] * J[8]) * invDetJ,
+        (J[0] * J[8] - J[2] * J[6]) * invDetJ,
+        (J[2] * J[3] - J[0] * J[5]) * invDetJ,
+        (J[3] * J[7] - J[4] * J[6]) * invDetJ,
+        (J[1] * J[6] - J[0] * J[7]) * invDetJ,
+        (J[0] * J[4] - J[1] * J[3]) * invDetJ
+      ];
+      const dN = new Float64Array(12);
+      dN[3] = Ji[0];
+      dN[4] = Ji[1];
+      dN[5] = Ji[2];
+      dN[6] = Ji[3];
+      dN[7] = Ji[4];
+      dN[8] = Ji[5];
+      dN[9] = Ji[6];
+      dN[10] = Ji[7];
+      dN[11] = Ji[8];
+      dN[0] = -(dN[3] + dN[6] + dN[9]);
+      dN[1] = -(dN[4] + dN[7] + dN[10]);
+      dN[2] = -(dN[5] + dN[8] + dN[11]);
+      const nodes = [n0, n1, n2, n3];
+      const strain = new Float64Array(6);
+      for (let a = 0; a < 4; a++) {
+        const dnx = dN[a * 3], dny = dN[a * 3 + 1], dnz = dN[a * 3 + 2];
+        const ux = this.displacements[nodes[a] * 3];
+        const uy = this.displacements[nodes[a] * 3 + 1];
+        const uz = this.displacements[nodes[a] * 3 + 2];
+        strain[0] += dnx * ux;
+        strain[1] += dny * uy;
+        strain[2] += dnz * uz;
+        strain[3] += dny * ux + dnx * uy;
+        strain[4] += dnz * uy + dny * uz;
+        strain[5] += dnz * ux + dnx * uz;
+      }
+      const stress = new Float64Array(6);
+      for (let i = 0; i < 6; i++) {
+        for (let j = 0; j < 6; j++) {
+          stress[i] += D[i * 6 + j] * strain[j];
+        }
+      }
+      const sxx = stress[0], syy = stress[1], szz = stress[2];
+      const txy = stress[3], tyz = stress[4], txz = stress[5];
+      const vm = Math.sqrt(
+        sxx * sxx + syy * syy + szz * szz - sxx * syy - syy * szz - szz * sxx + 3 * (txy * txy + tyz * tyz + txz * txz)
+      );
+      this.vonMisesStress[e] = vm;
+      this.safetyFactors[e] = Sy > 0 ? Sy / Math.max(vm, 1e-20) : Infinity;
+    }
+  }
+  // ── Public API ──────────────────────────────────────────────────────────
+  getVonMisesStress() {
+    return this.vonMisesStress;
+  }
+  getSafetyFactor() {
+    return this.safetyFactors;
+  }
+  getDisplacements() {
+    return this.displacements;
+  }
+  /** Update a load and re-solve */
+  updateLoad(id, force) {
+    const load = this.config.loads.find((l) => l.id === id);
+    if (load) {
+      load.force = force;
+      this.assembleForces();
+    }
+  }
+  getStats() {
+    let maxVM = 0, minSF = Infinity;
+    for (let e = 0; e < this.elementCount; e++) {
+      if (this.vonMisesStress[e] > maxVM) maxVM = this.vonMisesStress[e];
+      if (this.safetyFactors[e] < minSF) minSF = this.safetyFactors[e];
+    }
+    return {
+      nodeCount: this.nodeCount,
+      elementCount: this.elementCount,
+      maxVonMises: maxVM,
+      minSafetyFactor: minSF,
+      solveResult: this.solveResult,
+      solveTimeMs: this.solveTimeMs
+    };
+  }
+  dispose() {
+    this.elementStiffness = [];
+  }
+};
+
+// src/simulation/HydraulicSolver.ts
+var HydraulicSolver = class {
+  config;
+  pipes;
+  nodes;
+  nodeMap;
+  pipeMap;
+  loops;
+  // arrays of pipe indices per loop
+  pressures;
+  flowRates;
+  solveResult = null;
+  viscosity;
+  constructor(config) {
+    this.config = config;
+    this.viscosity = config.viscosity ?? 1004e-9;
+    this.nodeMap = /* @__PURE__ */ new Map();
+    this.nodes = config.nodes.map((n, i) => {
+      this.nodeMap.set(n.id, i);
+      return {
+        index: i,
+        config: n,
+        head: n.type === "reservoir" ? n.head ?? 0 : n.elevation ?? 0
+      };
+    });
+    this.pipeMap = /* @__PURE__ */ new Map();
+    this.pipes = [];
+    for (const conn of config.connections) {
+      const [fromId, pipeId, toId] = conn;
+      const pipeConfig = config.pipes.find((p) => p.id === pipeId);
+      if (!pipeConfig) continue;
+      const fromIdx = this.nodeMap.get(fromId);
+      const toIdx = this.nodeMap.get(toId);
+      if (fromIdx === void 0 || toIdx === void 0) continue;
+      const idx = this.pipes.length;
+      this.pipeMap.set(pipeId, idx);
+      const valve = config.valves.find((v) => v.pipe === pipeId);
+      const opening = valve?.opening ?? 1;
+      const effectiveD = pipeConfig.diameter * Math.sqrt(Math.max(opening, 1e-3));
+      this.pipes.push({
+        index: idx,
+        config: pipeConfig,
+        fromNode: fromIdx,
+        toNode: toIdx,
+        flowRate: 1e-3,
+        // initial guess
+        effectiveDiameter: effectiveD
+      });
+    }
+    this.pressures = new Float32Array(this.nodes.length);
+    this.flowRates = new Float32Array(this.pipes.length);
+    this.loops = this.findLoops();
+    this.initialFlowGuess();
+  }
+  /**
+   * Solve the pipe network for steady-state pressures and flow rates.
+   */
+  solve() {
+    const maxIter = this.config.maxIterations;
+    const tol = this.config.convergence;
+    let maxCorrection = 0;
+    let iter = 0;
+    for (iter = 0; iter < maxIter; iter++) {
+      maxCorrection = 0;
+      for (const loop of this.loops) {
+        let sumHf = 0;
+        let sumDhf = 0;
+        for (const pipeIdx of loop) {
+          const pipe = this.pipes[pipeIdx];
+          const hf = this.headLoss(pipe);
+          const Q = pipe.flowRate;
+          sumHf += hf;
+          sumDhf += Math.abs(Q) > 1e-12 ? 2 * Math.abs(hf) / Math.abs(Q) : 0;
+        }
+        if (Math.abs(sumDhf) < 1e-20) continue;
+        const dQ = -sumHf / sumDhf;
+        maxCorrection = Math.max(maxCorrection, Math.abs(dQ));
+        for (const pipeIdx of loop) {
+          this.pipes[pipeIdx].flowRate += dQ;
+        }
+      }
+      if (maxCorrection < tol) {
+        this.computeNodePressures();
+        this.updateOutputArrays();
+        this.solveResult = { converged: true, iterations: iter + 1, residual: maxCorrection, maxChange: maxCorrection };
+        return this.solveResult;
+      }
+    }
+    this.computeNodePressures();
+    this.updateOutputArrays();
+    this.solveResult = { converged: false, iterations: iter, residual: maxCorrection, maxChange: maxCorrection };
+    return this.solveResult;
+  }
+  /**
+   * Head loss in a pipe using Darcy-Weisbach: hf = f * (L/D) * (V²/2g)
+   * Sign follows flow direction.
+   */
+  headLoss(pipe) {
+    const Q = pipe.flowRate;
+    const D = pipe.effectiveDiameter;
+    const L = pipe.config.length;
+    const A = Math.PI / 4 * D * D;
+    const V = Q / A;
+    const Re = Math.abs(V) * D / this.viscosity;
+    let f;
+    if (Re < 2300) {
+      f = Re > 0 ? 64 / Re : 0;
+    } else {
+      const eD = pipe.config.roughness / D;
+      const logArg = eD / 3.7 + 5.74 / Math.pow(Re, 0.9);
+      const logVal = Math.log10(logArg);
+      f = 0.25 / (logVal * logVal);
+    }
+    const g = 9.81;
+    return f * L * V * Math.abs(V) / (D * 2 * g);
+  }
+  /**
+   * Compute node pressures by walking from known-head nodes.
+   */
+  computeNodePressures() {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const node of this.nodes) {
+      if (node.config.type === "reservoir") {
+        node.head = node.config.head ?? 0;
+        visited.add(node.index);
+        queue.push(node.index);
+      }
+    }
+    while (queue.length > 0) {
+      const nodeIdx = queue.shift();
+      const nodeHead = this.nodes[nodeIdx].head;
+      for (const pipe of this.pipes) {
+        let neighborIdx = null;
+        let sign = 1;
+        if (pipe.fromNode === nodeIdx && !visited.has(pipe.toNode)) {
+          neighborIdx = pipe.toNode;
+          sign = 1;
+        } else if (pipe.toNode === nodeIdx && !visited.has(pipe.fromNode)) {
+          neighborIdx = pipe.fromNode;
+          sign = -1;
+        }
+        if (neighborIdx !== null) {
+          const hf = this.headLoss(pipe);
+          this.nodes[neighborIdx].head = nodeHead - sign * hf;
+          visited.add(neighborIdx);
+          queue.push(neighborIdx);
+        }
+      }
+    }
+  }
+  /**
+   * Initial flow guess by distributing demand.
+   */
+  initialFlowGuess() {
+    const totalDemand = this.nodes.reduce(
+      (sum, n) => sum + (n.config.demand ?? 0),
+      0
+    );
+    const avgFlow = totalDemand / Math.max(this.pipes.length, 1);
+    for (const pipe of this.pipes) {
+      pipe.flowRate = avgFlow > 0 ? avgFlow : 1e-3;
+    }
+  }
+  /**
+   * Find independent loops using spanning tree fundamental cycles.
+   *
+   * Uses BFS to build a spanning tree, then each non-tree edge defines
+   * exactly one fundamental cycle. This guarantees independent loops
+   * (no duplicates or overlaps) which Hardy-Cross requires.
+   */
+  findLoops() {
+    const loops = [];
+    const n = this.nodes.length;
+    if (n === 0) return loops;
+    const adj = Array.from({ length: n }, () => []);
+    for (const pipe of this.pipes) {
+      adj[pipe.fromNode].push([pipe.toNode, pipe.index]);
+      adj[pipe.toNode].push([pipe.fromNode, pipe.index]);
+    }
+    const treeParent = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const treeEdges = /* @__PURE__ */ new Set();
+    const bfs = (start) => {
+      const queue = [start];
+      visited.add(start);
+      while (queue.length > 0) {
+        const node = queue.shift();
+        for (const [neighbor, pipeIdx] of adj[node]) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            treeParent.set(neighbor, { node, pipe: pipeIdx });
+            treeEdges.add(pipeIdx);
+            queue.push(neighbor);
+          }
+        }
+      }
+    };
+    for (let i = 0; i < n; i++) {
+      if (!visited.has(i)) bfs(i);
+    }
+    for (const pipe of this.pipes) {
+      if (treeEdges.has(pipe.index)) continue;
+      const pathA = this.traceToRoot(pipe.fromNode, treeParent);
+      const pathB = this.traceToRoot(pipe.toNode, treeParent);
+      const setA = new Set(pathA.map((p) => p.node));
+      let lcaIdx = 0;
+      for (let i = 0; i < pathB.length; i++) {
+        if (setA.has(pathB[i].node)) {
+          lcaIdx = i;
+          break;
+        }
+      }
+      const lcaNode = pathB[lcaIdx].node;
+      const loopPipes = [pipe.index];
+      for (const entry of pathA) {
+        if (entry.node === lcaNode) break;
+        if (entry.pipe >= 0) loopPipes.push(entry.pipe);
+      }
+      for (let i = 0; i < lcaIdx; i++) {
+        if (pathB[i].pipe >= 0) loopPipes.push(pathB[i].pipe);
+      }
+      if (loopPipes.length > 1) loops.push(loopPipes);
+    }
+    return loops;
+  }
+  /** Trace a node to root of spanning tree, returning (node, pipe) pairs */
+  traceToRoot(start, treeParent) {
+    const path = [{ node: start, pipe: -1 }];
+    let current = start;
+    while (treeParent.has(current)) {
+      const parent = treeParent.get(current);
+      path.push({ node: parent.node, pipe: parent.pipe });
+      current = parent.node;
+    }
+    return path;
+  }
+  updateOutputArrays() {
+    for (const node of this.nodes) {
+      this.pressures[node.index] = node.head;
+    }
+    for (const pipe of this.pipes) {
+      this.flowRates[pipe.index] = pipe.flowRate;
+    }
+  }
+  // ── Public API ──────────────────────────────────────────────────────────
+  getPressureField() {
+    return this.pressures;
+  }
+  getFlowRates() {
+    return this.flowRates;
+  }
+  setValveOpening(id, opening) {
+    const valve = this.config.valves.find((v) => v.id === id);
+    if (valve) {
+      valve.opening = opening;
+      const pipeIdx = this.pipeMap.get(valve.pipe);
+      if (pipeIdx !== void 0) {
+        const pipe = this.pipes[pipeIdx];
+        pipe.effectiveDiameter = pipe.config.diameter * Math.sqrt(Math.max(opening, 1e-3));
+      }
+    }
+  }
+  setDemand(nodeId, demand) {
+    const idx = this.nodeMap.get(nodeId);
+    if (idx !== void 0) {
+      this.nodes[idx].config.demand = demand;
+    }
+  }
+  setPumpPressure(nodeId, head) {
+    const idx = this.nodeMap.get(nodeId);
+    if (idx !== void 0 && this.nodes[idx].config.type === "reservoir") {
+      this.nodes[idx].config.head = head;
+      this.nodes[idx].head = head;
+    }
+  }
+  getStats() {
+    let maxP = -Infinity, minP = Infinity, totalD = 0;
+    for (const node of this.nodes) {
+      if (node.head > maxP) maxP = node.head;
+      if (node.head < minP) minP = node.head;
+      totalD += node.config.demand ?? 0;
+    }
+    return {
+      nodeCount: this.nodes.length,
+      pipeCount: this.pipes.length,
+      loopCount: this.loops.length,
+      maxPressure: maxP,
+      minPressure: minP,
+      totalDemand: totalD,
+      solveResult: this.solveResult
+    };
+  }
+  dispose() {
+    this.pipes = [];
+    this.nodes = [];
+  }
+};
+
+// src/simulation/SaturationManager.ts
+var SaturationManager = class {
+  config;
+  cellStates;
+  // 0=normal, 1=warning, 2=critical
+  phaseTransitionCells;
+  cellCount;
+  constructor(config) {
+    this.config = config;
+    this.cellCount = config.field instanceof RegularGrid3D ? config.field.cellCount : config.field.length;
+    this.cellStates = new Uint8Array(this.cellCount);
+    this.phaseTransitionCells = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Check all cells against thresholds. Returns events for cells that changed state.
+   */
+  update() {
+    const events = [];
+    const { warning, critical, recovery } = this.config.thresholds;
+    const field = this.config.field instanceof RegularGrid3D ? this.config.field.data : this.config.field;
+    for (let i = 0; i < this.cellCount; i++) {
+      const value = field[i];
+      const prevState = this.cellStates[i];
+      let newState = prevState;
+      if (prevState === 0) {
+        if (value >= critical) newState = 2;
+        else if (value >= warning) newState = 1;
+      } else if (prevState === 1) {
+        if (value >= critical) newState = 2;
+        else if (value < recovery) newState = 0;
+      } else {
+        if (value < recovery) newState = 0;
+        else if (value < warning) newState = 1;
+      }
+      if (newState !== prevState) {
+        this.cellStates[i] = newState;
+        let phaseTransition = false;
+        if (this.config.phaseTransition) {
+          const pt = this.config.phaseTransition;
+          if (prevState < 2 && newState === 2 && value >= pt.transitionPoint || prevState === 2 && newState < 2 && value < pt.transitionPoint) {
+            phaseTransition = true;
+            if (newState === 2) {
+              this.phaseTransitionCells.add(i);
+            } else {
+              this.phaseTransitionCells.delete(i);
+            }
+          }
+        }
+        events.push({
+          index: i,
+          from: stateLabel(prevState),
+          to: stateLabel(newState),
+          value,
+          type: this.config.type,
+          phaseTransition
+        });
+      }
+    }
+    return events;
+  }
+  /** Get per-cell state field: 0=normal, 1=warning, 2=critical */
+  getStateField() {
+    return this.cellStates;
+  }
+  /** Fraction of cells at or above warning level */
+  getSaturationFraction() {
+    let count = 0;
+    for (let i = 0; i < this.cellCount; i++) {
+      if (this.cellStates[i] > 0) count++;
+    }
+    return count / this.cellCount;
+  }
+  /** Whether any cell is currently undergoing a phase transition */
+  isPhaseTransitionActive() {
+    return this.phaseTransitionCells.size > 0;
+  }
+  getStats() {
+    let normal = 0, warning = 0, critical = 0;
+    for (let i = 0; i < this.cellCount; i++) {
+      switch (this.cellStates[i]) {
+        case 0:
+          normal++;
+          break;
+        case 1:
+          warning++;
+          break;
+        case 2:
+          critical++;
+          break;
+      }
+    }
+    return {
+      totalCells: this.cellCount,
+      normalCount: normal,
+      warningCount: warning,
+      criticalCount: critical,
+      saturationFraction: (warning + critical) / this.cellCount,
+      phaseTransitionActive: this.phaseTransitionCells.size > 0,
+      phaseTransitionCells: this.phaseTransitionCells.size
+    };
+  }
+  /** Update the monitored field reference (e.g., after solver re-allocation) */
+  setField(field) {
+    this.config.field = field;
+    const newCount = field instanceof RegularGrid3D ? field.cellCount : field.length;
+    if (newCount !== this.cellCount) {
+      this.cellCount = newCount;
+      this.cellStates = new Uint8Array(newCount);
+      this.phaseTransitionCells.clear();
+    }
+  }
+  /** Update thresholds at runtime */
+  setThresholds(thresholds) {
+    Object.assign(this.config.thresholds, thresholds);
+  }
+  dispose() {
+    this.phaseTransitionCells.clear();
+  }
+};
+function stateLabel(s) {
+  return s === 0 ? "normal" : s === 1 ? "warning" : "critical";
+}
+
+// src/simulation/CouplingManager.ts
+var CouplingManager = class {
+  solvers = /* @__PURE__ */ new Map();
+  couplings = [];
+  saturationManagers = [];
+  lastEvents = [];
+  totalEvents = 0;
+  lastStepMs = 0;
+  /**
+   * Register a solver with a unique name.
+   */
+  registerSolver(name, type, solver) {
+    this.solvers.set(name, { type, solver });
+  }
+  /**
+   * Add a field coupling between two solvers.
+   */
+  addCoupling(coupling) {
+    this.couplings.push({ enabled: true, ...coupling });
+  }
+  /**
+   * Add a saturation monitor on a solver's field.
+   */
+  addSaturationMonitor(monitor) {
+    this.saturationManagers.push(monitor);
+  }
+  /**
+   * Step all solvers, transfer coupled fields, check saturation.
+   *
+   * Order:
+   * 1. Step all time-dependent solvers (thermal)
+   * 2. Transfer coupled fields (thermal → structural, etc.)
+   * 3. Re-solve steady-state solvers if inputs changed (structural, hydraulic)
+   * 4. Check saturation thresholds
+   */
+  step(dt) {
+    const t0 = performance.now();
+    this.lastEvents = [];
+    for (const [, entry] of this.solvers) {
+      if (entry.type === "thermal") {
+        entry.solver.step(dt);
+      }
+    }
+    for (const coupling of this.couplings) {
+      if (coupling.enabled === false) continue;
+      this.transferField(coupling);
+    }
+    for (const [, entry] of this.solvers) {
+      if (entry.type === "structural") {
+        entry.solver.solve();
+      } else if (entry.type === "hydraulic") {
+        entry.solver.solve();
+      }
+    }
+    for (const monitor of this.saturationManagers) {
+      const events = monitor.update();
+      this.lastEvents.push(...events);
+    }
+    this.totalEvents += this.lastEvents.length;
+    this.lastStepMs = performance.now() - t0;
+    return this.lastEvents;
+  }
+  /**
+   * Transfer a field value from source solver to target solver.
+   */
+  transferField(coupling) {
+    const sourceEntry = this.solvers.get(coupling.source.solver);
+    const targetEntry = this.solvers.get(coupling.target.solver);
+    if (!sourceEntry || !targetEntry) return;
+    const sourceField = this.getField(sourceEntry, coupling.source.field);
+    if (!sourceField) return;
+    if (sourceField instanceof RegularGrid3D) {
+      const targetGrid = this.getField(targetEntry, coupling.target.field);
+      if (targetGrid instanceof RegularGrid3D) {
+        const d = sourceField.data;
+        const td = targetGrid.data;
+        if (d.length !== td.length) {
+          console.warn(
+            `CouplingManager: grid size mismatch in coupling ${coupling.source.solver}.${coupling.source.field} \u2192 ${coupling.target.solver}.${coupling.target.field} (${d.length} vs ${td.length})`
+          );
+        }
+        const len = Math.min(d.length, td.length);
+        for (let i = 0; i < len; i++) {
+          td[i] = coupling.transform(d[i]);
+        }
+      }
+    } else if (sourceField instanceof Float32Array) {
+      const targetArray = this.getField(targetEntry, coupling.target.field);
+      if (targetArray instanceof Float32Array) {
+        if (sourceField.length !== targetArray.length) {
+          console.warn(
+            `CouplingManager: array size mismatch in coupling ${coupling.source.solver}.${coupling.source.field} \u2192 ${coupling.target.solver}.${coupling.target.field} (${sourceField.length} vs ${targetArray.length})`
+          );
+        }
+        const len = Math.min(sourceField.length, targetArray.length);
+        for (let i = 0; i < len; i++) {
+          targetArray[i] = coupling.transform(sourceField[i]);
+        }
+      }
+    }
+  }
+  /**
+   * Get a named field from a solver.
+   */
+  getField(entry, fieldName) {
+    switch (entry.type) {
+      case "thermal": {
+        const solver = entry.solver;
+        if (fieldName === "temperature") return solver.getTemperatureGrid();
+        if (fieldName === "temperature_flat") return solver.getTemperatureField();
+        return null;
+      }
+      case "structural": {
+        const solver = entry.solver;
+        if (fieldName === "von_mises_stress") return solver.getVonMisesStress();
+        if (fieldName === "safety_factor") return solver.getSafetyFactor();
+        if (fieldName === "displacements") return solver.getDisplacements();
+        return null;
+      }
+      case "hydraulic": {
+        const solver = entry.solver;
+        if (fieldName === "pressure") return solver.getPressureField();
+        if (fieldName === "flow_rates") return solver.getFlowRates();
+        return null;
+      }
+      default:
+        return null;
+    }
+  }
+  /** Get events from the last step */
+  getLastEvents() {
+    return this.lastEvents;
+  }
+  /** Enable/disable a coupling by index */
+  setCouplingEnabled(index, enabled) {
+    if (this.couplings[index]) {
+      this.couplings[index].enabled = enabled;
+    }
+  }
+  getStats() {
+    return {
+      solverCount: this.solvers.size,
+      couplingCount: this.couplings.length,
+      saturationMonitors: this.saturationManagers.length,
+      totalEvents: this.totalEvents,
+      lastStepMs: this.lastStepMs
+    };
+  }
+  dispose() {
+    for (const [, entry] of this.solvers) {
+      entry.solver.dispose();
+    }
+    for (const monitor of this.saturationManagers) {
+      monitor.dispose();
+    }
+    this.solvers.clear();
+    this.couplings = [];
+    this.saturationManagers = [];
+  }
+};
+
+export {
+  RegularGrid3D,
+  applyBoundaryConditions,
+  getMaterial,
+  findMaterial,
+  registerMaterial,
+  listMaterials,
+  thermalDiffusivity,
+  conjugateGradient,
+  jacobiIteration,
+  ThermalSolver,
+  StructuralSolver,
+  HydraulicSolver,
+  SaturationManager,
+  CouplingManager,
+  simulation_exports
+};