@adatechnology/game-destruction 0.7.2 → 0.8.0

package/dist/index.js

@@ -525,6 +525,7 @@ var isMember = (dims) => {
   const [a = 0, b = 0, c = 0] = [...dims].sort((x, y) => x - y);
   return b / a < 3 && c / b >= 3;
 };
+var memberBarCount = (width, spacing) => spread(width, COVER, spacing, MAX_MEMBER_BARS_PER_SIDE).length;
 var rebarBars = (dims, thin, spacing) => {
   const out = [];
   if (isMember(dims)) {
@@ -560,12 +561,808 @@ var clipBarsToDisc = (bars, u, v, center, radius) => {
   }
   return out;
 };
+var verticalBarCount = (dims, thin, spacing) => {
+  if (isMember(dims)) {
+    if (dims.indexOf(Math.max(...dims)) !== 1) return 0;
+    const us = spread(dims[0], COVER, spacing, Infinity).length, vs = spread(dims[2], COVER, spacing, Infinity).length;
+    return 2 * us + 2 * Math.max(0, vs - 2);
+  }
+  const [u = 0, v = 0] = [0, 1, 2].filter((i) => i !== thin);
+  if (u === 1) return spread(dims[v], COVER, spacing, Infinity).length;
+  if (v === 1) return spread(dims[u], COVER, spacing, Infinity).length;
+  return 0;
+};
 var rebarMass = (bars, diameter, density = STEEL_DENSITY) => {
   let length = 0;
   for (const [a, b] of bars) length += Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) + Math.abs(a[2] - b[2]);
   return Math.PI * (diameter / 2) * (diameter / 2) * length * density;
 };
 
