@adatechnology/game-destruction 0.7.2 → 0.8.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Vec3, Quat, MaterialId, FractureStyle, DamageType, DebrisKind, DestructionEvent, BlastOptions, DestructibleSpec, ObjectState, DestructibleImpl, Hit, HitResult, RayHit, ToolKind, JointState, PartState, DestructionEventType, StructureRole, ConfinementOptions, FragmentHitOptions, ShelterOptions, ExplosionChain, PartSpec, JointKind, JointSpec, PartShape, SurfaceLayer, PartUnits, Reinforcement, PartBreach, PartStatus } from '@adatechnology/game-contracts';
-export { BlastOptions, BlastReport, ChainDelay, ConfinementOptions, Crack, DamageStage, DamageType, DebrisKind, Dent, DestructibleImpl, DestructibleSpec, DestructionEvent, DestructionEventType, ExplosionChain, FluidKind, FractureStyle, Fragment, FragmentHitOptions, FragmentMark, Hit, HitResult, Hole, IMPACT_CONTRACT, ImpactContract, JointKind, JointSpec, JointState, MaterialId, ObjectState, PartBreach, PartShape, PartSpec, PartState, PartStatus, PartUnits, Quat, RayHit, Reinforcement, ShelterOptions, StructureRole, SurfaceLayer, ToolKind, Vec3, checkHit } from '@adatechnology/game-contracts';
+import { Vec3, Quat, MaterialId, FractureStyle, DamageType, DebrisKind, DestructionEvent, StructureRole, SoilProfile, WindExposure, IgnitionRules, BlastOptions, DestructibleSpec, ObjectState, DestructibleImpl, Hit, HitResult, RayHit, BallisticExtras, ToolKind, JointState, PartState, DestructionEventType, ConfinementOptions, FragmentHitOptions, ShelterOptions, ExplosionChain, PartSpec, JointKind, JointSpec, PartShape, SurfaceLayer, PartUnits, Reinforcement, PartBreach, PileSpec, PartStatus } from '@adatechnology/game-contracts';
+export { BallisticExtras, BlastOptions, BlastReport, ChainDelay, ConfinementOptions, Crack, DamageStage, DamageType, DebrisKind, Dent, DestructibleImpl, DestructibleSpec, DestructionEvent, DestructionEventType, ExplosionChain, FluidKind, FractureStyle, Fragment, FragmentHitOptions, FragmentMark, Hit, HitIgnition, HitResult, Hole, IMPACT_CONTRACT, ImpactContract, JointKind, JointSpec, JointState, MaterialId, ObjectState, PartBreach, PartShape, PartSpec, PartState, PartStatus, PartUnits, PileSpec, Quat, RayHit, Reinforcement, ShelterOptions, SoilLayer, SoilProfile, SoilState, StructureRole, SurfaceLayer, TensionRebar, ToolKind, TunedMassDamper, Vec3, WindExposure, WindState, checkHit } from '@adatechnology/game-contracts';
 
 /**
  * Public types of @adatechnology/game-destruction.
@@ -46,6 +46,16 @@ interface MaterialDef {
      * through and keeps the rest; one that carries less stops (dent, crack or lodge).
      */
     penetration: number;
+    /**
+     * Which entry of `Hit.penetration` this material is measured by (`steel`, `concrete`, `brick`, `wood`; default its own id). A structural steel beam is
+     * `steel`, an aluminium sheet is `steel` too, softwood is `wood`.
+     */
+    penetrationClass?: string;
+    /**
+     * Millimetres of this material a round goes through for every millimetre of its `penetrationClass` reference in the table (default 1). Structural
+     * steel (S235) is softer than the RHA the tables use, so 1.3; softwood against hardwood 1.5; aluminium against steel 3.
+     */
+    penetrationScale?: number;
     /** 0 = brittle (glass), 1 = very ductile (soft steel). Ductile parts dent and bend before they break; brittle parts crack and shatter. */
     ductility: number;
     /** How the part fails when its hp reaches 0. */
@@ -77,6 +87,193 @@ interface MaterialDef {
      * softwood 100 000, steel 2 000 000). Default 20 000. See `PartSpec.structure`.
      */
     compressive?: number;
