@theerapat-s28/ts-structural-eng-tools 2.3.0 → 3.1.0

package/CHANGELOG.md

@@ -6,6 +6,83 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [3.1.0] — 2026-10-31
+
+**Engine reorganised, and a guide for upgrading from 2.x.** The analysis engine behind `/fea` is reorganised into separate parts for frame members, shell elements and the analysis that runs them together. Nothing you call changes: every export keeps its name, its import path and its behaviour, and every result is identical to 3.0.0. Coming from 2.x? Read **Upgrading from 2.x** below; it covers this release and 3.0.0 together.
+
+### Changed
+
+- **Files inside `dist/` moved.** The code behind `/fea` moved from `dist/fea/frame/…` into `dist/fea/shared/`, `dist/fea/frame/` (members and null areas), `dist/fea/shell/` (the shell element) and `dist/fea/analysis/` (`analyzeFrame`, `validateFrameModel`, and the model and result types), in both the CommonJS and the ES-module builds. Imports from the package root and the subpaths (`/fea`, `/core`, …) are unaffected. An import of a file inside `dist/` no longer resolves: the `exports` map has never allowed one, but TypeScript's legacy `"moduleResolution": "node"` and bundler aliases can reach those files. Import from the root or `/fea` instead. Your editor's "go to definition" now opens the new files.
+
+### Fixed
+
+- The type comment and the reference page for `FrameCaseResult.shellForces` said one entry per shell area. There is one entry per shell element, area by area in model order, as the results have always had.
+
+### Upgrading from 2.x
+
+Nothing has been removed or renamed since 2.3.0, and no input has become required. A model that runs on 2.3.0 runs unchanged and gives the same numbers, warnings and validation issues; results only gain the fields in step 3. Most frontends need step 1 and a look at steps 3 and 4. Step 5 matters once you start sending shells (see 3.0.0 for the shell features themselves).
+
+1. **Update the dependency.** A `^2.x` range does not pick up a major version: run `pnpm add @theerapat-s28/ts-structural-eng-tools@^3.1.0` (or `npm install` / `yarn add` with the same spec).
+
+2. **Imports.** Nothing to change. Every name exported in 2.3.0 is still exported from the same place: the package root and `/fea`, `/rc`, `/strengthening`, `/core`, `/utils`. Only imports of files inside `dist/` break (see **Changed**).
+
+3. **New result fields, on every result.** Without shells they are empty or zero:
+
+   | Field | Without shells |
+   | --- | --- |
+   | `cases[id].shellForces`, `combinations[id].shellForces` | `[]` |
+   | `envelope.shells` (when the model has combinations) | `[]` |
+   | `calculationDetails.shellCount` | `0` |
+   | `units.forcePerLength`, `units.momentPerLength`, `units.stress` | `"kN/m"`, `"kN·m/m"`, `"MPa"` |
+   | `mesh` | absent; present only when the model has shells |
+
+   Code that only reads results needs no change. Update code that:
+   - **builds** a `FrameResult` or `FrameCaseResult` itself, such as an empty placeholder in app state, test fixtures or mocks. TypeScript names the missing fields.
+   - **validates** stored or received results against a strict schema (Zod `.strict()`, JSON Schema `additionalProperties: false`).
+   - **snapshots** whole results. Refresh the snapshots once; the values in them do not change.
+   - maps **every key of `units`** to a label, e.g. for a units display.
+
+4. **Errors and warnings.** For frame-only models the codes, `details` and the order of `issues` are unchanged, but two messages are reworded to mention shells:
+   - 303 `DUPLICATE_ID`: "Node ids, member ids and restrained node ids must each be unique, area ids must be unique across null areas and shells, and load case and combination ids must be unique across both lists."
+   - 313 `MISSING_UNIT_WEIGHT`: "A load case requests self-weight but a member or shell section has no unitWeight; set unitWeight (0 for a weightless member or shell)."
+
+   If your code matches on `message`, match on `code` instead. Models with shells can also raise 326 `INVALID_SHELL_GEOMETRY`, 327 `INVALID_SHELL_SECTION`, 328 `SHELL_DOF_UNSUPPORTED` and 329 `INVALID_SHELL_MESH`, located by the new `details.shellId` (the shell area's id). Add them to any code-to-message table, and highlight the shell area that `shellId` names. The new warning **Shell area meshing** appears in `result.warnings`.
+
+5. **When you add shells to a model.** These points apply only to models with `shells`:
+   - **Generated nodes in node results.** Meshing adds nodes. `nodalDisplacements` and `reactions` list them after your own nodes, with string ids — `"<areaId>:<i>,<j>"` inside an area, `"<a>~<b>:<k>"` along an edge between your nodes `a` and `b` — even when your ids are numbers. Their coordinates are in `result.mesh.nodes`. Do not assume every node id in a result is one of yours; `calculationDetails.nodeCount` counts the generated nodes too.
+   - **Drawing the mesh.** `result.mesh.shells` lists every element with its four node ids. `shellForces[].shellId` and `envelope.shells[].shellId` name these elements, and `areaId` groups them under your area; an area that is not meshed is one element with the area's own id. `calculationDetails.shellCount` counts elements, not areas.
+   - **Contours.** Shell results are corner values in each element's local axes (`ShellCornerForces`), and `ShellForceComponent` lists the components for a picker. As usual for shell results, elements meeting at a node give different values there; average them for a smooth contour.
+   - **Members along meshed edges** are split internally at the mesh nodes on them, but every member result (end forces, diagrams, release deformations, envelopes, `memberDemandEnvelope`) stays under the member's own id, along its full length. `calculationDetails.memberCount` counts your members.
+   - **One id namespace for areas.** A null area and a shell cannot share an id (303), and an `AreaLoad` can name either. `distributeAreaLoads` returns only the loads from null areas; loads on shells stay on the shell.
+   - **Supports along an edge.** Fix a wall base or a slab edge with `lineRestraints`: they reach the generated nodes, which a point `Restraint` cannot name.
+   - **Model size.** Shell models have many more nodes than frames. Run the analysis in a Web Worker, and consider `diagrams: "extremes"` with `createFrameAnalysis(...).memberDiagram` to compute member diagrams on demand.
+
+## [3.0.0] — 2026-10-31
+
+**Shell element analysis.** `analyzeFrame` now analyses walls, cores, slabs and mats as shell elements alongside the frame: four-node flat shells with membrane and plate stiffness, meshed by the engine, with internal forces and stresses in every load case, combination and envelope. The major version marks this milestone; nothing is removed or renamed, and frame-only models give the same results as in 2.3.0, which only gain the new fields below (empty `shellForces` and `envelope.shells`, and the new `units` keys).
+
+### Added
+
+- **Shell areas** (`model.shells`): `ShellArea` (`{ id, nodeIds, type?, section, angle?, modifiers?, mesh? }`), a four-node flat shell with its own stiffness, sharing nodes with members and other shells. Null areas are unchanged; use shells where a surface's stiffness matters.
+  - The element is a drilling-rotation membrane (after Ibrahimbegovic, Taylor & Wilson), so a beam framing into a wall in its plane transfers its moment, plus a thin DKQ plate (Batoz & Ben Tahar). `type` `"membrane"` or `"plate"` keeps only one part; `"shell"` (the default) keeps both.
+  - Slightly warped quads are built on their mean plane and linked to their corners, up to `SHELL_WARPING_LIMIT` (0.1 × √A off the plane).
+  - Local axes follow ETABS: local 3 by the right-hand rule around `nodeIds`, local 2 up on walls, local 1 = +X on horizontal shells, rotated by `angle`.
+  - `ShellSection` (`thickness`, `E`, `nu`, `unitWeight?`) and `ShellModifiers` (`f11`, `f22`, `f12`, `m11`, `m22`, `m12`, `weight`) for cracked-section stiffness, e.g. the ACI 318-19 6.6.3.1.1 values entered by the user.
+- **Engine meshing**: `ShellArea.mesh` (`ShellMesh`: `{ maxSize }` in mm, or `{ divisions: [n1, n2] }` as a minimum) divides an area into elements. Neighbouring areas share their mesh nodes, also where an area edge meets another at a node (a slab edge on two wall panels); division counts grow as needed, and an unmeshed area next to a meshed one is divided too. Model nodes lying on an area edge become mesh nodes. Generated elements are named `"<areaId>:<i>,<j>"`, generated nodes `"<areaId>:<i>,<j>"` inside an area or `"<a>~<b>:<k>"` on an edge; an area that stays one element keeps its id.
+- **Members along meshed edges** (an edge beam under a slab, a beam on a wall top) are split at the mesh nodes inside them so they share them with the shells; their end forces, release deformations, diagrams, envelopes and design demands stay under the member's own id, the diagram stitched along its full length.
+- **Line restraints** (`model.lineRestraints`, `LineRestraint`): `{ nodeIds: [a, b], ux?…rz? }` fixes those DOFs at every node on the segment from a to b, generated mesh nodes included, e.g. a wall base fixed along its length. A DOF fixed by a point or a line restraint is fixed.
+- **Loads on shells**: an `AreaLoad` names a shell area by its id (area ids are shared by null areas and shells) and loads all its elements; self-weight acts as `selfWeight · unitWeight · thickness · modifiers.weight` per unit area. Both act as forces at the element corners.
+- **Shell results**: every load case and combination has `shellForces` (`ShellElementForces[]`), per element with its `areaId`, the forces per unit width at its corners in its local axes: membrane forces `F11`, `F22`, `F12` (kN/m), moments `M11`, `M22`, `M12` (kN·m/m, positive with the −3 face in tension, i.e. sagging when local 3 is up, like a member's `M3`), transverse shears `V13`, `V23` (kN/m, `V13 = −(∂M11/∂x₁ + ∂M12/∂x₂)`), and top and bottom face stresses `S11Top` … `S12Bot` (MPa). They are extrapolated from the element's Gauss points, combine by superposition and are enveloped per corner in `envelope.shells`. The shears are recovered from the moments and are the coarsest output. Types `ShellCornerForces` and `ShellForceComponent`.
+- `result.mesh` (`FrameMesh`): the generated nodes and every shell element with its nodes, for drawing; displacements and reactions include the generated nodes. `calculationDetails.shellCount`; `units.forcePerLength` (`"kN/m"`), `units.momentPerLength` (`"kN·m/m"`) and `units.stress` (`"MPa"`).
+- Errors 326 (`INVALID_SHELL_GEOMETRY`), 327 (`INVALID_SHELL_SECTION`), 328 (`SHELL_DOF_UNSUPPORTED`: a translation that nothing resists at a node connected only to membrane or plate shells, with `nodeId`, `shellId` and `dof`) and 329 (`INVALID_SHELL_MESH`: areas that cannot be meshed), and `FrameErrorDetails.shellId`. A warning (**Shell area meshing**) for a member node inside a shell area but not on its mesh, which leaves it unconnected.
+- Types `ShellArea`, `ShellSection`, `ShellModifiers`, `ShellType`, `ShellMesh`, `LineRestraint`, `ShellElementForces`, `ShellCornerForces`, `ShellForceComponent` and `FrameMesh` from `/fea` and the package root; `SHELL_WARPING_LIMIT` from `/core` and the root.
+- Shell element theory notes in the documentation (`shell-element.html`): how the element's stiffness is formed, the integration choices, and the benchmarks it is checked against (patch tests, MacNeal–Harder cantilevers and twisted beam, Timoshenko plates, Scordelis–Lo roof, pinched cylinder).
+
+### Changed
+
+- `calculationDetails.nodeCount` counts the generated mesh nodes too, and `memberCount` counts model members (not the pieces a meshed edge splits them into).
+- Error 303 also covers an area id used by both a null area and a shell, and 313 also covers a shell section without `unitWeight`; their messages say so.
+
 ## [2.3.0] — 2026-10-24
 
 ### Added
@@ -137,7 +214,9 @@ Maintenance release with no changes to the library code.
 
 First version, under the unscoped name `ts-structural-eng-tools`: `rectBeamMomentCapacity` (singly and doubly reinforced rectangular beams per ACI 318-19), steel plate jacketing, and concrete property helpers.
 
-[Unreleased]: https://github.com/theerapat-s28/ts-structural-eng/compare/v2.3.0...HEAD
+[Unreleased]: https://github.com/theerapat-s28/ts-structural-eng/compare/v3.1.0...HEAD
+[3.1.0]: https://github.com/theerapat-s28/ts-structural-eng/compare/v3.0.0...v3.1.0
+[3.0.0]: https://github.com/theerapat-s28/ts-structural-eng/compare/v2.3.0...v3.0.0
 [2.3.0]: https://github.com/theerapat-s28/ts-structural-eng/compare/v2.2.0...v2.3.0
 [2.2.0]: https://github.com/theerapat-s28/ts-structural-eng/compare/v2.1.1...v2.2.0
 [2.1.1]: https://github.com/theerapat-s28/ts-structural-eng/compare/v2.1.0...v2.1.1

package/README.md

@@ -30,6 +30,7 @@ Full API reference, with parameter tables, worked examples, warnings and error c
 - [RC Beam Design](https://theerapat-s28.github.io/ts-structural-eng/rc/) — `@theerapat-s28/ts-structural-eng-tools/rc`
 - [Strengthening](https://theerapat-s28.github.io/ts-structural-eng/strengthening/) — `@theerapat-s28/ts-structural-eng-tools/strengthening`
 - [FEA — Frame Analysis](https://theerapat-s28.github.io/ts-structural-eng/fea/) — `@theerapat-s28/ts-structural-eng-tools/fea`
+- [Shell element theory notes](https://theerapat-s28.github.io/ts-structural-eng/shell-element.html) — how the shell element's stiffness is formed, with its benchmarks
 
 The pages are served from [`html-docs/`](https://github.com/theerapat-s28/ts-structural-eng/tree/main/html-docs) via GitHub Pages.
 
@@ -142,15 +143,35 @@ src/
 │   └── rc-beam-side-plate-shear.ts       # Shear capacity before/after bolted side plates (two models)
 ├── fea/                  # Finite-element analysis
 │   ├── index.ts
-│   └── frame/            # 3D frame analysis (direct stiffness method)
+│   ├── shared/           # The base every part builds on
+│   │   ├── index.ts
+│   │   ├── types/            # Nodes, restraints, area loads
+│   │   ├── solver/           # Generic element assembly, boundary conditions, automatic restraint
+│   │   └── validation/       # Issue helpers shared by the model checks
+│   ├── frame/            # Frame members (3D beam element) and null areas
+│   │   ├── index.ts
+│   │   ├── area/             # Null areas: geometry, edge-member chains, area-load distribution
+│   │   ├── elements/         # Reference beam stiffness matrix, fixed-end forces, end releases and partial-fixity condensation
+│   │   ├── transformation/   # ETABS-style local axes and the 12×12 transformation
+│   │   ├── solver/           # Member pieces, member-load resolution, member assembly helpers
+│   │   ├── validation/       # Checks on members, member loads and null areas
+│   │   ├── post/             # Member force diagrams
+│   │   └── types/            # Member, member-load and null-area types; member result types
+│   ├── shell/            # Flat shell element (drilling membrane + DKQ plate)
+│   │   ├── index.ts
+│   │   ├── elements/         # Membrane, DKQ plate, flat shell, local axes, warping links, quad geometry
+│   │   ├── mesh/             # Shell-area meshing
+│   │   ├── solver/           # Shell elements of the system and their surface-load vectors
+│   │   ├── post/             # Shell forces and stresses
+│   │   ├── validation/       # Checks on shell areas
+│   │   └── types/            # Shell-area model and result types
+│   └── analysis/         # The whole model, members and shells together (direct stiffness method)
 │       ├── index.ts
-│       ├── area/             # Null areas: geometry, edge-member chains, area-load distribution
-│       ├── elements/         # Reference beam stiffness matrix, fixed-end forces, end releases and partial-fixity condensation
-│       ├── transformation/   # ETABS-style local axes and the 12×12 transformation
-│       ├── solver/           # System build (with automatic joint restraint) + skyline factorisation, per-case solve, combinations, analyzeFrame
+│       ├── mesh/             # The analysed model: shell mesh, line restraints, member splitting at mesh nodes
+│       ├── solver/           # System build + skyline factorisation, per-case solve, combinations, analyzeFrame, distributeAreaLoads
 │       ├── validation/       # validateFrameModel: every input problem, with its location
-│       ├── post/             # Result presentation, member force diagrams, envelopes, design demands
-│       └── types/            # Model (incl. null areas, load cases, combinations) and result types
+│       ├── post/             # Result presentation, envelopes, design demands
+│       └── types/            # FrameModel (load cases, combinations, nodal loads, line restraints) and FrameResult
 ├── core/                 # Shared infrastructure
 │   ├── index.ts
 │   ├── constants/        # RC design constants (ACI 318) and frame-analysis tolerances
@@ -167,7 +188,10 @@ examples/
 tests/
 ├── rc/                   # Tests for RC module
 ├── strengthening/        # Tests for strengthening module
-├── fea/frame/            # Tests for frame analysis
+├── fea/frame/            # Tests for members and null areas
+├── fea/shell/            # Tests for shell elements, meshing and shell results
+├── fea/shared/           # Tests for element assembly and automatic restraint
+├── fea/analysis/         # Tests for analyzeFrame, combinations, validation, errors and RC integration
 └── utils/                # Tests for utilities
 html-docs/                # HTML API reference, deployed to GitHub Pages
 ├── DESIGN.md             # Style guide for the doc pages
@@ -230,10 +254,10 @@ ACI 440.2R-17 11.4.2 (spacing, which defers to the ACI 318 limits) and 11.4.3 (`
 
 Linear-elastic 3D frame analysis by the direct stiffness method, imported from `@theerapat-s28/ts-structural-eng-tools/fea`. Global axes X, Y, Z (Z up) and ETABS-style local axes 1, 2, 3; inputs in mm, MPa, kN and kN·m, results in kN, kN·m, mm and rad.
 
-- **`analyzeFrame(model, options?)`** — Analyses every load case in `model.loadCases` (dead, superimposed dead, live, wind…, each with an optional `selfWeight` multiplier) and forms every combination in `model.combinations` by superposition. The loads are flat top-level lists, `model.nodalLoads` and `model.memberLoads` (uniform, trapezoidal and point loads in local or global directions, and torques about the member axis; uniform and trapezoidal loads in a global direction can be given per unit projected length with `projected: true`, e.g. snow on a sloped rafter), each load tagged with its `loadCase`, so large models stay readable. Area loads (`model.areaLoads`, kN/m²) on null areas (`model.areas`) are first distributed to the members along each area's edges — see `distributeAreaLoads`. A combination is a list of factored terms `{ case, factor }` or `{ combination, factor }`; factors are entered by the user, and nested combinations are expanded. Supports end releases — full (`true`) or partial fixity (a spring stiffness in series with the member end) on any of the six end DOFs, with the deformation across each release reported in `releaseDeformations` — and fixed or spring supports. Joint rotations that no member resists, as at pin-jointed truss joints, are held automatically and listed in `calculationDetails.autoRestrainedDofs`. The stiffness matrix is factorised once for all cases. Returns `cases` and `combinations` keyed by id — each with displacements, reactions, member end forces, member diagrams along each member (forces `N`, `V2`, `V3`, `T`, `M2`, `M3` and deflections `u1`–`u3` local / `ux`–`uz` global, ready for plotting) and an equilibrium check — and an `envelope` of max/min over the combinations with the governing combination. Combination diagrams are rebuilt exactly, not summed from case extremes. The stiffness is stored in skyline (banded) form with nodes in reverse Cuthill–McKee order, so a building of ~850 nodes runs in about 1.5 s. Model and result are plain JSON, so it runs in a Web Worker. Invalid models, load cases or combinations and mechanisms throw `FrameAnalysisError` (codes 301–317) with `details` locating the problem.
+- **`analyzeFrame(model, options?)`** — Analyses every load case in `model.loadCases` (dead, superimposed dead, live, wind…, each with an optional `selfWeight` multiplier) and forms every combination in `model.combinations` by superposition. The loads are flat top-level lists, `model.nodalLoads` and `model.memberLoads` (uniform, trapezoidal and point loads in local or global directions, and torques about the member axis; uniform and trapezoidal loads in a global direction can be given per unit projected length with `projected: true`, e.g. snow on a sloped rafter), each load tagged with its `loadCase`, so large models stay readable. Area loads (`model.areaLoads`, kN/m²) on null areas (`model.areas`) are first distributed to the members along each area's edges — see `distributeAreaLoads`. Shell areas (`model.shells`, `{ id, nodeIds, type?, section: { thickness, E, nu, unitWeight? }, angle?, modifiers? }`) are four-node flat shell elements with their own stiffness — a drilling-rotation membrane and a thin (DKQ) plate, as `"shell"`, `"membrane"` or `"plate"` — for walls, cores and slabs; they share nodes with members, take `areaLoads` naming their id and self-weight as corner forces, and accept cracked-section modifiers (`f11`…`m12`). Give an area `mesh: { maxSize }` (or `{ divisions }`) and the engine meshes it: neighbouring areas, including T-junctions, share their mesh nodes, model nodes on an area edge become mesh nodes, and members along meshed edges are split internally while their results stay under their own id; `model.lineRestraints` (`{ nodeIds: [a, b], ux?…rz? }`) fix every node on a line, generated nodes included, and `result.mesh` lists the generated nodes and elements. A translation that nothing resists at a node connected only to membranes or plates throws 328, an area that cannot be meshed 329. Each case and combination reports `shellForces` — per shell and corner, membrane forces `F11`, `F22`, `F12` (kN/m), moments `M11`, `M22`, `M12` (kN·m/m, sagging positive), shears `V13`, `V23` and top/bottom stresses — and the envelope has them per corner. A combination is a list of factored terms `{ case, factor }` or `{ combination, factor }`; factors are entered by the user, and nested combinations are expanded. Supports end releases — full (`true`) or partial fixity (a spring stiffness in series with the member end) on any of the six end DOFs, with the deformation across each release reported in `releaseDeformations` — and fixed or spring supports. Joint rotations that no member resists, as at pin-jointed truss joints, are held automatically and listed in `calculationDetails.autoRestrainedDofs`. The stiffness matrix is factorised once for all cases. Returns `cases` and `combinations` keyed by id — each with displacements, reactions, member end forces, member diagrams along each member (forces `N`, `V2`, `V3`, `T`, `M2`, `M3` and deflections `u1`–`u3` local / `ux`–`uz` global, ready for plotting) and an equilibrium check — and an `envelope` of max/min over the combinations with the governing combination. Combination diagrams are rebuilt exactly, not summed from case extremes. The stiffness is stored in skyline (banded) form with nodes in reverse Cuthill–McKee order, so a building of ~850 nodes runs in about 1.5 s. Model and result are plain JSON, so it runs in a Web Worker. Invalid models, load cases or combinations and mechanisms throw `FrameAnalysisError` (codes 301–317 and 326–329) with `details` locating the problem.
 - **`createFrameAnalysis(model, options?)`** — Same analysis, keeping the solution: returns `{ result, memberDiagram(resultId, memberId) }` so full member diagrams can be computed on demand. Combine with `options.diagrams: "extremes"`, which keeps diagram extremes (and the envelope) but drops the station arrays, for results about 4× smaller on large models.
-- **`validateFrameModel(model)`** — Checks a model without analysing it and returns every problem, each with `details` (`nodeId`, `memberId`, `areaId`, `edge`, `loadCaseId`, `combinationId`, `field`, `dof`) for highlighting in a UI. `analyzeFrame` runs it first and throws the first problem as a `FrameAnalysisError` whose `issues` lists all of them; non-finite numbers, negative springs, invalid end-release values and unknown option values are rejected (314).
-- **`distributeAreaLoads(model)`** — Returns `{ memberLoads, warnings }`: the member loads that the model's null areas send to their edge members, exactly what `analyzeFrame` adds, for checking or previewing. A null area (`{ id, nodeIds, distribution, supportEdges? }`) has 3 or 4 nodes forming a planar convex polygon and adds no stiffness. `"twoWay"` sends each point to its nearest edge (the corner-bisector split, any convex shape); `"oneWay"` spans strips between the listed `supportEdges`, parallel to the unsupported edges, half to each end; `"cantilever"` (rectangles) puts `q·c` and a torque `q·c²/2` on its one support edge. Area loads (`{ loadCase, areaId, direction: "3" | "X" | "Y" | "Z", q, projected? }`) are per unit true area, `"3"` being the area's normal; with `projected: true` and a global direction, `q` is per unit projected area (e.g. per plan area on a ramp) and is converted to true area before distribution. Edges split by intermediate nodes are cut at them. Area problems throw 315 (geometry), 316 (an edge without members) or 317 (supports that do not fit the distribution).
+- **`validateFrameModel(model)`** — Checks a model without analysing it and returns every problem, each with `details` (`nodeId`, `memberId`, `areaId`, `shellId`, `edge`, `loadCaseId`, `combinationId`, `field`, `dof`) for highlighting in a UI. `analyzeFrame` runs it first and throws the first problem as a `FrameAnalysisError` whose `issues` lists all of them; non-finite numbers, negative springs, invalid end-release values and unknown option values are rejected (314).
+- **`distributeAreaLoads(model)`** — Returns `{ memberLoads, warnings }`: the member loads that the model's null areas send to their edge members, exactly what `analyzeFrame` adds, for checking or previewing (loads on shell areas act on the shells and are not included). A null area (`{ id, nodeIds, distribution, supportEdges? }`) has 3 or 4 nodes forming a planar convex polygon and adds no stiffness. `"twoWay"` sends each point to its nearest edge (the corner-bisector split, any convex shape); `"oneWay"` spans strips between the listed `supportEdges`, parallel to the unsupported edges, half to each end; `"cantilever"` (rectangles) puts `q·c` and a torque `q·c²/2` on its one support edge. Area loads (`{ loadCase, areaId, direction: "3" | "X" | "Y" | "Z", q, projected? }`) are per unit true area, `"3"` being the area's normal; with `projected: true` and a global direction, `q` is per unit projected area (e.g. per plan area on a ramp) and is converted to true area before distribution. Edges split by intermediate nodes are cut at them. Area problems throw 315 (geometry), 316 (an edge without members) or 317 (supports that do not fit the distribution).
 - **`memberDemandEnvelope(result, memberId, options?)`** — Reduces a member's diagrams to `MuPositive`, `MuNegative`, `Vu` (optionally at distance `d` from the supports) and `Nu`, enveloped over all combinations (or the `combinations` / `cases` you select), with the `governing` combination of each, for the RC capacity functions.
 - **`rectBeamToSectionProperties(section, options?)`** (from `rc`) — Converts a rectangular RC section into `SectionProperties` (`E`, `G`, `A`, `I22`, `I33`, `J`, `unitWeight`) with the ACI 318-19 6.6.3.1.1 inertia modifiers (0.35 beams, 0.70 columns) and a unit weight for self-weight (default 24 kN/m³, common practice rather than an ACI value).
 - **`beam3dLocalStiffness(E, G, A, I22, I33, J, L)`** — The 12×12 local stiffness matrix exactly as in the reference "Complete Beam Stiffness Matrix". Its bending rotations R2 and R3 follow the opposite sign to the right-hand rule; **`beam3dLocalStiffnessRightHanded`** returns the right-handed form that `analyzeFrame` uses.

package/dist/core/constants/frame.constant.d.ts

@@ -17,3 +17,18 @@ export declare const EQUILIBRIUM_TOLERANCE = 0.000001;
  * edges, nodes lying on an edge): distances are compared with this times the longest edge.
  */
 export declare const AREA_GEOMETRY_TOLERANCE = 0.000001;
+/**
+ * Penalty factor γ of the shell membrane's drilling rotation, as a multiple of the shear modulus
+ * G: the term ½·γ·t·∫(θ − ω)² dA, integrated at the element centre, ties each element's rotation
+ * about the shell normal θ to the in-plane rotation of the material ω = ½(v,x − u,y). γ = G
+ * follows Ibrahimbegovic, Taylor & Wilson (1990); with the one-point rule the results change by
+ * well under 1 % for γ between 0.01 G and 100 G.
+ */
+export declare const DRILLING_PENALTY_RATIO = 1;
+/**
+ * Largest warping of a shell element accepted, as the distance of its corners from their mean
+ * plane relative to √A (A = projected area). Warped elements are built flat on the mean plane
+ * and linked rigidly to their corners, which is accurate for mild warping (the MacNeal–Harder
+ * twisted beam, 0.024, is within 0.5 %); beyond this the element is rejected (326).
+ */
+export declare const SHELL_WARPING_LIMIT = 0.1;

package/dist/core/constants/frame.constant.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AREA_GEOMETRY_TOLERANCE = exports.EQUILIBRIUM_TOLERANCE = exports.SINGULARITY_TOLERANCE = exports.VERTICAL_MEMBER_TOLERANCE = exports.CONCRETE_UNIT_WEIGHT = exports.COLUMN_INERTIA_MODIFIER = exports.BEAM_INERTIA_MODIFIER = exports.CONCRETE_POISSON_RATIO = void 0;
+exports.SHELL_WARPING_LIMIT = exports.DRILLING_PENALTY_RATIO = exports.AREA_GEOMETRY_TOLERANCE = exports.EQUILIBRIUM_TOLERANCE = exports.SINGULARITY_TOLERANCE = exports.VERTICAL_MEMBER_TOLERANCE = exports.CONCRETE_UNIT_WEIGHT = exports.COLUMN_INERTIA_MODIFIER = exports.BEAM_INERTIA_MODIFIER = exports.CONCRETE_POISSON_RATIO = void 0;
 /** Poisson's ratio of concrete, for G = E / (2(1 + ν)). */
 exports.CONCRETE_POISSON_RATIO = 0.2;
 /** ACI 318-19 Table 6.6.3.1.1(a): effective I of beams for elastic analysis at factored load. */
@@ -20,4 +20,19 @@ exports.EQUILIBRIUM_TOLERANCE = 1e-6;
  * edges, nodes lying on an edge): distances are compared with this times the longest edge.
  */
 exports.AREA_GEOMETRY_TOLERANCE = 1e-6;
+/**
+ * Penalty factor γ of the shell membrane's drilling rotation, as a multiple of the shear modulus
+ * G: the term ½·γ·t·∫(θ − ω)² dA, integrated at the element centre, ties each element's rotation
+ * about the shell normal θ to the in-plane rotation of the material ω = ½(v,x − u,y). γ = G
+ * follows Ibrahimbegovic, Taylor & Wilson (1990); with the one-point rule the results change by
+ * well under 1 % for γ between 0.01 G and 100 G.
+ */
+exports.DRILLING_PENALTY_RATIO = 1;
+/**
+ * Largest warping of a shell element accepted, as the distance of its corners from their mean
+ * plane relative to √A (A = projected area). Warped elements are built flat on the mean plane
+ * and linked rigidly to their corners, which is accurate for mild warping (the MacNeal–Harder
+ * twisted beam, 0.024, is within 0.5 %); beyond this the element is rejected (326).
+ */
+exports.SHELL_WARPING_LIMIT = 0.1;
 //# sourceMappingURL=frame.constant.js.map

package/dist/core/constants/frame.constant.js.map

@@ -1 +1 @@
-{"version":3,"file":"frame.constant.js","sourceRoot":"","sources":["../../../src/core/constants/frame.constant.ts"],"names":[],"mappings":";;;AAAA,2DAA2D;AAC9C,QAAA,sBAAsB,GAAG,GAAG,CAAC;AAE1C,iGAAiG;AACpF,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAE1C,mGAAmG;AACtF,QAAA,uBAAuB,GAAG,GAAG,CAAC;AAE3C,qGAAqG;AACxF,QAAA,oBAAoB,GAAG,EAAE,CAAC;AAEvC,gGAAgG;AACnF,QAAA,yBAAyB,GAAG,IAAI,CAAC;AAE9C,uGAAuG;AAC1F,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAE1C,2EAA2E;AAC9D,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAE1C;;;GAGG;AACU,QAAA,uBAAuB,GAAG,IAAI,CAAC"}
+{"version":3,"file":"frame.constant.js","sourceRoot":"","sources":["../../../src/core/constants/frame.constant.ts"],"names":[],"mappings":";;;AAAA,2DAA2D;AAC9C,QAAA,sBAAsB,GAAG,GAAG,CAAC;AAE1C,iGAAiG;AACpF,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAE1C,mGAAmG;AACtF,QAAA,uBAAuB,GAAG,GAAG,CAAC;AAE3C,qGAAqG;AACxF,QAAA,oBAAoB,GAAG,EAAE,CAAC;AAEvC,gGAAgG;AACnF,QAAA,yBAAyB,GAAG,IAAI,CAAC;AAE9C,uGAAuG;AAC1F,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAE1C,2EAA2E;AAC9D,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAE1C;;;GAGG;AACU,QAAA,uBAAuB,GAAG,IAAI,CAAC;AAE5C;;;;;;GAMG;AACU,QAAA,sBAAsB,GAAG,CAAC,CAAC;AAExC;;;;;GAKG;AACU,QAAA,mBAAmB,GAAG,GAAG,CAAC"}

package/dist/core/errors/frame-analysis.error.d.ts

@@ -5,6 +5,7 @@ export interface FrameErrorDetails {
     nodeId?: string | number;
     memberId?: string | number;
     areaId?: string | number;
+    shellId?: string | number;
     /** For an area: the edge index, edge i running from `nodeIds[i]` to `nodeIds[i + 1]`. */
     edge?: number;
     loadCaseId?: string;

package/dist/core/errors/frame-analysis.error.js

@@ -24,7 +24,7 @@ exports.FrameErrors = {
     },
     DUPLICATE_ID: {
         code: 303,
-        message: "Node ids, member ids, area ids and restrained node ids must each be unique, and load case and combination ids must be unique across both lists.",
+        message: "Node ids, member ids and restrained node ids must each be unique, area ids must be unique across null areas and shells, and load case and combination ids must be unique across both lists.",
     },
     STRUCTURE_UNSTABLE: {
         code: 304,
@@ -64,7 +64,7 @@ exports.FrameErrors = {
     },
     MISSING_UNIT_WEIGHT: {
         code: 313,
-        message: "A load case requests self-weight but a member section has no unitWeight; set unitWeight (0 for a weightless member).",
+        message: "A load case requests self-weight but a member or shell section has no unitWeight; set unitWeight (0 for a weightless member or shell).",
     },
     INVALID_INPUT_VALUE: {
         code: 314,
@@ -82,5 +82,21 @@ exports.FrameErrors = {
         code: 317,
         message: "An area's supportEdges do not fit its distribution: two-way takes none; one-way needs at least one edge left unsupported, with every unsupported edge parallel to the others (the span direction); cantilever needs exactly one, and its loads may not act along that edge.",
     },
+    INVALID_SHELL_GEOMETRY: {
+        code: 326,
+        message: "A shell area must have 4 distinct nodes, listed in order around it, forming a convex quadrilateral that is close to flat (each corner within 0.1·√A of the mean plane).",
+    },
+    INVALID_SHELL_SECTION: {
+        code: 327,
+        message: "A shell section's thickness and E must be positive, nu must be at least 0 and below 0.5, and unitWeight, when given, must not be negative.",
+    },
+    SHELL_DOF_UNSUPPORTED: {
+        code: 328,
+        message: 'A node connected only to shells has a translation that nothing resists: a membrane carries no load out of its plane and a plate none in its plane. Restrain that DOF, connect a member, or use type "shell".',
+    },
+    INVALID_SHELL_MESH: {
+        code: 329,
+        message: "Shell areas cannot be meshed: no division counts make the meshes of areas sharing edges meet node to node, a generated element is not a valid quadrilateral, or a generated id is already in use. Divide the areas so they meet edge to edge, or change their mesh sizes.",
+    },
 };
 //# sourceMappingURL=frame-analysis.error.js.map

package/dist/core/errors/frame-analysis.error.js.map

@@ -1 +1 @@
-{"version":3,"file":"frame-analysis.error.js","sourceRoot":"","sources":["../../../src/core/errors/frame-analysis.error.ts"],"names":[],"mappings":";;;AAiBA,MAAa,kBAAmB,SAAQ,KAAK;IAO3C,YACE,MAA8B,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,EACnE,UAA6B,EAAE,EAC/B,MAA0B;QAE1B,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5E,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC5D,CAAC;CACF;AAnBD,gDAmBC;AAcY,QAAA,WAAW,GAA2C;IACjE,8BAA8B;IAC9B,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,sEAAsE;KAChF;IACD,sBAAsB,EAAE;QACtB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,iGAAiG;KACpG;IACD,YAAY,EAAE;QACZ,IAAI,EAAE,GAAG;QACT,OAAO,EACL,iJAAiJ;KACpJ;IACD,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,mHAAmH;KACtH;IACD,0BAA0B,EAAE;QAC1B,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,iDAAiD;KAC3D;IACD,eAAe,EAAE;QACf,IAAI,EAAE,GAAG;QACT,OAAO,EACL,yFAAyF;KAC5F;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,4EAA4E;KACtF;IACD,iBAAiB,EAAE;QACjB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,oBAAoB,EAAE;QACpB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,mDAAmD;KAC7D;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,4GAA4G;KAC/G;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,gEAAgE;KAC1E;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,sHAAsH;KACzH;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,8JAA8J;KACjK;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gJAAgJ;KACnJ;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gIAAgI;KACnI;IACD,yBAAyB,EAAE;QACzB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,6QAA6Q;KAChR;CACF,CAAC"}
+{"version":3,"file":"frame-analysis.error.js","sourceRoot":"","sources":["../../../src/core/errors/frame-analysis.error.ts"],"names":[],"mappings":";;;AAkBA,MAAa,kBAAmB,SAAQ,KAAK;IAO3C,YACE,MAA8B,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,EACnE,UAA6B,EAAE,EAC/B,MAA0B;QAE1B,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5E,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC5D,CAAC;CACF;AAnBD,gDAmBC;AAcY,QAAA,WAAW,GAA2C;IACjE,8BAA8B;IAC9B,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,sEAAsE;KAChF;IACD,sBAAsB,EAAE;QACtB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,iGAAiG;KACpG;IACD,YAAY,EAAE;QACZ,IAAI,EAAE,GAAG;QACT,OAAO,EACL,6LAA6L;KAChM;IACD,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,mHAAmH;KACtH;IACD,0BAA0B,EAAE;QAC1B,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,iDAAiD;KAC3D;IACD,eAAe,EAAE;QACf,IAAI,EAAE,GAAG;QACT,OAAO,EACL,yFAAyF;KAC5F;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,4EAA4E;KACtF;IACD,iBAAiB,EAAE;QACjB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,oBAAoB,EAAE;QACpB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,mDAAmD;KAC7D;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,4GAA4G;KAC/G;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,gEAAgE;KAC1E;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,wIAAwI;KAC3I;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,8JAA8J;KACjK;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gJAAgJ;KACnJ;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gIAAgI;KACnI;IACD,yBAAyB,EAAE;QACzB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,6QAA6Q;KAChR;IACD,sBAAsB,EAAE;QACtB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,yKAAyK;KAC5K;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,4IAA4I;KAC/I;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,8MAA8M;KACjN;IACD,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2QAA2Q;KAC9Q;CACF,CAAC"}

package/dist/core/index.d.ts

@@ -6,7 +6,7 @@ export type { SectionProperties } from "./types/section-properties.type";
 export type { Warnings, calculationResult } from "./types/output-message.type";
 export type { unit } from "./types/unit.type";
 export { FLEXURAL_STRENGTH_REDUCTION_FACTOR, CONCRETE_ULTIMATE_STRAIN, SHEAR_STRENGTH_REDUCTION_FACTOR, ANCHOR_SHEAR_STRENGTH_REDUCTION_FACTOR, MAX_PLATE_BOLT_SPACING, PLATE_SHEAR_YIELD_COEFFICIENT, SIDE_PLATE_EFFECTIVE_STRAIN_LIMIT, SIDE_PLATE_REDUCTION_FACTOR_PSI, } from "./constants/rc.constant";
-export { CONCRETE_POISSON_RATIO, CONCRETE_UNIT_WEIGHT, BEAM_INERTIA_MODIFIER, COLUMN_INERTIA_MODIFIER, VERTICAL_MEMBER_TOLERANCE, SINGULARITY_TOLERANCE, EQUILIBRIUM_TOLERANCE, AREA_GEOMETRY_TOLERANCE, } from "./constants/frame.constant";
+export { CONCRETE_POISSON_RATIO, CONCRETE_UNIT_WEIGHT, BEAM_INERTIA_MODIFIER, COLUMN_INERTIA_MODIFIER, VERTICAL_MEMBER_TOLERANCE, SINGULARITY_TOLERANCE, EQUILIBRIUM_TOLERANCE, AREA_GEOMETRY_TOLERANCE, SHELL_WARPING_LIMIT, } from "./constants/frame.constant";
 export { RCDesignError, Errors } from "./errors/rc-design.error";
 export { FrameAnalysisError, FrameErrors } from "./errors/frame-analysis.error";
 export type { FrameErrorDetails, FrameModelIssue } from "./errors/frame-analysis.error";

package/dist/core/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FrameErrors = exports.FrameAnalysisError = exports.Errors = exports.RCDesignError = exports.AREA_GEOMETRY_TOLERANCE = exports.EQUILIBRIUM_TOLERANCE = exports.SINGULARITY_TOLERANCE = exports.VERTICAL_MEMBER_TOLERANCE = exports.COLUMN_INERTIA_MODIFIER = exports.BEAM_INERTIA_MODIFIER = exports.CONCRETE_UNIT_WEIGHT = exports.CONCRETE_POISSON_RATIO = exports.SIDE_PLATE_REDUCTION_FACTOR_PSI = exports.SIDE_PLATE_EFFECTIVE_STRAIN_LIMIT = exports.PLATE_SHEAR_YIELD_COEFFICIENT = exports.MAX_PLATE_BOLT_SPACING = exports.ANCHOR_SHEAR_STRENGTH_REDUCTION_FACTOR = exports.SHEAR_STRENGTH_REDUCTION_FACTOR = exports.CONCRETE_ULTIMATE_STRAIN = exports.FLEXURAL_STRENGTH_REDUCTION_FACTOR = exports.hasSidePlate = exports.hasBottomPlate = exports.hasTopPlate = exports.isSinglyReinforced = void 0;
+exports.FrameErrors = exports.FrameAnalysisError = exports.Errors = exports.RCDesignError = exports.SHELL_WARPING_LIMIT = exports.AREA_GEOMETRY_TOLERANCE = exports.EQUILIBRIUM_TOLERANCE = exports.SINGULARITY_TOLERANCE = exports.VERTICAL_MEMBER_TOLERANCE = exports.COLUMN_INERTIA_MODIFIER = exports.BEAM_INERTIA_MODIFIER = exports.CONCRETE_UNIT_WEIGHT = exports.CONCRETE_POISSON_RATIO = exports.SIDE_PLATE_REDUCTION_FACTOR_PSI = exports.SIDE_PLATE_EFFECTIVE_STRAIN_LIMIT = exports.PLATE_SHEAR_YIELD_COEFFICIENT = exports.MAX_PLATE_BOLT_SPACING = exports.ANCHOR_SHEAR_STRENGTH_REDUCTION_FACTOR = exports.SHEAR_STRENGTH_REDUCTION_FACTOR = exports.CONCRETE_ULTIMATE_STRAIN = exports.FLEXURAL_STRENGTH_REDUCTION_FACTOR = exports.hasSidePlate = exports.hasBottomPlate = exports.hasTopPlate = exports.isSinglyReinforced = void 0;
 var rc_beam_type_1 = require("./types/rc-beam.type");
 Object.defineProperty(exports, "isSinglyReinforced", { enumerable: true, get: function () { return rc_beam_type_1.isSinglyReinforced; } });
 var plate_jacketing_type_1 = require("./types/plate-jacketing.type");
@@ -26,6 +26,7 @@ Object.defineProperty(exports, "VERTICAL_MEMBER_TOLERANCE", { enumerable: true,
 Object.defineProperty(exports, "SINGULARITY_TOLERANCE", { enumerable: true, get: function () { return frame_constant_1.SINGULARITY_TOLERANCE; } });
 Object.defineProperty(exports, "EQUILIBRIUM_TOLERANCE", { enumerable: true, get: function () { return frame_constant_1.EQUILIBRIUM_TOLERANCE; } });
 Object.defineProperty(exports, "AREA_GEOMETRY_TOLERANCE", { enumerable: true, get: function () { return frame_constant_1.AREA_GEOMETRY_TOLERANCE; } });
+Object.defineProperty(exports, "SHELL_WARPING_LIMIT", { enumerable: true, get: function () { return frame_constant_1.SHELL_WARPING_LIMIT; } });
 // Errors
 var rc_design_error_1 = require("./errors/rc-design.error");
 Object.defineProperty(exports, "RCDesignError", { enumerable: true, get: function () { return rc_design_error_1.RCDesignError; } });

package/dist/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";;;AAWA,qDAA0D;AAAjD,kHAAA,kBAAkB,OAAA;AAW3B,qEAAyF;AAAhF,mHAAA,WAAW,OAAA;AAAE,sHAAA,cAAc,OAAA;AAAE,oHAAA,YAAY,OAAA;AAKlD,YAAY;AACZ,uDASiC;AAR/B,iIAAA,kCAAkC,OAAA;AAClC,uHAAA,wBAAwB,OAAA;AACxB,8HAAA,+BAA+B,OAAA;AAC/B,qIAAA,sCAAsC,OAAA;AACtC,qHAAA,sBAAsB,OAAA;AACtB,4HAAA,6BAA6B,OAAA;AAC7B,gIAAA,iCAAiC,OAAA;AACjC,8HAAA,+BAA+B,OAAA;AAGjC,6DASoC;AARlC,wHAAA,sBAAsB,OAAA;AACtB,sHAAA,oBAAoB,OAAA;AACpB,uHAAA,qBAAqB,OAAA;AACrB,yHAAA,uBAAuB,OAAA;AACvB,2HAAA,yBAAyB,OAAA;AACzB,uHAAA,qBAAqB,OAAA;AACrB,uHAAA,qBAAqB,OAAA;AACrB,yHAAA,uBAAuB,OAAA;AAGzB,SAAS;AACT,4DAAiE;AAAxD,gHAAA,aAAa,OAAA;AAAE,yGAAA,MAAM,OAAA;AAC9B,sEAAgF;AAAvE,0HAAA,kBAAkB,OAAA;AAAE,mHAAA,WAAW,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";;;AAWA,qDAA0D;AAAjD,kHAAA,kBAAkB,OAAA;AAW3B,qEAAyF;AAAhF,mHAAA,WAAW,OAAA;AAAE,sHAAA,cAAc,OAAA;AAAE,oHAAA,YAAY,OAAA;AAKlD,YAAY;AACZ,uDASiC;AAR/B,iIAAA,kCAAkC,OAAA;AAClC,uHAAA,wBAAwB,OAAA;AACxB,8HAAA,+BAA+B,OAAA;AAC/B,qIAAA,sCAAsC,OAAA;AACtC,qHAAA,sBAAsB,OAAA;AACtB,4HAAA,6BAA6B,OAAA;AAC7B,gIAAA,iCAAiC,OAAA;AACjC,8HAAA,+BAA+B,OAAA;AAGjC,6DAUoC;AATlC,wHAAA,sBAAsB,OAAA;AACtB,sHAAA,oBAAoB,OAAA;AACpB,uHAAA,qBAAqB,OAAA;AACrB,yHAAA,uBAAuB,OAAA;AACvB,2HAAA,yBAAyB,OAAA;AACzB,uHAAA,qBAAqB,OAAA;AACrB,uHAAA,qBAAqB,OAAA;AACrB,yHAAA,uBAAuB,OAAA;AACvB,qHAAA,mBAAmB,OAAA;AAGrB,SAAS;AACT,4DAAiE;AAAxD,gHAAA,aAAa,OAAA;AAAE,yGAAA,MAAM,OAAA;AAC9B,sEAAgF;AAAvE,0HAAA,kBAAkB,OAAA;AAAE,mHAAA,WAAW,OAAA"}

package/dist/esm/core/constants/frame.constant.js

@@ -17,4 +17,19 @@ export const EQUILIBRIUM_TOLERANCE = 1e-6;
  * edges, nodes lying on an edge): distances are compared with this times the longest edge.
  */
 export const AREA_GEOMETRY_TOLERANCE = 1e-6;
+/**
+ * Penalty factor γ of the shell membrane's drilling rotation, as a multiple of the shear modulus
+ * G: the term ½·γ·t·∫(θ − ω)² dA, integrated at the element centre, ties each element's rotation
+ * about the shell normal θ to the in-plane rotation of the material ω = ½(v,x − u,y). γ = G
+ * follows Ibrahimbegovic, Taylor & Wilson (1990); with the one-point rule the results change by
+ * well under 1 % for γ between 0.01 G and 100 G.
+ */
+export const DRILLING_PENALTY_RATIO = 1;
+/**
+ * Largest warping of a shell element accepted, as the distance of its corners from their mean
+ * plane relative to √A (A = projected area). Warped elements are built flat on the mean plane
+ * and linked rigidly to their corners, which is accurate for mild warping (the MacNeal–Harder
+ * twisted beam, 0.024, is within 0.5 %); beyond this the element is rejected (326).
+ */
+export const SHELL_WARPING_LIMIT = 0.1;
 //# sourceMappingURL=frame.constant.js.map

package/dist/esm/core/constants/frame.constant.js.map

@@ -1 +1 @@
-{"version":3,"file":"frame.constant.js","sourceRoot":"","sources":["../../../../src/core/constants/frame.constant.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAE1C,iGAAiG;AACjG,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C,mGAAmG;AACnG,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C,qGAAqG;AACrG,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC,gGAAgG;AAChG,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,CAAC;AAE9C,uGAAuG;AACvG,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C,2EAA2E;AAC3E,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,CAAC"}
+{"version":3,"file":"frame.constant.js","sourceRoot":"","sources":["../../../../src/core/constants/frame.constant.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAE1C,iGAAiG;AACjG,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C,mGAAmG;AACnG,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C,qGAAqG;AACrG,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC,gGAAgG;AAChG,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,CAAC;AAE9C,uGAAuG;AACvG,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C,2EAA2E;AAC3E,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC"}

package/dist/esm/core/errors/frame-analysis.error.js

@@ -20,7 +20,7 @@ export const FrameErrors = {
     },
     DUPLICATE_ID: {
         code: 303,
-        message: "Node ids, member ids, area ids and restrained node ids must each be unique, and load case and combination ids must be unique across both lists.",
+        message: "Node ids, member ids and restrained node ids must each be unique, area ids must be unique across null areas and shells, and load case and combination ids must be unique across both lists.",
     },
     STRUCTURE_UNSTABLE: {
         code: 304,
@@ -60,7 +60,7 @@ export const FrameErrors = {
     },
     MISSING_UNIT_WEIGHT: {
         code: 313,
-        message: "A load case requests self-weight but a member section has no unitWeight; set unitWeight (0 for a weightless member).",
+        message: "A load case requests self-weight but a member or shell section has no unitWeight; set unitWeight (0 for a weightless member or shell).",
     },
     INVALID_INPUT_VALUE: {
         code: 314,
@@ -78,5 +78,21 @@ export const FrameErrors = {
         code: 317,
         message: "An area's supportEdges do not fit its distribution: two-way takes none; one-way needs at least one edge left unsupported, with every unsupported edge parallel to the others (the span direction); cantilever needs exactly one, and its loads may not act along that edge.",
     },
+    INVALID_SHELL_GEOMETRY: {
+        code: 326,
+        message: "A shell area must have 4 distinct nodes, listed in order around it, forming a convex quadrilateral that is close to flat (each corner within 0.1·√A of the mean plane).",
+    },
+    INVALID_SHELL_SECTION: {
+        code: 327,
+        message: "A shell section's thickness and E must be positive, nu must be at least 0 and below 0.5, and unitWeight, when given, must not be negative.",
+    },
+    SHELL_DOF_UNSUPPORTED: {
+        code: 328,
+        message: 'A node connected only to shells has a translation that nothing resists: a membrane carries no load out of its plane and a plate none in its plane. Restrain that DOF, connect a member, or use type "shell".',
+    },
+    INVALID_SHELL_MESH: {
+        code: 329,
+        message: "Shell areas cannot be meshed: no division counts make the meshes of areas sharing edges meet node to node, a generated element is not a valid quadrilateral, or a generated id is already in use. Divide the areas so they meet edge to edge, or change their mesh sizes.",
+    },
 };
 //# sourceMappingURL=frame-analysis.error.js.map

package/dist/esm/core/errors/frame-analysis.error.js.map

@@ -1 +1 @@
-{"version":3,"file":"frame-analysis.error.js","sourceRoot":"","sources":["../../../../src/core/errors/frame-analysis.error.ts"],"names":[],"mappings":"AAiBA,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAO3C,YACE,MAA8B,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,EACnE,UAA6B,EAAE,EAC/B,MAA0B;QAE1B,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5E,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC5D,CAAC;CACF;AAcD,MAAM,CAAC,MAAM,WAAW,GAA2C;IACjE,8BAA8B;IAC9B,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,sEAAsE;KAChF;IACD,sBAAsB,EAAE;QACtB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,iGAAiG;KACpG;IACD,YAAY,EAAE;QACZ,IAAI,EAAE,GAAG;QACT,OAAO,EACL,iJAAiJ;KACpJ;IACD,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,mHAAmH;KACtH;IACD,0BAA0B,EAAE;QAC1B,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,iDAAiD;KAC3D;IACD,eAAe,EAAE;QACf,IAAI,EAAE,GAAG;QACT,OAAO,EACL,yFAAyF;KAC5F;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,4EAA4E;KACtF;IACD,iBAAiB,EAAE;QACjB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,oBAAoB,EAAE;QACpB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,mDAAmD;KAC7D;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,4GAA4G;KAC/G;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,gEAAgE;KAC1E;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,sHAAsH;KACzH;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,8JAA8J;KACjK;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gJAAgJ;KACnJ;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gIAAgI;KACnI;IACD,yBAAyB,EAAE;QACzB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,6QAA6Q;KAChR;CACF,CAAC"}
+{"version":3,"file":"frame-analysis.error.js","sourceRoot":"","sources":["../../../../src/core/errors/frame-analysis.error.ts"],"names":[],"mappings":"AAkBA,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAO3C,YACE,MAA8B,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,EACnE,UAA6B,EAAE,EAC/B,MAA0B;QAE1B,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5E,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC5D,CAAC;CACF;AAcD,MAAM,CAAC,MAAM,WAAW,GAA2C;IACjE,8BAA8B;IAC9B,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,sEAAsE;KAChF;IACD,sBAAsB,EAAE;QACtB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,iGAAiG;KACpG;IACD,YAAY,EAAE;QACZ,IAAI,EAAE,GAAG;QACT,OAAO,EACL,6LAA6L;KAChM;IACD,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,mHAAmH;KACtH;IACD,0BAA0B,EAAE;QAC1B,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,iDAAiD;KAC3D;IACD,eAAe,EAAE;QACf,IAAI,EAAE,GAAG;QACT,OAAO,EACL,yFAAyF;KAC5F;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,4EAA4E;KACtF;IACD,iBAAiB,EAAE;QACjB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2HAA2H;KAC9H;IACD,oBAAoB,EAAE;QACpB,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,mDAAmD;KAC7D;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,4GAA4G;KAC/G;IACD,aAAa,EAAE;QACb,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,gEAAgE;KAC1E;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,wIAAwI;KAC3I;IACD,mBAAmB,EAAE;QACnB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,8JAA8J;KACjK;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gJAAgJ;KACnJ;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,gIAAgI;KACnI;IACD,yBAAyB,EAAE;QACzB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,6QAA6Q;KAChR;IACD,sBAAsB,EAAE;QACtB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,yKAAyK;KAC5K;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,4IAA4I;KAC/I;IACD,qBAAqB,EAAE;QACrB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,8MAA8M;KACjN;IACD,kBAAkB,EAAE;QAClB,IAAI,EAAE,GAAG;QACT,OAAO,EACL,2QAA2Q;KAC9Q;CACF,CAAC"}

package/dist/esm/core/index.js

@@ -2,7 +2,7 @@ export { isSinglyReinforced } from "./types/rc-beam.type.js";
 export { hasTopPlate, hasBottomPlate, hasSidePlate } from "./types/plate-jacketing.type.js";
 // Constants
 export { FLEXURAL_STRENGTH_REDUCTION_FACTOR, CONCRETE_ULTIMATE_STRAIN, SHEAR_STRENGTH_REDUCTION_FACTOR, ANCHOR_SHEAR_STRENGTH_REDUCTION_FACTOR, MAX_PLATE_BOLT_SPACING, PLATE_SHEAR_YIELD_COEFFICIENT, SIDE_PLATE_EFFECTIVE_STRAIN_LIMIT, SIDE_PLATE_REDUCTION_FACTOR_PSI, } from "./constants/rc.constant.js";
-export { CONCRETE_POISSON_RATIO, CONCRETE_UNIT_WEIGHT, BEAM_INERTIA_MODIFIER, COLUMN_INERTIA_MODIFIER, VERTICAL_MEMBER_TOLERANCE, SINGULARITY_TOLERANCE, EQUILIBRIUM_TOLERANCE, AREA_GEOMETRY_TOLERANCE, } from "./constants/frame.constant.js";
+export { CONCRETE_POISSON_RATIO, CONCRETE_UNIT_WEIGHT, BEAM_INERTIA_MODIFIER, COLUMN_INERTIA_MODIFIER, VERTICAL_MEMBER_TOLERANCE, SINGULARITY_TOLERANCE, EQUILIBRIUM_TOLERANCE, AREA_GEOMETRY_TOLERANCE, SHELL_WARPING_LIMIT, } from "./constants/frame.constant.js";
 // Errors
 export { RCDesignError, Errors } from "./errors/rc-design.error.js";
 export { FrameAnalysisError, FrameErrors } from "./errors/frame-analysis.error.js";

package/dist/esm/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAW1D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAKzF,YAAY;AACZ,OAAO,EACL,kCAAkC,EAClC,wBAAwB,EACxB,+BAA+B,EAC/B,sCAAsC,EACtC,sBAAsB,EACtB,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,GAChC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AAEpC,SAAS;AACT,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAW1D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAKzF,YAAY;AACZ,OAAO,EACL,kCAAkC,EAClC,wBAAwB,EACxB,+BAA+B,EAC/B,sCAAsC,EACtC,sBAAsB,EACtB,6BAA6B,EAC7B,iCAAiC,EACjC,+BAA+B,GAChC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AAEpC,SAAS;AACT,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/esm/fea/frame/elements/shell/dkq-plate.js

@@ -0,0 +1,109 @@
+import { zeros } from "../../../../utils/matrix.js";
+import { GAUSS_2X2, quadJacobian, serendipityShape } from "./quad-geometry.js";
+import { isotropicRigidity } from "./rigidity.js";
+const edgeCoefficients = (corners) => [0, 1, 2, 3].map((k) => {
+    const [xi, yi] = corners[k];
+    const [xj, yj] = corners[(k + 1) % 4];
+    const x = xi - xj;
+    const y = yi - yj;
+    const l2 = x * x + y * y;
+    return {
+        a: -x / l2,
+        b: (0.75 * x * y) / l2,
+        c: (0.25 * x * x - 0.5 * y * y) / l2,
+        d: -y / l2,
+        e: (0.25 * y * y - 0.5 * x * x) / l2,
+    };
+});
+/**
+ * The rotations of the normal `βx = Hxᵀ·U`, `βy = Hyᵀ·U` (or a derivative of them), given the
+ * eight serendipity values `F` (or the same derivative of them): corners in `F[0…3]`, mid-sides
+ * of edges 1→2, 2→3, 3→4, 4→1 in `F[4…7]`.
+ */
+const rotationRows = (edges, F) => {
+    const Hx = new Array(12).fill(0);
+    const Hy = new Array(12).fill(0);
+    for (let i = 0; i < 4; i++) {
+        // m: the edge that starts at corner i; k: the edge that ends at it
+        const m = i;
+        const k = (i + 3) % 4;
+        const Fm = F[4 + m];
+        const Fk = F[4 + k];
+        const em = edges[m];
+        const ek = edges[k];
+        Hx[3 * i] = 1.5 * (em.a * Fm - ek.a * Fk);
+        Hx[3 * i + 1] = em.b * Fm + ek.b * Fk;
+        Hx[3 * i + 2] = F[i] - em.c * Fm - ek.c * Fk;
+        Hy[3 * i] = 1.5 * (em.d * Fm - ek.d * Fk);
+        Hy[3 * i + 1] = -F[i] + em.e * Fm + ek.e * Fk;
+        Hy[3 * i + 2] = -Hx[3 * i + 1];
+    }
+    return { Hx, Hy };
+};
+/**
+ * Curvature–displacement rows of the discrete Kirchhoff quadrilateral (DKQ) at (ξ, η).
+ *
+ * The rotations of the normal βx, βy (with u = z·βx, v = z·βy) are interpolated over the 8
+ * serendipity nodes; the Kirchhoff condition at the corners (βx = −w,x, βy = −w,y), a cubic w
+ * along each edge with ∫(w,s + βs) ds = 0, and a normal rotation linear along each edge
+ * eliminate the mid-side values (Batoz & Ben Tahar 1982). The geometry map stays bilinear.
+ *
+ * @param corners - The four corners in the element plane (mm), counter-clockwise
+ * @param xi - Natural coordinate ξ
+ * @param eta - Natural coordinate η
+ */
+export const dkqCurvatureRows = (corners, xi, eta) => {
+    const jacobian = quadJacobian(corners, xi, eta);
+    const shape = serendipityShape(xi, eta);
+    const edges = edgeCoefficients(corners);
+    const dXi = rotationRows(edges, shape.dXi);
+    const dEta = rotationRows(edges, shape.dEta);
+    const [[j11, j12], [j21, j22]] = jacobian.inverse;
+    const B = [[], [], []];
+    for (let p = 0; p < 12; p++) {
+        const HxX = j11 * dXi.Hx[p] + j12 * dEta.Hx[p];
+        const HxY = j21 * dXi.Hx[p] + j22 * dEta.Hx[p];
+        const HyX = j11 * dXi.Hy[p] + j12 * dEta.Hy[p];
+        const HyY = j21 * dXi.Hy[p] + j22 * dEta.Hy[p];
+        B[0].push(HxX);
+        B[1].push(HyY);
+        B[2].push(HxY + HyX);
+    }
+    return { B, detJ: jacobian.detJ };
+};
+/**
+ * Plate bending rigidity `E·t³/(12(1 − ν²))·[[1, ν, 0], [ν, 1, 0], [0, 0, (1 − ν)/2]]`
+ * (N·mm), with the stiffness modifiers applied (see `isotropicRigidity`).
+ */
+export const plateRigidity = ({ E, nu, t, modifiers }) => isotropicRigidity((E * t ** 3) / (12 * (1 - nu * nu)), nu, modifiers);
+/**
+ * Local stiffness of the discrete Kirchhoff quadrilateral (DKQ, Batoz & Ben Tahar 1982), a thin
+ * plate element without transverse shear deformation, integrated with 2×2 Gauss points.
+ *
+ * The DOFs are `[w₁ θx₁ θy₁ … w₄ θx₄ θy₄]`: the deflection along the element normal and the
+ * right-handed rotations about the element's x and y axes (θx = w,y, θy = −w,x), at corners listed
+ * counter-clockwise about the normal. The quad must be convex (det J > 0 throughout), which
+ * validation guarantees.
+ *
+ * @param corners - The four corners in the element plane (mm)
+ * @param properties - E (MPa), ν and thickness t (mm)
+ * @returns The symmetric 12×12 stiffness in N and mm (N/mm, N, N·mm/rad); exactly three
+ *   zero-energy modes, the out-of-plane rigid-body motions
+ */
+export const dkqPlateStiffness = (corners, properties) => {
+    const D = plateRigidity(properties);
+    const k = zeros(12, 12);
+    for (const { xi, eta, weight } of GAUSS_2X2) {
+        const { B, detJ } = dkqCurvatureRows(corners, xi, eta);
+        const scale = detJ * weight;
+        // Bᵀ·D·B via D·B
+        const DB = D.map((row) => B[0].map((_, a) => row[0] * B[0][a] + row[1] * B[1][a] + row[2] * B[2][a]));
+        for (let a = 0; a < 12; a++) {
+            for (let b = 0; b < 12; b++) {
+                k[a][b] += (B[0][a] * DB[0][b] + B[1][a] * DB[1][b] + B[2][a] * DB[2][b]) * scale;
+            }
+        }
+    }
+    return k;
+};
+//# sourceMappingURL=dkq-plate.js.map

package/dist/esm/fea/frame/elements/shell/dkq-plate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dkq-plate.js","sourceRoot":"","sources":["../../../../../../src/fea/frame/elements/shell/dkq-plate.ts"],"names":[],"mappings":"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"}