+// src/flexure.ts
+var GRAVITY = 9.81;
+var MPA = 1e6;
+var FLEXURE_DEFAULTS = {
+  enabled: true,
+  roles: ["beam", "slab", "roof", "stair"],
+  scope: "rebar",
+  crackFactor: 1.5,
+  rebarYieldMPa: 500,
+  cover: 0.03,
+  neutralAxisLimit: 0.45,
+  failRotationDeg: 10,
+  loadFactor: 0.64,
+  massFactor: 0.5,
+  tntJoules: 4184e3,
+  impulse: 200,
+  reflection: 2,
+  reflectionNear: 4,
+  nearScaled: 0.5
+};
+var MASONRY_DEFAULTS = { minEccentricity: 0.05, slendernessLimit: 40, concreteFactor: 0.85 };
+var resolveFlexure = (o) => ({ ...FLEXURE_DEFAULTS, ...definedOf(o) });
+var resolveMasonry = (o) => ({ ...MASONRY_DEFAULTS, ...definedOf(o) });
+var definedOf = (o) => Object.fromEntries(Object.entries(o ?? {}).filter(([, v]) => v !== void 0));
+var RATIO_BAR = 0.01;
+var crackingMoment = (tensileMPa, b, h, alpha = FLEXURE_DEFAULTS.crackFactor) => alpha * tensileMPa * MPA * (b * h * h) / 6;
+var steelMoment = (area, yieldMPa, d, b, compressiveMPa, options = {}) => {
+  if (area <= 0 || d <= 0 || b <= 0) return 0;
+  const T = area * yieldMPa * MPA;
+  const block = 0.68 * compressiveMPa * MPA * b;
+  const x = T / block;
+  const xl = (options.neutralAxisLimit ?? FLEXURE_DEFAULTS.neutralAxisLimit) * d;
+  if (x <= xl) return T * (d - 0.4 * x);
+  const top = Math.min(d / 2, (options.cover ?? FLEXURE_DEFAULTS.cover) + RATIO_BAR / 2);
+  return block * xl * (d - 0.4 * xl) + (T - block * xl) * (d - top);
+};
+var spanStiffness = (EI, span) => 384 * EI / (5 * span ** 3);
+var elasticEnergy = (moment, span, EI, loadFactor = FLEXURE_DEFAULTS.loadFactor) => {
+  const R = 8 * moment / span;
+  return loadFactor * R * R / (2 * spanStiffness(EI, span));
+};
+var momentOfEnergy = (energy, span, EI, loadFactor = FLEXURE_DEFAULTS.loadFactor) => span / 8 * Math.sqrt(2 * Math.max(0, energy) * spanStiffness(EI, span) / loadFactor);
+var impulseEnergy = (impulse, mass, options = {}) => {
+  const KL = options.loadFactor ?? FLEXURE_DEFAULTS.loadFactor;
+  const KM = options.massFactor ?? FLEXURE_DEFAULTS.massFactor;
+  return mass > 0 ? (KL * impulse) ** 2 / (2 * KM * mass) : 0;
+};
+var blastImpulse = (tnt, distance, options = {}) => {
+  if (tnt <= 0) return 0;
+  const o = { ...FLEXURE_DEFAULTS, ...definedOf(options) };
+  const cube = Math.cbrt(tnt);
+  const r = Math.max(distance, o.nearScaled * cube);
+  return (o.reflection + o.reflectionNear / (r / cube)) * (o.impulse * cube * cube / r);
+};
+var slendernessFactor = (h, t, options = {}) => {
+  const o = resolveMasonry(options);
+  const lambda = h / Math.max(t, 1e-3);
+  return Math.max(0, (1 - 2 * o.minEccentricity) * (1 - (lambda / o.slendernessLimit) ** 3));
+};
+var isReinforced = (part) => !!part.reinforcement || (part.structure?.rebar?.ratio ?? 0) > 0;
+var isSlender = (part, material) => material.strength?.slender ?? (!!material.tags?.includes("masonry") && !isReinforced(part));
+var isFlexural = (part, material, options) => options.enabled && material.strength?.tensileMPa !== void 0 && !!part.structure && options.roles.includes(part.structure.role) && (part.structure.rebar !== void 0 || options.scope === "all" || options.scope === "reinforced" && !!part.reinforcement);
+var tensionSteel = (part, dims, section, options) => {
+  const rebar = part.structure?.rebar;
+  const cage = part.reinforcement;
+  const bar2 = rebar ? RATIO_BAR : cage?.diameter ?? RATIO_BAR;
+  const d = Math.max(0.01, section.h - (rebar?.cover ?? options.cover) - bar2 / 2);
+  const yieldMPa = rebar?.yieldMPa ?? options.rebarYieldMPa;
+  if (rebar && rebar.ratio > 0) return { area: rebar.ratio * section.b * d, d, yieldMPa };
+  if (!cage) return { area: 0, d, yieldMPa };
+  const one = Math.PI * cage.diameter * cage.diameter / 4;
+  const count = isMember(dims) ? memberBarCount(section.b, cage.spacing) : section.b / cage.spacing;
+  return { area: one * count, d, yieldMPa };
+};
+var sectionMoments = (material, section, steel, options) => {
+  const s = material.strength;
+  const cracking = crackingMoment(s.tensileMPa ?? 0, section.b, section.h, options.crackFactor);
+  const steelM = steelMoment(steel.area, steel.yieldMPa, steel.d, section.b, s.compressiveMPa, options);
+  return { cracking, steel: steelM, ultimate: Math.max(cracking, steelM), reinforced: steelM > 0 };
+};
+var spanMoment = (w, span) => w * span * span / 8;
+var bendGeometry = (part) => {
+  const dims = shapeDims(part.shape);
+  const member = isMember(dims);
+  const q = quatFromEuler(...part.rotation ?? [0, 0, 0]);
+  const up = rotateVec(quat.conjugate(q), [0, 1, 0]);
+  let spanAxes;
+  let depthAxes;
+  if (member) {
+    const long = dims.indexOf(Math.max(...dims));
+    spanAxes = [long];
+    depthAxes = [0, 1, 2].filter((i) => i !== long);
+  } else {
+    const thin = thinAxisOf(dims);
+    spanAxes = [...planeAxes(thin)];
+    depthAxes = [thin];
+  }
+  let gravity = -1;
+  for (const a of depthAxes) if (Math.abs(up[a]) > Math.SQRT1_2 && (gravity < 0 || Math.abs(up[a]) > Math.abs(up[gravity]))) gravity = a;
+  return { dims, member, spanAxes, depthAxes, gravity, up };
+};
+var sectionWidth = (g, axis) => g.member ? g.dims[g.depthAxes.find((a) => a !== axis) ?? axis] : 1;
+var lineLoad = (g, load) => {
+  const area = g.member ? g.dims[g.spanAxes[0]] : g.dims[g.spanAxes[0]] * g.dims[g.spanAxes[1]];
+  return load * GRAVITY / Math.max(area, 1e-6);
+};
+var spanOf = (g, contacts, samples = 9) => {
+  if (contacts.length === 0) return 0;
+  const axes = g.spanAxes;
+  const steps = (a) => Array.from({ length: samples }, (_, i) => (i / (samples - 1) - 0.5) * g.dims[a]);
+  const us = steps(axes[0]);
+  const vs = axes.length > 1 ? steps(axes[1]) : [0];
+  let far = 0;
+  for (const u of us) for (const v of vs) {
+    let near = Infinity;
+    for (const [lo, hi] of contacts) {
+      let gap = 0;
+      const x = [u, v];
+      axes.forEach((a, k) => gap = Math.max(gap, lo[a] - x[k], x[k] - hi[a], 0));
+      if (gap < near) near = gap;
+    }
+    if (near > far) far = near;
+  }
+  return 2 * far;
+};
+var FLEXURAL_ROLES = FLEXURE_DEFAULTS.roles;
+var bearingWallThickness = (options) => {
+  const gf = options.loadFactor ?? 1.4;
+  const gm = options.materialFactor ?? 2;
+  const min = options.minThickness ?? 0.14;
+  const step = options.step ?? 0.01;
+  const fd = (options.material.strength?.compressiveMPa ?? 0) * MPA / gm;
+  const own = options.material.density * GRAVITY * options.storeyHeight;
+  const out = [];
+  let above = 0;
+  for (let i = 0; i < options.storeys; i++) {
+    const n = above + options.floorLoad;
+    let t = min;
+    for (let k = 0; k < 60; k++) {
+      const room = fd * slendernessFactor(options.storeyHeight, t, options.masonry) - gf * own;
+      if (room <= 0) {
+        t *= 1.25;
+        if (t > 20) {
+          t = Infinity;
+          break;
+        }
+        continue;
+      }
+      const next = Math.max(min, gf * n / room);
+      if (Math.abs(next - t) < 1e-5) break;
+      t = next;
+    }
+    t = Number.isFinite(t) ? Math.ceil(t / step - 1e-9) * step : Infinity;
+    out.push(t);
+    above = n + own * (Number.isFinite(t) ? t : 0);
+  }
+  return out.reverse();
+};
+
+// src/data/soils.json
+var soils_default = [
+  { id: "rock", kind: "rock", allowableKPa: 3e3, spt: 50, elasticMPa: 1e4, poisson: 0.2, pile: { tipKPa: 9e3, skinKPa: 500 } },
+  { id: "rock_fractured", kind: "rock", allowableKPa: 1500, spt: 50, elasticMPa: 2e3, poisson: 0.25, pile: { tipKPa: 4500, skinKPa: 300 } },
+  { id: "gravel_dense", kind: "gravel", allowableKPa: 600, spt: 40, elasticMPa: 132, poisson: 0.3 },
+  { id: "gravel_loose", kind: "gravel", allowableKPa: 300, spt: 8, elasticMPa: 26, poisson: 0.3 },
+  { id: "sand_very_dense", kind: "sand", allowableKPa: 500, spt: 45, elasticMPa: 120, poisson: 0.3 },
+  { id: "sand_dense", kind: "sand", allowableKPa: 400, spt: 25, elasticMPa: 68, poisson: 0.3 },
+  { id: "sand_medium", kind: "sand", allowableKPa: 200, spt: 12, elasticMPa: 32, poisson: 0.3 },
+  { id: "sand_loose", kind: "sand", allowableKPa: 50, spt: 3, elasticMPa: 8, poisson: 0.3 },
+  { id: "silt_hard", kind: "silt", allowableKPa: 300, spt: 25, elasticMPa: 44, poisson: 0.35 },
+  { id: "silt_stiff", kind: "silt", allowableKPa: 200, spt: 15, elasticMPa: 26, poisson: 0.35 },
+  { id: "silt_medium", kind: "silt", allowableKPa: 100, spt: 8, elasticMPa: 14, poisson: 0.35 },
+  { id: "clay_hard", kind: "clay", allowableKPa: 300, spt: 25, elasticMPa: 35, poisson: 0.4 },
+  { id: "clay_stiff", kind: "clay", allowableKPa: 200, spt: 15, elasticMPa: 21, poisson: 0.4 },
+  { id: "clay_medium", kind: "clay", allowableKPa: 100, spt: 8, elasticMPa: 11, poisson: 0.4 },
+  { id: "clay_soft", kind: "clay", allowableKPa: 30, spt: 3, elasticMPa: 4.2, poisson: 0.4 },
+  { id: "clay_very_soft", kind: "clay", allowableKPa: 15, spt: 1, elasticMPa: 1.4, poisson: 0.4 }
+];
+
+// src/soil.ts
+var SOILS = soils_default;
+var SOIL_DEFAULTS = {
+  safety: 3,
+  pileSafety: 2,
+  rigidity: 0.82,
+  influence: 2,
+  imperfection: 1 / 200,
+  cells: 4,
+  sinkRate: 0.05,
+  tiltRate: 1.5,
+  pileElasticGPa: 25,
+  footingWidth: 0.6
+};
+var resolveSoil = (o = {}) => {
+  const byId = new Map(SOILS.map((s) => [s.id, s]));
+  for (const s of o.soils ?? []) byId.set(s.id, s);
+  const { soils: _soils, site, ...rest } = o;
+  return { ...SOIL_DEFAULTS, ...rest, ...site !== void 0 ? { site } : {}, byId };
+};
+var profileOf = (soil) => typeof soil === "string" ? { layers: [{ soil }] } : soil;
+var layersBetween = (profile, top, bottom, soils) => {
+  const out = [];
+  let z = 0;
+  const layers = profile.layers;
+  for (let i = 0; i < layers.length; i++) {
+    const def = soils.get(layers[i].soil);
+    if (!def) throw new Error(`unknown soil "${layers[i].soil}"`);
+    const last = i === layers.length - 1;
+    const end = last ? Infinity : z + Math.max(0, layers[i].thickness ?? 0);
+    const a = Math.max(z, top), b = Math.min(end, bottom);
+    if (b > a) out.push({ soil: def, thickness: b - a, top: a });
+    z = end;
+    if (z >= bottom) break;
+  }
+  return out;
+};
+var soilAt = (profile, depth, soils) => {
+  let z = 0;
+  for (let i = 0; i < profile.layers.length; i++) {
+    const def = soils.get(profile.layers[i].soil);
+    if (!def) throw new Error(`unknown soil "${profile.layers[i].soil}"`);
+    z += Math.max(0, profile.layers[i].thickness ?? 0);
+    if (i === profile.layers.length - 1 || depth < z) return def;
+  }
+  throw new Error("a soil profile needs at least one layer");
+};
+var footingSoil = (profile, depth, width, soils, influence = SOIL_DEFAULTS.influence) => {
+  const zone = layersBetween(profile, depth, depth + Math.max(0.01, influence * width), soils);
+  let allowable = Infinity, e = 0, nu = 0, t = 0;
+  for (const l of zone) {
+    allowable = Math.min(allowable, l.soil.allowableKPa);
+    e += l.soil.elasticMPa * l.thickness;
+    nu += l.soil.poisson * l.thickness;
+    t += l.thickness;
+  }
+  if (t <= 0) {
+    const l = soilAt(profile, depth, soils);
+    return { allowableKPa: l.allowableKPa, elasticMPa: l.elasticMPa, poisson: l.poisson };
+  }
+  return { allowableKPa: allowable, elasticMPa: e / t, poisson: nu / t };
+};
+var DQ_C = { clay: 120, silt: 200, sand: 400, gravel: 400, rock: 400 };
+var BORED = {
+  clay: { alpha: 0.85, beta: 0.8 },
+  silt: { alpha: 0.6, beta: 0.65 },
+  sand: { alpha: 0.5, beta: 0.5 },
+  gravel: { alpha: 0.5, beta: 0.5 },
+  rock: { alpha: 1, beta: 1 }
+};
+var clampN = (n) => Math.min(50, Math.max(3, n));
+var pileCapacity = (profile, pile, top, soils) => {
+  const d = pile.diameter;
+  const area = Math.PI * d * d / 4;
+  const perimeter = Math.PI * d;
+  const driven = pile.method === "driven";
+  let skin = 0;
+  for (const l of layersBetween(profile, top, top + pile.length, soils)) {
+    const f = driven ? 1 : BORED[l.soil.kind].beta;
+    const kPa = l.soil.pile?.skinKPa ?? f * 10 * (clampN(l.soil.spt) / 3 + 1);
+    skin += kPa * 1e3 * perimeter * l.thickness;
+  }
+  const tipDepth = top + pile.length;
+  const tipSoil = soilAt(profile, tipDepth, soils);
+  const alpha = driven ? 1 : BORED[tipSoil.kind].alpha;
+  const tipKPa = tipSoil.pile?.tipKPa ?? alpha * DQ_C[tipSoil.kind] * clampN(tipSoil.spt);
+  const tip = tipKPa * 1e3 * area;
+  return { tip, skin, ultimate: tip + skin, tipSoil };
+};
+var pileLength = (profile, o) => {
+  const soils = o.soils ?? resolveSoil().byId;
+  const safety = o.safety ?? SOIL_DEFAULTS.pileSafety;
+  const step = o.step ?? 0.5;
+  const max = o.maxLength ?? 60;
+  for (let L = step; L <= max + 1e-9; L += step) {
+    if (pileCapacity(profile, { length: L, diameter: o.diameter, ...o.method ? { method: o.method } : {} }, o.top ?? 0, soils).ultimate / safety >= o.load) return Math.round(L / step) * step;
+  }
+  return max;
+};
+var pileStiffness = (pile, pileElasticGPa, tipElasticMPa, tipPoisson) => {
+  const area = Math.PI * pile.diameter * pile.diameter / 4;
+  const shaft = pile.length / (2 * pileElasticGPa * 1e9 * area);
+  const tip = (1 - tipPoisson * tipPoisson) / (tipElasticMPa * 1e6 * pile.diameter);
+  return 1 / (shaft + tip);
+};
+var subgradeModulus = (elasticMPa, poisson, width, rigidity = SOIL_DEFAULTS.rigidity) => elasticMPa * 1e6 / (Math.max(0.05, width) * (1 - poisson * poisson) * rigidity);
+var footingArea = (load, allowableKPa) => load / (allowableKPa * 1e3);
+var yieldSprings = (springs, s, a, b) => {
+  const [x0, z0] = stiffnessCentre(springs);
+  return springs.map((sp) => {
+    const set = sp.set ?? 0;
+    const w = s + a * (sp.x - x0) + b * (sp.z - z0);
+    return sp.k * (w - set) > sp.cap ? w - sp.cap / sp.k : set;
+  });
+};
+var stiffnessCentre = (springs) => {
+  let k = 0, x = 0, z = 0;
+  for (const s of springs) {
+    k += s.k;
+    x += s.k * s.x;
+    z += s.k * s.z;
+  }
+  return k > 0 ? [x / k, z / k] : [0, 0];
+};
+var cholesky3 = (J, r) => {
+  const L = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+  for (let i = 0; i < 3; i++) {
+    for (let j = 0; j <= i; j++) {
+      let sum = J[i][j];
+      for (let k = 0; k < j; k++) sum -= L[i][k] * L[j][k];
+      if (i === j) {
+        if (!(sum > 1e-9 * Math.max(1, Math.abs(J[i][i])))) return null;
+        L[i][i] = Math.sqrt(sum);
+      } else L[i][j] = sum / L[j][j];
+    }
+  }
+  const y = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    let sum = r[i];
+    for (let k = 0; k < i; k++) sum -= L[i][k] * y[k];
+    y[i] = sum / L[i][i];
+  }
+  const x = [0, 0, 0];
+  for (let i = 2; i >= 0; i--) {
+    let sum = y[i];
+    for (let k = i + 1; k < 3; k++) sum -= L[k][i] * x[k];
+    x[i] = sum / L[i][i];
+  }
+  return x;
+};
+var solveFoundation = (springs, weight, xg, zg, height, imperfection, start = { s: 0, a: 0, b: 0 }) => {
+  const [x0, z0] = stiffnessCentre(springs);
+  const capSum = springs.reduce((sum, s2) => sum + s2.cap, 0);
+  const span = Math.max(1, ...springs.map((s2) => Math.max(Math.abs(s2.x - x0) + s2.hx, Math.abs(s2.z - z0) + s2.hz)));
+  let s = start.s, a = start.a, b = start.b;
+  if (springs.every((sp) => s + a * (sp.x - x0) + b * (sp.z - z0) - (sp.set ?? 0) <= 0)) {
+    s = weight / Math.max(1e-9, springs.reduce((sum, sp) => sum + sp.k, 0));
+    a = b = 0;
+  }
+  const Wh = weight * height;
+  const evaluate = () => {
+    let F = 0, Mx = 0, Mz = 0, edge = 0, yielded = false;
+    const Jt = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    const Je = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+    const add = (J, k, dx, dz) => {
+      J[0][0] += k;
+      J[0][1] += k * dx;
+      J[0][2] += k * dz;
+      J[1][1] += k * dx * dx;
+      J[1][2] += k * dx * dz;
+      J[2][2] += k * dz * dz;
+    };
+    for (const sp of springs) {
+      const dx = sp.x - x0, dz = sp.z - z0;
+      const w = s + a * dx + b * dz - (sp.set ?? 0);
+      if (w <= 0) continue;
+      const f = sp.k * w;
+      add(Je, sp.k, dx, dz);
+      let force = f;
+      if (f >= sp.cap) {
+        force = sp.cap;
+        yielded = true;
+      } else add(Jt, sp.k, dx, dz);
+      edge = Math.max(edge, force / sp.cap);
+      F += force;
+      Mx += force * dx;
+      Mz += force * dz;
+    }
+    for (const J of [Jt, Je]) {
+      J[1][0] = J[0][1];
+      J[2][0] = J[0][2];
+      J[2][1] = J[1][2];
+      J[1][1] -= Wh;
+      J[2][2] -= Wh;
+    }
+    const r = [weight - F, weight * (xg - x0 + height * (a + imperfection[0])) - Mx, weight * (zg - z0 + height * (b + imperfection[1])) - Mz];
+    return { r, Jt, Je, edge, yielded };
+  };
+  let ev = evaluate();
+  let converged = false;
+  const tol = 1e-7 * weight;
+  for (let it = 0; it < 120; it++) {
+    if (Math.abs(ev.r[0]) < tol && Math.abs(ev.r[1]) < tol * span && Math.abs(ev.r[2]) < tol * span) {
+      converged = true;
+      break;
+    }
+    const d = cholesky3(ev.Jt, ev.r) ?? cholesky3(ev.Je, ev.r);
+    if (!d) break;
+    s += d[0];
+    a += d[1];
+    b += d[2];
+    if (!Number.isFinite(s + a + b) || Math.abs(a) > 2 || Math.abs(b) > 2) break;
+    ev = evaluate();
+  }
+  const stable = converged && cholesky3(ev.Jt, [0, 0, 0]) !== null;
+  return { s, a, b, stable, yielded: ev.yielded, bearing: capSum > 0 ? weight / capSum : Infinity, edge: ev.edge, residual: [ev.r[0], ev.r[1], ev.r[2]] };
+};
+
+// src/data/wind-terrain.json
+var wind_terrain_default = [
+  { id: "I", zg: 250, b: { A: 1.1, B: 1.11, C: 1.12 }, p: { A: 0.06, B: 0.065, C: 0.07 }, z0: 5e-3 },
+  { id: "II", zg: 300, b: { A: 1, B: 1, C: 1 }, p: { A: 0.085, B: 0.09, C: 0.1 }, z0: 0.05 },
+  { id: "III", zg: 350, b: { A: 0.94, B: 0.94, C: 0.93 }, p: { A: 0.1, B: 0.105, C: 0.115 }, z0: 0.3 },
+  { id: "IV", zg: 420, b: { A: 0.86, B: 0.85, C: 0.84 }, p: { A: 0.12, B: 0.125, C: 0.135 }, z0: 1 },
+  { id: "V", zg: 500, b: { A: 0.74, B: 0.73, C: 0.71 }, p: { A: 0.15, B: 0.16, C: 0.175 }, z0: 2.5 }
+];
+
+// src/wind.ts
+var WIND_TERRAIN = wind_terrain_default;
+var WIND_DEFAULTS = {
+  speed: 40,
+  direction: [1, 0, 0],
+  terrain: "III",
+  class: "auto",
+  topography: 1,
+  statistical: 1,
+  drag: 1.3,
+  damping: 0.016,
+  airDensity: 1.226,
+  minHeight: 5,
+  bandHeight: 3,
+  stiffnessFactor: 0.8,
+  beamFactor: 0.4,
+  flange: 0.1,
+  driftLimit: 1 / 500,
+  loadFactor: 1.4,
+  chord: false,
+  meanRatio: 0.69,
+  gustFactor: { A: 1, B: 0.98, C: 0.95 },
+  gust: { components: 400, maxHz: 2, scale: 1200, seed: 1 },
+  peakDecay: 60,
+  tuning: "den-hartog"
+};
+var definedOf2 = (o) => Object.fromEntries(Object.entries(o ?? {}).filter(([, v]) => v !== void 0));
+var resolveWind = (o = {}) => {
+  const terrains = new Map(WIND_TERRAIN.map((t) => [t.id, t]));
+  for (const t of o.terrains ?? []) terrains.set(t.id, t);
+  const { terrains: _terrains, gustFactor, gust, ...rest } = o;
+  return {
+    ...WIND_DEFAULTS,
+    ...definedOf2(rest),
+    direction: o.direction ?? WIND_DEFAULTS.direction,
+    gustFactor: { ...WIND_DEFAULTS.gustFactor, ...definedOf2(gustFactor) },
+    gust: { ...WIND_DEFAULTS.gust, ...definedOf2(gust) },
+    terrains
+  };
+};
+var exposureOf = (w, spec) => spec ? { ...w, ...definedOf2(spec) } : w;
+var windPressure = (speed, density = WIND_DEFAULTS.airDensity) => 0.5 * density * speed * speed;
+var windClass = (largest) => largest <= 20 ? "A" : largest <= 50 ? "B" : "C";
+var heightFactor = (z, terrain, cls, o = {}) => {
+  const zz = Math.min(terrain.zg, Math.max(o.minHeight ?? WIND_DEFAULTS.minHeight, z));
+  return terrain.b[cls] * (o.gustFactor ?? WIND_DEFAULTS.gustFactor)[cls] * (zz / 10) ** terrain.p[cls];
+};
+var meanHeightFactor = (z, terrain, cls, o = {}) => (o.meanRatio ?? WIND_DEFAULTS.meanRatio) * heightFactor(z, terrain, cls, { gustFactor: { A: 1, B: 1, C: 1 }, ...o.minHeight !== void 0 ? { minHeight: o.minHeight } : {} });
+var turbulenceIntensity = (z, z0) => Math.min(0.5, 1 / Math.log(Math.max(z, 1.5 * z0) / z0));
+var solveWallFrame = (hb, ei, ga, V) => {
+  const n = hb.length;
+  const diag = new Array(n + 1).fill(0);
+  const off = new Array(n).fill(0);
+  const rhs = new Array(n + 1).fill(0);
+  for (let j = 0; j < n; j++) {
+    const h = hb[j], e = ei[j], g = ga[j];
+    diag[j] += e / h + g * h / 3;
+    diag[j + 1] += e / h + g * h / 3;
+    off[j] = -e / h + g * h / 6;
+    rhs[j] += h / 6 * (2 * V[j] + V[j + 1]);
+    rhs[j + 1] += h / 6 * (V[j] + 2 * V[j + 1]);
+  }
+  const wall = ei[0] / (ei[0] + ga[0] * hb[0] * hb[0]);
+  diag[0] += 1e6 * (ei[0] / hb[0] + ga[0] * hb[0]) * wall;
+  const c = new Array(n + 1).fill(0);
+  const d = new Array(n + 1).fill(0);
+  const psi = new Array(n + 1).fill(0);
+  c[0] = off[0] / diag[0];
+  d[0] = rhs[0] / diag[0];
+  for (let i = 1; i <= n; i++) {
+    const m = diag[i] - off[i - 1] * c[i - 1];
+    c[i] = i < n ? off[i] / m : 0;
+    d[i] = (rhs[i] - off[i - 1] * d[i - 1]) / m;
+  }
+  psi[n] = d[n];
+  for (let i = n - 1; i >= 0; i--) psi[i] = d[i] - c[i] * psi[i + 1];
+  const w = new Array(n + 1).fill(0);
+  for (let j = 0; j < n; j++) w[j + 1] = w[j] + hb[j] * (psi[j] + psi[j + 1]) / 2;
+  return { psi, w };
+};
+var shearNodes = (f) => {
+  const V = new Array(f.length + 1).fill(0);
+  for (let j = f.length - 1; j >= 0; j--) V[j] = V[j + 1] + f[j];
+  return V;
+};
+var momentNodes = (hb, V) => {
+  const M = new Array(V.length).fill(0);
+  for (let j = hb.length - 1; j >= 0; j--) M[j] = M[j + 1] + hb[j] * (V[j] + V[j + 1]) / 2;
+  return M;
+};
+var RIGID = 1e3;
+var tBeamInertia = (bw, h, bf, tf) => {
+  const web = bw * h;
+  const fl = Math.max(0, bf - bw) * Math.min(tf, h);
+  const t = Math.min(tf, h);
+  const yc = (web * (h / 2) + fl * (h - t / 2)) / (web + fl);
+  return bw * h ** 3 / 12 + web * (h / 2 - yc) ** 2 + Math.max(0, bf - bw) * t ** 3 / 12 + fl * (h - t / 2 - yc) ** 2;
+};
+var shapeAt = (a, z) => {
+  const { z: zs, phi } = a.shape;
+  if (z <= zs[0]) return phi[0];
+  for (let i = 1; i < zs.length; i++) if (z <= zs[i]) return phi[i - 1] + (phi[i] - phi[i - 1]) * (z - zs[i - 1]) / (zs[i] - zs[i - 1]);
+  return phi[phi.length - 1];
+};
+var analyzeWind = (parts, c, ground) => {
+  const [dx, dz] = c.direction;
+  const along = (p) => {
+    const cx = (p.min[0] + p.max[0]) / 2, cz = (p.min[2] + p.max[2]) / 2;
+    const hx = (p.max[0] - p.min[0]) / 2, hz = (p.max[2] - p.min[2]) / 2;
+    return {
+      u: cx * dx + cz * dz,
+      v: -cx * dz + cz * dx,
+      du: 2 * (Math.abs(dx) * hx + Math.abs(dz) * hz),
+      dv: 2 * (Math.abs(dz) * hx + Math.abs(dx) * hz)
+    };
+  };
+  const g = parts.map(along);
+  let topY = ground;
+  let resists = false;
+  for (const p of parts) {
+    if (p.kind === "foundation") continue;
+    topY = Math.max(topY, p.max[1]);
+    if ((p.kind === "wall" || p.kind === "column") && p.elasticPa) resists = true;
+  }
+  const height = topY - ground;
+  if (!(height > 0) || !resists) return null;
+  const n = Math.max(1, Math.ceil(height / c.bandHeight - 1e-9));
+  const bands = Array.from({ length: n }, (_, j) => Math.min(c.bandHeight, height - j * c.bandHeight));
+  const z0 = Array.from({ length: n }, (_, j) => j * c.bandHeight);
+  const mid = bands.map((h, j) => z0[j] + h / 2);
+  const share = (p, j) => {
+    const a = Math.max(p.min[1] - ground, z0[j]), b = Math.min(p.max[1] - ground, z0[j] + bands[j]);
+    return Math.max(0, b - a);
+  };
+  const vmin = new Array(n).fill(Infinity), vmax = new Array(n).fill(-Infinity);
+  const mass = new Array(n).fill(0);
+  let weight = 0, wu = 0;
+  let footEnd = -Infinity;
+  let anyFoundation = false;
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    weight += p.mass * GRAVITY;
+    wu += p.mass * g[i].u;
+    if (p.kind === "foundation") {
+      anyFoundation = true;
+      footEnd = Math.max(footEnd, g[i].u + g[i].du / 2);
+      continue;
+    }
+    const full = Math.max(1e-6, p.max[1] - p.min[1]);
+    for (let j = 0; j < n; j++) {
+      const ov = share(p, j);
+      if (ov <= 0) continue;
+      vmin[j] = Math.min(vmin[j], g[i].v - g[i].dv / 2);
+      vmax[j] = Math.max(vmax[j], g[i].v + g[i].dv / 2);
+      if (!p.damper) mass[j] += p.mass * ov / full;
+    }
+  }
+  if (!anyFoundation) {
+    for (let i = 0; i < parts.length; i++) if (parts[i].min[1] - ground < 0.1) footEnd = Math.max(footEnd, g[i].u + g[i].du / 2);
+  }
+  const totalMass = weight / GRAVITY;
+  const uCg = totalMass > 0 ? wu / totalMass : 0;
+  const width = vmax.map((hi, j) => hi > vmin[j] ? hi - vmin[j] : 0);
+  const widest = Math.max(...width);
+  const cls = c.cls === "auto" ? windClass(Math.max(height, widest)) : c.cls;
+  const k0 = c.speed * c.topography * c.statistical;
+  const pressure = mid.map((z2) => windPressure(k0 * heightFactor(z2, c.terrain, cls, { gustFactor: c.gustFactor, minHeight: c.minHeight }), c.airDensity));
+  const meanPressure = mid.map((z2) => windPressure(k0 * meanHeightFactor(z2, c.terrain, cls, { meanRatio: c.meanRatio, minHeight: c.minHeight }), c.airDensity));
+  const forces = bands.map((h, j) => pressure[j] * c.drag * width[j] * h);
+  const meanForces = bands.map((h, j) => meanPressure[j] * c.drag * width[j] * h);
+  const V = shearNodes(forces);
+  const M = momentNodes(bands, V);
+  const ea = new Array(n).fill(0), eau = new Array(n).fill(0);
+  const vertical = [];
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (p.kind !== "wall" && !(p.kind === "column" && c.chord) || !p.elasticPa) continue;
+    vertical.push(i);
+    const area = g[i].du * g[i].dv;
+    const e = p.elasticPa * c.stiffnessFactor;
+    for (let j = 0; j < n; j++) {
+      const w = share(p, j) / bands[j];
+      if (w <= 0) continue;
+      ea[j] += e * area * w;
+      eau[j] += e * area * g[i].u * w;
+    }
+  }
+  const centre = ea.map((v, j) => v > 0 ? eau[j] / v : 0);
+  const ei = new Array(n).fill(0);
+  const ga = new Array(n).fill(0);
+  for (const i of vertical) {
+    const p = parts[i];
+    const e = p.elasticPa * c.stiffnessFactor;
+    for (let j = 0; j < n; j++) {
+      const w = share(p, j) / bands[j];
+      if (w <= 0) continue;
+      ei[j] += e * (g[i].du ** 3 * g[i].dv / 12 + g[i].du * g[i].dv * (g[i].u - centre[j]) ** 2) * w;
+    }
+  }
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (p.kind !== "column" || !p.elasticPa) continue;
+    const h = Math.max(1e-6, p.max[1] - p.min[1]);
+    const kc = p.elasticPa * c.stiffnessFactor * (g[i].du ** 3 * g[i].dv) / 12 / h;
+    let beams = 0;
+    for (const b of p.beams ?? []) {
+      const q = parts[b];
+      if (!q?.elasticPa) continue;
+      const hx = q.max[0] - q.min[0], hz = q.max[2] - q.min[2];
+      const long = Math.max(hx, hz), short = Math.min(hx, hz);
+      const cos = hx >= hz ? Math.abs(dx) : Math.abs(dz);
+      const depth = q.max[1] - q.min[1];
+      const inertia = tBeamInertia(short, depth, short + 2 * c.flange * long, q.slab ?? 0);
+      beams += cos * cos * q.elasticPa * c.beamFactor * inertia / Math.max(long, 1e-6);
+    }
+    const k = beams / kc;
+    const base = p.min[1] - ground < 0.05;
+    const a = base ? (0.5 + k) / (2 + k) : k / (2 + k);
+    const stiffness = a * 12 * (p.elasticPa * c.stiffnessFactor) * (g[i].du ** 3 * g[i].dv / 12) / (h * h);
+    for (let j = 0; j < n; j++) ga[j] += stiffness * share(p, j) / bands[j];
+  }
+  let last = -1;
+  for (let j = 0; j < n; j++) if (ei[j] > 0 || ga[j] > 0) last = j;
+  for (let j = last + 1; j < n && last >= 0; j++) {
+    ei[j] = ei[last] * RIGID;
+    ga[j] = ga[last] * RIGID;
+  }
+  const tiny = 1;
+  const eiS = ei.map((v) => Math.max(v, tiny));
+  const gaS = ga.map((v) => Math.max(v, tiny));
+  const sol = solveWallFrame(bands, eiS, gaS, V);
+  const deflection = sol.w[n];
+  const lean = solveWallFrame(bands, eiS, gaS, shearNodes(meanForces)).w[n];
+  const kappa = bands.map((h, j) => (sol.psi[j + 1] - sol.psi[j]) / h);
+  const Mmid = bands.map((h, j) => M[j + 1] + h / 2 * (V[j + 1] + (V[j] + V[j + 1]) / 2) / 2);
+  const Mwall = ei.map((v, j) => Math.min(Mmid[j], Math.max(0, v * kappa[j])));
+  const axial = new Array(parts.length).fill(0);
+  for (const i of vertical) {
+    const p = parts[i];
+    let sum = 0, tot = 0;
+    for (let j = 0; j < n; j++) {
+      const w = share(p, j);
+      if (w <= 0) continue;
+      sum += w * p.elasticPa * c.stiffnessFactor * kappa[j] * g[i].du * g[i].dv * (g[i].u - centre[j]);
+      tot += w;
+    }
+    axial[i] = tot > 0 ? sum / tot : 0;
+  }
+  if (!c.chord) {
+    const colA = new Array(n).fill(0), colAu = new Array(n).fill(0);
+    const cols = [];
+    for (let i = 0; i < parts.length; i++) {
+      if (parts[i].kind !== "column") continue;
+      cols.push(i);
+      for (let j = 0; j < n; j++) {
+        const w = share(parts[i], j) / bands[j];
+        colA[j] += g[i].du * g[i].dv * w;
+        colAu[j] += g[i].du * g[i].dv * g[i].u * w;
+      }
+    }
+    const colC = colA.map((a, j) => a > 0 ? colAu[j] / a : 0);
+    const colI = new Array(n).fill(0);
+    for (const i of cols) for (let j = 0; j < n; j++) colI[j] += g[i].du * g[i].dv * (g[i].u - colC[j]) ** 2 * share(parts[i], j) / bands[j];
+    for (const i of cols) {
+      let sum = 0, tot = 0;
+      for (let j = 0; j < n; j++) {
+        const w = share(parts[i], j);
+        if (w <= 0 || colI[j] <= 0) continue;
+        sum += w * (Math.max(0, Mmid[j] - Mwall[j]) * g[i].du * g[i].dv * (g[i].u - colC[j])) / colI[j];
+        tot += w;
+      }
+      axial[i] = tot > 0 ? sum / tot : 0;
+    }
+  }
+  const arm = footEnd - uCg;
+  const overturn = arm > 0 ? c.loadFactor * M[0] / (weight * arm) : Infinity;
+  const mode = solveWallFrame(bands, eiS, gaS, shearNodes(mass));
+  const top = mode.w[n];
+  const um = bands.map((_, j) => (mode.w[j] + mode.w[j + 1]) / 2);
+  let mu = 0, muu = 0;
+  mass.forEach((m, j) => {
+    mu += m * um[j];
+    muu += m * um[j] * um[j];
+  });
+  const omega = muu > 0 ? Math.sqrt(mu / muu) : 0;
+  const phi = um.map((u) => top > 0 ? u / top : 0);
+  const modalMass = mass.reduce((s, m, j) => s + m * phi[j] * phi[j], 0);
+  const modalForce = meanForces.reduce((s, f, j) => s + f * phi[j], 0);
+  const z = [0, ...bands.map((_, j) => z0[j] + bands[j])];
+  const intensity = turbulenceIntensity(Math.max(0.6 * height, c.minHeight), c.terrain.z0);
+  return {
+    height,
+    cls,
+    width: widest,
+    bands,
+    mid,
+    forces,
+    meanForces,
+    pressure: pressure[n - 1],
+    shear: V[0],
+    moment: M[0],
+    deflection,
+    drift: deflection / height,
+    lean,
+    weight,
+    overturn,
+    wallShare: M[0] > 0 ? Mwall[0] / M[0] : 0,
+    ei,
+    ga,
+    frequency: omega / (2 * Math.PI),
+    omega,
+    modalMass,
+    modalStiffness: omega * omega * modalMass,
+    shape: { z, phi: mode.w.map((w) => top > 0 ? w / top : 0) },
+    modalForce,
+    intensity,
+    axial
+  };
+};
+var damperTuning = (mu, kind = "den-hartog") => kind === "warburton" ? { frequency: Math.sqrt(1 - mu / 2) / (1 + mu), damping: Math.sqrt(mu * (1 - mu / 4) / (4 * (1 + mu) * (1 - mu / 2))) } : { frequency: 1 / (1 + mu), damping: Math.sqrt(3 * mu / (8 * (1 + mu) ** 3)) };
+var damperAmplification = (r, mu, g, damper, structure = 0) => {
+  const mul = (a, b) => [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]];
+  const div = (a, b) => {
+    const d = b[0] * b[0] + b[1] * b[1];
+    return [(a[0] * b[0] + a[1] * b[1]) / d, (a[1] * b[0] - a[0] * b[1]) / d];
+  };
+  const A = [g * g, 2 * damper * g * r];
+  const main = [1 - r * r, 2 * structure * r];
+  const coupling = mu > 0 ? mul([mu * r * r, 0], div(A, [A[0] - r * r, A[1]])) : [0, 0];
+  const total = [main[0] - coupling[0], main[1] - coupling[1]];
+  return 1 / Math.hypot(total[0], total[1]);
+};
+var makeGust = (v10, o) => {
+  const rng = createRng(o.seed);
+  const n = Math.max(1, Math.floor(o.components));
+  const df = o.maxHz / n;
+  const freq = Array.from({ length: n }, (_, k) => (k + 0.5) * df);
+  const weight = freq.map((f) => {
+    const x = o.scale * f / Math.max(v10, 1e-6);
+    return 4 * x * x / (1 + x * x) ** (4 / 3) / f * df;
+  });
+  const sum = weight.reduce((s, w) => s + w, 0);
+  return { freq, amp: weight.map((w) => Math.sqrt(2 * w / sum)), phase: freq.map(() => rng.next() * 2 * Math.PI) };
+};
+var gustAt = (gust, t) => {
+  let s = 0;
+  for (let k = 0; k < gust.freq.length; k++) s += gust.amp[k] * Math.cos(2 * Math.PI * gust.freq[k] * t + gust.phase[k]);
+  return s;
+};
+var stepSway = (s, sys, t, dt, force, maxStep = Infinity) => {
+  const steps = Math.max(1, Math.ceil(dt / maxStep - 1e-9));
+  const h = dt / steps;
+  const d = sys.damper;
+  const f = (x, v, y, w, tt) => {
+    const fd = d ? d.k * (y - x) + d.c * (w - v) : 0;
+    return [v, (force(tt) - sys.K * x - sys.C * v + fd) / sys.M, d ? w : 0, d ? -fd / d.m : 0];
+  };
+  for (let i = 0; i < steps; i++) {
+    const tt = t + i * h;
+    const k1 = f(s.x, s.v, s.y, s.w, tt);
+    const k2 = f(s.x + h / 2 * k1[0], s.v + h / 2 * k1[1], s.y + h / 2 * k1[2], s.w + h / 2 * k1[3], tt + h / 2);
+    const k3 = f(s.x + h / 2 * k2[0], s.v + h / 2 * k2[1], s.y + h / 2 * k2[2], s.w + h / 2 * k2[3], tt + h / 2);
+    const k4 = f(s.x + h * k3[0], s.v + h * k3[1], s.y + h * k3[2], s.w + h * k3[3], tt + h);
+    s.x += h / 6 * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]);
+    s.v += h / 6 * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]);
+    s.y += h / 6 * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2]);
+    s.w += h / 6 * (k1[3] + 2 * k2[3] + 2 * k3[3] + k4[3]);
+  }
+};
+var tensionCapacity = (dims, o) => {
+  const section = dims[0] * dims[2];
+  if (o.reinforcement) {
+    const bars = verticalBarCount(dims, thinAxisOf(dims), o.reinforcement.spacing);
+    return bars * Math.PI * (o.reinforcement.diameter / 2) ** 2 * o.yieldMPa * 1e6;
+  }
+  if (o.ratio) return o.ratio * section * o.yieldMPa * 1e6;
+  return (o.tensileMPa ?? 0) * 1e6 * section;
+};
+
 // src/data/materials.json
 var materials_default = [
   {
@@ -573,6 +1370,8 @@ var materials_default = [
     density: 7850,
     hpPerKg: 400,
     penetration: 110,
+    penetrationClass: "steel",
+    penetrationScale: 1.3,
     ductility: 0.9,
     fracture: "none",
     damageScale: {
@@ -602,6 +1401,8 @@ var materials_default = [
     density: 7200,
     hpPerKg: 150,
     penetration: 160,
+    penetrationClass: "steel",
+    penetrationScale: 1,
     ductility: 0.2,
     fracture: "snap",
     fragmentSize: [
@@ -635,6 +1436,8 @@ var materials_default = [
     density: 2700,
     hpPerKg: 250,
     penetration: 60,
+    penetrationClass: "steel",
+    penetrationScale: 3,
     ductility: 0.85,
     fracture: "none",
     damageScale: {
@@ -663,6 +1466,8 @@ var materials_default = [
     density: 8960,
     hpPerKg: 300,
     penetration: 70,
+    penetrationClass: "steel",
+    penetrationScale: 1.5,
     ductility: 0.95,
     fracture: "none",
     damageScale: {
@@ -691,6 +1496,8 @@ var materials_default = [
     density: 500,
     hpPerKg: 90,
     penetration: 9,
+    penetrationClass: "wood",
+    penetrationScale: 1.5,
     ductility: 0.35,
     fracture: "splinter",
     fragmentSize: [
@@ -727,6 +1534,8 @@ var materials_default = [
     density: 750,
     hpPerKg: 140,
     penetration: 14,
+    penetrationClass: "wood",
+    penetrationScale: 1,
     ductility: 0.3,
     fracture: "splinter",
     fragmentSize: [
@@ -762,6 +1571,8 @@ var materials_default = [
     density: 600,
     hpPerKg: 70,
     penetration: 7,
+    penetrationClass: "wood",
+    penetrationScale: 2,
     ductility: 0.3,
     fracture: "snap",
     fragmentSize: [
@@ -797,6 +1608,8 @@ var materials_default = [
     density: 750,
     hpPerKg: 45,
     penetration: 6,
+    penetrationClass: "wood",
+    penetrationScale: 2.5,
     ductility: 0.15,
     fracture: "snap",
     fragmentSize: [
@@ -925,6 +1738,8 @@ var materials_default = [
     density: 2300,
     hpPerKg: 14,
     penetration: 18,
+    penetrationClass: "concrete",
+    penetrationScale: 1,
     ductility: 0.03,
     fracture: "crumble",
     fragmentSize: [
@@ -944,13 +1759,20 @@ var materials_default = [
       "masonry",
       "brittle"
     ],
-    compressive: 444e3
+    compressive: 444e3,
+    strength: {
+      compressiveMPa: 25,
+      tensileMPa: 2.56,
+      elasticGPa: 28
+    }
   },
   {
     id: "brick",
     density: 1900,
     hpPerKg: 12,
     penetration: 14,
+    penetrationClass: "brick",
+    penetrationScale: 1,
     ductility: 0.05,
     fracture: "crumble",
     fragmentSize: [
@@ -967,13 +1789,20 @@ var materials_default = [
       "masonry",
       "brittle"
     ],
-    compressive: 4e4
+    compressive: 4e4,
+    strength: {
+      compressiveMPa: 2.35,
+      tensileMPa: 0.1,
+      elasticGPa: 2.35
+    }
   },
   {
     id: "plaster",
     density: 850,
     hpPerKg: 18,
     penetration: 3,
+    penetrationClass: "brick",
+    penetrationScale: 3,
     ductility: 0.05,
     fracture: "crumble",
     fragmentSize: [
@@ -997,6 +1826,8 @@ var materials_default = [
     density: 2700,
     hpPerKg: 25,
     penetration: 25,
+    penetrationClass: "concrete",
+    penetrationScale: 0.9,
     ductility: 0.03,
     fracture: "crumble",
     fragmentSize: [
@@ -1260,6 +2091,8 @@ var materials_default = [
     density: 650,
     hpPerKg: 5,
     penetration: 10,
+    penetrationClass: "wood",
+    penetrationScale: 1.2,
     ductility: 0.5,
     fracture: "splinter",
     fragmentSize: [
@@ -1561,13 +2394,26 @@ var inferJoints = (parts, tolerance = 0.01, materials = MATERIAL_MAP) => {
   }
   return out;
 };
-var partCapacity = (part, material) => {
+var partCapacity = (part, material, options = {}) => {
   if (part.structure?.capacity !== void 0) return part.structure.capacity;
   const d = shapeDims(part.shape).sort((a, b) => a - b);
   const role = part.structure?.role;
   const sh = shapeDims(part.shape);
   const section = role === "wall" || role === "partition" ? Math.min(sh[0], sh[2]) * Math.max(sh[0], sh[2]) : role === "slab" ? d[0] * d[2] : d[0] * d[1];
-  return Math.max(1, section * (material.compressive ?? 2e4) * (role === "foundation" ? 10 : 1));
+  const foundation = role === "foundation" ? 10 : 1;
+  const strength = material.strength;
+  if (!strength) return Math.max(1, section * (material.compressive ?? 2e4) * foundation);
+  const fc = strength.compressiveMPa * 1e6;
+  let newtons = fc * section;
+  const upright = role === "wall" || role === "partition" || role === "column";
+  if (upright && isSlender(part, material)) newtons *= slendernessFactor(sh[1], Math.min(sh[0], sh[2]), options.masonry);
+  else if (role === "column" && part.reinforcement) {
+    const m = resolveMasonry(options.masonry);
+    const bars = rebarBars(sh, thinAxisOf(sh), part.reinforcement.spacing).length;
+    const steel = bars * Math.PI * (part.reinforcement.diameter / 2) ** 2;
+    newtons = m.concreteFactor * fc * section + steel * resolveFlexure(options.flexure).rebarYieldMPa * 1e6;
+  }
+  return Math.max(1, newtons / GRAVITY * foundation);
 };
 var fragility = (ductility, thickness) => {
   if (ductility >= 0.3) return 1;
@@ -1575,22 +2421,32 @@ var fragility = (ductility, thickness) => {
 };
 
 // src/world.ts
+import { ignitionChance, resolveIgnitionRules, sparkTargetFactor } from "@adatechnology/game-contracts";
+var THIN_SHEET_DISHING = 5e-3;
 var DMG_PER_J = 0.02;
 var BLAST_COUPLING = 0.1;
 var SHELTER_DEFAULTS = { k: 2800, brokenTransmission: 0.5, minPath: 5e-3 };
 var FRAGMENT_HIT_DEFAULTS = { max: 24, energyFactor: 0.5, hitType: "blunt", range: 6, flightTime: 0.4, spread: 10, aim: 40 };
 var CONFINEMENT_DEFAULTS = { rays: 26, reach: 1.5, gain: 1.5, power: 2, max: 3 };
 var FLAMMABLE_FLUIDS = ["gas", "fuel"];
+var VENT_DIAMETER = 8e-3;
+var FLAME_LIGHTS_LEAK_C = 470;
 var BREACH_RADIUS = 0.55;
 var BREACH_BLAST_FACTOR = 6;
 var BREACH_AREA = 0.25;
-var BREACH_BLAST_REACH = Infinity;
+var BREACH_BLAST_REACH = 0.12;
 var RESIDUAL_CAPACITY = 0.15;
+var SUPPORT_TOLERANCE = 0.05;
 var UNIT_FRAGMENT_FACTOR = 4;
 var BREACH_GRID_CAP = 4096;
 var CUT_SLICE = 1;
 var cutFactorOf = (shape) => clamp2(Math.max(...shapeDims(shape)) / CUT_SLICE, 1, 50);
 var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
+var penetrationOf = (mat, table) => {
+  if (!table) return void 0;
+  const v = table[mat.penetrationClass ?? mat.id] ?? table[mat.id];
+  return v === void 0 ? void 0 : v * (mat.penetrationScale ?? 1);
+};
 var capacityScale = (p) => {
   if (p.st.stripped) return p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
   return p.rt.removed ? Math.max(0.05, 1 - p.rt.removed / p.mass0) : 1;
@@ -1618,8 +2474,14 @@ var createDestruction = (options = {}) => {
   const maxHoles = options.maxHoles ?? 32;
   const fireSpread = options.fireSpread ?? 0.6;
   const breachRadius = options.breach?.radius ?? BREACH_RADIUS;
+  const structureSafety = options.structure?.safetyFactor ?? 1;
+  const flexure = resolveFlexure(options.structure?.flexure);
+  const masonry = resolveMasonry(options.structure?.masonry);
+  const soilCfg = resolveSoil(options.soil);
+  let windOpts = options.wind;
+  let windCfg = windOpts ? resolveWind(windOpts) : null;
+  const ignitionRules = resolveIgnitionRules(options.ignition);
   const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
-  const breachBlastReach = options.breach?.blastReach ?? BREACH_BLAST_REACH;
   const rng = createRng(options.seed ?? 1);
   const rnd = () => rng.next();
   let time = 0;
@@ -1646,7 +2508,7 @@ var createDestruction = (options = {}) => {
   const pendingCollapse = /* @__PURE__ */ new Map();
   let runDepth = 0;
   const drainBlasts = () => {
-    for (let blast = blasts.shift(); blast; blast = blasts.shift()) blastWorld(blast.point, blast.energy, blast.radius, blast.source);
+    for (let blast = blasts.shift(); blast; blast = blasts.shift()) blastWorld(blast.point, blast.energy, blast.radius, blast.source, void 0, void 0, blast.lethalRadius);
   };
   const run = (fn) => {
     const prev = cur;
@@ -1716,7 +2578,8 @@ var createDestruction = (options = {}) => {
       collapsed: new Set(carry?.collapsed ?? []),
       unsup: [],
       anyAnchor: false,
-      order: ++orderCounter
+      order: ++orderCounter,
+      base: { pos: [pos[0], pos[1], pos[2]], rot: [rot[0], rot[1], rot[2], rot[3]] }
     };
     for (const ps of spec.parts) {
       if (o.byId.has(ps.id)) throw new Error(`duplicate part id "${ps.id}"`);
@@ -1768,10 +2631,17 @@ var createDestruction = (options = {}) => {
         rt: c?.rt ?? { ...freshRuntime(), prevTemp: pst.temperature },
         structural: !!ps.structure && ps.structure.role !== "none",
         anchored: !!ps.anchored || ps.structure?.role === "foundation",
-        cap: ps.structure ? partCapacity(ps, mat) : 0,
+        cap: ps.structure ? partCapacity(ps, mat, { masonry, flexure }) : 0,
+        orphan: false,
         staged,
         thin: thinAxisOf(shapeDims(ps.shape)),
-        layers
+        layers,
+        span: 0,
+        spanKey: "",
+        restMoment: 0,
+        bendLoad: 0,
+        snap: false,
+        ...ps.shape.kind === "box" && isFlexural(ps, mat, flexure) ? { bend: bendGeometry(ps) } : {}
       };
       if (p.structural) o.hasStructure = true;
       if (p.rt.chainDue !== void 0 && !isLost(p)) primed.set(p, o);
@@ -1805,7 +2675,14 @@ var createDestruction = (options = {}) => {
     updateBound(o);
     o.anyAnchor = o.parts.some((p) => p.anchored);
     o.unsup = o.parts.map(() => false);
+    if (windCfg && o.hasStructure && spec.wind !== false) o.wind = newWind(o, carry?.wind);
+    const ground = spec.soil ?? soilCfg.site;
+    if (ground !== void 0 && o.parts.some((p) => p.spec.structure?.role === "foundation")) initSoil(o, profileOf(ground), carry?.soil, carry?.soilSets);
+    o.seeding = true;
     solveStructure(o);
+    o.seeding = false;
+    if (o.soil && !carry?.soil) settleSoil(o, 0);
+    if (o.soil) o.soil.dirty = false;
     recomputeGroups(o);
     o.st.destroyed = o.parts.length > 0 && o.parts.every(isLost);
     o.active = o.maxStress > 0.8 || o.parts.some((p) => p.st.burning || p.st.temperature > ambient + 0.5 || (p.st.liters ?? 0) > 0);
@@ -1857,12 +2734,126 @@ var createDestruction = (options = {}) => {
     for (const p of o.parts) if (isLost(p)) p.st.group = -1;
     list.forEach((g, gi) => g.ix.forEach((i) => o.parts[i].st.group = gi));
   };
-  const restsOn = (j, r) => {
+  const restsOn = (o, j, r) => {
     const b = j.bears;
     if (!b) return -1;
-    if (b === true) return j.ia === r ? j.ib : j.ia;
-    if (b === "a_on_b") return j.ia === r ? j.ib : -1;
-    return j.ib === r ? j.ia : -1;
+    const k = b === true ? j.ia === r ? j.ib : j.ia : b === "a_on_b" ? j.ia === r ? j.ib : -1 : j.ib === r ? j.ia : -1;
+    if (k < 0 || j.spec.kind !== "tie") return k;
+    return partXf(o, o.parts[k]).c[1] > partXf(o, o.parts[r]).c[1] + 1e-6 ? k : -1;
+  };
+  const contactBox = (p, support) => {
+    const A = aabbOf(p.spec.shape, p.pos, p.q), B = aabbOf(support.spec.shape, support.pos, support.q);
+    const lo = [0, 0, 0], hi = [0, 0, 0];
+    for (let k = 0; k < 3; k++) {
+      const a = Math.max(A.min[k], B.min[k]) - SUPPORT_TOLERANCE, b = Math.min(A.max[k], B.max[k]) + SUPPORT_TOLERANCE;
+      lo[k] = Math.min(a, b);
+      hi[k] = Math.max(a, b);
+    }
+    const out = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+    for (let c = 0; c < 8; c++) {
+      const l = toLocal(p.pos, p.q, [c & 1 ? hi[0] : lo[0], c & 2 ? hi[1] : lo[1], c & 4 ? hi[2] : lo[2]]);
+      for (let k = 0; k < 3; k++) {
+        out[0][k] = Math.min(out[0][k], l[k]);
+        out[1][k] = Math.max(out[1][k], l[k]);
+      }
+    }
+    return out;
+  };
+  const contactCentre = (p, above) => {
+    const [lo, hi] = contactBox(p, above);
+    return toWorld(p.pos, p.q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
+  };
+  const overSupportAt = (o, p, at, lower) => {
+    const g = p.bend;
+    const local = toLocal(p.pos, p.q, at);
+    const depth = g.gravity >= 0 ? g.dims[g.gravity] : Math.min(...g.depthAxes.map((a) => g.dims[a]));
+    let best = -1;
+    let bestGap = depth;
+    for (const k of lower) {
+      const [a, b] = contactBox(p, o.parts[k]);
+      let gap = 0;
+      for (const ax of g.spanAxes) gap = Math.max(gap, a[ax] - local[ax], local[ax] - b[ax]);
+      if (gap <= bestGap) {
+        best = k;
+        bestGap = gap - 1e-9;
+      }
+    }
+    return best;
+  };
+  const sectionOf = (p, axis) => {
+    const g = p.bend;
+    const section = { b: sectionWidth(g, axis), h: g.dims[axis] };
+    const rebar = tensionSteel(p.spec, g.dims, section, flexure);
+    return { section, rebar, ...sectionMoments(p.mat, section, rebar, flexure) };
+  };
+  const restFlexure = (o, p, lower) => {
+    const g = p.bend;
+    const key = lower.join(",");
+    if (key !== p.spanKey) {
+      p.spanKey = key;
+      p.span = spanOf(g, lower.map((k) => contactBox(p, o.parts[k])));
+    }
+    p.restMoment = 0;
+    if (g.gravity < 0 || p.span <= 0) return 0;
+    const sec = sectionOf(p, g.gravity);
+    p.restMoment = spanMoment(lineLoad(g, p.bendLoad) * Math.abs(g.up[g.gravity]), p.span);
+    const holds = (p.st.cracked ? sec.steel : sec.ultimate) * capacityScale(p);
+    return p.restMoment * structureSafety / Math.max(holds, 1);
+  };
+  const bendByBlast = (o, p, point, energy, radius, reach, src) => {
+    const g = p.bend;
+    if (!g || p.span <= 0 || isLost(p) || p.st.stripped || reach <= 0) return;
+    const s = p.mat.strength;
+    if (!s.elasticGPa) return;
+    const { c, q } = partXf(o, p);
+    const near = surfacePoint(p.spec.shape, toLocal(c, q, point));
+    const local = toLocal(c, q, point);
+    const away = vec.normalize(vec.sub(near.point, local), vec.scale(near.normal, -1));
+    let axis = g.depthAxes[0];
+    for (const a of g.depthAxes) if (Math.abs(away[a]) > Math.abs(away[axis])) axis = a;
+    const cos = Math.abs(away[axis]);
+    if (cos < 1e-3) return;
+    const tnt = energy / flexure.tntJoules;
+    const L = p.span;
+    const offsets = g.member ? [[-0.5], [-0.25], [0], [0.25], [0.5]] : [[0, 0], [-0.25, 0], [0.25, 0], [0, -0.25], [0, 0.25]];
+    const face = -Math.sign(away[axis]) * g.dims[axis] / 2;
+    let sum = 0;
+    for (const off of offsets) {
+      const sp = [near.point[0], near.point[1], near.point[2]];
+      g.spanAxes.forEach((a, k) => sp[a] = Math.max(-g.dims[a] / 2, Math.min(g.dims[a] / 2, sp[a] + off[k] * L)));
+      sp[axis] = face;
+      const r = vec.distance(toWorld(c, q, sp), point);
+      if (r < radius) sum += blastImpulse(tnt, r, flexure);
+    }
+    const width = sectionWidth(g, axis);
+    const impulse = sum / offsets.length * cos * reach * width * L;
+    const weight = axis === g.gravity ? p.bendLoad : p.st.mass;
+    const kinetic = impulseEnergy(impulse, lineLoad(g, weight) / GRAVITY * L, flexure);
+    const sec = sectionOf(p, axis);
+    const EI = s.elasticGPa * 1e9 * sec.section.b * sec.section.h ** 3 / 12;
+    const along = axis === g.gravity ? -Math.sign(away[axis] * g.up[axis]) : 0;
+    const dynamic = momentOfEnergy(kinetic, L, EI, flexure.loadFactor);
+    const peak = Math.abs(dynamic + along * p.restMoment);
+    if (peak <= sec.cracking) return;
+    if (!p.st.cracked) {
+      p.st.cracked = true;
+      const tension = [near.point[0], near.point[1], near.point[2]];
+      tension[axis] = dynamic + along * p.restMoment >= 0 ? -face : face;
+      const n = [0, 0, 0];
+      n[axis] = Math.sign(tension[axis]) || 1;
+      addCrack(o, p, toWorld(c, q, tension), rotateVec(q, n), sec.section.b, src);
+    }
+    if (!sec.reinforced) {
+      p.snap = true;
+      failPart(o, p, point, away, kinetic, 12, src, "snap");
+      return;
+    }
+    solveStructure(o);
+    if (peak <= sec.steel) return;
+    const rotation = (elasticEnergy(peak, L, EI, flexure.loadFactor) - elasticEnergy(sec.steel, L, EI, flexure.loadFactor)) / (2 * sec.steel);
+    p.rt.hinge = (p.rt.hinge ?? 0) + rotation;
+    markDamaged(p);
+    if (p.rt.hinge >= flexure.failRotationDeg * Math.PI / 180) hingeDrop(o, p, src);
   };
   const solveStructure = (o) => {
     o.maxStress = 0;
@@ -1883,23 +2874,41 @@ var createDestruction = (options = {}) => {
       for (const j of o.byPart.get(parts[s].spec.id)) {
         if (j.st.open || !j.bears) continue;
         const r = j.ia === s ? j.ib : j.ia;
-        if (dist[r] >= 0 || !ok(r) || restsOn(j, r) !== s) continue;
+        if (dist[r] >= 0 || !ok(r) || restsOn(o, j, r) !== s) continue;
         dist[r] = dist[s] + 1;
         queue.push(r);
       }
     }
     const incoming = new Array(n).fill(0);
-    for (let h = queue.length - 1; h >= 0; h--) {
-      const i = queue[h];
-      const total = parts[i].st.mass + incoming[i];
-      parts[i].st.load = total;
+    const lowerOf = /* @__PURE__ */ new Map();
+    for (const i of queue) {
       const lower = [];
       for (const j of o.byPart.get(parts[i].spec.id)) {
         if (j.st.open || !j.bears) continue;
-        const k = restsOn(j, i);
+        const k = restsOn(o, j, i);
         if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
       }
+      lowerOf.set(i, lower);
+    }
+    const bending = new Array(n).fill(0);
+    const through = parts.map(() => []);
+    const pass = (k, at, mass) => {
+      const over = overSupportAt(o, parts[k], at, lowerOf.get(k) ?? []);
+      if (over < 0) bending[k] += mass;
+      else through[k].push({ at, mass, over });
+    };
+    for (let h = queue.length - 1; h >= 0; h--) {
+      const i = queue[h];
+      const total = parts[i].st.mass + incoming[i];
+      parts[i].st.load = total;
+      const lower = lowerOf.get(i);
       for (const k of lower) incoming[k] += total / lower.length;
+      if (lower.length === 0) continue;
+      const bulk = parts[i].bend ? parts[i].st.mass + bending[i] : total;
+      for (const k of lower) if (parts[k].bend) pass(k, contactCentre(parts[k], parts[i]), bulk / lower.length);
+      if (parts[i].bend) {
+        for (const item of through[i]) if (parts[item.over]?.bend) pass(item.over, item.at, item.mass);
+      }
     }
     for (let i = 0; i < n; i++) {
       const p = parts[i];
@@ -1908,13 +2917,420 @@ var createDestruction = (options = {}) => {
       if (dist[i] < 0 || isLost(p)) {
         p.st.load = p.st.mass;
         p.st.stress = 0;
-        o.unsup[i] = o.anyAnchor && !isLost(p);
+        if (o.seeding && !p.anchored && !isLost(p) && p.st.status !== "collapsed" && !o.collapsed.has(p.spec.id)) p.orphan = true;
+        o.unsup[i] = o.anyAnchor && !isLost(p) && !p.orphan;
         continue;
       }
-      p.st.stress = p.st.load / (p.cap * capacityScale(p));
+      p.st.stress = p.st.load * structureSafety / (p.cap * capacityScale(p));
+      if (p.bend) {
+        p.bendLoad = p.st.mass + bending[i];
+        const bent = restFlexure(o, p, lowerOf.get(i) ?? []);
+        p.st.flexure = bent;
+        p.snap = bent > 1 && !p.st.stripped && !sectionOf(p, p.bend.gravity).reinforced;
+        if (p.spec.structure?.capacity === void 0 || bent > p.st.stress) p.st.stress = bent;
+      }
       if (p.st.stress > o.maxStress) o.maxStress = p.st.stress;
     }
+    if (o.wind) applyWind(o);
     if (o.maxStress > 0.8) o.active = true;
+    if (o.soil) o.soil.dirty = true;
+  };
+  const newWind = (o, carried) => {
+    const cfg = exposureOf(windCfg, o.spec.wind);
+    const [x = 0, v = 0, y = 0, w = 0, peak = 0] = carried ?? [];
+    return {
+      cfg,
+      gust: { freq: [], amp: [], phase: [] },
+      gustKey: "",
+      analysis: null,
+      parts: [],
+      sys: null,
+      mu: 0,
+      dyn: { x, v, y, w, peak },
+      tension: /* @__PURE__ */ new Map(),
+      emitted: { t: -Infinity, peak: 0, status: "ok" }
+    };
+  };
+  const windDirection = (o, cfg) => {
+    const d = rotateVec(quat.conjugate(o.base.rot), cfg.direction);
+    const h = Math.hypot(d[0], d[2]);
+    return h > 1e-9 ? [d[0] / h, d[2] / h] : [1, 0];
+  };
+  const applyWind = (o) => {
+    const w = o.wind;
+    const cfg = w.cfg = exposureOf(windCfg, o.spec.wind);
+    const terrain = cfg.terrains.get(cfg.terrain);
+    if (!terrain) throw new Error(`unknown wind terrain "${cfg.terrain}"`);
+    const inputs = [];
+    const at = /* @__PURE__ */ new Map();
+    const keep = [];
+    let ground = Infinity, foundationTop = -Infinity;
+    o.parts.forEach((p, i) => {
+      if (isLost(p) || isTerrain(p) || o.collapsed.has(p.spec.id) || o.unsup[i]) return;
+      const box = aabbOf(p.spec.shape, p.pos, p.q);
+      const role = p.spec.structure?.role;
+      const e = p.mat.strength?.elasticGPa;
+      const kind = role === "wall" ? "wall" : role === "column" ? "column" : role === "beam" ? "beam" : role === "foundation" ? "foundation" : "other";
+      at.set(i, inputs.length);
+      keep.push(i);
+      ground = Math.min(ground, box.min[1]);
+      if (kind === "foundation") foundationTop = Math.max(foundationTop, box.max[1]);
+      inputs.push({ min: box.min, max: box.max, kind, ...e ? { elasticPa: e * 1e9 } : {}, mass: p.st.mass, ...p.spec.damper ? { damper: true } : {} });
+    });
+    keep.forEach((i, k) => {
+      if (inputs[k].kind !== "column") return;
+      const beams = [];
+      for (const j of o.byPart.get(o.parts[i].spec.id)) {
+        if (j.st.open) continue;
+        const b = at.get(j.ia === i ? j.ib : j.ia);
+        if (b !== void 0 && inputs[b].kind === "beam") beams.push(b);
+      }
+      inputs[k].beams = beams;
+    });
+    keep.forEach((i, k) => {
+      if (inputs[k].kind !== "beam") return;
+      for (const j of o.byPart.get(o.parts[i].spec.id)) {
+        if (j.st.open) continue;
+        const q = o.parts[j.ia === i ? j.ib : j.ia];
+        const role = q.spec.structure?.role;
+        if ((role === "slab" || role === "roof") && !isLost(q) && q.spec.shape.kind === "box") {
+          inputs[k].slab = q.dims[1];
+          break;
+        }
+      }
+    });
+    const c = {
+      speed: cfg.speed,
+      direction: windDirection(o, cfg),
+      terrain,
+      cls: cfg.class,
+      topography: cfg.topography,
+      statistical: cfg.statistical,
+      drag: cfg.drag,
+      damping: cfg.damping,
+      airDensity: cfg.airDensity,
+      minHeight: cfg.minHeight,
+      bandHeight: cfg.bandHeight,
+      stiffnessFactor: cfg.stiffnessFactor,
+      beamFactor: cfg.beamFactor,
+      loadFactor: cfg.loadFactor,
+      chord: cfg.chord,
+      meanRatio: cfg.meanRatio,
+      gustFactor: cfg.gustFactor,
+      flange: cfg.flange
+    };
+    const a = inputs.length && cfg.speed > 0 ? analyzeWind(inputs, c, foundationTop > -Infinity ? foundationTop : ground) : null;
+    w.analysis = a;
+    w.parts = keep;
+    for (const p of o.parts) delete p.st.wind;
+    if (!a) {
+      w.sys = null;
+      delete o.st.wind;
+      return;
+    }
+    keep.forEach((i, k) => {
+      const N = a.axial[k];
+      const p = o.parts[i];
+      if (!N || !p.structural || o.unsup[i]) return;
+      p.st.wind = N;
+      const dead = p.st.load ?? p.st.mass;
+      const force = N * cfg.loadFactor;
+      let stress = 0;
+      if (force >= 0) stress = (dead * structureSafety + force / GRAVITY) / (p.cap * capacityScale(p));
+      else if (dead + force / GRAVITY < 0) {
+        let cap = w.tension.get(i);
+        if (cap === void 0) {
+          const r = p.spec.reinforcement;
+          const ratio = p.spec.structure?.rebar?.ratio;
+          cap = tensionCapacity(p.dims, {
+            ...r ? { reinforcement: r } : {},
+            ...ratio ? { ratio } : {},
+            yieldMPa: flexure.rebarYieldMPa,
+            ...p.mat.strength?.tensileMPa !== void 0 ? { tensileMPa: p.mat.strength.tensileMPa } : {}
+          });
+          w.tension.set(i, cap);
+        }
+        stress = Math.min(10, -(dead + force / GRAVITY) * GRAVITY / Math.max(cap * capacityScale(p), 1));
+      }
+      if (stress > (p.st.stress ?? 0)) p.st.stress = stress;
+      if ((p.st.stress ?? 0) > o.maxStress) o.maxStress = p.st.stress ?? 0;
+    });
+    const key = `${cfg.speed}|${cfg.terrain}|${cfg.topography}|${cfg.statistical}|${cfg.meanRatio}|${cfg.gust.components}|${cfg.gust.maxHz}|${cfg.gust.scale}|${cfg.gust.seed}`;
+    if (key !== w.gustKey) {
+      w.gustKey = key;
+      const v10 = cfg.speed * cfg.topography * cfg.statistical * meanHeightFactor(10, terrain, a.cls, { meanRatio: cfg.meanRatio, minHeight: cfg.minHeight });
+      w.gust = makeGust(v10, cfg.gust);
+    }
+    let md = 0, spec;
+    for (const i of keep) {
+      const p = o.parts[i];
+      if (!p.spec.damper) continue;
+      const phi = shapeAt(a, p.pos[1] - (foundationTop > -Infinity ? foundationTop : ground));
+      md += p.st.mass * phi * phi;
+      spec ?? (spec = p.spec.damper);
+    }
+    const sys = { M: a.modalMass, K: a.modalStiffness, C: 2 * cfg.damping * a.omega * a.modalMass };
+    w.mu = 0;
+    if (md > 0 && a.modalMass > 0) {
+      w.mu = md / a.modalMass;
+      const tuned = damperTuning(w.mu, cfg.tuning);
+      const f = spec?.frequency ?? tuned.frequency * a.frequency;
+      const zeta = spec?.damping ?? tuned.damping;
+      sys.damper = { m: md, k: md * (2 * Math.PI * f) ** 2, c: 2 * zeta * md * 2 * Math.PI * f };
+    }
+    w.sys = a.modalMass > 0 && a.omega > 0 ? sys : null;
+    const st = {
+      speed: cfg.speed,
+      pressure: a.pressure,
+      shear: a.shear,
+      moment: a.moment,
+      deflection: a.deflection,
+      drift: a.drift,
+      limit: cfg.driftLimit,
+      overturn: Math.min(a.overturn, 1e3),
+      frequency: a.frequency,
+      lean: a.lean,
+      sway: w.dyn.x,
+      peak: w.dyn.peak,
+      status: a.overturn > 1 ? "overturn" : a.drift > cfg.driftLimit ? "drift" : "ok"
+    };
+    if (sys.damper) st.damper = { ratio: w.mu, travel: w.dyn.y - w.dyn.x };
+    o.st.wind = st;
+  };
+  const stepWind = (o, dt) => {
+    const w = o.wind;
+    const a = w.analysis;
+    const st = o.st.wind;
+    if (!a || !st || !w.sys) return;
+    const gust = w.gust;
+    const I = a.intensity;
+    const force = (t) => {
+      const n = gustAt(gust, t);
+      return a.modalForce * (2 * I * n + I * I * (n * n - 1));
+    };
+    const wn = Math.max(a.omega, w.sys.damper ? Math.sqrt(w.sys.damper.k / w.sys.damper.m) : 0);
+    stepSway(w.dyn, w.sys, time - dt, dt, force, 2 * Math.PI / wn / 20);
+    const d = w.dyn;
+    d.peak = Math.max(Math.abs(d.x), d.peak * Math.exp(-dt / w.cfg.peakDecay));
+    st.sway = d.x;
+    st.peak = d.peak;
+    if (st.damper) st.damper.travel = d.y - d.x;
+    const e = w.emitted;
+    if (d.peak < e.peak * 0.8) e.peak = d.peak;
+    if (st.status !== e.status || time - e.t >= 0.5 && d.peak > e.peak * 1.05 + 1e-3) {
+      w.emitted = { t: time, peak: d.peak, status: st.status };
+      const dir = windDirection(o, w.cfg);
+      const world2 = rotateVec(o.base.rot, [dir[0], 0, dir[1]]);
+      emit({ ...base(o), type: "sway", sway: d.x, peak: d.peak, drift: st.drift, overturn: st.overturn, frequency: st.frequency, direction: world2, status: st.status });
+    }
+  };
+  const isTerrain = (p) => !!p.spec.tags?.includes("terrain");
+  const isFoundation = (p) => p.spec.structure?.role === "foundation" && !isLost(p);
+  const slopeTilt = (a, b) => Math.atan(Math.hypot(a, b));
+  const soilSprings = (o, profile) => {
+    const found = o.parts.filter(isFoundation);
+    const box = (p) => aabbOf(p.spec.shape, p.pos, p.q);
+    const surface = profile.surface ?? Math.max(...found.map((p) => box(p).max[1]));
+    const prints = [];
+    for (const f of found) {
+      const b = box(f);
+      if (!isTerrain(f)) {
+        prints.push({ x0: b.min[0], x1: b.max[0], z0: b.min[2], z1: b.max[2], bottom: b.min[1], part: f });
+        continue;
+      }
+      const fi = o.idx.get(f.spec.id);
+      const width = profile.footingWidth ?? soilCfg.footingWidth;
+      for (const j of o.byPart.get(f.spec.id)) {
+        if (j.st.open || !j.bears) continue;
+        const r = j.ia === fi ? j.ib : j.ia;
+        const q = o.parts[r];
+        if (!q.structural || isLost(q) || restsOn(o, j, r) !== fi) continue;
+        const c = box(q);
+        const x0 = Math.max(c.min[0], b.min[0]), x1 = Math.min(c.max[0], b.max[0]), z0 = Math.max(c.min[2], b.min[2]), z1 = Math.min(c.max[2], b.max[2]);
+        const cx = (x0 + x1) / 2, cz = (z0 + z1) / 2;
+        const wx = Math.max(width, x1 - x0), wz = Math.max(width, z1 - z0);
+        prints.push({ x0: cx - wx / 2, x1: cx + wx / 2, z0: cz - wz / 2, z1: cz + wz / 2, bottom: c.min[1], part: q });
+      }
+    }
+    const springs = [];
+    for (const fp of prints) {
+      const wx = Math.max(0.01, fp.x1 - fp.x0), wz = Math.max(0.01, fp.z1 - fp.z0);
+      const depth = Math.max(0, surface - fp.bottom);
+      const pile = fp.part.spec.structure?.role === "foundation" ? fp.part.spec.structure.pile : void 0;
+      if (pile) {
+        const count = Math.max(1, Math.round(pile.count ?? 1));
+        const nx2 = Math.ceil(Math.sqrt(count)), nz2 = Math.ceil(count / nx2);
+        const cap = pileCapacity(profile, pile, depth, soilCfg.byId).ultimate;
+        const tip = soilAt(profile, depth + pile.length, soilCfg.byId);
+        const k = pileStiffness(pile, fp.part.mat.strength?.elasticGPa ?? soilCfg.pileElasticGPa, tip.elasticMPa, tip.poisson);
+        for (let i = 0; i < count; i++) {
+          const col = i % nx2, row = Math.floor(i / nx2);
+          springs.push({ key: `${fp.part.spec.id}#${i}`, x: fp.x0 + (col + 0.5) * wx / nx2, z: fp.z0 + (row + 0.5) * wz / nz2, hx: wx / (2 * nx2), hz: wz / (2 * nz2), k, cap });
+        }
+        continue;
+      }
+      const B = Math.min(wx, wz);
+      const g = footingSoil(profile, depth, B, soilCfg.byId, soilCfg.influence);
+      const ks = subgradeModulus(g.elasticMPa, g.poisson, B, soilCfg.rigidity);
+      const size = Math.max(wx, wz) / Math.max(1, soilCfg.cells);
+      const nx = Math.max(1, Math.round(wx / size)), nz = Math.max(1, Math.round(wz / size));
+      const area = wx * wz / (nx * nz);
+      for (let i = 0; i < nx; i++) {
+        for (let k = 0; k < nz; k++) {
+          springs.push({ key: `${fp.part.spec.id}#${i}.${k}`, x: fp.x0 + (i + 0.5) * wx / nx, z: fp.z0 + (k + 0.5) * wz / nz, hx: wx / (2 * nx), hz: wz / (2 * nz), k: ks * area, cap: soilCfg.safety * g.allowableKPa * 1e3 * area });
+        }
+      }
+    }
+    return { springs, baseY: prints.length ? Math.min(...prints.map((fp) => fp.bottom)) : 0 };
+  };
+  const soilWeight = (o) => {
+    let m = 0;
+    const c = [0, 0, 0];
+    for (const p of o.parts) {
+      if (isLost(p) || isTerrain(p) || o.collapsed.has(p.spec.id) || o.unsup[o.idx.get(p.spec.id)]) continue;
+      m += p.st.mass;
+      for (let k = 0; k < 3; k++) c[k] += p.st.mass * p.pos[k];
+    }
+    return { w: m * GRAVITY, c: m > 0 ? [c[0] / m, c[1] / m, c[2] / m] : c };
+  };
+  const initSoil = (o, profile, carried, carrySets) => {
+    const so = { profile, s: 0, a: 0, b: 0, imp: [0, 0], pivot: [0, 0, 0], dirty: true, sets: /* @__PURE__ */ new Map(), emitted: { t: -Infinity, s: 0, tilt: 0, status: "stable" } };
+    const { springs, baseY } = soilSprings(o, profile);
+    if (!springs.length) return;
+    const [x0, z0] = stiffnessCentre(springs);
+    so.pivot = [x0, baseY, z0];
+    let ix = 0, iz = 0;
+    for (const sp of springs) {
+      ix += sp.k * (sp.x - x0) ** 2;
+      iz += sp.k * (sp.z - z0) ** 2;
+    }
+    const { c } = soilWeight(o);
+    const along = ix <= iz ? 0 : 1;
+    const off = along === 0 ? c[0] - x0 : c[2] - z0;
+    const sign = Math.abs(off) > 1e-6 ? Math.sign(off) : 1;
+    so.imp = along === 0 ? [sign * soilCfg.imperfection, 0] : [0, sign * soilCfg.imperfection];
+    if (carried) {
+      const t = Math.tan(carried.tilt * Math.PI / 180);
+      so.s = carried.settlement;
+      so.a = t * carried.direction[0];
+      so.b = t * carried.direction[2];
+      so.emitted = { t: -Infinity, s: carried.settlement, tilt: carried.tilt, status: carried.status };
+      o.st.soil = clone(carried);
+      for (const [k, v] of Object.entries(carrySets ?? {})) so.sets.set(k, v);
+      if (carried.status === "toppled") for (const p of o.parts) p.anchored = false;
+    }
+    o.soil = so;
+    applySoilPose(o);
+  };
+  const applySoilPose = (o) => {
+    const so = o.soil;
+    if (!so) {
+      o.st.position = [o.base.pos[0], o.base.pos[1], o.base.pos[2]];
+      o.st.rotation = [o.base.rot[0], o.base.rot[1], o.base.rot[2], o.base.rot[3]];
+      return;
+    }
+    const angle = slopeTilt(so.a, so.b);
+    const R = angle > 1e-12 ? quat.fromAxisAngle(vec.normalize([so.b, 0, -so.a]), angle) : quat.identity();
+    const t = vec.sub(vec.sub(so.pivot, rotateVec(R, so.pivot)), [0, so.s, 0]);
+    o.st.rotation = quat.normalize(quat.mul(o.base.rot, R));
+    o.st.position = vec.add(o.base.pos, rotateVec(o.base.rot, t));
+    const lean = Math.hypot(so.a, so.b);
+    const st = o.st.soil ?? { settlement: 0, tilt: 0, direction: [0, 0, 0], bearing: 0, edge: 0, status: "stable", offset: { position: [0, 0, 0], rotation: [0, 0, 0, 1] } };
+    st.settlement = so.s;
+    st.tilt = angle * 180 / Math.PI;
+    st.direction = lean > 1e-12 ? [so.a / lean, 0, so.b / lean] : [0, 0, 0];
+    st.offset = { position: t, rotation: R };
+    o.st.soil = st;
+  };
+  const topple = (o, src) => {
+    for (const p of o.parts) p.anchored = false;
+    solveStructure(o);
+    recomputeGroups(o);
+    if (!pendingCollapse.has(o)) pendingCollapse.set(o, src);
+  };
+  const settleSoil = (o, dt) => {
+    const so = o.soil;
+    const st = o.st.soil;
+    if (st?.status === "toppled") return;
+    const { springs } = soilSprings(o, so.profile);
+    for (const sp of springs) sp.set = so.sets.get(sp.key) ?? 0;
+    const { w, c } = soilWeight(o);
+    if (!springs.length || w <= 0) {
+      if (springs.length === 0 && w > 0) {
+        so.s += soilCfg.sinkRate * dt;
+        applySoilPose(o);
+        o.st.soil.status = "yielding";
+      }
+      return;
+    }
+    const height = Math.max(0, c[1] - so.pivot[1]);
+    const wa = o.wind?.analysis;
+    const push = wa ? windDirection(o, o.wind.cfg) : [0, 0];
+    const shift = wa ? wa.moment / w : 0;
+    const r = solveFoundation(springs, w, c[0] + shift * push[0], c[2] + shift * push[1], height, so.imp, { s: so.s, a: so.a, b: so.b });
+    let status = "stable";
+    const sinkStep = soilCfg.sinkRate * dt;
+    const tiltStep = Math.tan(soilCfg.tiltRate * Math.PI / 180) * dt;
+    if (r.stable && (!r.yielded || dt === 0)) {
+      so.s = r.s;
+      so.a = r.a;
+      so.b = r.b;
+    } else if (r.stable) {
+      const ds = r.s - so.s, da = r.a - so.a, db = r.b - so.b;
+      const fs = Math.abs(ds) > sinkStep ? sinkStep / Math.abs(ds) : 1;
+      const lean2 = Math.hypot(da, db);
+      const ft = lean2 > tiltStep ? tiltStep / lean2 : 1;
+      so.s += ds * fs;
+      so.a += da * ft;
+      so.b += db * ft;
+      if (fs < 1 || ft < 1) status = "yielding";
+    } else {
+      status = "yielding";
+      if (dt === 0) {
+        so.s = w / springs.reduce((sum, sp) => sum + sp.k, 0);
+      } else {
+        so.s += sinkStep * (r.bearing >= 1 ? 1 : 0.25);
+        const lean2 = Math.hypot(so.a, so.b);
+        const ux = lean2 > 1e-9 ? so.a / lean2 : Math.sign(so.imp[0]), uz = lean2 > 1e-9 ? so.b / lean2 : Math.sign(so.imp[1]);
+        so.a += ux * tiltStep;
+        so.b += uz * tiltStep;
+      }
+    }
+    if (so.s !== 0 || so.a !== 0 || so.b !== 0) {
+      const sets = yieldSprings(springs, so.s, so.a, so.b);
+      springs.forEach((sp, i) => {
+        if (sets[i] > 0) so.sets.set(sp.key, sets[i]);
+      });
+    }
+    applySoilPose(o);
+    const out = o.st.soil;
+    out.bearing = r.bearing;
+    out.edge = r.edge;
+    out.status = status;
+    const lean = Math.hypot(so.a, so.b);
+    if (lean > 1e-9) {
+      const [x0, z0] = [so.pivot[0], so.pivot[2]];
+      const ux = so.a / lean, uz = so.b / lean;
+      const e = (c[0] - x0 + height * (so.a + so.imp[0])) * ux + (c[2] - z0 + height * (so.b + so.imp[1])) * uz;
+      let edge = 0;
+      for (const sp of springs) edge = Math.max(edge, (sp.x - x0) * ux + (sp.z - z0) * uz + sp.hx * Math.abs(ux) + sp.hz * Math.abs(uz));
+      if (e > edge || slopeTilt(so.a, so.b) > Math.PI / 3) out.status = "toppled";
+    }
+  };
+  const stepSoil = (o, dt) => {
+    const so = o.soil;
+    if (o.st.soil?.status === "toppled") return;
+    if (!so.dirty && o.st.soil?.status !== "yielding") return;
+    so.dirty = false;
+    settleSoil(o, dt);
+    const st = o.st.soil;
+    const e = so.emitted;
+    const changed = st.status !== e.status || (time - e.t >= 0.5 || e.t === -Infinity) && (Math.abs(st.tilt - e.tilt) > 0.01 || Math.abs(st.settlement - e.s) > 2e-3);
+    if (changed) {
+      so.emitted = { t: time, s: st.settlement, tilt: st.tilt, status: st.status };
+      emit({ ...base(o), type: "settle", settlement: st.settlement, tilt: st.tilt, direction: rotateVec(o.base.rot, st.direction), bearing: st.bearing, status: st.status });
+    }
+    if (st.status === "toppled") topple(o);
   };
   const collapseCheck = (o, src) => {
     if (!o.hasStructure || !o.parts.some((p) => p.anchored)) return;
@@ -2151,7 +3567,7 @@ var createDestruction = (options = {}) => {
     if (split && mine.length) amount /= mine.length;
     for (const j of mine) {
       if (j.st.open) continue;
-      if (j.spec.kind === "rebar" && (o.parts[j.ia].spec.reinforcement || o.parts[j.ib].spec.reinforcement)) continue;
+      if (j.spec.kind === "rebar" && (isReinforced(o.parts[j.ia].spec) || isReinforced(o.parts[j.ib].spec))) continue;
       if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
       j.st.hp -= amount;
       if (j.st.hp <= 0) {
@@ -2307,14 +3723,37 @@ var createDestruction = (options = {}) => {
     debris(o, p, "sparks", partXf(o, p).c, [0, 1, 0], 6, 3, src);
     partLost(o, p, src);
   };
-  const failPart = (o, p, origin, dir, fragEnergy, cap, src) => {
+  const hingeDrop = (o, p, src) => {
+    const i = o.idx.get(p.spec.id);
+    const opened = [];
+    for (const j of o.byPart.get(p.spec.id) ?? []) {
+      if (j.st.open || restsOn(o, j, i) < 0) continue;
+      j.st.open = true;
+      j.st.hp = 0;
+      j.st.openedBy = "break";
+      opened.push(j);
+    }
+    p.st.hp = Math.max(1, p.st.maxHp * 0.1);
+    p.st.cracked = true;
+    markDamaged(p);
+    debris(o, p, p.mat.breakDebris, partXf(o, p).c, [0, -1, 0], 12, 2, src);
+    solveStructure(o);
+    recomputeGroups(o);
+    detachEvents(o, opened, "break", src);
+    collapseCheck(o, src);
+  };
+  const failPart = (o, p, origin, dir, fragEnergy, cap, src, force) => {
     if (isLost(p)) return;
     if (p.st.stripped) {
       loseCage(o, p, src);
       return;
     }
+    if (!force && p.bend && (p.st.flexure ?? 0) > 1 && sectionOf(p, p.bend.gravity).reinforced) {
+      hingeDrop(o, p, src);
+      return;
+    }
     const ex = p.spec.explodes;
-    const style = p.mat.fracture === "none" ? "snap" : p.mat.fracture;
+    const style = force ?? (p.snap ? "snap" : p.mat.fracture === "none" ? "snap" : p.mat.fracture);
     const { c, q } = partXf(o, p);
     const hitW = origin ?? c;
     const grain = p.spec.grain ? AXIS[p.spec.grain] : void 0;
@@ -2371,8 +3810,8 @@ var createDestruction = (options = {}) => {
       return;
     }
     if (ex) {
-      emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
-      blasts.push({ point: c, energy: ex.energy, radius: ex.radius, source: src });
+      emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
+      blasts.push({ point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, source: src });
     }
     partLost(o, p, src);
   };
@@ -2401,8 +3840,33 @@ var createDestruction = (options = {}) => {
     else if (chained && (trigger === "explosion" || 1 - p.st.hp / p.st.maxHp >= shotDamageFractionOf(p.spec))) prime(o, p, trigger, src);
     return done;
   };
-  const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src, piercing = 1) => {
+  const leaksFlammable = (p) => {
+    const c = p.spec.contains;
+    return !!c && FLAMMABLE_FLUIDS.includes(c.fluid) && (p.st.liters ?? 0) > 0 && p.st.holes.some((h) => h.through);
+  };
+  const rollIgnition = (o, p, round) => {
+    const c = p.spec.contains;
+    if (!c || !FLAMMABLE_FLUIDS.includes(c.fluid) || p.rt.jet || p.rt.lit) return;
+    const fill = c.liters > 0 ? (p.st.liters ?? 0) / c.liters : 0;
+    const chance = ignitionChance(round, { sparkTarget: sparkTargetFactor(p.mat.id, !!p.mat.tags?.includes("metal"), ignitionRules), fill, fluid: c.fluid }, ignitionRules);
+    if (chance > 0 && rnd() < chance) {
+      p.rt.lit = true;
+      o.active = true;
+    }
+  };
+  const lightLeaksNear = (centre, radius) => {
+    for (const o of objects.values()) {
+      for (const q of o.parts) {
+        if (isLost(q) || q.rt.lit || q.rt.jet || !leaksFlammable(q)) continue;
+        if (vec.distance(partXf(o, q).c, centre) - q.bound > radius) continue;
+        q.rt.lit = true;
+        o.active = true;
+      }
+    }
+  };
+  const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src, round = {}) => {
     const mat = p.mat;
+    const piercing = round.piercing ?? 1;
     if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry))) {
       return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry, d, Math.min(pathLen, p.thickness)), damage: 0 };
     }
@@ -2415,7 +3879,8 @@ var createDestruction = (options = {}) => {
     const coats = p.layers.length > 0 ? layersEnergy(p.layers, p.rt.spalls, face, objLocal(o, entry)) + layersEnergy(p.layers, p.rt.spalls, -face, exitLocal) : 0;
     const thr = coats > 0 ? (mat.penetration * p.thickness * 1e3 + coats) / slant : mat.penetration * effM * 1e3;
     const hard = mat.tags?.includes("metal") || mat.tags?.includes("masonry");
-    const Ep = piercing === 1 || !hard ? E : E * piercing;
+    const penMm = penetrationOf(mat, round.penetration);
+    const Ep = penMm !== void 0 ? penMm * mat.penetration : piercing === 1 || !hard ? E : E * piercing;
     const penetrated = Ep > thr;
     const scale = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
     const id = p.spec.id;
@@ -2436,6 +3901,7 @@ var createDestruction = (options = {}) => {
       const hole = addHole(o, p, entry, n, caliber / 1e3 * (mat.ductility >= 0.3 ? 1 : 1.5), true, exitPoint, src);
       if (p.layers.length > 0) spallOuter(o, p, exitPoint, -face, vec.scale(n, -1), Math.max(0.03, caliber / 1e3 * 4), src);
       addBreach(o, p, entry, Math.PI * (hole.diameter / 2) * (hole.diameter / 2), E, d, src);
+      if (mat.ductility >= 0.5 && p.thickness <= THIN_SHEET_DISHING) addDent(o, p, entry, n, Math.max(caliber * 3 / 1e3, 0.012), clamp2(E * 2e-5, 1e-3, 0.03), src);
       if (brittle && mat.fracture === "shatter") addCrack(o, p, entry, n, crackLen, src);
       if (p.spec.contains && (p.st.liters ?? 0) > 0) {
         emit({
@@ -2444,10 +3910,11 @@ var createDestruction = (options = {}) => {
           part: id,
           fluid: p.spec.contains.fluid,
           point: entry,
-          direction: n,
+          direction: p.spec.contains.outflow ? vec.normalize(rotateVec(o.st.rotation, rotateVec(p.q, p.spec.contains.outflow))) : n,
           rate: holeRate(hole, !!p.spec.contains.pressurized),
           pressurized: !!p.spec.contains.pressurized
         });
+        rollIgnition(o, p, round);
       }
     } else if (mat.ductility >= 0.5) {
       addDent(o, p, entry, n, Math.max(caliber * 3 / 1e3, 0.012), clamp2(Math.min(Math.max(p.thickness * 3, 3e-3), ratio * 0.01), 1e-3, 0.05), src);
@@ -2458,7 +3925,7 @@ var createDestruction = (options = {}) => {
     debris(o, p, mat.hitDebris, entry, n, clamp2(Math.round(E / 60) + 2, 2, 14), clamp2(Math.sqrt(E) / 6, 1, 8), src);
     wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true);
     const dmg = applyDamage(o, p, E * DMG_PER_J * scale, "ballistic", entry, d, E * 0.1, 12, src);
-    return { penetrated, exitEnergy: penetrated ? E - thr / (hard ? piercing : 1) : 0, exitPoint, damage: dmg };
+    return { penetrated, exitEnergy: penetrated ? penMm !== void 0 ? E * (1 - thr / Ep) : E - thr / (hard ? piercing : 1) : 0, exitPoint, damage: dmg };
   };
   const melee = (o, p, kind, E, point, n, d, contactR, src) => {
     const mat = p.mat;
@@ -2478,8 +3945,9 @@ var createDestruction = (options = {}) => {
       }
       debris(o, p, mat.hitDebris, point, n, clamp2(Math.round(E / 25) + 1, 1, 10), clamp2(Math.sqrt(E) / 8, 1, 6), src);
     }
-    if (kind === "blunt") wearJoints(o, p, E * 0.3, void 0, 0, src);
-    else wearJoints(o, p, E * 0.3, point, 0.06, src);
+    if (kind === "blunt") {
+      if (!(p.anchored && p.spec.tags?.includes("terrain"))) wearJoints(o, p, E * 0.3, void 0, 0, src);
+    } else wearJoints(o, p, E * 0.3, point, 0.06, src);
     if (kind === "blunt" && E > 0 && p.layers.length > 0) spallOuter(o, p, point, faceOf(o, p, n), n, Math.max(contactR, 0.05), src);
     const scale = mat.damageScale?.[kind] ?? 1;
     const done = applyDamage(o, p, Ec * DMG_PER_J * scale * (kind === "slash" ? p.cutFactor : 1), kind, point, d, E * 0.1, 12, src);
@@ -2526,7 +3994,8 @@ var createDestruction = (options = {}) => {
     if (Ein > 20 && p.layers.length > 0) spallOuter(o, p, wp, faceOf(o, p, wn), wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), src);
     const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
     res.damage += dealt;
-    if (dist <= breachBlastReach * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
+    if (p.bend && flexure.enabled) bendByBlast(o, p, point, energy, radius, reach, src);
+    if (dist <= BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
     return reach;
   };
   const blastObject = (o, point, energy, radius, src) => {
@@ -2589,7 +4058,7 @@ var createDestruction = (options = {}) => {
   };
   const FLAG_LOST = 1;
   const FLAG_OPEN = 2;
-  const blastPlain = (point, energy, radius, src) => {
+  const blastPlain = (point, energy, radius, src, lethal) => {
     const out = [];
     for (const o of [...objects.values()]) {
       if (vec.distance(toWorld(o.st.position, o.st.rotation, o.bc), point) - o.br >= radius) continue;
@@ -2597,7 +4066,7 @@ var createDestruction = (options = {}) => {
       if (r.part) out.push(r);
     }
     for (const im of [...impls.values()]) {
-      if (implInRange(im, point, radius)) out.push(implHit(im, { type: "explosive", point, energy, radius, ...src !== void 0 ? { source: src } : {} }));
+      if (implInRange(im, point, radius)) out.push(implHit(im, { type: "explosive", point, energy, radius, ...lethal !== void 0 ? { lethalRadius: lethal } : {}, ...src !== void 0 ? { source: src } : {} }));
     }
     return out;
   };
@@ -2606,7 +4075,7 @@ var createDestruction = (options = {}) => {
     return { ps, c: toWorld(im.position, im.rotation, ov?.pos ?? ps.position), q: quat.mul(im.rotation, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0])) };
   });
   const implInRange = (im, point, radius) => implParts(im).some(({ ps, c, q }) => distanceToShape(ps.shape, toLocal(c, q, point)) < radius);
-  const blastScene = (point, energy, radius, src, cfg, only) => {
+  const blastScene = (point, energy, radius, src, cfg, only, lethal) => {
     const mult = confinementOf(cfg.conf, point, radius);
     const E = energy * mult;
     const shelter = cfg.shelter;
@@ -2713,7 +4182,7 @@ var createDestruction = (options = {}) => {
           den += f;
         }
         const k = den > 0 ? num / den : 1;
-        const res = implHit(im, { type: "explosive", point, energy: E * k, radius, ...shelter ? { shelter: k } : {}, ...src !== void 0 ? { source: src } : {} });
+        const res = implHit(im, { type: "explosive", point, energy: E * k, radius, ...lethal !== void 0 ? { lethalRadius: lethal } : {}, ...shelter ? { shelter: k } : {}, ...src !== void 0 ? { source: src } : {} });
         results.set(im, res);
         report(im).shelter = k;
       }
@@ -2811,10 +4280,11 @@ var createDestruction = (options = {}) => {
     if (!rep) reports.set(key, rep = { shelter: 1, confinement: mult, fragmentHits: 0 });
     rep.fragmentHits++;
   };
-  const blastWorld = (point, energy, radius, src, call, only) => {
+  const blastWorld = (point, energy, radius, src, call, only, lethal) => {
     const cfg = blastCfg(call);
-    if (!cfg.shelter && !cfg.frag && cfg.conf === null) return blastPlain(point, energy, radius, src);
-    return blastScene(point, energy, radius, src, cfg, only);
+    const res = !cfg.shelter && !cfg.frag && cfg.conf === null ? blastPlain(point, energy, radius, src, lethal) : blastScene(point, energy, radius, src, cfg, only, lethal);
+    lightLeaksNear(point, radius);
+    return res;
   };
   const heatObject = (o, point, T, radius, duration, src) => {
     const start = cur.length;
@@ -2833,6 +4303,7 @@ var createDestruction = (options = {}) => {
         p.st.temperature += (T - p.st.temperature) * (1 - Math.exp(-k * duration));
       }
       o.active = true;
+      if (T >= FLAME_LIGHTS_LEAK_C && !p.rt.jet && !p.rt.lit && leaksFlammable(p)) p.rt.lit = true;
       checkIgnite(o, p, src);
     }
     res.events = cur.slice(start);
@@ -2852,7 +4323,7 @@ var createDestruction = (options = {}) => {
     if (hit.type === "ballistic") {
       const loc = locate(o, point, dir, 0.05, only);
       if (loc) {
-        const out = ballistic(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src, hit.piercing ?? 1);
+        const out = ballistic(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src, hit);
         res = { ...res, part: loc.p.spec.id, point: loc.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy };
       }
     } else if (hit.type === "blunt" || hit.type === "slash") {
@@ -3006,7 +4477,8 @@ var createDestruction = (options = {}) => {
         if (rate > 0) {
           s.liters = Math.max(0, (s.liters ?? 0) - rate * dt);
           hot = true;
-          if (FLAMMABLE_FLUIDS.includes(cont.fluid) && s.temperature >= 350 && !p.rt.jet) {
+          if (FLAMMABLE_FLUIDS.includes(cont.fluid) && (s.temperature >= 350 || p.rt.lit) && !p.rt.jet) {
+            p.rt.lit = false;
             if (ex && chainDelayOf(p.spec, "fire") !== void 0) {
               prime(o, p, "fire");
               continue;
@@ -3021,6 +4493,7 @@ var createDestruction = (options = {}) => {
           }
         }
       }
+      if ((s.liters ?? 0) <= 0) p.rt.lit = false;
       if (p.rt.jet && (s.liters ?? 0) <= 0) {
         p.rt.jet = false;
         s.burning = false;
@@ -3070,6 +4543,25 @@ var createDestruction = (options = {}) => {
     }
     o.active = hot;
   };
+  const igniteLeaksNearFire = (sources, dt) => {
+    const { radius, chancePerSecond } = ignitionRules.fireNear;
+    if (chancePerSecond <= 0) return;
+    const chance = 1 - Math.exp(-chancePerSecond * dt);
+    for (const src of sources) {
+      if (!src.p.st.burning && !src.p.rt.jet) continue;
+      const sc = partXf(src.o, src.p).c;
+      for (const o of objects.values()) {
+        for (const q of o.parts) {
+          if (q === src.p || isLost(q) || q.rt.lit || q.rt.jet || !leaksFlammable(q)) continue;
+          if (vec.distance(partXf(o, q).c, sc) - q.bound - src.p.bound > radius) continue;
+          if (rnd() < chance) {
+            q.rt.lit = true;
+            o.active = true;
+          }
+        }
+      }
+    }
+  };
   const spread2 = (sources, dt) => {
     for (const src of sources) {
       if (!src.p.st.burning && !src.p.rt.jet) continue;
@@ -3195,8 +4687,8 @@ var createDestruction = (options = {}) => {
         return;
       }
       const o = getObj(id);
-      o.st.position = [position[0], position[1], position[2]];
-      o.st.rotation = [rotation[0], rotation[1], rotation[2], rotation[3]];
+      o.base = { pos: [position[0], position[1], position[2]], rot: [rotation[0], rotation[1], rotation[2], rotation[3]] };
+      applySoilPose(o);
     },
     splitGroup(id, group, newId) {
       if (impls.has(id)) throw new Error(`object "${id}" is a registered DestructibleImpl and cannot be split; its module owns its pieces`);
@@ -3219,13 +4711,17 @@ var createDestruction = (options = {}) => {
         const s = { parts: o.spec.parts.filter((p) => keep(p.id)), joints: (o.spec.joints ?? []).filter((j) => keep(j.a) && keep(j.b)) };
         if (o.spec.name !== void 0) s.name = o.spec.name;
         if (o.spec.tags) s.tags = [...o.spec.tags];
+        if (o.spec.soil !== void 0) s.soil = o.spec.soil;
         return clone(s);
       };
       const inNew = (pid) => moved.has(pid);
       const inOld = (pid) => !moved.has(pid);
       const pos = o.st.position, rot = o.st.rotation;
       const fresh = build(sub(inNew), nid, pos, rot, carryFor(inNew, (a, b) => inNew(a) && inNew(b)));
-      const rest = build(sub(inOld), id, pos, rot, carryFor(inOld, (a, b) => !(inNew(a) && inNew(b))));
+      const restCarry = carryFor(inOld, (a, b) => !(inNew(a) && inNew(b)));
+      if (o.st.soil) restCarry.soil = o.st.soil;
+      if (o.soil?.sets.size) restCarry.soilSets = Object.fromEntries(o.soil.sets);
+      const rest = build(sub(inOld), id, o.soil ? o.base.pos : pos, o.soil ? o.base.rot : rot, restCarry);
       objects.set(id, rest);
       objects.set(nid, fresh);
       return nid;
@@ -3250,7 +4746,8 @@ var createDestruction = (options = {}) => {
       const r = raycastInternal(origin, direction, maxDistance);
       return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
     },
-    shoot(origin, direction, energy, caliber, source, piercing) {
+    shoot(origin, direction, energy, caliber, source, round) {
+      const extras = typeof round === "number" ? { piercing: round } : round ?? {};
       return withCollapses(run(() => {
         const results = [];
         const d = vec.normalize(direction);
@@ -3262,7 +4759,7 @@ var createDestruction = (options = {}) => {
           if (!rh) break;
           const im = impls.get(rh.object);
           if (im) {
-            const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...piercing !== void 0 ? { piercing } : {}, ...source !== void 0 ? { source } : {} });
+            const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...extras, ...source !== void 0 ? { source } : {} });
             r.part = rh.part;
             r.point = rh.point;
             r.exitEnergy = r.penetrated ? E * 0.5 : 0;
@@ -3276,7 +4773,7 @@ var createDestruction = (options = {}) => {
           const o = getObj(rh.object);
           const p = getPart(o, rh.part);
           const start = cur.length;
-          const out = ballistic(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source, piercing ?? 1);
+          const out = ballistic(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source, extras);
           results.push({ object: o.id, part: p.spec.id, point: rh.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy, events: cur.slice(start) });
           ignore.add(`${o.id}\0${p.spec.id}`);
           if (!out.penetrated || !out.exitPoint) break;
@@ -3375,6 +4872,52 @@ var createDestruction = (options = {}) => {
         o.active = true;
       });
     },
+    setWind(next) {
+      windOpts = { ...windOpts, ...Object.fromEntries(Object.entries(next).filter(([, v]) => v !== void 0)) };
+      windCfg = resolveWind(windOpts);
+      for (const o of objects.values()) {
+        if (!o.hasStructure || o.spec.wind === false) continue;
+        o.wind ?? (o.wind = newWind(o));
+        o.dirty = true;
+        o.active = true;
+      }
+    },
+    vent(objectId, partId, opening = {}) {
+      if (impls.has(objectId)) return false;
+      const o = getObj(objectId);
+      const p = getPart(o, partId);
+      const c = p.spec.contains;
+      if (!c || isLost(p) || (p.st.liters ?? 0) <= 0) return false;
+      if (p.st.holes.some((h) => h.vent)) return true;
+      return run(() => {
+        const wp = opening.point ?? partXf(o, p).c;
+        const wn = vec.normalize(opening.normal ?? [0, 1, 0]);
+        const hole = { point: objLocal(o, wp), normal: objLocalDir(o, wn), diameter: opening.diameter ?? VENT_DIAMETER, through: true, vent: true };
+        p.st.holes.push(hole);
+        if (p.st.holes.length > maxHoles) p.st.holes.shift();
+        o.active = true;
+        emit({
+          ...base(o),
+          type: "leak",
+          part: partId,
+          fluid: c.fluid,
+          point: wp,
+          direction: c.outflow ? vec.normalize(rotateVec(o.st.rotation, rotateVec(p.q, c.outflow))) : wn,
+          rate: holeRate(hole, !!c.pressurized),
+          pressurized: !!c.pressurized
+        });
+        return true;
+      }).value;
+    },
+    seal(objectId, partId) {
+      if (impls.has(objectId)) return 0;
+      const o = getObj(objectId);
+      const p = getPart(o, partId);
+      const before = p.st.holes.length;
+      p.st.holes = p.st.holes.filter((h) => !h.vent);
+      o.active = true;
+      return before - p.st.holes.length;
+    },
     setLiters(objectId, partId, liters) {
       if (impls.has(objectId)) return;
       const p = getPart(getObj(objectId), partId);
@@ -3388,7 +4931,12 @@ var createDestruction = (options = {}) => {
         time += dt;
         const sources = [];
         for (const o of [...objects.values()]) if (o.active) stepObject(o, dt, sources);
-        if (sources.length) spread2(sources, dt);
+        for (const o of [...objects.values()]) if (o.soil && objects.get(o.id) === o) stepSoil(o, dt);
+        for (const o of [...objects.values()]) if (o.wind && objects.get(o.id) === o) stepWind(o, dt);
+        if (sources.length) {
+          spread2(sources, dt);
+          igniteLeaksNearFire(sources, dt);
+        }
         detonatePrimed(time);
         releaseFront();
         for (const im of [...impls.values()]) {
@@ -3410,7 +4958,7 @@ var createDestruction = (options = {}) => {
         return;
       }
       const o = getObj(id);
-      objects.set(id, build(o.spec, id, o.st.position, o.st.rotation));
+      objects.set(id, build(o.spec, id, o.base.pos, o.base.rot));
     },
     on(type, fn) {
       let set = listeners.get(type);
@@ -3427,7 +4975,7 @@ var createDestruction = (options = {}) => {
         rng: rng.state(),
         counter,
         objects: [...objects.values()].map((o) => {
-          const runtime = { parts: {}, joints: {}, collapsed: [...o.collapsed] };
+          const runtime = { parts: {}, joints: {}, collapsed: [...o.collapsed], ...o.soil?.sets.size ? { soil: Object.fromEntries(o.soil.sets) } : {}, ...o.wind ? { wind: [o.wind.dyn.x, o.wind.dyn.v, o.wind.dyn.y, o.wind.dyn.w, o.wind.dyn.peak] } : {} };
           for (const p of o.parts) runtime.parts[p.spec.id] = clone(p.rt);
           for (const j of o.joints) runtime.joints[j.spec.id] = j.step;
           return { id: o.id, spec: clone(o.spec), state: clone(o.st), runtime };
@@ -3448,9 +4996,17 @@ var createDestruction = (options = {}) => {
             state.parts.map((st) => [st.id, { st, rt: e.runtime?.parts[st.id] ? clone(e.runtime.parts[st.id]) : { ...freshRuntime(), prevTemp: st.temperature } }])
           ),
           joints: new Map(state.joints.map((st) => [st.id, { st, step: e.runtime?.joints[st.id] ?? 0 }])),
-          collapsed: e.runtime?.collapsed
+          collapsed: e.runtime?.collapsed,
+          ...e.runtime?.wind ? { wind: e.runtime.wind } : {}
         };
-        objects.set(e.id, build(clone(e.spec), e.id, state.position, state.rotation, carry));
+        let pos = state.position, rot = state.rotation;
+        if (state.soil) {
+          carry.soil = state.soil;
+          if (e.runtime?.soil) carry.soilSets = e.runtime.soil;
+          rot = quat.normalize(quat.mul(state.rotation, quat.conjugate(state.soil.offset.rotation)));
+          pos = vec.sub(state.position, rotateVec(rot, state.soil.offset.position));
+        }
+        objects.set(e.id, build(clone(e.spec), e.id, pos, rot, carry));
       }
       for (const e of snap.impls ?? []) {
         const im = impls.get(e.id);
@@ -3464,21 +5020,6 @@ var createDestruction = (options = {}) => {
   return world;
 };
 
-// src/piercing.ts
-var PIERCING_BY_KIND = {
-  fmj: 1,
-  hp: 0.6,
-  ap: 1.6,
-  buck: 0.5,
-  slug: 0.25,
-  birdshot: 0.3,
-  rimfire: 1,
-  arrow: 1,
-  bolt: 1
-};
-var PIERCING_BY_CALIBER = { "5_56x45": 0.5, "5_45x39": 0.5, "22lr": 0.5 };
-var piercingOf = (caliber, kind) => PIERCING_BY_CALIBER[caliber] ?? PIERCING_BY_KIND[kind ?? "fmj"] ?? 1;
-
 // src/data/assemblies.json
 var assemblies_default = [
   {
@@ -3591,21 +5132,35 @@ var buildFrame = (o = {}) => {
   const dw = o.doorWidth ?? 1, dh = o.doorHeight ?? 2.1;
   const mat = o.material ?? "concrete", wmat = o.wallMaterial ?? "brick";
   const roof = o.roof ?? true;
+  const rebarOf = (kind) => o.rebar === false ? {} : { rebar: { ratio: o.rebar?.[kind] ?? (kind === "beam" ? 0.01 : 5e-3) } };
   const xs = Array.from({ length: nx }, (_, i) => -spanX / 2 + i * spanX / (nx - 1));
   const zs = Array.from({ length: nz }, (_, j) => -spanZ / 2 + j * spanZ / (nz - 1));
   const parts = [];
   const joints = [];
   const on = (a, b, kind) => joints.push({ id: `${a}~${b}`, a, b, kind, bears: "a_on_b" });
-  for (let i = 0; i < nx; i++) {
-    for (let j = 0; j < nz; j++) {
-      parts.push({
-        id: `foundation_${i}_${j}`,
-        material: mat,
-        shape: { kind: "box", size: [cs * 2.2, 0.3, cs * 2.2] },
-        position: [xs[i], -0.15, zs[j]],
-        structure: { role: "foundation" },
-        anchored: true
-      });
+  const pad = o.footing ?? cs * 2.2;
+  const pile = o.piles ? { pile: { ...o.piles } } : {};
+  if (o.raft) {
+    parts.push({
+      id: "raft",
+      material: mat,
+      shape: { kind: "box", size: [spanX + pad, 0.4, spanZ + pad] },
+      position: [0, -0.2, 0],
+      structure: { role: "foundation", ...pile },
+      anchored: true
+    });
+  } else {
+    for (let i = 0; i < nx; i++) {
+      for (let j = 0; j < nz; j++) {
+        parts.push({
+          id: `foundation_${i}_${j}`,
+          material: mat,
+          shape: { kind: "box", size: [pad, 0.3, pad] },
+          position: [xs[i], -0.15, zs[j]],
+          structure: { role: "foundation", ...pile },
+          anchored: true
+        });
+      }
     }
   }
   for (let f = 0; f < floors; f++) {
@@ -3621,14 +5176,15 @@ var buildFrame = (o = {}) => {
           material: mat,
           shape: { kind: "box", size: [cs, H, cs] },
           position: [xs[i], yb + H / 2, zs[j]],
-          structure: o.columnCapacity === void 0 ? { role: "column" } : { role: "column", capacity: o.columnCapacity }
+          structure: o.columnCapacity === void 0 ? { role: "column" } : { role: "column", capacity: o.columnCapacity },
+          ...o.columnCage ? { reinforcement: { ...o.columnCage } } : {}
         });
-        on(id, f === 0 ? `foundation_${i}_${j}` : `slab_${f - 1}`, "rebar");
+        on(id, f === 0 ? o.raft ? "raft" : `foundation_${i}_${j}` : o.continuousColumns ? `column_${f - 1}_${i}_${j}` : `slab_${f - 1}`, "rebar");
       }
     }
     const beams = [];
     const beam = (id, size, pos, c1, c2) => {
-      parts.push({ id, material: mat, shape: { kind: "box", size }, position: pos, structure: { role: "beam" } });
+      parts.push({ id, material: mat, shape: { kind: "box", size }, position: pos, structure: { role: "beam", ...rebarOf("beam") } });
       on(id, c1, "rebar");
       on(id, c2, "rebar");
       beams.push(id);
@@ -3643,13 +5199,13 @@ var buildFrame = (o = {}) => {
         beam(`beam_z_${f}_${i}_${j}`, [bw, bh, zs[j + 1] - zs[j] - cs], [xs[i], top - bh / 2, (zs[j] + zs[j + 1]) / 2], `column_${f}_${i}_${j}`, `column_${f}_${i}_${j + 1}`);
       }
     }
-    const thick = last && roof ? T * 0.75 : T;
+    const thick = last && roof ? o.roofThickness ?? T * 0.75 : T;
     parts.push({
       id: slabId,
       material: mat,
       shape: { kind: "box", size: [spanX + cs + 0.2, thick, spanZ + cs + 0.2] },
       position: [0, top + thick / 2, 0],
-      structure: { role: last && roof ? "roof" : "slab" }
+      structure: { role: last && roof ? "roof" : "slab", ...rebarOf("slab") }
     });
     for (const b of beams) on(slabId, b, last && roof ? "resting" : "rebar");
     if (o.walls) {
@@ -3682,28 +5238,91 @@ var buildFrame = (o = {}) => {
       }
     }
   }
-  return { name: "frame", parts, joints, tags: ["structure"] };
+  return { name: "frame", parts, joints, tags: ["structure"], ...o.soil !== void 0 ? { soil: o.soil } : {} };
 };
 
 // src/size.ts
+var MAX_REBAR_RATIO = 0.04;
+var onRock = (spec) => {
+  if (spec.soil === void 0) return spec;
+  const { soil: _soil, ...rest } = spec;
+  return rest;
+};
+var without = (spec, id) => {
+  const reduced = { ...spec, parts: spec.parts.filter((p) => p.id !== id), joints: (spec.joints ?? []).filter((j) => j.a !== id && j.b !== id) };
+  if (!spec.joints) delete reduced.joints;
+  return reduced;
+};
+var sizeRebar = (spec, options = {}) => {
+  const flexure = resolveFlexure(options.flexure);
+  const materials = new Map(MATERIALS.map((m) => [m.id, m]));
+  for (const m of options.materials ?? []) materials.set(m.id, m);
+  const out = structuredClone(spec);
+  const targets = out.parts.filter((p) => {
+    const m = materials.get(p.material);
+    return p.shape.kind === "box" && !!m && isReinforced(p) && isFlexural(p, m, flexure);
+  });
+  if (targets.length === 0) return out;
+  const safety = options.safety ?? 0.65;
+  const safetyOf = (role) => options.safetyByRole?.[role] ?? safety;
+  const bending = (s) => {
+    const w = createDestruction({ ...options.materials ? { materials: options.materials } : {}, structure: { flexure: options.flexure } });
+    const id = w.add(onRock(s));
+    return new Map(w.state(id).parts.map((p) => [p.id, p.flexure ?? 0]));
+  };
+  const base = bending(out);
+  const factor = new Map(targets.map((p) => [p.id, (base.get(p.id) ?? 0) / safetyOf(p.structure.role)]));
+  if (options.redundancy !== void 0) {
+    const roles = options.redundancyRoles ?? ["column"];
+    for (const lost of out.parts) {
+      if (!lost.structure || !roles.includes(lost.structure.role)) continue;
+      const l = bending(without(out, lost.id));
+      for (const p of targets) if (p.id !== lost.id) factor.set(p.id, Math.max(factor.get(p.id), (l.get(p.id) ?? 0) / options.redundancy));
+    }
+  }
+  for (const p of targets) {
+    const f = factor.get(p.id);
+    const g = bendGeometry(p);
+    if (f <= 1 || g.gravity < 0) continue;
+    const section = { b: sectionWidth(g, g.gravity), h: g.dims[g.gravity] };
+    const steel = tensionSteel(p, g.dims, section, flexure);
+    const m = materials.get(p.material);
+    const need = f * sectionMoments(m, section, steel, flexure).ultimate;
+    const momentOf = (area) => steelMoment(area, steel.yieldMPa, steel.d, section.b, m.strength.compressiveMPa, flexure);
+    const cap = MAX_REBAR_RATIO * section.b * steel.d;
+    if (steel.area >= cap) continue;
+    let lo = steel.area, hi = cap;
+    if (momentOf(hi) > need) {
+      for (let k = 0; k < 60; k++) {
+        const mid = (lo + hi) / 2;
+        if (momentOf(mid) < need) lo = mid;
+        else hi = mid;
+      }
+    }
+    const ratio = hi / (section.b * steel.d);
+    p.structure = { ...p.structure, rebar: { ...p.structure.rebar, ratio } };
+  }
+  return out;
+};
 var sizeStructure = (spec, options = {}) => {
   const safety = options.safety ?? 0.65;
   const redundancy = options.redundancy;
   const redundancyRoles = options.redundancyRoles ?? ["column"];
   const safetyOf = (role) => options.safetyByRole?.[role] ?? safety;
-  const loads = (s) => {
-    const w = createDestruction(options.materials ? { materials: options.materials } : {});
-    const id = w.add(s);
-    return new Map(w.state(id).parts.map((p) => [p.id, { load: p.load ?? 0, stress: p.stress ?? 0 }]));
+  const loads = (s, wind) => {
+    const w = createDestruction({ ...options.materials ? { materials: options.materials } : {}, ...wind ? { wind } : {} });
+    const id = w.add(onRock(s));
+    return new Map(w.state(id).parts.map((p) => [p.id, { load: p.load ?? 0, stress: p.stress ?? 0, wind: p.wind ?? 0 }]));
   };
   const out = structuredClone(spec);
-  const base = loads(out);
+  const base = loads(out, options.wind);
+  const gamma = options.wind ? resolveWind(options.wind).loadFactor : 0;
   const need = /* @__PURE__ */ new Map();
   for (const p of out.parts) {
     if (!p.structure || p.structure.role === "none") continue;
     const b = base.get(p.id);
     if (!b || b.stress <= 0) continue;
-    need.set(p.id, b.load / safetyOf(p.structure.role));
+    need.set(p.id, (b.load + (b.wind > 0 ? gamma * b.wind / GRAVITY : 0)) / safetyOf(p.structure.role));
   }
   if (redundancy !== void 0) {
     for (const col of out.parts) {
@@ -3725,7 +5344,20 @@ var sizeStructure = (spec, options = {}) => {
     const n = need.get(p.id);
     if (n !== void 0) p.structure = { ...p.structure, capacity: n };
   }
-  return out;
+  if (options.wind) {
+    const yieldMPa = resolveFlexure(options.flexure).rebarYieldMPa;
+    for (const p of out.parts) {
+      const b = base.get(p.id);
+      if (!b || b.wind >= 0 || !p.reinforcement || p.shape.kind !== "box") continue;
+      const pull = -(b.load + gamma * b.wind / GRAVITY) * GRAVITY;
+      if (pull <= 0) continue;
+      const dims = shapeDims(p.shape);
+      const have = tensionCapacity(dims, { reinforcement: p.reinforcement, yieldMPa });
+      const want = pull / safetyOf(p.structure?.role ?? "wall");
+      if (have > 0 && want > have) p.reinforcement = { ...p.reinforcement, diameter: Math.min(0.04, p.reinforcement.diameter * Math.sqrt(want / have)) };
+    }
+  }
+  return sizeRebar(out, options);
 };
 
 // src/locale.ts
@@ -3807,6 +5439,8 @@ var locales = {
       primed: "about to explode",
       stress: "overload",
       collapse: "collapsed",
+      settle: "ground gave way",
+      sway: "sway",
       spall: "plaster came off",
       stage: "damage stage",
       expose: "rebar bare",
@@ -3895,6 +5529,8 @@ var locales = {
       primed: "prestes a explodir",
       stress: "sobrecarga",
       collapse: "desabou",
+      settle: "recalque do solo",
+      sway: "balan\xE7o",
       spall: "reboco soltou",
       stage: "est\xE1gio de dano",
       expose: "vergalh\xE3o \xE0 mostra",
@@ -3920,39 +5556,87 @@ export {
   ASSEMBLIES,
   CONFINEMENT_DEFAULTS,
   FIRE_PRIME_C,
+  FLEXURE_DEFAULTS,
   FRAGMENT_HIT_DEFAULTS,
+  GRAVITY,
   IMPACT_CONTRACT,
   JOINT_BY_MATERIALS,
   JOINT_DEFAULTS,
+  MASONRY_DEFAULTS,
   MATERIALS,
-  PIERCING_BY_CALIBER,
-  PIERCING_BY_KIND,
   SHELTER_DEFAULTS,
+  SOILS,
+  SOIL_DEFAULTS,
+  WIND_DEFAULTS,
+  WIND_TERRAIN,
+  analyzeWind,
   assemblyDepth,
   assemblyPart,
+  bearingWallThickness,
+  bendGeometry,
+  blastImpulse,
   buildFrame,
   checkDestructible,
   checkHit,
+  crackingMoment,
   createDestruction,
+  damperAmplification,
+  damperTuning,
+  elasticEnergy,
   explosivePart,
+  exposureOf,
+  footingArea,
+  footingSoil,
   fragility,
   getAssembly,
   guessMaterial,
+  gustAt,
+  heightFactor,
+  impulseEnergy,
   inferJoints,
+  layersBetween,
   locales,
+  makeGust,
+  meanHeightFactor,
+  momentNodes,
+  momentOfEnergy,
   partCapacity,
   partMass,
   partThickness,
   partVolume,
-  piercingOf,
+  pileCapacity,
+  pileLength,
+  pileStiffness,
+  profileOf,
   quat,
   quatFromEuler,
   registerAssembly,
   resolveStrings,
+  resolveWind,
   rotateVec,
+  sectionMoments,
+  shapeAt,
+  shearNodes,
+  sizeRebar,
   sizeStructure,
+  slendernessFactor,
+  soilAt,
+  solveFoundation,
+  solveWallFrame,
+  spanMoment,
+  spanOf,
+  steelMoment,
+  stepSway,
+  stiffnessCentre,
+  subgradeModulus,
+  tBeamInertia,
+  tensionCapacity,
+  tensionSteel,
   toLocal,
   toWorld,
-  vec
+  turbulenceIntensity,
+  vec,
+  windClass,
+  windPressure
 };
 //# sourceMappingURL=index.js.map