@adatechnology/game-destruction 0.7.2 → 0.8.1

package/dist/index.global.js

@@ -24,40 +24,88 @@ var GameDestruction = (() => {
     ASSEMBLIES: () => ASSEMBLIES,
     CONFINEMENT_DEFAULTS: () => CONFINEMENT_DEFAULTS,
     FIRE_PRIME_C: () => FIRE_PRIME_C,
+    FLEXURE_DEFAULTS: () => FLEXURE_DEFAULTS,
     FRAGMENT_HIT_DEFAULTS: () => FRAGMENT_HIT_DEFAULTS,
+    GRAVITY: () => GRAVITY,
     IMPACT_CONTRACT: () => IMPACT_CONTRACT,
     JOINT_BY_MATERIALS: () => JOINT_BY_MATERIALS,
     JOINT_DEFAULTS: () => JOINT_DEFAULTS,
+    MASONRY_DEFAULTS: () => MASONRY_DEFAULTS,
     MATERIALS: () => MATERIALS,
-    PIERCING_BY_CALIBER: () => PIERCING_BY_CALIBER,
-    PIERCING_BY_KIND: () => PIERCING_BY_KIND,
     SHELTER_DEFAULTS: () => SHELTER_DEFAULTS,
+    SOILS: () => SOILS,
+    SOIL_DEFAULTS: () => SOIL_DEFAULTS,
+    WIND_DEFAULTS: () => WIND_DEFAULTS,
+    WIND_TERRAIN: () => WIND_TERRAIN,
+    analyzeWind: () => analyzeWind,
     assemblyDepth: () => assemblyDepth,
     assemblyPart: () => assemblyPart,
+    bearingWallThickness: () => bearingWallThickness,
+    bendGeometry: () => bendGeometry,
+    blastImpulse: () => blastImpulse,
     buildFrame: () => buildFrame,
     checkDestructible: () => checkDestructible2,
     checkHit: () => checkHit,
+    crackingMoment: () => crackingMoment,
     createDestruction: () => createDestruction,
+    damperAmplification: () => damperAmplification,
+    damperTuning: () => damperTuning,
+    elasticEnergy: () => elasticEnergy,
     explosivePart: () => explosivePart,
+    exposureOf: () => exposureOf,
+    footingArea: () => footingArea,
+    footingSoil: () => footingSoil,
     fragility: () => fragility,
     getAssembly: () => getAssembly,
     guessMaterial: () => guessMaterial,
+    gustAt: () => gustAt,
+    heightFactor: () => heightFactor,
+    impulseEnergy: () => impulseEnergy,
     inferJoints: () => inferJoints,
+    layersBetween: () => layersBetween,
     locales: () => locales,
+    makeGust: () => makeGust,
+    meanHeightFactor: () => meanHeightFactor,
+    momentNodes: () => momentNodes,
+    momentOfEnergy: () => momentOfEnergy,
     partCapacity: () => partCapacity,
     partMass: () => partMass,
     partThickness: () => partThickness,
     partVolume: () => partVolume,
-    piercingOf: () => piercingOf,
+    pileCapacity: () => pileCapacity,
+    pileLength: () => pileLength,
+    pileStiffness: () => pileStiffness,
+    profileOf: () => profileOf,
     quat: () => quat,
     quatFromEuler: () => quatFromEuler,
     registerAssembly: () => registerAssembly,
     resolveStrings: () => resolveStrings,
+    resolveWind: () => resolveWind,
     rotateVec: () => rotateVec,
+    sectionMoments: () => sectionMoments,
+    shapeAt: () => shapeAt,
+    shearNodes: () => shearNodes,
+    sizeRebar: () => sizeRebar,
     sizeStructure: () => sizeStructure,
+    slendernessFactor: () => slendernessFactor,
+    soilAt: () => soilAt,
+    solveFoundation: () => solveFoundation,
+    solveWallFrame: () => solveWallFrame,
+    spanMoment: () => spanMoment,
+    spanOf: () => spanOf,
+    steelMoment: () => steelMoment,
+    stepSway: () => stepSway,
+    stiffnessCentre: () => stiffnessCentre,
+    subgradeModulus: () => subgradeModulus,
+    tBeamInertia: () => tBeamInertia,
+    tensionCapacity: () => tensionCapacity,
+    tensionSteel: () => tensionSteel,
     toLocal: () => toLocal,
     toWorld: () => toWorld,
-    vec: () => vec
+    turbulenceIntensity: () => turbulenceIntensity,
+    vec: () => vec,
+    windClass: () => windClass,
+    windPressure: () => windPressure
   });
 
   // src/chain.ts