+    /**
+     * Engineering strengths of the material, in real units. When present they replace the game-tuned `compressive` for the capacity of the part and
+     * turn on the bending model of beams and slabs (`tensileMPa`). See `MaterialStrength`.
+     */
+    strength?: MaterialStrength;
+}
+/**
+ * Real strengths of a structural material (characteristic values). Concrete C25 (NBR 6118 / Eurocode 2): compressive 25, tensile 0.3 * fck^(2/3) = 2.56,
+ * elastic 5600 * sqrt(fck) = 28 GPa. Clay brick masonry (Eurocode 6, fk = 0.55 * fb^0.7 * fm^0.3 with fb 4 MPa, mortar M5): compressive 2.35.
+ */
+interface MaterialStrength {
+    /** Characteristic compressive strength in MPa (fck of concrete, fk of a masonry wall). */
+    compressiveMPa: number;
+    /** Mean axial tensile strength in MPa (fctm of concrete). Without it the material does not take part in the bending model. */
+    tensileMPa?: number;
+    /** Modulus of elasticity in GPa (tangent at the origin, Eci, for the dynamic stiffness). */
+    elasticGPa?: number;
+    /**
+     * Masonry and plain concrete walls and pillars lose capacity with their slenderness and the unavoidable eccentricity of the load (`structure.masonry`).
+     * Default true for materials tagged `masonry` that are not reinforced.
+     */
+    slender?: boolean;
+}
+/** Bending of beams, slabs, roofs and stairs (`DestructionOptions.structure.flexure`). Every number is configurable; the defaults are real values. */
+interface FlexureOptions {
+    /** Off: beams and slabs are checked in compression only, as before (default true). */
+    enabled?: boolean;
+    /** Roles the bending model applies to (default beam, slab, roof, stair). Only parts whose material has `strength.tensileMPa`. */
+    roles?: readonly StructureRole[];
+    /**
+     * Which beams and slabs the bending model takes. `rebar` (default): those that declare their tension steel in `structure.rebar` (a ratio of 0 is
+     * plain concrete). `reinforced`: also those with only a `reinforcement` cage, their steel taken from the cage. `all`: every one, and those with no
+     * steel at all are plain concrete. The default leaves structures made before this model as they were.
+     */
+    scope?: 'rebar' | 'reinforced' | 'all';
+    /** Factor alpha on the tensile strength for the cracking moment of a rectangular section, `Mr = alpha * fct * b * h^2 / 6` (NBR 6118 17.3.1: 1.5). */
+    crackFactor?: number;
+    /** Yield strength of the tension steel in MPa when the part does not say it (500: CA-50, NBR 7480). */
+    rebarYieldMPa?: number;
+    /** Cover from the tension face to the bar in metres when the part does not say it (0.03: NBR 6118 table 7.2, class II, beams). */
+    cover?: number;
+    /**
+     * Largest neutral axis depth over d of a ductile section (0.45: NBR 6118 14.6.4.3). Steel beyond it is taken as double reinforcement (it adds its
+     * pull times `d - d'`).
+     */
+    neutralAxisLimit?: number;
+    /** Support rotation in degrees at which a reinforced member fails under a blast (10: PDC-TR 06-08, hazardous damage of RC beams and slabs). */
+    failRotationDeg?: number;
+    /** Load factor of the equivalent one-degree-of-freedom system (0.64: Biggs 1964, simply supported, uniform load, elastic). */
+    loadFactor?: number;
+    /** Mass factor of the equivalent system (0.50: Biggs 1964, same case). */
+    massFactor?: number;
+    /** Joules per kilogram of TNT to turn a blast energy into a charge mass (4.184e6, the definition of the TNT equivalent). */
+    tntJoules?: number;
+    /** Incident impulse coefficient in Pa s m / kg^(2/3): `i = impulse * W^(2/3) / R` (200: Sadovsky). */
+    impulse?: number;
+    /** Reflected over incident impulse far from the charge (2: normal reflection of a weak shock). */
+    reflection?: number;
+    /** Rise of the reflection near the charge, in m/kg^(1/3): the factor is `reflection + reflectionNear / Z` (4: about 4 at Z = 2, 6 at Z = 1). */
+    reflectionNear?: number;
+    /** Smallest scaled distance in m/kg^(1/3) the impulse formula is used at; nearer, the breach model of the hit points takes over (0.5). */
+    nearScaled?: number;
+}
+/** Crushing of bearing walls and pillars of masonry or plain concrete (`DestructionOptions.structure.masonry`). */
+interface MasonryOptions {
+    /** Unavoidable eccentricity of the load over the thickness (0.05: NBR 16868-1 and Eurocode 6 6.1.2.2): the capacity is times `1 - 2 * e`. */
+    minEccentricity?: number;
+    /** Slenderness `h / t` at which the capacity reaches zero in `1 - (lambda / limit)^3` (40: NBR 16868-1 reduction factor R). */
+    slendernessLimit?: number;
+    /** Share of the cross-section of concrete counted in the axial capacity of a reinforced pillar, `0.85 * fck` (0.85: NBR 6118 17.2.2). */
+    concreteFactor?: number;
+}
+/** What a soil is made of: decides the pile factors (Décourt-Quaresma) and the modulus correlation. */
+type SoilKind = 'clay' | 'silt' | 'sand' | 'gravel' | 'rock';
+/** A soil class of the registry (`SOILS`, `soils.json`): real allowable pressures and stiffness. Add or override them with `soil.soils`. */
+interface SoilDef {
+    id: string;
+    kind: SoilKind;
+    /** Allowable pressure of a shallow footing in kPa (NBR 6122 basic pressures); the soil gives way at `allowableKPa * soil.safety`. */
+    allowableKPa: number;
+    /** SPT blow count N (NBR 6484), used for the pile resistance (Décourt-Quaresma). */
+    spt: number;
+    /** Young's modulus in MPa (Teixeira & Godoy: `alpha * K * N`). */
+    elasticMPa: number;
+    /** Poisson's ratio. */
+    poisson: number;
+    /** Ultimate pile resistances in kPa when they do not come from `spt` (rock): end bearing at the tip and skin friction on the shaft. */
+    pile?: {
+        tipKPa?: number;
+        skinKPa?: number;
+    };
+}
+/** The soil model. Every number has a real default; see `SOIL_DEFAULTS`. */
+interface SoilOptions {
+    /** Extra or overriding soil classes (merged over `SOILS` by id). */
+    soils?: SoilDef[];
+    /** Profile for objects with foundations whose spec has no `soil` (default none: only objects with `soil` bear on the ground). */
+    site?: string | SoilProfile;
+    /** Global safety factor of a shallow footing: the soil gives way at this times the allowable pressure (3: NBR 6122). */
+    safety?: number;
+    /** Global safety factor of a pile (2: NBR 6122); `pileLength` sizes with it. */
+    pileSafety?: number;
+    /** Influence factor of a rigid footing in the elastic settlement `q B (1 - nu^2) Iw / E` (0.82: rigid square, Bowles). */
+    rigidity?: number;
+    /** Depth under a footing, in footing widths, whose soil it bears on (2: the stress bulb of a square footing). */
+    influence?: number;
+    /** Out-of-plumb of a building, radians (1/200: Eurocode 2 5.2 basic imperfection); it leans this way before any load. */
+    imperfection?: number;
+    /** Footing cells per side for the contact pressure (default 4). */
+    cells?: number;
+    /** Speed at which a yielding foundation sinks, in m/s of game time (0.05; the real thing takes hours to days). */
+    sinkRate?: number;
+    /** Speed at which a yielding object leans further, in degrees per second of game time (1.5). */
+    tiltRate?: number;
+    /** Width a footing has at least under a part that rests on a `terrain` foundation, metres (0.6: NBR 6122 minimum), unless the profile says. */
+    footingWidth?: number;
+    /** Young's modulus of the piles in GPa when the material has no `strength.elasticGPa` (25). */
+    pileElasticGPa?: number;
+}
+/** A terrain roughness category of the wind profile (`wind.terrains`, `WIND_TERRAIN`): NBR 6123 table 1 and the roughness length. */
+interface WindTerrainDef {
+    id: string;
+    /** Gradient height in metres: the profile stops growing above it. */
+    zg: number;
+    /** Parameter `b` of the profile `S2 = b * Fr * (z / 10)^p`, by class of the building. */
+    b: {
+        A: number;
+        B: number;
+        C: number;
+    };
+    /** Exponent `p` of the profile, by class. */
+    p: {
+        A: number;
+        B: number;
+        C: number;
+    };
+    /** Roughness length in metres, for the turbulence intensity `1 / ln(z / z0)` (EN 1991-1-4 4.4). */
+    z0: number;
+}
+/**
+ * The wind. Every number has a real default; see `WIND_DEFAULTS`. The fields of `WindExposure` are the defaults for every object; an object's
+ * `DestructibleSpec.wind` replaces them for itself.
+ */
+interface WindOptions extends WindExposure {
+    /** Basic wind speed V0 in m/s: the 3 s gust at 10 m over flat open ground, 50-year return (NBR 6123 isopleths; 40). */
+    speed?: number;
+    /** Direction the wind blows towards, in world space (the horizontal part is used; default `[1, 0, 0]`). */
+    direction?: Vec3;
+    /** Air density in kg/m³ (1.226: `q = 0.613 V^2`). */
+    airDensity?: number;
+    /** Lowest height the profile is evaluated at, metres (5: NBR 6123). */
+    minHeight?: number;
+    /** Height of one slice of the building, metres (3). */
+    bandHeight?: number;
+    /** Share of the gross stiffness the cracked structure keeps (0.8: NBR 6118 15.7.3). */
+    stiffnessFactor?: number;
+    /** Share of the gross stiffness the cracked beams keep (0.4: NBR 6118 15.7.3); they set how much the columns of a frame resist. */
+    beamFactor?: number;
+    /** Share of the span each side of the web that the slab adds to a beam as a flange (0.1: NBR 6118 14.6.2.2); 0 leaves the slab out of the frame. */
+    flange?: number;
+    /** Drift limit, top deflection over height (1/500). */
+    driftLimit?: number;
+    /** Factor on the wind in the strength checks of the parts and the overturning (1.4: NBR 8681 variable action). */
+    loadFactor?: number;
+    /** Count the axial stiffness of the columns in the bending of the whole building (false: a frame of shallow beams does not act as a tube). */
+    chord?: boolean;
+    /** Fraction of the design gust the 10-minute mean wind is (0.69: NBR 6123 chapter 9). */
+    meanRatio?: number;
+    /** Gust factor Fr of each class (NBR 6123 table 1: 1, 0.98, 0.95). */
+    gustFactor?: {
+        A: number;
+        B: number;
+        C: number;
+    };
+    /** Extra or overriding terrain categories (merged over `WIND_TERRAIN` by id). */
+    terrains?: WindTerrainDef[];
+    /** The gust in time: sines drawn from the Davenport spectrum (`components` of them up to `maxHz`, `scale` metres in `x = scale f / V10`, `seed` for the phases). */
+    gust?: {
+        components?: number;
+        maxHz?: number;
+        scale?: number;
+        seed?: number;
+    };
+    /** Seconds in which the recorded peak of the sway decays by a factor e (60). */
+    peakDecay?: number;
+    /** Tuning of a tuned mass damper that gives no frequency: `den-hartog` (harmonic force) or `warburton` (random force). */
+    tuning?: 'den-hartog' | 'warburton';
 }
 interface DestructionOptions {
     /** Extra or overriding materials (merged over `MATERIALS` by id). */
@@ -95,18 +292,43 @@ interface DestructionOptions {
     maxHoles?: number;
     /** Distance at which a burning part heats parts of other objects, in metres (default 0.6). */
     fireSpread?: number;
+    /**
+     * The structure solver. A slab or beam is held by the sum of the capacities of what it rests on: its load is shared among the supports that are
+     * left, so losing columns moves the load to the rest and the structure falls when the capacity left (the sum) is less than the load.
+     * The capacity of each part is `structure.capacity`, else the material's `compressive` (kg/m², in `MaterialDef`) times its section.
+     */
+    structure?: {
+        /**
+         * Multiplies every load before it is compared with the capacities: stress = `load * safetyFactor / capacity` (default 1). Above 1 the whole
+         * structure is loaded harder than its capacities were sized for (a worn building, a weaker material); below 1 it has extra margin. It does not
+         * change the capacities; to size them use `sizeStructure({ safety })`.
+         */
+        safetyFactor?: number;
+        /** Bending of beams and slabs: the tension face cracks, the steel carries the pull, a member without steel snaps. See `FlexureOptions`. */
+        flexure?: FlexureOptions;
+        /** Crushing of bearing walls and pillars with slenderness. See `MasonryOptions`. */
+        masonry?: MasonryOptions;
+    };
+    /** The ground under objects that have `DestructibleSpec.soil` (or `soil.site`): settlement, tilt, bearing failure and piles. See `SoilOptions`. */
+    soil?: SoilOptions;
+    /**
+     * The wind of the world on every structure (default none: no wind). A lateral load that grows with height, the core and the frame that resist it, the
+     * sway of the top and tuned mass dampers. See `WindOptions`.
+     */
+    wind?: WindOptions;
+    /**
+     * What lights the flammable fluid that leaks from a container (a fuel tank, a jerrycan, a gas bottle). A round that goes through only makes a
+     * leak; it lights it only when `Hit.ignition` (a spark on metal), `Hit.incendiary` or `Hit.tracer` say so, by the chance of the round weighed by
+     * how full the container is; a burning part within `fireNear.radius` or a blast also lights it. See `IgnitionRules` of the contracts for every
+     * number and its default.
+     */
+    ignition?: Partial<IgnitionRules>;
     /** Breach of staged parts (see `PartSpec.breach`). */
     breach?: {
         /** Metres around a hit within which through damage adds up (default 0.55). */
         radius?: number;
         /** Multiplier of the breach area a blast makes over a blow of the same damage: a blast loads the whole crater (default 6). */
         blastFactor?: number;
-        /**
-         * Metres of reach per cube root of kilojoule: a blast only opens a breach in a part within `blastReach * cbrt(energy / 1000)` of the centre
-         * (a hand grenade of 200 kJ: 0.7 m; 2 MJ: 1.5 m). Farther away it still damages, dents and cracks. Without it a falloff that is gentle over a
-         * large radius let a grenade at 1 m cut a reinforced column in two. Default `Infinity` (off, so the goldens stay as they were); 0.12 is the value that matches real charges.
-         */
-        blastReach?: number;
     };
     /**
      * Speed of the blast front in m/s. A glass part at distance `d` from an explosion breaks `d / blastFrontSpeed` seconds later, in `update`
@@ -134,6 +356,18 @@ interface SizeStructureOptions {
     redundancy?: number;
     /** Extra or overriding materials, the same list given to `createDestruction`. */
     materials?: MaterialDef[];
+    /**
+     * Bending options of the world the spec will go into (`DestructionOptions.structure.flexure`). Reinforced beams and slabs (a `reinforcement` cage
+     * or `structure.rebar`) get the tension steel ratio they need: at rest at `safety` (per role) of their moment, and, with `redundancy`, after the loss
+     * of any part of `redundancyRoles`. Steel is only added, never removed, and plain concrete stays plain.
+     */
+    flexure?: FlexureOptions;
+    /**
+     * The wind the structure is designed for (the same `WindOptions` the world will have): each wall and column gets the capacity for its dead load
+     * plus the factored axial force the wind adds to it, at `safety`, and a reinforced one that the wind pulls past its dead load gets bars thick enough
+     * (to 40 mm) to hold the pull at `safety`. Beams and slabs do not change (the wind moment in the frame is not modelled).
+     */
+    wind?: WindOptions;
 }
 interface AddOptions {
     /** Object id (default a generated `obj_1`, `obj_2`...). */
@@ -181,7 +415,7 @@ interface DestructionWorld {
     /** Raycast against every part shape (world space). */
     raycast(origin: Vec3, direction: Vec3, maxDistance?: number): RayHit | null;
     /** Ballistic shot: raycast, hit, and continue through with the exit energy (up to 4 objects/parts). */
-    shoot(origin: Vec3, direction: Vec3, energy: number, caliber: number, source?: string, piercing?: number): HitResult[];
+    shoot(origin: Vec3, direction: Vec3, energy: number, caliber: number, source?: string, round?: number | BallisticExtras): HitResult[];
     /**
      * Work on a joint with a tool for `dt` seconds (call every frame while the player holds the button). Returns the progress 0..1, or -1 when the
      * tool cannot undo this joint. At 1 the joint opens (`detach` with `by: 'tool'`).
@@ -218,6 +452,26 @@ interface DestructionWorld {
      * that drain or refill the part. Does nothing when the part has no `contains`.
      */
     setLiters(objectId: string, partId: string, liters: number): void;
+    /**
+     * Opens a through opening of `diameter` metres (default 8 mm) in a container part (`PartSpec.contains`) at a world point, as a valve or a tap does: the part leaks like it does from a bullet hole
+     * (a `leak` event, the level drops in `update`, gas lights from a flame and then burns or goes off by its `explodes.chain`) but nothing is damaged and no `hole` event is sent. `point` defaults to the part's
+     * centre and `normal` (the way the fluid leaves) to up. Returns false when the part holds nothing, is lost or the object is a registered impl; true when it is open (also when it already was).
+     */
+    vent(objectId: string, partId: string, opening?: {
+        point?: Vec3;
+        normal?: Vec3;
+        diameter?: number;
+    }): boolean;
+    /** Closes the openings `vent` made in a part; returns how many it closed. The leak stops (a gas jet that is burning goes out when the level reaches zero or the fluid no longer flows). */
+    seal(objectId: string, partId: string): number;
+    /**
+     * Change the wind of the world (`DestructionOptions.wind`) while playing: its speed and the direction it blows towards. Turns the wind on when the
+     * world was made without it.
+     */
+    setWind(wind: {
+        speed?: number;
+        direction?: Vec3;
+    }): void;
     /** Seconds since creation. */
     readonly time: number;
 }
@@ -233,6 +487,8 @@ interface PartRuntime {
     shockT: number;
     /** A leaking flammable fluid is burning on this part. */
     jet: boolean;
+    /** A spark, a flame or a blast reached the flammable fluid that leaks from this part: it burns (or goes off) at the next update. */
+    lit?: boolean;
     /** Seconds left before the next `stress` event. */
     stressT?: number;
     /** World time at which a primed explosive part goes off (`explodes.chain`). */
@@ -243,6 +499,8 @@ interface PartRuntime {
     breach?: Array<[number, number, number, number]>;
     /** Mass in kg that left the part in a breach. */
     removed?: number;
+    /** Plastic rotation in radians a reinforced beam or slab took in bending (blasts add it up; `flexure.failRotationDeg` breaks it). */
+    hinge?: number;
 }
 /** Opaque bookkeeping of an object (see `PartRuntime`). `joints` holds the last disassembly step reported per joint id. */
 interface ObjectRuntime {
@@ -250,6 +508,10 @@ interface ObjectRuntime {
     joints: Record<string, number>;
     /** Parts of groups that already reported a `collapse`. */
     collapsed?: string[];
+    /** Permanent settlement of the soil under each footing cell or pile that yielded (`DestructibleSpec.soil`), metres. */
+    soil?: Record<string, number>;
+    /** Sway of the top and of the tuned mass damper: `[x, v, y, w, peak]` (displacement and velocity of the building, of the damper, recorded peak). */
+    wind?: [number, number, number, number, number];
 }
 interface DestructionSnapshot {
     version: 1;
@@ -304,18 +566,6 @@ interface ExplosivePartOptions {
  */
 declare const explosivePart: (explosive: WorldExplosive, part: Omit<PartSpec, "explodes">, options?: ExplosivePartOptions) => PartSpec;
 
-/**
- * How well a bullet cuts through for its energy (`Hit.piercing`, the 6th argument of `shoot`). The material's `penetration` is joules per
- * millimetre for a hard bullet; soft lead deforms on steel and concrete and a core of hardened steel does better. A host that knows the kind
- * of the bullet (`CaliberDef.kind` of `@adatechnology/game-weapons`) takes the number from here, or replaces the tables with its own.
- *
- * Reference: a 12 ga slug (3000 J) does not go through 8 mm of mild steel, a .50 BMG (18000 J) goes through 20 mm and more.
- */
-declare const PIERCING_BY_KIND: Readonly<Record<string, number>>;
-/** Caliber ids whose bullet is lighter on the target than its kind says (a soft-core 5.56 ball does not go through a steel flange). */
-declare const PIERCING_BY_CALIBER: Readonly<Record<string, number>>;
-declare const piercingOf: (caliber: string, kind?: string) => number;
-
 /** Built-in materials (data in `src/data/materials.json`). Override or extend with the `materials` option of `createDestruction`. */
 declare const MATERIALS: MaterialDef[];
 /** Default joint strength (joint hit points), tools that undo it and seconds of tool work. */
@@ -344,10 +594,16 @@ declare const partThickness: (part: PartSpec) => number;
  */
 declare const inferJoints: (parts: PartSpec[], tolerance?: number, materials?: ReadonlyMap<string, MaterialDef>) => JointSpec[];
 /**
- * Load in kg a structural part carries before it fails: `structure.capacity`, else `material.compressive` (default 20 000 kg/m²) times the
- * section. The section is the product of the two smallest dimensions (thickness times longest dimension for slabs; thickness times horizontal length for walls); foundations get x10.
+ * Load in kg a structural part carries before it fails in compression: `structure.capacity`, else the section times the material's strength. The
+ * section is the product of the two smallest dimensions (thickness times longest dimension for slabs; thickness times horizontal length for walls);
+ * foundations get x10. With `material.strength` (real values) the strength is `compressiveMPa`: a slender masonry or plain concrete wall or pillar keeps
+ * `slendernessFactor` of it (the unavoidable eccentricity and its height over thickness), a reinforced pillar carries `0.85 * fck * Ac + As * fy`
+ * (NBR 6118). Without it, the game-tuned `material.compressive` (default 20 000 kg/m²).
  */
-declare const partCapacity: (part: PartSpec, material: MaterialDef) => number;
+declare const partCapacity: (part: PartSpec, material: MaterialDef, options?: {
+    masonry?: MasonryOptions;
+    flexure?: FlexureOptions;
+}) => number;
 /**
  * Multiplier of blunt damage on brittle parts (ductility < 0.3): up to x4.7 for fully brittle materials (glass, ceramic, stone), times a thinness
  * term that follows bending stress (1 / thickness squared, x1 at 2 cm or more, at most x25). A 3 mm glass bottle breaks from a 1.5 m drop; a
@@ -431,6 +687,31 @@ interface FrameOptions {
     wallMaterial?: MaterialId;
     /** Override the load capacity of every column, kg (see `PartState.load`). */
     columnCapacity?: number;
+    /**
+     * Tension steel ratio of the beams and slabs (`structure.rebar.ratio`; default beams 1%, slabs and roof 0.5%, inside the ranges of NBR 6118);
+     * `false` makes them plain concrete (they snap when they bend past cracking).
+     */
+    rebar?: {
+        beam?: number;
+        slab?: number;
+    } | false;
+    /** Side of the square pad under each column in metres (default 2.2 x `columnSize`), 0.3 m thick. */
+    footing?: number;
+    /** One raft under the whole frame instead of a pad per column (`raft`, the footprint plus `footing` / 2 each side, 0.4 m thick). */
+    raft?: boolean;
+    /** Piles under each pad (or under the raft): the pad becomes a pile cap. */
+    piles?: PileSpec;
+    /**
+     * Columns run from storey to storey: each one rests on the column below (through the slab, as a cast-in-place column does) instead of on the slab,
+     * so the slab carries only its own floor. Default false (the column of each storey stands on the slab below, as before).
+     */
+    continuousColumns?: boolean;
+    /** Rebar cage of the columns (`PartSpec.reinforcement`; default none). A caged column carries `0.85 fck Ac + As fy` and its `rebar` joints are monolithic. */
+    columnCage?: Reinforcement;
+    /** Thickness of the roof slab (default 0.75 x `slabThickness`; a flat roof that carries a screed and equipment is as thick as a floor). */
+    roofThickness?: number;
+    /** The ground the frame stands on (`DestructibleSpec.soil`). */
+    soil?: string | SoilProfile;
 }
 /**
  * A parametric test structure: a grid of columns on foundations, beams between the column tops, one slab per floor (the last one a roof), and
@@ -440,6 +721,13 @@ interface FrameOptions {
  */
 declare const buildFrame: (o?: FrameOptions) => DestructibleSpec;
 
+/**
+ * Sizes the tension steel of the reinforced beams, slabs, roofs and stairs of a structure (a `reinforcement` cage or a `structure.rebar`), the way
+ * `sizeStructure` sizes the capacities: each one gets the `structure.rebar.ratio` that keeps its bending at rest (`PartState.flexure`) at `safety`
+ * (`safetyByRole`) and, with `redundancy`, at most `redundancy` after the loss of any part of `redundancyRoles`. Steel is only added (up to 4% of the
+ * section) and plain concrete stays plain: a beam the spec makes without steel is a beam without steel. Returns a copy.
+ */
+declare const sizeRebar: (spec: DestructibleSpec, options?: SizeStructureOptions) => DestructibleSpec;
 /**
  * Sizes the load capacity of a structure the way an engineer would, from the loads the world itself computes. The intact spec goes through the
  * same load solver `createDestruction` uses, and each structural part (`structure.role` other than `none`) gets `structure.capacity = load / safety`,
@@ -450,6 +738,233 @@ declare const buildFrame: (o?: FrameOptions) => DestructibleSpec;
  */
 declare const sizeStructure: (spec: DestructibleSpec, options?: SizeStructureOptions) => DestructibleSpec;
 
+/**
+ * Real structural engineering of beams, slabs, walls and pillars: bending (the tension face cracks, the steel carries the pull, a member without
+ * steel snaps) and crushing of slender bearing walls. Pure formulas in SI units (N, m, Pa, J); the world calls them with the parts' geometry.
+ */
+/** Standard gravity, m/s². A physical constant. */
+declare const GRAVITY = 9.81;
+declare const FLEXURE_DEFAULTS: Required<FlexureOptions>;
+declare const MASONRY_DEFAULTS: Required<MasonryOptions>;
+/** Cracking moment of a rectangular section in N m: `alpha * fct * b * h^2 / 6` (NBR 6118 17.3.1). */
+declare const crackingMoment: (tensileMPa: number, b: number, h: number, alpha?: number) => number;
+/**
+ * Moment the tension steel gives in N m, with the rectangular stress block of NBR 6118 17.2.2 (`0.85 * fck` over `0.8 x`): the steel pulls
+ * `T = As * fy`, the block takes it at depth `x = T / (0.68 * fck * b)`, and `M = T * (d - 0.4 x)`. Past the ductility limit `x = limit * d` the
+ * concrete would crush first, so the steel beyond what balances the block is taken as paired with compression steel (double reinforcement, NBR 6118
+ * 17.2.4): it adds `T2 * (d - d')`, `d'` being the cover to the compression bars.
+ */
+declare const steelMoment: (area: number, yieldMPa: number, d: number, b: number, compressiveMPa: number, options?: Pick<FlexureOptions, "neutralAxisLimit" | "cover">) => number;
+/**
+ * Strain energy in J of the equivalent one-degree-of-freedom system of a span whose peak moment is `M` (uniform load: `R = 8 M / L`): `KL * R^2 / (2 k)`.
+ */
+declare const elasticEnergy: (moment: number, span: number, EI: number, loadFactor?: number) => number;
+/** Inverse of `elasticEnergy`: the peak moment in N m a span reaches when it takes `energy` J elastically. */
+declare const momentOfEnergy: (energy: number, span: number, EI: number, loadFactor?: number) => number;
+/** Kinetic energy in J an impulse `I` (N s) gives the equivalent system of a span of mass `m` (kg): `(KL I)^2 / (2 KM m)` (Biggs 1964). */
+declare const impulseEnergy: (impulse: number, mass: number, options?: Pick<FlexureOptions, "loadFactor" | "massFactor">) => number;
+/**
+ * Reflected impulse per area in Pa s of a charge of `tnt` kg at `distance` m on a face that looks at it. The incident impulse is Sadovsky's
+ * `impulse * W^(2/3) / R`; the face reflects it by `reflection + reflectionNear / Z` (`Z = R / W^(1/3)`, m/kg^(1/3)): about 2 far away, 4 to 6 at
+ * one or two metres per cube root kilogram, as the reflected-impulse curves of UFC 3-340-02 (fig. 2-7) rise towards the charge. Below `nearScaled`
+ * the distance is held at that scaled distance.
+ */
+declare const blastImpulse: (tnt: number, distance: number, options?: Pick<FlexureOptions, "impulse" | "reflection" | "reflectionNear" | "nearScaled">) => number;
+/**
+ * Share of the compressive strength a wall or pillar of height `h` and thickness `t` keeps: the unavoidable eccentricity `(1 - 2 e)` times the
+ * slenderness reduction `1 - (h / t / limit)^3` (NBR 16868-1), never below 0.
+ */
+declare const slendernessFactor: (h: number, t: number, options?: MasonryOptions) => number;
+/** A bending section: width `b`, depth `h` (along the bending), in metres. */
+interface BendSection {
+    b: number;
+    h: number;
+}
+/** Tension steel of a section: area in m², effective depth in m, yield in MPa. */
+interface TensionSteel {
+    area: number;
+    d: number;
+    yieldMPa: number;
+}
+/**
+ * Tension steel of the part for a section of width `b` and depth `h`: from `structure.rebar` (`ratio * b * d`), else from the `reinforcement` cage
+ * (a plate's grid: one bar every `spacing` across `b`; a long member: the bars of the perimeter on the tension face). Zero for plain concrete.
+ */
+declare const tensionSteel: (part: PartSpec, dims: Vec3, section: BendSection, options: Required<FlexureOptions>) => TensionSteel;
+/**
+ * Moments of a section in N m: `cracking` (the concrete's), `steel` (what the tension steel gives once the concrete has cracked; 0 for plain
+ * concrete), `ultimate` (what the uncracked section holds: the larger of the two) and `reinforced` (it has steel: when it fails it hinges and its bars
+ * keep it in one piece; without steel it snaps).
+ */
+interface SectionMoments {
+    cracking: number;
+    steel: number;
+    ultimate: number;
+    reinforced: boolean;
+}
+declare const sectionMoments: (material: MaterialDef, section: BendSection, steel: TensionSteel, options: Required<FlexureOptions>) => SectionMoments;
+/** Static moment in N m at mid-span of a span `L` under a uniform load `w` (N/m): `w L^2 / 8`. */
+declare const spanMoment: (w: number, span: number) => number;
+/**
+ * How a box part bends, in its own axes. A long member (beam) spans along `long` and bends about either cross axis; a plate (slab) spans in the plane
+ * of `plane` and bends across its thickness `thin`. `gravity` is the axis the weight bends it along (the local axis closest to the vertical among those
+ * it can bend along, when it is within 45 degrees of it; -1 for a plate standing on edge). `up` is the world vertical in the part's axes.
+ */
+interface BendGeometry {
+    dims: Vec3;
+    member: boolean;
+    /** Axes the span is measured along: `[long]` for a member, the two plane axes for a plate. */
+    spanAxes: number[];
+    /** Axes the part can bend along (its depth): the two cross axes of a member, the thickness of a plate. */
+    depthAxes: number[];
+    gravity: number;
+    up: Vec3;
+}
+declare const bendGeometry: (part: PartSpec) => BendGeometry;
+/**
+ * Span in metres from the regions the part rests on (`contacts`: boxes `[min, max]` in the part's axes): twice the farthest any point of the part
+ * is from its nearest support, measured along the span axes as the largest of the per-axis gaps. Two walls 4 m apart give 4 m, four columns at the
+ * corners of a 5 x 4 m panel give 5 m (the long way), a cantilever of 1.5 m gives 3 m (the same moment, `w c^2 / 2`). 0 without contacts.
+ */
+declare const spanOf: (g: BendGeometry, contacts: ReadonlyArray<readonly [Vec3, Vec3]>, samples?: number) => number;
+interface BearingWallOptions {
+    /** Storeys the wall carries, the ground floor included. */
+    storeys: number;
+    /** Height of one storey in metres. */
+    storeyHeight: number;
+    /** Load each floor puts on one metre of wall, in N/m (dead and live load of the floor's share). */
+    floorLoad: number;
+    /** Material of the wall (default the built-in `brick`): `strength.compressiveMPa` and `density`. */
+    material: Pick<MaterialDef, 'density' | 'strength'>;
+    /** Load factor (1.4: NBR 8681, permanent and variable loads). */
+    loadFactor?: number;
+    /** Material factor (2.0: NBR 16868-1, masonry). */
+    materialFactor?: number;
+    /** Thinnest bearing wall in metres (0.14: NBR 16868-1). */
+    minThickness?: number;
+    /** Thicknesses are rounded up to this many metres (0.01). */
+    step?: number;
+    masonry?: MasonryOptions;
+}
+/**
+ * Thickness of a bearing masonry wall storey by storey, ground floor first, as a designer sizes it: the load from the top down (every floor plus the
+ * walls above, times `loadFactor`) within `fk / materialFactor` times the slenderness factor of each storey's wall. `Infinity` when a storey cannot be
+ * carried at any thickness (the wall's own weight per storey already uses up the strength).
+ */
+declare const bearingWallThickness: (options: BearingWallOptions) => number[];
+
+/**
+ * Soil and foundations. A footing bears on the soil under it as a bed of springs (the subgrade modulus of the elastic settlement of a rigid footing)
+ * that give way at the soil's bearing capacity; a pile carries its load by end bearing and skin friction (Décourt-Quaresma) and gives way when the
+ * load passes them. The whole object rests on those springs as a rigid body: it settles, leans with the out-of-plumb of the building and with its
+ * own weight moving over as it leans (P-delta), and, when the springs cannot hold it, it keeps sinking and leaning until its centre of mass passes
+ * the edge of its foundations and it tips over.
+ */
+/** Built-in soil classes (data in `src/data/soils.json`): NBR 6122 basic pressures, SPT N, moduli from Teixeira & Godoy. */
+declare const SOILS: readonly SoilDef[];
+declare const SOIL_DEFAULTS: {
+    readonly safety: 3;
+    readonly pileSafety: 2;
+    readonly rigidity: 0.82;
+    readonly influence: 2;
+    readonly imperfection: number;
+    readonly cells: 4;
+    readonly sinkRate: 0.05;
+    readonly tiltRate: 1.5;
+    readonly pileElasticGPa: 25;
+    readonly footingWidth: 0.6;
+};
+/** A profile from a soil class id or a profile. */
+declare const profileOf: (soil: string | SoilProfile) => SoilProfile;
+/** The layers of a profile that lie between two depths (metres below the surface), with the thickness of each inside that range. */
+declare const layersBetween: (profile: SoilProfile, top: number, bottom: number, soils: ReadonlyMap<string, SoilDef>) => Array<{
+    soil: SoilDef;
+    thickness: number;
+    top: number;
+}>;
+/** The soil class at a depth (metres below the surface). */
+declare const soilAt: (profile: SoilProfile, depth: number, soils: ReadonlyMap<string, SoilDef>) => SoilDef;
+/** The soil a footing of width `width` at `depth` bears on: the weakest allowable pressure and the mean modulus over `influence` widths below it. */
+declare const footingSoil: (profile: SoilProfile, depth: number, width: number, soils: ReadonlyMap<string, SoilDef>, influence?: number) => {
+    allowableKPa: number;
+    elasticMPa: number;
+    poisson: number;
+};
+/**
+ * Ultimate resistance of one pile in newtons, by Décourt-Quaresma: end bearing `alpha C N A` at the tip and skin friction `beta 10 (N/3 + 1)` kPa
+ * along the shaft in each layer (N limited to 3..50). Rock with `pile` resistances uses those instead. `top` is the depth of the pile head.
+ */
+declare const pileCapacity: (profile: SoilProfile, pile: PileSpec, top: number, soils: ReadonlyMap<string, SoilDef>) => {
+    tip: number;
+    skin: number;
+    ultimate: number;
+    tipSoil: SoilDef;
+};
+/**
+ * The shortest pile (to `step` metres) whose ultimate resistance over `safety` carries `load` newtons, going down from `top`; `maxLength` if none.
+ * This is how a designer takes a pile down to firm ground.
+ */
+declare const pileLength: (profile: SoilProfile, o: {
+    load: number;
+    diameter: number;
+    top?: number;
+    method?: PileSpec["method"];
+    safety?: number;
+    step?: number;
+    maxLength?: number;
+    soils?: ReadonlyMap<string, SoilDef>;
+}) => number;
+/** Stiffness of one pile in N/m: the shaft shortens under the mean of its force (`L / (2 E A)`) in series with the tip as a rigid plate (`E d / (1 - nu^2)`). */
+declare const pileStiffness: (pile: PileSpec, pileElasticGPa: number, tipElasticMPa: number, tipPoisson: number) => number;
+/** Subgrade modulus in Pa/m of a rigid footing of width `width`: `E / (B (1 - nu^2) Iw)`, the elastic settlement of the footing as springs. */
+declare const subgradeModulus: (elasticMPa: number, poisson: number, width: number, rigidity?: number) => number;
+/**
+ * Thickness-free design check of a shallow footing: the area a load of `load` newtons needs on `soil` (allowable pressure), as a designer sizes it.
+ */
+declare const footingArea: (load: number, allowableKPa: number) => number;
+/** One support of the object on the ground: a footing cell or a pile, at object-local `x, z`, `hx`/`hz` half its size. */
+interface SoilSpring {
+    x: number;
+    z: number;
+    hx: number;
+    hz: number;
+    /** N/m. */
+    k: number;
+    /** Newtons it carries before it gives way. */
+    cap: number;
+    /** Permanent settlement of the soil under it from yielding, metres: it pushes back only past this (default 0). */
+    set?: number;
+}
+interface FoundationSolve {
+    /** Settlement at the centre of stiffness, metres. */
+    s: number;
+    /** Slopes of the base: the foundations go down `a` per metre of x and `b` per metre of z. */
+    a: number;
+    b: number;
+    /** An equilibrium was found and it is stable. */
+    stable: boolean;
+    /** Some spring is at its capacity in that equilibrium. */
+    yielded: boolean;
+    /** Weight over the sum of the capacities. */
+    bearing: number;
+    /** Largest force over capacity of a spring, 0..1. */
+    edge: number;
+    /** Residual of the vertical force and moments at the end, to tell which way an unstable object moves. */
+    residual: [number, number, number];
+}
+/** Centre of stiffness of the springs. */
+declare const stiffnessCentre: (springs: readonly SoilSpring[]) => [number, number];
+/**
+ * Equilibrium of a rigid object of weight `weight` (N) on elastic-perfectly-plastic springs that carry no tension, with its centre of mass at
+ * `(xg, zg)` and `height` metres above the base, leaning `imperfection` (radians, x and z) before any load and moving over as it leans (P-delta).
+ * Newton iterations from `start`; where the tangent is not positive definite the elastic stiffness of the springs in contact is used instead.
+ */
+declare const solveFoundation: (springs: readonly SoilSpring[], weight: number, xg: number, zg: number, height: number, imperfection: readonly [number, number], start?: {
+    s: number;
+    a: number;
+    b: number;
+}) => FoundationSolve;
+
 /** Small vector helpers (arrays of three numbers). Pure functions; they allocate a new array. */
 declare const vec: {
     add: (a: Vec3, b: Vec3) => Vec3;
@@ -517,4 +1032,269 @@ declare const checkDestructible: (impl: DestructibleImpl, options?: CheckOptions
     problems: string[];
 };
 
-export { ASSEMBLIES, type AddOptions, type AssemblyDef, type AssemblyPartOptions, CONFINEMENT_DEFAULTS, type ChainTrigger, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type ExplosivePartOptions, FIRE_PRIME_C, FRAGMENT_HIT_DEFAULTS, type FrameOptions, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MATERIALS, type MaterialDef, type MaterialThermal, type ObjectRuntime, PIERCING_BY_CALIBER, PIERCING_BY_KIND, type PartRuntime, SHELTER_DEFAULTS, type SizeStructureOptions, type WorldExplosive, assemblyDepth, assemblyPart, buildFrame, checkDestructible, createDestruction, explosivePart, fragility, getAssembly, guessMaterial, inferJoints, locales, partCapacity, partMass, partThickness, partVolume, piercingOf, quat, quatFromEuler, registerAssembly, resolveStrings, rotateVec, sizeStructure, toLocal, toWorld, vec };
+/**
+ * Wind on a building. The wind pressure grows with the height (NBR 6123), the building is cut into storey-high bands, each band takes the force of
+ * its area, and the structure that resists it is the walls (a cantilever of composite section) working with the frame (storey shear stiffness) as
+ * the wall-frame interaction of Heidebrecht & Stafford Smith. The same stiffness gives the first mode (Rayleigh), and a gust series moves the top
+ * against it, with a tuned mass damper if there is one. Pure formulas in SI units (N, m, Pa, s); the world calls them with the parts' boxes.
+ */
+/** Built-in terrain categories (data in `src/data/wind-terrain.json`): NBR 6123 table 1 and the roughness lengths. */
+declare const WIND_TERRAIN: readonly WindTerrainDef[];
+declare const WIND_DEFAULTS: {
+    readonly speed: 40;
+    readonly direction: Vec3;
+    readonly terrain: NonNullable<WindExposure["terrain"]>;
+    readonly class: NonNullable<WindExposure["class"]>;
+    readonly topography: 1;
+    readonly statistical: 1;
+    readonly drag: 1.3;
+    readonly damping: 0.016;
+    readonly airDensity: 1.226;
+    readonly minHeight: 5;
+    readonly bandHeight: 3;
+    readonly stiffnessFactor: 0.8;
+    readonly beamFactor: 0.4;
+    readonly flange: 0.1;
+    readonly driftLimit: number;
+    readonly loadFactor: 1.4;
+    readonly chord: false;
+    readonly meanRatio: 0.69;
+    readonly gustFactor: {
+        readonly A: 1;
+        readonly B: 0.98;
+        readonly C: 0.95;
+    };
+    readonly gust: {
+        readonly components: 400;
+        readonly maxHz: 2;
+        readonly scale: 1200;
+        readonly seed: 1;
+    };
+    readonly peakDecay: 60;
+    readonly tuning: NonNullable<WindOptions["tuning"]>;
+};
+type ResolvedWind = Required<Omit<WindOptions, 'terrains' | 'gustFactor' | 'gust' | 'direction'>> & {
+    direction: Vec3;
+    gustFactor: {
+        A: number;
+        B: number;
+        C: number;
+    };
+    gust: {
+        components: number;
+        maxHz: number;
+        scale: number;
+        seed: number;
+    };
+    terrains: Map<string, WindTerrainDef>;
+};
+declare const resolveWind: (o?: WindOptions) => ResolvedWind;
+/** The world's wind with one object's `DestructibleSpec.wind` over it. */
+declare const exposureOf: (w: ResolvedWind, spec?: WindExposure | false) => ResolvedWind;
+/** Dynamic pressure in N/m² of a wind of `speed` m/s: `q = rho V^2 / 2`, which is `0.613 V^2` for the air at 15 °C (NBR 6123 4.2). */
+declare const windPressure: (speed: number, density?: number) => number;
+/** Class of a building by its largest dimension (NBR 6123 table 1): `A` up to 20 m, `B` up to 50 m, `C` above. */
+declare const windClass: (largest: number) => "A" | "B" | "C";
+/**
+ * Height factor of the gust `S2 = b * Fr * (z / 10)^p` (NBR 6123 5.3), `z` in metres above the ground: at least `minHeight` and at most the gradient
+ * height of the category.
+ */
+declare const heightFactor: (z: number, terrain: WindTerrainDef, cls: "A" | "B" | "C", o?: {
+    gustFactor?: {
+        A: number;
+        B: number;
+        C: number;
+    };
+    minHeight?: number;
+}) => number;
+/** The same profile for the 10-minute mean wind: no gust factor, times `meanRatio` (the share of the gust the mean is). */
+declare const meanHeightFactor: (z: number, terrain: WindTerrainDef, cls: "A" | "B" | "C", o?: {
+    meanRatio?: number;
+    minHeight?: number;
+}) => number;
+/** Turbulence intensity at `z` over terrain of roughness length `z0`: `1 / ln(z / z0)` (EN 1991-1-4 4.4), no more than 0.5. */
+declare const turbulenceIntensity: (z: number, z0: number) => number;
+interface WallFrameSolution {
+    /** Rotation `w'` at the n + 1 nodes. */
+    psi: number[];
+    /** Deflection at the nodes (0 at the base). */
+    w: number[];
+}
+/**
+ * A cantilever with bending stiffness `ei[j]` (N m²) and shear stiffness `ga[j]` (N) in each band of height `hb[j]`, loaded by the shear `V` at the
+ * n + 1 nodes (from the base up; `V[n]` is the shear at the top, 0 when nothing hangs there). The wall and the frame share the load as
+ * `-(EI psi')' + GA psi = V`, `psi(0) = 0` (as far as there is a wall), zero moment at the top: linear elements, one per band, a tridiagonal system. Without the frame
+ * (`ga` 0) it is the bending cantilever (`w = w H^4 / (8 EI)` for a uniform load), without the wall (`ei` 0) the shear beam (`w' = V / GA`).
+ */
+declare const solveWallFrame: (hb: readonly number[], ei: readonly number[], ga: readonly number[], V: readonly number[]) => WallFrameSolution;
+/** Shear at the n + 1 nodes of loads `f[j]` spread over each band (the load of the bands above, from the top). */
+declare const shearNodes: (f: readonly number[]) => number[];
+/** Moment at the n + 1 nodes from the shear at the nodes (linear inside each band, so the trapezoid is exact). */
+declare const momentNodes: (hb: readonly number[], V: readonly number[]) => number[];
+interface WindPartInput {
+    /** Object-local box of the part (`aabbOf`). */
+    min: Vec3;
+    max: Vec3;
+    /** `wall` and `column` resist, `beam` frames into the columns, `foundation` is the footprint, `other` only weighs and shows area. */
+    kind: 'wall' | 'column' | 'beam' | 'foundation' | 'other';
+    /** Young's modulus in Pa (walls, columns, beams). */
+    elasticPa?: number;
+    /** Mass in kg (what rests on it is counted by the parts that rest). */
+    mass: number;
+    /** A tuned mass damper: weighs, but is not part of the modal mass of the building. */
+    damper?: boolean;
+    /** Indices of the beams that frame into this column (closed joints). */
+    beams?: readonly number[];
+    /** Thickness of the slab that rests on this beam and works with it as a T section (0: none). */
+    slab?: number;
+}
+/** Everything `analyzeWind` needs once it is resolved for one building (`ResolvedWind` with its terrain and direction). */
+interface WindCase {
+    speed: number;
+    /** Horizontal unit vector the wind blows towards, object-local `[x, z]`. */
+    direction: readonly [number, number];
+    terrain: WindTerrainDef;
+    cls: 'auto' | 'A' | 'B' | 'C';
+    topography: number;
+    statistical: number;
+    drag: number;
+    damping: number;
+    airDensity: number;
+    minHeight: number;
+    bandHeight: number;
+    stiffnessFactor: number;
+    beamFactor: number;
+    flange: number;
+    loadFactor: number;
+    chord: boolean;
+    meanRatio: number;
+    gustFactor: {
+        A: number;
+        B: number;
+        C: number;
+    };
+}
+interface WindAnalysis {
+    /** Height of the top above the ground and the class used. */
+    height: number;
+    cls: 'A' | 'B' | 'C';
+    /** Largest width across the wind. */
+    width: number;
+    /** Band heights and the height of the middle of each above the ground. */
+    bands: number[];
+    mid: number[];
+    /** Design force on each band, N, and the force of the 10-minute mean wind. */
+    forces: number[];
+    meanForces: number[];
+    /** Design pressure at the top, N/m². */
+    pressure: number;
+    /** Design base shear (N) and overturning moment (N m). */
+    shear: number;
+    moment: number;
+    /** Top deflection under the design wind (m), over the height, and under the mean wind. */
+    deflection: number;
+    drift: number;
+    lean: number;
+    /** Weight, N, and the overturning moment (factored) over the stabilizing moment `W e`. */
+    weight: number;
+    overturn: number;
+    /** Share of the base moment the walls carry (the rest is the frame's couple). */
+    wallShare: number;
+    /** Bending and shear stiffness of each band (cracked). */
+    ei: number[];
+    ga: number[];
+    /** First mode (Rayleigh): frequency in Hz, angular frequency, modal mass and stiffness, shape at the nodes. */
+    frequency: number;
+    omega: number;
+    modalMass: number;
+    modalStiffness: number;
+    shape: {
+        z: number[];
+        phi: number[];
+    };
+    /** Modal force of the mean wind, N; turbulence intensity for the gust. */
+    modalForce: number;
+    intensity: number;
+    /** Axial force the design wind adds to each input part, N (compression positive), without the load factor. */
+    axial: number[];
+}
+/**
+ * Second moment of area of a beam of web `bw` and depth `h` with a slab flange of width `bf` and thickness `tf` on top (a T section, about its own
+ * centroid); the web alone when there is no flange.
+ */
+declare const tBeamInertia: (bw: number, h: number, bf: number, tf: number) => number;
+/** The shape of the first mode at height `z` above the ground (linear between the nodes). */
+declare const shapeAt: (a: Pick<WindAnalysis, "shape">, z: number) => number;
+/**
+ * Wind on a building of `parts` standing on the ground at `ground` (the y of the top of the foundations). Null when it has no wall or column.
+ * Bands of `bandHeight`; a part gives to a band the share of itself that lies inside it.
+ */
+declare const analyzeWind: (parts: readonly WindPartInput[], c: WindCase, ground: number) => WindAnalysis | null;
+/**
+ * Optimal tuning of a damper of mass ratio `mu` (damper mass over the modal mass): its frequency over the building's and its damping ratio.
+ * `den-hartog` (1956): `1 / (1 + mu)` and `sqrt(3 mu / (8 (1 + mu)^3))`, for a harmonic force on an undamped structure. `warburton` (1982): for a random
+ * force, `sqrt(1 - mu / 2) / (1 + mu)` and `sqrt(mu (1 - mu / 4) / (4 (1 + mu) (1 - mu / 2)))`.
+ */
+declare const damperTuning: (mu: number, kind?: "den-hartog" | "warburton") => {
+    frequency: number;
+    damping: number;
+};
+/**
+ * Amplitude of the structure under a harmonic force over its static deflection, with a damper: `r` the forcing frequency over the structure's,
+ * `mu` the mass ratio, `g` the damper's frequency over the structure's, `damper` and `structure` the damping ratios. Solves
+ * `[(1 - r^2 + 2 i zs r) - mu A r^2 / (A - r^2)] X = 1` with `A = g^2 + 2 i zd g r`. `mu` 0 is the structure alone (`1 / (2 zs)` at resonance).
+ */
+declare const damperAmplification: (r: number, mu: number, g: number, damper: number, structure?: number) => number;
+/** A gust series: sines of equal frequency spacing whose amplitudes follow the Davenport spectrum, normalized to unit variance. */
+interface Gust {
+    freq: number[];
+    amp: number[];
+    phase: number[];
+}
+/**
+ * The turbulence at the 10 m mean speed `v10`: `components` sines up to `maxHz`, amplitudes from the Davenport spectrum `f S(f) / u*^2 = 4 x^2 / (1 + x^2)^(4/3)`,
+ * `x = scale f / v10` (NBR 6123 chapter 9, Simiu & Scanlan), phases from the seed.
+ */
+declare const makeGust: (v10: number, o: {
+    components: number;
+    maxHz: number;
+    scale: number;
+    seed: number;
+}) => Gust;
+/** The gust at time `t`: zero mean, unit variance. */
+declare const gustAt: (gust: Gust, t: number) => number;
+/** The first mode of a building with an optional tuned mass damper: modal mass, stiffness and damping, and the damper's mass, stiffness and dashpot. */
+interface SwaySystem {
+    M: number;
+    K: number;
+    C: number;
+    damper?: {
+        m: number;
+        k: number;
+        c: number;
+    };
+}
+/** Displacement and velocity of the top, and of the damper's mass (absolute). */
+interface SwayState {
+    x: number;
+    v: number;
+    y: number;
+    w: number;
+}
+/** Advances `s` by `dt` seconds under the force `force(t)` (N, on the modal mass), RK4 with steps no longer than `maxStep`. */
+declare const stepSway: (s: SwayState, sys: SwaySystem, t: number, dt: number, force: (t: number) => number, maxStep?: number) => void;
+/**
+ * Force in newtons a wall or column holds in tension: its vertical rebar at yield (`reinforcement` bars, or `ratio` of the section) when it has any,
+ * else the tensile strength of its material times the section, else nothing (a masonry wall does not pull).
+ */
+declare const tensionCapacity: (dims: Vec3, o: {
+    reinforcement?: {
+        spacing: number;
+        diameter: number;
+    };
+    ratio?: number;
+    yieldMPa: number;
+    tensileMPa?: number;
+}) => number;
+
+export { ASSEMBLIES, type AddOptions, type AssemblyDef, type AssemblyPartOptions, type BearingWallOptions, type BendGeometry, type BendSection, CONFINEMENT_DEFAULTS, type ChainTrigger, type CheckOptions, type DestructionLocale, type DestructionOptions, type DestructionSnapshot, type DestructionStrings, type DestructionWorld, type ExplosivePartOptions, FIRE_PRIME_C, FLEXURE_DEFAULTS, FRAGMENT_HIT_DEFAULTS, type FlexureOptions, type FoundationSolve, type FrameOptions, GRAVITY, type Gust, JOINT_BY_MATERIALS, JOINT_DEFAULTS, MASONRY_DEFAULTS, MATERIALS, type MasonryOptions, type MaterialDef, type MaterialStrength, type MaterialThermal, type ObjectRuntime, type PartRuntime, type ResolvedWind, SHELTER_DEFAULTS, SOILS, SOIL_DEFAULTS, type SectionMoments, type SizeStructureOptions, type SoilDef, type SoilKind, type SoilOptions, type SoilSpring, type SwayState, type SwaySystem, type TensionSteel, WIND_DEFAULTS, WIND_TERRAIN, type WallFrameSolution, type WindAnalysis, type WindCase, type WindOptions, type WindPartInput, type WindTerrainDef, type WorldExplosive, analyzeWind, assemblyDepth, assemblyPart, bearingWallThickness, bendGeometry, blastImpulse, buildFrame, checkDestructible, crackingMoment, createDestruction, damperAmplification, damperTuning, elasticEnergy, explosivePart, exposureOf, footingArea, footingSoil, fragility, getAssembly, guessMaterial, gustAt, heightFactor, impulseEnergy, inferJoints, layersBetween, locales, makeGust, meanHeightFactor, momentNodes, momentOfEnergy, partCapacity, partMass, partThickness, partVolume, pileCapacity, pileLength, pileStiffness, profileOf, quat, quatFromEuler, registerAssembly, resolveStrings, resolveWind, rotateVec, sectionMoments, shapeAt, shearNodes, sizeRebar, sizeStructure, slendernessFactor, soilAt, solveFoundation, solveWallFrame, spanMoment, spanOf, steelMoment, stepSway, stiffnessCentre, subgradeModulus, tBeamInertia, tensionCapacity, tensionSteel, toLocal, toWorld, turbulenceIntensity, vec, windClass, windPressure };