@jtgtools/xbeam 0.0.1

package/dist/index.js

@@ -0,0 +1,649 @@
+// src/constants.ts
+var HALF_BANDWIDTH = 3;
+var TOLERANCE = 1e-9;
+var DEFAULT_MAX_ELEMENTS = 200;
+var DEFAULT_MIN_ELEMENTS_PER_SEGMENT = 2;
+var DEFAULT_DIAGRAM_POINTS_PER_ELEMENT = 12;
+
+// src/mesh.ts
+function generateMesh(beam, options = {}) {
+  const eps = options.eps ?? TOLERANCE;
+  const maxElements = options.maxElements ?? DEFAULT_MAX_ELEMENTS;
+  const minElementsPerSegment = options.minElementsPerSegment ?? DEFAULT_MIN_ELEMENTS_PER_SEGMENT;
+  const critical = collectCriticalPoints(beam);
+  critical.sort((a, b) => a - b);
+  const unique = [];
+  for (const x of critical) {
+    if (unique.length === 0) {
+      unique.push(x);
+      continue;
+    }
+    const last = unique[unique.length - 1];
+    if (Math.abs(x - last) >= eps) unique.push(x);
+  }
+  const nodes = [];
+  const L = beam.length;
+  if (unique.length < 2) {
+    nodes.push(0, L);
+    return {
+      nodes: new Float64Array(nodes),
+      findNodeIndex: (xQuery, epsQuery) => findClosestNodeIndex(nodes, xQuery, epsQuery)
+    };
+  }
+  const targetDensity = maxElements / L;
+  for (let i = 0; i < unique.length - 1; i++) {
+    const xStart = unique[i];
+    const xEnd = unique[i + 1];
+    const segLen = xEnd - xStart;
+    if (segLen <= eps) continue;
+    const nElem = Math.max(Math.floor(segLen * targetDensity), minElementsPerSegment);
+    for (let j = 0; j < nElem; j++) {
+      const s = j / nElem;
+      nodes.push(xStart + s * segLen);
+    }
+  }
+  nodes.push(L);
+  const nodeArray = new Float64Array(nodes);
+  return {
+    nodes: nodeArray,
+    findNodeIndex: (xQuery, epsQuery) => findClosestNodeIndex(nodeArray, xQuery, epsQuery)
+  };
+}
+function collectCriticalPoints(beam) {
+  const points = [0, beam.length];
+  for (const s of beam.supports) points.push(s.position);
+  for (const pl of beam.pointLoads) points.push(pl.position);
+  for (const dl of beam.distributedLoads) {
+    points.push(dl.startPosition, dl.endPosition);
+  }
+  for (const am of beam.appliedMoments ?? []) points.push(am.position);
+  return points;
+}
+function findClosestNodeIndex(nodes, x, eps) {
+  let lo = 0;
+  let hi = nodes.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const v = nodes[mid];
+    if (x < v - eps) hi = mid - 1;
+    else if (x > v + eps) lo = mid + 1;
+    else return mid;
+  }
+  const candidates = [];
+  if (lo >= 0 && lo < nodes.length) candidates.push(lo);
+  if (lo - 1 >= 0 && lo - 1 < nodes.length) candidates.push(lo - 1);
+  let bestIdx = -1;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const idx of candidates) {
+    const d = Math.abs(nodes[idx] - x);
+    if (d <= eps && d < bestDist) {
+      bestDist = d;
+      bestIdx = idx;
+    }
+  }
+  return bestIdx;
+}
+
+// src/hermite.ts
+function hermiteShapeInto(s, l, out) {
+  const s2 = s * s;
+  const s3 = s2 * s;
+  out[0] = 1 - 3 * s2 + 2 * s3;
+  out[1] = l * (s - 2 * s2 + s3);
+  out[2] = 3 * s2 - 2 * s3;
+  out[3] = l * (-s2 + s3);
+}
+function hermiteD2Into(s, l, out) {
+  const l2 = l * l;
+  const l2Inv = 1 / l2;
+  const sixS = 6 * s;
+  out[0] = (-6 + 12 * s) * l2Inv;
+  out[1] = l * (-4 + sixS) * l2Inv;
+  out[2] = (6 - 12 * s) * l2Inv;
+  out[3] = l * (-2 + sixS) * l2Inv;
+}
+
+// src/element.ts
+var GAUSS_POINTS = [-Math.sqrt(3 / 5), 0, Math.sqrt(3 / 5)];
+var GAUSS_WEIGHTS = [5 / 9, 8 / 9, 5 / 9];
+function stiffnessCoefficients(le, E, I) {
+  const EI = E * I;
+  const le2 = le * le;
+  const le3 = le2 * le;
+  return {
+    k11: 12 * EI / le3,
+    k12: 6 * EI / le2,
+    k22: 4 * EI / le,
+    k24: 2 * EI / le
+  };
+}
+function consistentDistributedLoadGaussInto(qa, qb, sa, sb, le, out, shapeScratch) {
+  const mid = (sa + sb) / 2;
+  const hw = (sb - sa) / 2;
+  const dq = sb > sa ? (qb - qa) / (sb - sa) : 0;
+  for (let g = 0; g < 3; g++) {
+    const s = mid + hw * GAUSS_POINTS[g];
+    const q = qa + dq * (s - sa);
+    hermiteShapeInto(s, le, shapeScratch);
+    const w = GAUSS_WEIGHTS[g] * hw * le * q;
+    out[0] += w * shapeScratch[0];
+    out[1] += w * shapeScratch[1];
+    out[2] += w * shapeScratch[2];
+    out[3] += w * shapeScratch[3];
+  }
+}
+
+// src/utils.ts
+function distributedIntensityAt(x, dl) {
+  const a = dl.startPosition;
+  const b = dl.endPosition;
+  const len = b - a;
+  if (Math.abs(len) < TOLERANCE) return dl.startMagnitude;
+  if (x < Math.min(a, b) - TOLERANCE) return 0;
+  if (x > Math.max(a, b) + TOLERANCE) return 0;
+  const t = Math.max(0, Math.min(1, (x - a) / len));
+  return dl.startMagnitude + (dl.endMagnitude - dl.startMagnitude) * t;
+}
+
+// src/assembler.ts
+function assembleSystem(beam, mesh) {
+  const nodes = mesh.nodes;
+  const nNodes = nodes.length;
+  const nDof = 2 * nNodes;
+  const bp1 = HALF_BANDWIDTH + 1;
+  const bandedK = new Float64Array(nDof * bp1);
+  const forceVector = new Float64Array(nDof);
+  assembleStiffness(beam, nodes, bandedK, bp1);
+  assembleForces(beam, mesh, nodes, forceVector);
+  return { bandedK, forceVector, nodePositions: nodes };
+}
+function getBoundaryConditions(beam, mesh) {
+  const nodes = mesh.nodes;
+  const nNodes = nodes.length;
+  const nDof = 2 * nNodes;
+  const restrained = new Uint8Array(nDof);
+  for (const s of beam.supports) {
+    const idx = mesh.findNodeIndex(s.position, TOLERANCE);
+    if (idx < 0) continue;
+    const wDof = 2 * idx;
+    switch (s.kind) {
+      case "PINNED":
+      case "ROLLER":
+        restrained[wDof] = 1;
+        break;
+      case "FIXED":
+        restrained[wDof] = 1;
+        restrained[wDof + 1] = 1;
+        break;
+    }
+  }
+  let nFree = 0;
+  let nRest = 0;
+  for (let dof = 0; dof < nDof; dof++) {
+    if (restrained[dof]) nRest++;
+    else nFree++;
+  }
+  const freeDofs = new Int32Array(nFree);
+  const restrainedDofs = new Int32Array(nRest);
+  let fi = 0;
+  let ri = 0;
+  for (let dof = 0; dof < nDof; dof++) {
+    if (restrained[dof]) restrainedDofs[ri++] = dof;
+    else freeDofs[fi++] = dof;
+  }
+  return { freeDofs, restrainedDofs };
+}
+function assembleStiffness(beam, nodes, bandedK, bp1) {
+  const E = beam.modulusOfElasticity;
+  const I = beam.momentOfInertia;
+  const nNodes = nodes.length;
+  for (let e = 0; e < nNodes - 1; e++) {
+    const le = nodes[e + 1] - nodes[e];
+    if (le <= TOLERANCE) continue;
+    const { k11, k12, k22, k24 } = stiffnessCoefficients(le, E, I);
+    const a = 2 * e;
+    const b = 2 * e + 1;
+    const c = 2 * (e + 1);
+    const d = 2 * (e + 1) + 1;
+    bandedK[a * bp1 + 0] += k11;
+    bandedK[a * bp1 + 1] += k12;
+    bandedK[a * bp1 + 2] += -k11;
+    bandedK[a * bp1 + 3] += k12;
+    bandedK[b * bp1 + 0] += k22;
+    bandedK[b * bp1 + 1] += -k12;
+    bandedK[b * bp1 + 2] += k24;
+    bandedK[c * bp1 + 0] += k11;
+    bandedK[c * bp1 + 1] += -k12;
+    bandedK[d * bp1 + 0] += k22;
+  }
+}
+function assembleForces(beam, mesh, nodes, forceVector) {
+  const nNodes = nodes.length;
+  const nDof = 2 * nNodes;
+  if (forceVector.length !== nDof) throw new Error("Unexpected forceVector size.");
+  const loadScratch = new Float64Array(4);
+  const shapeScratch = new Float64Array(4);
+  for (const pl of beam.pointLoads) {
+    const idx = mesh.findNodeIndex(pl.position, TOLERANCE);
+    if (idx < 0) continue;
+    forceVector[2 * idx] += pl.magnitude;
+  }
+  for (const dl of beam.distributedLoads) {
+    const xMin = Math.min(dl.startPosition, dl.endPosition);
+    const xMax = Math.max(dl.startPosition, dl.endPosition);
+    if (xMax - xMin <= TOLERANCE) continue;
+    for (let e = 0; e < nNodes - 1; e++) {
+      const xa = nodes[e];
+      const xb = nodes[e + 1];
+      const le = xb - xa;
+      if (le <= TOLERANCE) continue;
+      const overlapStart = Math.max(xa, xMin);
+      const overlapEnd = Math.min(xb, xMax);
+      if (overlapEnd <= overlapStart + TOLERANCE) continue;
+      const sa = (overlapStart - xa) / le;
+      const sb = (overlapEnd - xa) / le;
+      const qa = distributedIntensityAt(overlapStart, dl);
+      const qb = distributedIntensityAt(overlapEnd, dl);
+      loadScratch.fill(0);
+      consistentDistributedLoadGaussInto(qa, qb, sa, sb, le, loadScratch, shapeScratch);
+      const wA = 2 * e;
+      const thA = 2 * e + 1;
+      const wB = 2 * (e + 1);
+      const thB = 2 * (e + 1) + 1;
+      forceVector[wA] += loadScratch[0];
+      forceVector[thA] += loadScratch[1];
+      forceVector[wB] += loadScratch[2];
+      forceVector[thB] += loadScratch[3];
+    }
+  }
+  for (const am of beam.appliedMoments ?? []) {
+    const idx = mesh.findNodeIndex(am.position, TOLERANCE);
+    if (idx < 0) continue;
+    forceVector[2 * idx + 1] -= am.magnitude;
+  }
+}
+
+// src/solver.ts
+var BP1 = HALF_BANDWIDTH + 1;
+function solveLinearSystem(system, bc) {
+  const nDof = system.forceVector.length;
+  const u = new Float64Array(nDof);
+  const { freeDofs, restrainedDofs } = bc;
+  const n = freeDofs.length;
+  if (n === 0) throw new Error("All DOFs restrained; nothing to solve.");
+  const globalOf = freeDofs;
+  const compactOf = new Int32Array(nDof);
+  compactOf.fill(-1);
+  for (let ii = 0; ii < n; ii++) compactOf[globalOf[ii]] = ii;
+  const Kff = new Float64Array(n * n);
+  for (let ii = 0; ii < n; ii++) {
+    const gi = globalOf[ii];
+    for (let jj = ii; jj < n; jj++) {
+      const gj = globalOf[jj];
+      const d = gj - gi;
+      if (d <= HALF_BANDWIDTH) {
+        Kff[ii * n + jj] = system.bandedK[gi * BP1 + d];
+        Kff[jj * n + ii] = Kff[ii * n + jj];
+      }
+    }
+  }
+  const ff = new Float64Array(n);
+  for (let ii = 0; ii < n; ii++) ff[ii] = system.forceVector[globalOf[ii]];
+  const L = Kff;
+  for (let i = 0; i < n; i++) {
+    for (let k = 0; k < i; k++) {
+      let sum2 = L[i * n + k];
+      for (let j = 0; j < k; j++) sum2 -= L[i * n + j] * L[k * n + j];
+      L[i * n + k] = sum2 / L[k * n + k];
+    }
+    let sum = L[i * n + i];
+    for (let j = 0; j < i; j++) sum -= L[i * n + j] * L[i * n + j];
+    if (sum <= 0) throw new Error(`Matrix not SPD near compact DOF ${i}`);
+    L[i * n + i] = Math.sqrt(sum);
+  }
+  const y = new Float64Array(n);
+  y[0] = ff[0] / L[0];
+  for (let i = 1; i < n; i++) {
+    let sum = ff[i];
+    for (let j = 0; j < i; j++) sum -= L[i * n + j] * y[j];
+    y[i] = sum / L[i * n + i];
+  }
+  const uf = new Float64Array(n);
+  uf[n - 1] = y[n - 1] / L[(n - 1) * n + (n - 1)];
+  for (let i = n - 2; i >= 0; i--) {
+    let sum = y[i];
+    for (let j = i + 1; j < n; j++) sum -= L[j * n + i] * uf[j];
+    uf[i] = sum / L[i * n + i];
+  }
+  for (let ii = 0; ii < n; ii++) u[globalOf[ii]] = uf[ii];
+  const nNodes = system.nodePositions.length;
+  const reactionVertical = new Float64Array(nNodes);
+  const reactionMoment = new Float64Array(nNodes);
+  for (let ri = 0; ri < restrainedDofs.length; ri++) {
+    const dof = restrainedDofs[ri];
+    let Ku = 0;
+    for (let d = 0; d <= HALF_BANDWIDTH; d++) {
+      const j = dof + d;
+      if (j >= nDof) break;
+      Ku += system.bandedK[dof * BP1 + d] * u[j];
+    }
+    for (let d = 1; d <= HALF_BANDWIDTH; d++) {
+      const j = dof - d;
+      if (j < 0) break;
+      Ku += system.bandedK[j * BP1 + d] * u[j];
+    }
+    const reaction = Ku - system.forceVector[dof];
+    const nodeIdx = dof >> 1;
+    if ((dof & 1) === 0) reactionVertical[nodeIdx] = reaction;
+    else reactionMoment[nodeIdx] = reaction;
+  }
+  return { displacements: u, reactions: { vertical: reactionVertical, moment: reactionMoment } };
+}
+function createSolverBuffers(nDof) {
+  return {
+    nDof,
+    compactOf: new Int32Array(nDof),
+    Kff: new Float64Array(nDof * BP1),
+    Lband: new Float64Array(nDof * BP1),
+    ff: new Float64Array(nDof),
+    y: new Float64Array(nDof),
+    uf: new Float64Array(nDof),
+    u: new Float64Array(nDof)
+  };
+}
+function solveLinearSystemBuffered(system, bc, buffers) {
+  const nDof = system.forceVector.length;
+  if (buffers.nDof !== nDof) throw new Error("Buffer size mismatch");
+  const { freeDofs, restrainedDofs } = bc;
+  const n = freeDofs.length;
+  if (n === 0) throw new Error("All DOFs restrained; nothing to solve.");
+  const globalOf = freeDofs;
+  const compactOf = buffers.compactOf;
+  compactOf.fill(-1);
+  for (let ii = 0; ii < n; ii++) compactOf[globalOf[ii]] = ii;
+  const Kff = new Float64Array(n * n);
+  for (let ii = 0; ii < n; ii++) {
+    const gi = globalOf[ii];
+    for (let jj = ii; jj < n; jj++) {
+      const gj = globalOf[jj];
+      const d = gj - gi;
+      if (d <= HALF_BANDWIDTH) {
+        Kff[ii * n + jj] = system.bandedK[gi * BP1 + d];
+        Kff[jj * n + ii] = Kff[ii * n + jj];
+      }
+    }
+  }
+  const ff = buffers.ff;
+  for (let ii = 0; ii < n; ii++) ff[ii] = system.forceVector[globalOf[ii]];
+  const L = Kff;
+  for (let i = 0; i < n; i++) {
+    for (let k = 0; k < i; k++) {
+      let sum2 = L[i * n + k];
+      for (let j = 0; j < k; j++) sum2 -= L[i * n + j] * L[k * n + j];
+      L[i * n + k] = sum2 / L[k * n + k];
+    }
+    let sum = L[i * n + i];
+    for (let j = 0; j < i; j++) sum -= L[i * n + j] * L[i * n + j];
+    if (sum <= 0) throw new Error(`Matrix not SPD near compact DOF ${i}`);
+    L[i * n + i] = Math.sqrt(sum);
+  }
+  const y = buffers.y;
+  y[0] = ff[0] / L[0];
+  for (let i = 1; i < n; i++) {
+    let sum = ff[i];
+    for (let j = 0; j < i; j++) sum -= L[i * n + j] * y[j];
+    y[i] = sum / L[i * n + i];
+  }
+  const uf = buffers.uf;
+  uf[n - 1] = y[n - 1] / L[(n - 1) * n + (n - 1)];
+  for (let i = n - 2; i >= 0; i--) {
+    let sum = y[i];
+    for (let j = i + 1; j < n; j++) sum -= L[j * n + i] * uf[j];
+    uf[i] = sum / L[i * n + i];
+  }
+  const u = buffers.u;
+  u.fill(0);
+  for (let ii = 0; ii < n; ii++) u[globalOf[ii]] = uf[ii];
+  const nNodes = system.nodePositions.length;
+  const reactionVertical = new Float64Array(nNodes);
+  const reactionMoment = new Float64Array(nNodes);
+  for (let ri = 0; ri < restrainedDofs.length; ri++) {
+    const dof = restrainedDofs[ri];
+    let Ku = 0;
+    for (let d = 0; d <= HALF_BANDWIDTH; d++) {
+      const j = dof + d;
+      if (j >= nDof) break;
+      Ku += system.bandedK[dof * BP1 + d] * u[j];
+    }
+    for (let d = 1; d <= HALF_BANDWIDTH; d++) {
+      const j = dof - d;
+      if (j < 0) break;
+      Ku += system.bandedK[j * BP1 + d] * u[j];
+    }
+    const reaction = Ku - system.forceVector[dof];
+    const nodeIdx = dof >> 1;
+    if ((dof & 1) === 0) reactionVertical[nodeIdx] = reaction;
+    else reactionMoment[nodeIdx] = reaction;
+  }
+  return { displacements: u.slice(), reactions: { vertical: reactionVertical, moment: reactionMoment } };
+}
+
+// src/postprocess.ts
+function computeNodalResponses(beam, mesh, displacements, reactions) {
+  const nodes = mesh.nodes;
+  const nNodes = nodes.length;
+  const nElems = nNodes - 1;
+  const w = new Float64Array(nNodes);
+  const theta = new Float64Array(nNodes);
+  for (let i = 0; i < nNodes; i++) {
+    w[i] = displacements[2 * i];
+    theta[i] = displacements[2 * i + 1];
+  }
+  const EI = beam.modulusOfElasticity * beam.momentOfInertia;
+  const momentSum = new Float64Array(nNodes);
+  const momentCount = new Uint16Array(nNodes);
+  for (let e = 0; e < nElems; e++) {
+    const xa = nodes[e];
+    const xb = nodes[e + 1];
+    const le = xb - xa;
+    if (le <= TOLERANCE) continue;
+    const wA = w[e];
+    const thA = theta[e];
+    const wB = w[e + 1];
+    const thB = theta[e + 1];
+    const invL = 1 / le;
+    const invL2 = invL * invL;
+    const kappaLeft = -6 * invL2 * wA + -4 * invL * thA + 6 * invL2 * wB + -2 * invL * thB;
+    const mLeft = EI * kappaLeft;
+    const kappaRight = 6 * invL2 * wA + 2 * invL * thA + -6 * invL2 * wB + 4 * invL * thB;
+    const mRight = EI * kappaRight;
+    momentSum[e] += mLeft;
+    momentCount[e] += 1;
+    momentSum[e + 1] += mRight;
+    momentCount[e + 1] += 1;
+  }
+  const moments = new Float64Array(nNodes);
+  for (let i = 0; i < nNodes; i++) {
+    moments[i] = momentCount[i] > 0 ? momentSum[i] / momentCount[i] : 0;
+  }
+  const concAtNode = new Float64Array(nNodes);
+  for (let i = 0; i < nNodes; i++) concAtNode[i] = reactions.vertical[i];
+  for (const pl of beam.pointLoads) {
+    const idx = mesh.findNodeIndex(pl.position, TOLERANCE);
+    if (idx >= 0) concAtNode[idx] += pl.magnitude;
+  }
+  const qAtNodes = new Float64Array(nNodes);
+  for (let i = 0; i < nNodes; i++) {
+    const x = nodes[i];
+    let sum = 0;
+    for (const dl of beam.distributedLoads) sum += distributedIntensityAt(x, dl);
+    qAtNodes[i] = sum;
+  }
+  const distPrefix = new Float64Array(nNodes);
+  distPrefix[0] = 0;
+  for (let e = 0; e < nElems; e++) {
+    const le = nodes[e + 1] - nodes[e];
+    distPrefix[e + 1] = distPrefix[e] + (qAtNodes[e] + qAtNodes[e + 1]) * 0.5 * le;
+  }
+  const prefixConc = new Float64Array(nNodes + 1);
+  prefixConc[0] = 0;
+  for (let i = 0; i < nNodes; i++) prefixConc[i + 1] = prefixConc[i] + concAtNode[i];
+  const shears = new Float64Array(nNodes);
+  for (let i = 0; i < nNodes; i++) shears[i] = prefixConc[i + 1] + distPrefix[i];
+  return {
+    nodePositions: nodes,
+    deflections: w,
+    rotations: theta,
+    moments,
+    shears,
+    reactions: { vertical: reactions.vertical, moment: reactions.moment }
+  };
+}
+
+// src/diagrams.ts
+function makeSeries(len) {
+  return { x: new Float64Array(len), y: new Float64Array(len) };
+}
+function pointLoadsAtNodes(beam, mesh, eps) {
+  const nNodes = mesh.nodes.length;
+  const out = new Float64Array(nNodes);
+  for (const pl of beam.pointLoads) {
+    const idx = mesh.findNodeIndex(pl.position, eps);
+    if (idx >= 0) out[idx] += pl.magnitude;
+  }
+  return out;
+}
+function sampleDiagrams(beam, mesh, results, options = {}) {
+  const nodes = results.nodePositions;
+  const nNodes = nodes.length;
+  const nElems = nNodes - 1;
+  const pointsPerElement = options.pointsPerElement ?? DEFAULT_DIAGRAM_POINTS_PER_ELEMENT;
+  const eps = options.eps ?? TOLERANCE;
+  const includeOutsideEnds = options.includeOutsideEnds ?? true;
+  if (nElems <= 0) {
+    const len = includeOutsideEnds ? 2 : 1;
+    const deflection2 = makeSeries(len);
+    const moment2 = makeSeries(len);
+    const shear2 = makeSeries(len);
+    deflection2.x[0] = nodes[0];
+    deflection2.y[0] = results.deflections[0];
+    if (includeOutsideEnds) {
+      deflection2.x[1] = nodes[0];
+      deflection2.y[1] = results.deflections[0];
+      moment2.x[1] = nodes[0];
+      shear2.x[1] = nodes[0];
+    }
+    moment2.x[0] = nodes[0];
+    shear2.x[0] = nodes[0];
+    return { deflection: deflection2, moment: moment2, shear: shear2 };
+  }
+  const EI = beam.modulusOfElasticity * beam.momentOfInertia;
+  const pointAtNode = pointLoadsAtNodes(beam, mesh, eps);
+  const concAtNode = new Float64Array(nNodes);
+  for (let i = 0; i < nNodes; i++) {
+    concAtNode[i] = results.reactions.vertical[i] + pointAtNode[i];
+  }
+  const prefixConc = new Float64Array(nNodes + 1);
+  prefixConc[0] = 0;
+  for (let i = 0; i < nNodes; i++) prefixConc[i + 1] = prefixConc[i] + concAtNode[i];
+  const qAtNodes = new Float64Array(nNodes);
+  for (let i = 0; i < nNodes; i++) {
+    const x = nodes[i];
+    let sum = 0;
+    for (const dl of beam.distributedLoads) sum += distributedIntensityAt(x, dl);
+    qAtNodes[i] = sum;
+  }
+  const distPrefix = new Float64Array(nNodes);
+  distPrefix[0] = 0;
+  for (let e = 0; e < nElems; e++) {
+    const le = nodes[e + 1] - nodes[e];
+    distPrefix[e + 1] = distPrefix[e] + (qAtNodes[e] + qAtNodes[e + 1]) * 0.5 * le;
+  }
+  const internalLen = nElems * (pointsPerElement + 1);
+  const totalLen = internalLen + (includeOutsideEnds ? 2 : 0);
+  const deflection = makeSeries(totalLen);
+  const moment = makeSeries(totalLen);
+  const shear = makeSeries(totalLen);
+  let idx = 0;
+  if (includeOutsideEnds) {
+    deflection.x[idx] = nodes[0];
+    deflection.y[idx] = results.deflections[0];
+    moment.x[idx] = nodes[0];
+    moment.y[idx] = 0;
+    shear.x[idx] = nodes[0];
+    shear.y[idx] = 0;
+    idx++;
+  }
+  const N = new Float64Array(4);
+  const d2N = new Float64Array(4);
+  for (let e = 0; e < nElems; e++) {
+    const xa = nodes[e];
+    const xb = nodes[e + 1];
+    const le = xb - xa;
+    if (le <= eps) continue;
+    const wA = results.deflections[e];
+    const thA = results.rotations[e];
+    const wB = results.deflections[e + 1];
+    const thB = results.rotations[e + 1];
+    const qA = qAtNodes[e];
+    const qB = qAtNodes[e + 1];
+    const VStart = prefixConc[e + 1] + distPrefix[e];
+    for (let j = 0; j <= pointsPerElement; j++) {
+      const s = j / pointsPerElement;
+      const x = xa + s * le;
+      hermiteShapeInto(s, le, N);
+      const w = N[0] * wA + N[1] * thA + N[2] * wB + N[3] * thB;
+      hermiteD2Into(s, le, d2N);
+      const kappa = d2N[0] * wA + d2N[1] * thA + d2N[2] * wB + d2N[3] * thB;
+      const M = EI * kappa;
+      const s2 = s * s;
+      const Vdist = le * (qA * s + (qB - qA) * 0.5 * s2);
+      const V = VStart + Vdist;
+      deflection.x[idx] = x;
+      deflection.y[idx] = w;
+      moment.x[idx] = x;
+      moment.y[idx] = M;
+      shear.x[idx] = x;
+      shear.y[idx] = V;
+      idx++;
+    }
+  }
+  if (includeOutsideEnds) {
+    const last = nNodes - 1;
+    deflection.x[idx] = nodes[last];
+    deflection.y[idx] = results.deflections[last];
+    moment.x[idx] = nodes[last];
+    moment.y[idx] = 0;
+    shear.x[idx] = nodes[last];
+    shear.y[idx] = 0;
+    idx++;
+  }
+  return { deflection, moment, shear };
+}
+
+// src/index.ts
+function analyzeBeam(beam, meshOptions) {
+  const mesh = generateMesh(beam, meshOptions);
+  const system = assembleSystem(beam, mesh);
+  const bc = getBoundaryConditions(beam, mesh);
+  const solved = solveLinearSystem(system, bc);
+  return computeNodalResponses(beam, mesh, solved.displacements, solved.reactions);
+}
+function analyzeBeamChartReady(beam, meshOptions, diagramOptions) {
+  const mesh = generateMesh(beam, meshOptions);
+  const system = assembleSystem(beam, mesh);
+  const bc = getBoundaryConditions(beam, mesh);
+  const solved = solveLinearSystem(system, bc);
+  const results = computeNodalResponses(beam, mesh, solved.displacements, solved.reactions);
+  const diagrams = sampleDiagrams(beam, mesh, results, diagramOptions);
+  return { results, diagrams };
+}
+export {
+  analyzeBeam,
+  analyzeBeamChartReady,
+  assembleSystem,
+  createSolverBuffers,
+  generateMesh,
+  getBoundaryConditions,
+  solveLinearSystemBuffered
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@jtgtools/xbeam",
+  "version": "0.0.1",
+  "description": "Fast Euler-Bernoulli beam FEM solver with chart-ready results",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "prepare": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "demo": "npm run build && npx serve . --listen 3000",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "bench": "vitest bench"
+  },
+  "dependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.2"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.2"
+  }
+}