@@ -587,6 +635,7 @@ var GameDestruction = (() => {
     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)) {
@@ -622,12 +671,808 @@ var GameDestruction = (() => {
     }
     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 = [
     {
@@ -635,6 +1480,8 @@ var GameDestruction = (() => {
       density: 7850,
       hpPerKg: 400,
       penetration: 110,
+      penetrationClass: "steel",
+      penetrationScale: 1.3,
       ductility: 0.9,
       fracture: "none",
       damageScale: {
@@ -664,6 +1511,8 @@ var GameDestruction = (() => {
       density: 7200,
       hpPerKg: 150,
       penetration: 160,
+      penetrationClass: "steel",
+      penetrationScale: 1,
       ductility: 0.2,
       fracture: "snap",
       fragmentSize: [
@@ -697,6 +1546,8 @@ var GameDestruction = (() => {
       density: 2700,
       hpPerKg: 250,
       penetration: 60,
+      penetrationClass: "steel",
+      penetrationScale: 3,
       ductility: 0.85,
       fracture: "none",
       damageScale: {
@@ -725,6 +1576,8 @@ var GameDestruction = (() => {
       density: 8960,
       hpPerKg: 300,
       penetration: 70,
+      penetrationClass: "steel",
+      penetrationScale: 1.5,
       ductility: 0.95,
       fracture: "none",
       damageScale: {
@@ -753,6 +1606,8 @@ var GameDestruction = (() => {
       density: 500,
       hpPerKg: 90,
       penetration: 9,
+      penetrationClass: "wood",
+      penetrationScale: 1.5,
       ductility: 0.35,
       fracture: "splinter",
       fragmentSize: [
@@ -789,6 +1644,8 @@ var GameDestruction = (() => {
       density: 750,
       hpPerKg: 140,
       penetration: 14,
+      penetrationClass: "wood",
+      penetrationScale: 1,
       ductility: 0.3,
       fracture: "splinter",
       fragmentSize: [
@@ -824,6 +1681,8 @@ var GameDestruction = (() => {
       density: 600,
       hpPerKg: 70,
       penetration: 7,
+      penetrationClass: "wood",
+      penetrationScale: 2,
       ductility: 0.3,
       fracture: "snap",
       fragmentSize: [
@@ -859,6 +1718,8 @@ var GameDestruction = (() => {
       density: 750,
       hpPerKg: 45,
       penetration: 6,
+      penetrationClass: "wood",
+      penetrationScale: 2.5,
       ductility: 0.15,
       fracture: "snap",
       fragmentSize: [
@@ -987,6 +1848,8 @@ var GameDestruction = (() => {
       density: 2300,
       hpPerKg: 14,
       penetration: 18,
+      penetrationClass: "concrete",
+      penetrationScale: 1,
       ductility: 0.03,
       fracture: "crumble",
       fragmentSize: [
@@ -1006,13 +1869,20 @@ var GameDestruction = (() => {
         "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: [
@@ -1029,13 +1899,20 @@ var GameDestruction = (() => {
         "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: [
@@ -1059,6 +1936,8 @@ var GameDestruction = (() => {
       density: 2700,
       hpPerKg: 25,
       penetration: 25,
+      penetrationClass: "concrete",
+      penetrationScale: 0.9,
       ductility: 0.03,
       fracture: "crumble",
       fragmentSize: [
@@ -1322,6 +2201,8 @@ var GameDestruction = (() => {
       density: 650,
       hpPerKg: 5,
       penetration: 10,
+      penetrationClass: "wood",
+      penetrationScale: 1.2,
       ductility: 0.5,
       fracture: "splinter",
       fragmentSize: [
@@ -1623,36 +2504,210 @@ var GameDestruction = (() => {
     }
     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;
     return (1 + 4 * (0.3 - ductility) / 0.3) * Math.min(25, Math.max(1, (0.02 / Math.max(thickness, 1e-4)) ** 2));
   };
 
+  // ../game-contracts/dist/index.js
+  var IMPACT_CONTRACT = {
+    ballistic: { required: ["type", "point", "direction", "energy", "caliber"], optional: ["space", "source"], note: "bullets and pellets: joules and diameter in millimetres" },
+    blunt: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "contact radius in metres (default 3 cm)" },
+    slash: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "axes, knives, machetes" },
+    explosive: { required: ["type", "point", "energy", "radius"], optional: ["lethalRadius", "space", "source"], note: "point is the centre of the blast, radius the range in metres" },
+    fire: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "flame temperature in \xB0C; duration in seconds (call every frame with `dt`)" },
+    heat: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "heat without flame (cutting torch, hot plate)" }
+  };
+  var checkHit = (hit) => {
+    const c = IMPACT_CONTRACT[hit.type];
+    if (!c) return [`unknown damage type "${String(hit.type)}"`];
+    const out = [];
+    for (const f of c.required) {
+      const v = hit[f];
+      if (v === void 0 || (Array.isArray(v) ? v.some((n) => !Number.isFinite(n)) : typeof v === "number" && !Number.isFinite(v))) out.push(`${hit.type} hit needs "${f}"`);
+    }
+    return out;
+  };
+  var finiteJson = (v, path, out) => {
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) out.push(`${path} is not a finite number`);
+    } else if (Array.isArray(v)) v.forEach((x, i) => finiteJson(x, `${path}[${i}]`, out));
+    else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) finiteJson(x, `${path}.${k}`, out);
+    else if (typeof v === "function" || typeof v === "symbol" || typeof v === "bigint") out.push(`${path} is not JSON`);
+  };
+  var checkDestructible = (impl, options = {}) => {
+    const problems = [];
+    const known = options.materials ? new Set(options.materials) : null;
+    let spec;
+    try {
+      spec = impl.describe();
+    } catch (e) {
+      return { ok: false, problems: [`describe() threw: ${String(e)}`] };
+    }
+    if (!spec || !Array.isArray(spec.parts) || spec.parts.length === 0) return { ok: false, problems: ["describe() must return at least one part"] };
+    const ids = /* @__PURE__ */ new Set();
+    for (const p of spec.parts) {
+      if (ids.has(p.id)) problems.push(`duplicate part id "${p.id}"`);
+      ids.add(p.id);
+      if (known && !known.has(p.material)) problems.push(`part "${p.id}" has unknown material "${p.material}"`);
+      if (!p.shape || !["box", "cylinder", "sphere"].includes(p.shape.kind)) problems.push(`part "${p.id}" has no valid shape`);
+      if (!Array.isArray(p.position) || p.position.length !== 3) problems.push(`part "${p.id}" has no position`);
+    }
+    const jointIds = /* @__PURE__ */ new Set();
+    for (const j of spec.joints ?? []) {
+      if (!ids.has(j.a) || !ids.has(j.b)) problems.push(`joint "${j.id ?? `${j.a}~${j.b}`}" references an unknown part`);
+      const jid = j.id ?? `${j.a}~${j.b}`;
+      if (jointIds.has(jid)) problems.push(`duplicate joint id "${jid}"`);
+      jointIds.add(jid);
+    }
+    const checkState = (label) => {
+      let st;
+      try {
+        st = impl.state();
+      } catch (e) {
+        problems.push(`state() threw ${label}: ${String(e)}`);
+        return;
+      }
+      const sids = st.parts.map((p) => p.id).sort().join(",");
+      if (sids !== [...ids].sort().join(",")) problems.push(`state() part ids do not match describe() ${label}`);
+      for (const p of st.parts) if (!(p.hp >= 0)) problems.push(`part "${p.id}" has negative or invalid hp ${label}`);
+    };
+    const checkEvents = (events, label) => {
+      if (!Array.isArray(events)) {
+        problems.push(`${label} must return an array`);
+        return;
+      }
+      const evs = events;
+      evs.forEach((e, i) => {
+        if (e.object !== impl.id) problems.push(`${label} event ${i} (${e.type}) has object "${String(e.object)}", expected "${impl.id}"`);
+        const part = e.part;
+        if (part !== void 0 && !ids.has(part)) problems.push(`${label} event ${i} (${e.type}) names unknown part "${part}"`);
+      });
+      const bad = [];
+      finiteJson(evs, "events", bad);
+      problems.push(...bad.map((b) => `${label}: ${b}`));
+      try {
+        const s = JSON.stringify(evs);
+        if (JSON.stringify(JSON.parse(s)) !== s) problems.push(`${label} events do not survive a JSON round trip`);
+      } catch (e) {
+        problems.push(`${label} events are not JSON-serializable: ${String(e)}`);
+      }
+    };
+    checkState("before the hit");
+    const target = spec.parts[0];
+    try {
+      const hit = { type: "ballistic", point: [target.position[0], target.position[1], target.position[2]], direction: [0, 0, -1], energy: 500, caliber: 9 };
+      checkEvents(impl.hit(hit), "hit()");
+    } catch (e) {
+      problems.push(`hit() threw: ${String(e)}`);
+    }
+    checkState("after the hit");
+    if (impl.update) {
+      try {
+        checkEvents(impl.update(0.016), "update()");
+      } catch (e) {
+        problems.push(`update() threw: ${String(e)}`);
+      }
+      checkState("after update");
+    }
+    try {
+      impl.reset?.();
+    } catch (e) {
+      problems.push(`reset() threw: ${String(e)}`);
+    }
+    return { ok: problems.length === 0, problems };
+  };
+  var DEFAULT_IGNITION_RULES = {
+    fillCurve: [
+      [0, 0.6],
+      [0.1, 1],
+      [0.35, 0.6],
+      [0.65, 0.3],
+      [0.9, 0.15],
+      [1, 0.12]
+    ],
+    flameFillInfluence: 0.5,
+    flameDefaults: { incendiary: 0.7, tracer: 0.2 },
+    sparkTarget: { steel: 1, iron: 1, aluminium: 0.25 },
+    sparkMetalDefault: 0.5,
+    sparkFluid: { diesel: 0.15 },
+    fireNear: { radius: 1.5, chancePerSecond: 0.5 }
+  };
+  var resolveIgnitionRules = (rules) => ({
+    ...DEFAULT_IGNITION_RULES,
+    ...rules,
+    flameDefaults: { ...DEFAULT_IGNITION_RULES.flameDefaults, ...rules?.flameDefaults },
+    sparkTarget: { ...DEFAULT_IGNITION_RULES.sparkTarget, ...rules?.sparkTarget },
+    sparkFluid: { ...DEFAULT_IGNITION_RULES.sparkFluid, ...rules?.sparkFluid },
+    fireNear: { ...DEFAULT_IGNITION_RULES.fireNear, ...rules?.fireNear }
+  });
+  var fillFactor = (fill, curve = DEFAULT_IGNITION_RULES.fillCurve) => {
+    if (curve.length === 0) return 1;
+    const f = Math.min(1, Math.max(0, fill));
+    if (f <= curve[0][0]) return curve[0][1];
+    for (let i = 1; i < curve.length; i++) {
+      const [x1, y1] = curve[i];
+      const [x0, y0] = curve[i - 1];
+      if (f <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (f - x0) / (x1 - x0);
+    }
+    return curve[curve.length - 1][1];
+  };
+  var sparkTargetFactor = (materialId, metal, rules = DEFAULT_IGNITION_RULES) => !metal ? 0 : rules.sparkTarget[materialId] ?? rules.sparkMetalDefault;
+  var ignitionChance = (hit, target, rules = DEFAULT_IGNITION_RULES) => {
+    const k = fillFactor(target.fill, rules.fillCurve);
+    const spark = (hit.ignition?.spark ?? 0) * target.sparkTarget * (target.fluid === void 0 ? 1 : rules.sparkFluid[target.fluid] ?? 1) * k;
+    const flameBase = hit.ignition?.flame ?? Math.max(hit.incendiary ? rules.flameDefaults.incendiary : 0, hit.tracer ? rules.flameDefaults.tracer : 0);
+    const flame = flameBase * (1 - rules.flameFillInfluence * (1 - k));
+    return 1 - (1 - Math.min(1, Math.max(0, spark))) * (1 - Math.min(1, Math.max(0, flame)));
+  };
+
   // src/world.ts
+  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;
@@ -1680,8 +2735,14 @@ var GameDestruction = (() => {
     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;
@@ -1708,7 +2769,7 @@ var GameDestruction = (() => {
     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;
@@ -1778,7 +2839,8 @@ var GameDestruction = (() => {
         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}"`);
@@ -1830,10 +2892,17 @@ var GameDestruction = (() => {
           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);
@@ -1867,7 +2936,14 @@ var GameDestruction = (() => {
       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);
@@ -1919,12 +2995,126 @@ var GameDestruction = (() => {
       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;
@@ -1945,23 +3135,41 @@ var GameDestruction = (() => {
         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];
@@ -1970,13 +3178,420 @@ var GameDestruction = (() => {
         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;
@@ -2213,7 +3828,7 @@ var GameDestruction = (() => {
       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) {
@@ -2369,14 +3984,37 @@ var GameDestruction = (() => {
       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;
@@ -2433,8 +4071,8 @@ var GameDestruction = (() => {
         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);
     };
@@ -2463,8 +4101,33 @@ var GameDestruction = (() => {
       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 };
       }
@@ -2477,7 +4140,8 @@ var GameDestruction = (() => {
       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;
@@ -2494,22 +4158,25 @@ var GameDestruction = (() => {
       const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
       let exitPoint;
       if (penetrated) {
-        exitPoint = vec.madd(entry, d, Math.min(pathLen, effM + layersThickness(p.layers, face) / slant + layersThickness(p.layers, -face) / slant));
+        const exitDist = p.spec.contains || p.spec.fill !== void 0 && p.spec.fill < 0.5 || p.thickness < pathLen * 0.5 ? pathLen : Math.min(pathLen, effM + layersThickness(p.layers, face) / slant + layersThickness(p.layers, -face) / slant);
+        exitPoint = vec.madd(entry, d, exitDist);
         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) {
+        if (p.spec.contains && (p.st.liters ?? 0) > 1e-4) {
           emit({
             ...base(o, src),
             type: "leak",
             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);
@@ -2520,7 +4187,7 @@ var GameDestruction = (() => {
       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;
@@ -2540,8 +4207,9 @@ var GameDestruction = (() => {
         }
         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);
@@ -2588,7 +4256,8 @@ var GameDestruction = (() => {
       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) => {
@@ -2651,7 +4320,7 @@ var GameDestruction = (() => {
     };
     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;
@@ -2659,7 +4328,7 @@ var GameDestruction = (() => {
         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;
     };
@@ -2668,7 +4337,7 @@ var GameDestruction = (() => {
       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;
@@ -2775,7 +4444,7 @@ var GameDestruction = (() => {
             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;
         }
@@ -2873,10 +4542,11 @@ var GameDestruction = (() => {
       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;
@@ -2895,6 +4565,7 @@ var GameDestruction = (() => {
           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);
@@ -2914,7 +4585,7 @@ var GameDestruction = (() => {
       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") {
@@ -3068,7 +4739,8 @@ var GameDestruction = (() => {
           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;
@@ -3083,6 +4755,7 @@ var GameDestruction = (() => {
             }
           }
         }
+        if ((s.liters ?? 0) <= 0) p.rt.lit = false;
         if (p.rt.jet && (s.liters ?? 0) <= 0) {
           p.rt.jet = false;
           s.burning = false;
@@ -3132,6 +4805,25 @@ var GameDestruction = (() => {
       }
       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;
@@ -3257,8 +4949,8 @@ var GameDestruction = (() => {
           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`);
@@ -3281,13 +4973,17 @@ var GameDestruction = (() => {
           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;
@@ -3312,7 +5008,8 @@ var GameDestruction = (() => {
         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);
@@ -3324,7 +5021,7 @@ var GameDestruction = (() => {
             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;
@@ -3338,7 +5035,7 @@ var GameDestruction = (() => {
             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;
@@ -3437,6 +5134,52 @@ var GameDestruction = (() => {
           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);
@@ -3450,7 +5193,12 @@ var GameDestruction = (() => {
           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()]) {
@@ -3472,7 +5220,7 @@ var GameDestruction = (() => {
           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);
@@ -3489,7 +5237,7 @@ var GameDestruction = (() => {
           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 };
@@ -3510,9 +5258,17 @@ var GameDestruction = (() => {
               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);
@@ -3526,21 +5282,6 @@ var GameDestruction = (() => {
     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 = [
     {
@@ -3653,21 +5394,35 @@ var GameDestruction = (() => {
     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++) {
@@ -3683,14 +5438,15 @@ var GameDestruction = (() => {
             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);
@@ -3705,13 +5461,13 @@ var GameDestruction = (() => {
           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) {
@@ -3744,28 +5500,91 @@ var GameDestruction = (() => {
         }
       }
     }
-    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) {
@@ -3787,7 +5606,20 @@ var GameDestruction = (() => {
       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
@@ -3869,6 +5701,8 @@ var GameDestruction = (() => {
         primed: "about to explode",
         stress: "overload",
         collapse: "collapsed",
+        settle: "ground gave way",
+        sway: "sway",
         spall: "plaster came off",
         stage: "damage stage",
         expose: "rebar bare",
@@ -3957,6 +5791,8 @@ var GameDestruction = (() => {
         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",
@@ -3971,115 +5807,6 @@ var GameDestruction = (() => {
   };
   var resolveStrings = (locale) => locales[locale ?? "en"] ?? locales.en;
 
-  // ../game-contracts/dist/index.js
-  var IMPACT_CONTRACT = {
-    ballistic: { required: ["type", "point", "direction", "energy", "caliber"], optional: ["space", "source"], note: "bullets and pellets: joules and diameter in millimetres" },
-    blunt: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "contact radius in metres (default 3 cm)" },
-    slash: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "axes, knives, machetes" },
-    explosive: { required: ["type", "point", "energy", "radius"], optional: ["space", "source"], note: "point is the centre of the blast, radius the range in metres" },
-    fire: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "flame temperature in \xB0C; duration in seconds (call every frame with `dt`)" },
-    heat: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "heat without flame (cutting torch, hot plate)" }
-  };
-  var checkHit = (hit) => {
-    const c = IMPACT_CONTRACT[hit.type];
-    if (!c) return [`unknown damage type "${String(hit.type)}"`];
-    const out = [];
-    for (const f of c.required) {
-      const v = hit[f];
-      if (v === void 0 || (Array.isArray(v) ? v.some((n) => !Number.isFinite(n)) : typeof v === "number" && !Number.isFinite(v))) out.push(`${hit.type} hit needs "${f}"`);
-    }
-    return out;
-  };
-  var finiteJson = (v, path, out) => {
-    if (typeof v === "number") {
-      if (!Number.isFinite(v)) out.push(`${path} is not a finite number`);
-    } else if (Array.isArray(v)) v.forEach((x, i) => finiteJson(x, `${path}[${i}]`, out));
-    else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) finiteJson(x, `${path}.${k}`, out);
-    else if (typeof v === "function" || typeof v === "symbol" || typeof v === "bigint") out.push(`${path} is not JSON`);
-  };
-  var checkDestructible = (impl, options = {}) => {
-    const problems = [];
-    const known = options.materials ? new Set(options.materials) : null;
-    let spec;
-    try {
-      spec = impl.describe();
-    } catch (e) {
-      return { ok: false, problems: [`describe() threw: ${String(e)}`] };
-    }
-    if (!spec || !Array.isArray(spec.parts) || spec.parts.length === 0) return { ok: false, problems: ["describe() must return at least one part"] };
-    const ids = /* @__PURE__ */ new Set();
-    for (const p of spec.parts) {
-      if (ids.has(p.id)) problems.push(`duplicate part id "${p.id}"`);
-      ids.add(p.id);
-      if (known && !known.has(p.material)) problems.push(`part "${p.id}" has unknown material "${p.material}"`);
-      if (!p.shape || !["box", "cylinder", "sphere"].includes(p.shape.kind)) problems.push(`part "${p.id}" has no valid shape`);
-      if (!Array.isArray(p.position) || p.position.length !== 3) problems.push(`part "${p.id}" has no position`);
-    }
-    const jointIds = /* @__PURE__ */ new Set();
-    for (const j of spec.joints ?? []) {
-      if (!ids.has(j.a) || !ids.has(j.b)) problems.push(`joint "${j.id ?? `${j.a}~${j.b}`}" references an unknown part`);
-      const jid = j.id ?? `${j.a}~${j.b}`;
-      if (jointIds.has(jid)) problems.push(`duplicate joint id "${jid}"`);
-      jointIds.add(jid);
-    }
-    const checkState = (label) => {
-      let st;
-      try {
-        st = impl.state();
-      } catch (e) {
-        problems.push(`state() threw ${label}: ${String(e)}`);
-        return;
-      }
-      const sids = st.parts.map((p) => p.id).sort().join(",");
-      if (sids !== [...ids].sort().join(",")) problems.push(`state() part ids do not match describe() ${label}`);
-      for (const p of st.parts) if (!(p.hp >= 0)) problems.push(`part "${p.id}" has negative or invalid hp ${label}`);
-    };
-    const checkEvents = (events, label) => {
-      if (!Array.isArray(events)) {
-        problems.push(`${label} must return an array`);
-        return;
-      }
-      const evs = events;
-      evs.forEach((e, i) => {
-        if (e.object !== impl.id) problems.push(`${label} event ${i} (${e.type}) has object "${String(e.object)}", expected "${impl.id}"`);
-        const part = e.part;
-        if (part !== void 0 && !ids.has(part)) problems.push(`${label} event ${i} (${e.type}) names unknown part "${part}"`);
-      });
-      const bad = [];
-      finiteJson(evs, "events", bad);
-      problems.push(...bad.map((b) => `${label}: ${b}`));
-      try {
-        const s = JSON.stringify(evs);
-        if (JSON.stringify(JSON.parse(s)) !== s) problems.push(`${label} events do not survive a JSON round trip`);
-      } catch (e) {
-        problems.push(`${label} events are not JSON-serializable: ${String(e)}`);
-      }
-    };
-    checkState("before the hit");
-    const target = spec.parts[0];
-    try {
-      const hit = { type: "ballistic", point: [target.position[0], target.position[1], target.position[2]], direction: [0, 0, -1], energy: 500, caliber: 9 };
-      checkEvents(impl.hit(hit), "hit()");
-    } catch (e) {
-      problems.push(`hit() threw: ${String(e)}`);
-    }
-    checkState("after the hit");
-    if (impl.update) {
-      try {
-        checkEvents(impl.update(0.016), "update()");
-      } catch (e) {
-        problems.push(`update() threw: ${String(e)}`);
-      }
-      checkState("after update");
-    }
-    try {
-      impl.reset?.();
-    } catch (e) {
-      problems.push(`reset() threw: ${String(e)}`);
-    }
-    return { ok: problems.length === 0, problems };
-  };
-
   // src/contracts.ts
   var checkDestructible2 = (impl, options = {}) => {
     const contractOptions = { materials: [...MATERIALS.map((m) => m.id), ...options.materials ?? []] };