Module tables 

Bulk per-(entity-kind) tables of the wire format (docs/input-format.md), one set for both profiles (header.ndm 2 or 3). Dimension-agnostic entities (nodes, trusses, zero-lengths, fibers, constraints, loads) have one table; formulations that differ between 2D and 3D (beam-columns) have one table each, suffixed 2d/3d, and the table of the other profile must be empty (DecodeError::TableNotInProfile).

Node/element/pattern references inside these tables are already resolved to dense 0-based row indices by the (not-yet-written) pysees compiler — the “duplicate/missing tags and every reference between entities” validation the compiler is responsible for happens upstream of decode, so decode only ever sees plain array indices, never sparse OpenSees-style tags.

Each field is a plain Vec, not yet the transferable Float64Array/ Uint8Array values the wire format ultimately specifies for postMessage: boundary.rs’s serde-wasm-bindgen decoding today accepts an ordinary JS array for each of these (or a typed array, copied element-by-element) rather than transferring one. Once real transferable-array support lands, each Vec<f64>/Vec<u32> here is exactly the shape a Float64Array/Uint32Array copies into. Every table of super::CarapaceInputV1 may be omitted, which is the same as empty.

#[serde(rename_all = "camelCase")] throughout so the JS/TS shape matches the PySees naming (nodeI, not node_i).

Structs

ElasticBeamColumn2dTable

ElasticBeamColumn3dTable

ElementLoadTable

EqualDofTable

Identity multi-point constraints (core::Domain::equal_dof’s doc comment): row i ties constrained[i]’s dofs listed in dofs exactly to the same dofs of retained[i]. dofs is sparse per row — (row, dof) pairs, mirroring ZeroLengthTable::materials’s own sparse convention — since most ties only ever list one or two dofs, not every dof a node has.

FiberBeamColumn2dTable

Shared shape for 2D DispBeamColumn and ForceBeamColumn — both are one prismatic fiber section (see FiberTable) replicated across integration points by core’s own element constructors.

FiberBeamColumn3dTable

Shared shape for DispBeamColumn3 and ForceBeamColumn3 — both are one prismatic biaxial fiber section (see FiberTable) replicated across integration points by core’s own element constructors. Unlike FiberBeamColumn2dTable, there is no corotational field: neither spatial fiber element supports it yet, and no separate transform field — g/j/vec_xz are passed directly to the constructor, since these elements only ever use Linear-type geometry.

FiberTable

Fibers for every DispBeamColumn/ForceBeamColumn section, flattened and offset-indexed: section k occupies section_offsets[k]..section_offsets[k + 1] in y/z/area/material. section_offsets therefore has num_sections + 1 entries. z is empty in a 2D model and parallel to y in a 3D model (biaxial bending) — torsion is deliberately excluded from the fiber loop in core (FiberSection3’s doc comment) and supplied instead as each owning table’s own g/j fields.

FrictionRow

One sparse friction row of ZeroLengthTable: the row’s one Friction (2D) / Friction3 (3D) — see their doc comments for the field meanings. normal_dof must already have a materials entry on the same row, and the shear DOFs must not (checked by core via debug_assert).

LinearConstraintTable

General linear multi-point constraints (core::Domain::add_constraint): row i defines u[slaveNode[i], slaveDof[i]] = sum coeff * u[node, dof] over the terms termOffsets[i]..termOffsets[i + 1] of the flattened sparse termNode/termDof/termCoeff arrays. termOffsets has rows + 1 entries (or none at all for an empty table).

LoadPatternTable

NodalLoadTable

NodeTable

Node table: coords stride ndm (x, y[, z]); fixed one bitmask byte per node (bit k = DOF k: ux, uy, rz in 2D; ux, uy, uz, rx, ry, rz in 3D); mass is sparse, addressed via a parallel node-index array since most nodes carry none.

OrientRow

One sparse orient row — OpenSees’ -orient x1 x2 x3 [yp1 yp2 yp3]: local x is x; in 3D local z is x × yp and local y completes the frame; in 2D yp is absent, x[2] must be 0 and local y is local x turned 90 degrees counter-clockwise. Every DOF of the row is evaluated along those axes. Rows without an entry use the global axes; at most one entry per row.

QuadTable

4-node bilinear quadrilaterals (2D models only). nodeIds has stride 4 (counter-clockwise); material indexes planeMaterials.

RigidDiaphragmTable

Rigid diaphragm: row i ties every node listed against it in constrained to retained[i] — in 2D the ux dof (core::Domain:: rigid_diaphragm’s doc comment); in 3D the two in-plane translational dofs (perpendicular to normal[i]) plus the lever-arm rotation term (core::Domain3::rigid_diaphragm_about). constrained is sparse per row — (row, node index) pairs — since a diaphragm’s node count varies. normal is 3D only: omitted or empty means every row’s normal is Y; a 2D model must leave it empty.

RigidLinkTable

Rigid links (core::Domain::rigid_link’s doc comment): slave moves with master as a rigid body, small-rotation lever arm taken from the node coordinates.

Shell3Table

3-node DKT/Allman shells (3D models only). nodeIds has stride 3 (the node order sets the local normal by the right-hand rule); section indexes shellSections.

Shell4Table

4-node MITC4 shells (3D models only). nodeIds has stride 4 (the node order fixes the local normal by the right-hand rule); section indexes shellSections.

TriangleTable

3-node constant-strain triangles (2D models only). nodeIds has stride 3 (counter-clockwise); material indexes planeMaterials.

TrussTable

Same fields in 2D and 3D.

ZeroLengthSectionTable

A ZeroLength driven by a coupled FiberSection (axial + moment response, [ux, rz] in 2D; axial + biaxial moment, [ux, ry, rz] in 3D) instead of ZeroLength’s independent per-DOF materials — see core::ZeroLengthSection’s doc comment.

ZeroLengthTable

Enums

Axis3Spec

core::Axis3’s wire mirror — core’s own type carries no serde derive (Axis3’s doc comment: it’s a plain repr(usize) enum for internal indexing, not wire-facing), so this is decode’s own translation, the same reason TransformSpec/TransformSpec3 mirror GeomTransf/ GeomTransf3 rather than deriving on the core type directly.

ElementKind

Every element formulation, 2D and 3D. A kind that does not belong to the model’s ndm is DecodeError::ElementKindNotInProfile.

ElementLoadSpec

IntegrationSpec

PlaneMaterialSpec

A plane (2D continuum) material, referenced by triangles/quads rows through the planeMaterials arena. Strain is [eps_x, eps_y, gamma_xy] with engineering shear.

PlaneStateSpec

Quad4FormulationSpec

ShellSectionSpec

A shell section, referenced by shell4s rows through the shellSections arena. Generalized strain and resultants follow OpenSees’ ElasticMembranePlateSection ordering.

TimeSeriesSpec

TransformSpec

TransformSpec3

GeomTransf3’s wire mirror. No Corotational3 — spatial corotational geometry doesn’t exist in core yet (GeomTransf3’s own doc comment).