@aethervtt/shard-core 0.0.1

package/dist/math/mat4.js

@@ -0,0 +1,224 @@
+const create = () => identity(new Float32Array(16));
+function identity(out) {
+  for (let i = 0; i < 16; i++) out[i] = i % 5 === 0 ? 1 : 0;
+  return out;
+}
+function copy(out, a) {
+  for (let i = 0; i < 16; i++) out[i] = a[i];
+  return out;
+}
+function multiply(out, a, b) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a03 = a[3];
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a13 = a[7];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const a23 = a[11];
+  const a30 = a[12];
+  const a31 = a[13];
+  const a32 = a[14];
+  const a33 = a[15];
+  for (let c = 0; c < 4; c++) {
+    const b0 = b[c * 4];
+    const b1 = b[c * 4 + 1];
+    const b2 = b[c * 4 + 2];
+    const b3 = b[c * 4 + 3];
+    out[c * 4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[c * 4 + 1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[c * 4 + 2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[c * 4 + 3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  }
+  return out;
+}
+function transpose(out, a) {
+  if (out === a) {
+    for (let r = 0; r < 4; r++) {
+      for (let c = r + 1; c < 4; c++) {
+        const tmp = out[c * 4 + r];
+        out[c * 4 + r] = out[r * 4 + c];
+        out[r * 4 + c] = tmp;
+      }
+    }
+    return out;
+  }
+  for (let r = 0; r < 4; r++) for (let c = 0; c < 4; c++) out[c * 4 + r] = a[r * 4 + c];
+  return out;
+}
+function invert(out, a) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a03 = a[3];
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a13 = a[7];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const a23 = a[11];
+  const a30 = a[12];
+  const a31 = a[13];
+  const a32 = a[14];
+  const a33 = a[15];
+  const b00 = a00 * a11 - a01 * a10;
+  const b01 = a00 * a12 - a02 * a10;
+  const b02 = a00 * a13 - a03 * a10;
+  const b03 = a01 * a12 - a02 * a11;
+  const b04 = a01 * a13 - a03 * a11;
+  const b05 = a02 * a13 - a03 * a12;
+  const b06 = a20 * a31 - a21 * a30;
+  const b07 = a20 * a32 - a22 * a30;
+  const b08 = a20 * a33 - a23 * a30;
+  const b09 = a21 * a32 - a22 * a31;
+  const b10 = a21 * a33 - a23 * a31;
+  const b11 = a22 * a33 - a23 * a32;
+  let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) return null;
+  det = 1 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+function fromTRS(out, t, q, s) {
+  const x = q[0];
+  const y = q[1];
+  const z = q[2];
+  const w = q[3];
+  const sx = s[0];
+  const sy = s[1];
+  const sz = s[2];
+  out[0] = (1 - 2 * (y * y + z * z)) * sx;
+  out[1] = 2 * (x * y + w * z) * sx;
+  out[2] = 2 * (x * z - w * y) * sx;
+  out[3] = 0;
+  out[4] = 2 * (x * y - w * z) * sy;
+  out[5] = (1 - 2 * (x * x + z * z)) * sy;
+  out[6] = 2 * (y * z + w * x) * sy;
+  out[7] = 0;
+  out[8] = 2 * (x * z + w * y) * sz;
+  out[9] = 2 * (y * z - w * x) * sz;
+  out[10] = (1 - 2 * (x * x + y * y)) * sz;
+  out[11] = 0;
+  out[12] = t[0];
+  out[13] = t[1];
+  out[14] = t[2];
+  out[15] = 1;
+  return out;
+}
+function getTranslation(out, m) {
+  out[0] = m[12];
+  out[1] = m[13];
+  out[2] = m[14];
+  return out;
+}
+function clear(out) {
+  for (let i = 0; i < 16; i++) out[i] = 0;
+}
+function perspective(out, fovY, aspect, near, far) {
+  const f = 1 / Math.tan(fovY / 2);
+  clear(out);
+  out[0] = f / aspect;
+  out[5] = f;
+  out[10] = far / (near - far);
+  out[11] = -1;
+  out[14] = far * near / (near - far);
+  return out;
+}
+function perspectiveReversedZ(out, fovY, aspect, near) {
+  const f = 1 / Math.tan(fovY / 2);
+  clear(out);
+  out[0] = f / aspect;
+  out[5] = f;
+  out[11] = -1;
+  out[14] = near;
+  return out;
+}
+function orthographic(out, left, right, bottom, top, near, far) {
+  clear(out);
+  out[0] = 2 / (right - left);
+  out[5] = 2 / (top - bottom);
+  out[10] = 1 / (near - far);
+  out[12] = (left + right) / (left - right);
+  out[13] = (top + bottom) / (bottom - top);
+  out[14] = near / (near - far);
+  out[15] = 1;
+  return out;
+}
+function orthographicReversedZ(out, left, right, bottom, top, near, far) {
+  orthographic(out, left, right, bottom, top, near, far);
+  out[10] = 1 / (far - near);
+  out[14] = far / (far - near);
+  return out;
+}
+function lookAt(out, eye, target, up) {
+  let zx = eye[0] - target[0];
+  let zy = eye[1] - target[1];
+  let zz = eye[2] - target[2];
+  let len = Math.sqrt(zx * zx + zy * zy + zz * zz) || 1;
+  zx /= len;
+  zy /= len;
+  zz /= len;
+  let xx = up[1] * zz - up[2] * zy;
+  let xy = up[2] * zx - up[0] * zz;
+  let xz = up[0] * zy - up[1] * zx;
+  len = Math.sqrt(xx * xx + xy * xy + xz * xz) || 1;
+  xx /= len;
+  xy /= len;
+  xz /= len;
+  const yx = zy * xz - zz * xy;
+  const yy = zz * xx - zx * xz;
+  const yz = zx * xy - zy * xx;
+  out[0] = xx;
+  out[1] = yx;
+  out[2] = zx;
+  out[3] = 0;
+  out[4] = xy;
+  out[5] = yy;
+  out[6] = zy;
+  out[7] = 0;
+  out[8] = xz;
+  out[9] = yz;
+  out[10] = zz;
+  out[11] = 0;
+  out[12] = -(xx * eye[0] + xy * eye[1] + xz * eye[2]);
+  out[13] = -(yx * eye[0] + yy * eye[1] + yz * eye[2]);
+  out[14] = -(zx * eye[0] + zy * eye[1] + zz * eye[2]);
+  out[15] = 1;
+  return out;
+}
+export {
+  copy,
+  create,
+  fromTRS,
+  getTranslation,
+  identity,
+  invert,
+  lookAt,
+  multiply,
+  orthographic,
+  orthographicReversedZ,
+  perspective,
+  perspectiveReversedZ,
+  transpose
+};

package/dist/math/quat.d.ts

@@ -0,0 +1,22 @@
+import type { Readable, Writable } from './types.js';
+/** Quaternions are [x, y, z, w]. */
+export declare const create: () => Float32Array;
+export declare function identity<T extends Writable>(out: T): T;
+export declare function set<T extends Writable>(out: T, x: number, y: number, z: number, w: number): T;
+export declare function copy<T extends Writable>(out: T, a: Readable): T;
+/** Rotation of `radians` around a unit `axis`. */
+export declare function fromAxisAngle<T extends Writable>(out: T, axis: Readable, radians: number): T;
+/** Euler angles in radians, applied X first, then Y, then Z (q = qz · qy · qx). */
+export declare function fromEuler<T extends Writable>(out: T, x: number, y: number, z: number): T;
+/** out = a · b (apply b, then a). */
+export declare function multiply<T extends Writable>(out: T, a: Readable, b: Readable): T;
+/** Inverse of a unit quaternion. */
+export declare function conjugate<T extends Writable>(out: T, a: Readable): T;
+export declare function normalize<T extends Writable>(out: T, a: Readable): T;
+export declare const dot: (a: Readable, b: Readable) => number;
+/** Spherical interpolation along the shortest arc. */
+export declare function slerp<T extends Writable>(out: T, a: Readable, b: Readable, t: number): T;
+/** Rotation from the columns of an orthonormal basis (x, y, z axes). */
+export declare function fromBasis<T extends Writable>(out: T, x: Readable, y: Readable, z: Readable): T;
+/** Rotation that points -Z along `forward`, keeping +Y as close to `up` as possible. */
+export declare function lookRotation<T extends Writable>(out: T, forward: Readable, up: Readable): T;

package/dist/math/quat.js

@@ -0,0 +1,233 @@
+const create = () => new Float32Array([0, 0, 0, 1]);
+function identity(out) {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 1;
+  return out;
+}
+function set(out, x, y, z, w) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+}
+function copy(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  return out;
+}
+function fromAxisAngle(out, axis, radians) {
+  const s = Math.sin(radians / 2);
+  out[0] = axis[0] * s;
+  out[1] = axis[1] * s;
+  out[2] = axis[2] * s;
+  out[3] = Math.cos(radians / 2);
+  return out;
+}
+function fromEuler(out, x, y, z) {
+  const sx = Math.sin(x / 2);
+  const cx = Math.cos(x / 2);
+  const sy = Math.sin(y / 2);
+  const cy = Math.cos(y / 2);
+  const sz = Math.sin(z / 2);
+  const cz = Math.cos(z / 2);
+  const bx = cy * sx;
+  const by = sy * cx;
+  const bz = -sy * sx;
+  const bw = cy * cx;
+  out[0] = cz * bx - sz * by;
+  out[1] = cz * by + sz * bx;
+  out[2] = sz * bw + cz * bz;
+  out[3] = cz * bw - sz * bz;
+  return out;
+}
+function multiply(out, a, b) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const bx = b[0];
+  const by = b[1];
+  const bz = b[2];
+  const bw = b[3];
+  out[0] = ax * bw + aw * bx + ay * bz - az * by;
+  out[1] = ay * bw + aw * by + az * bx - ax * bz;
+  out[2] = az * bw + aw * bz + ax * by - ay * bx;
+  out[3] = aw * bw - ax * bx - ay * by - az * bz;
+  return out;
+}
+function conjugate(out, a) {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  out[3] = a[3];
+  return out;
+}
+function normalize(out, a) {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  const w = a[3];
+  const len = Math.sqrt(x * x + y * y + z * z + w * w);
+  const inv = len > 0 ? 1 / len : 0;
+  out[0] = x * inv;
+  out[1] = y * inv;
+  out[2] = z * inv;
+  out[3] = w * inv;
+  return out;
+}
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+function slerp(out, a, b, t) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  let bx = b[0];
+  let by = b[1];
+  let bz = b[2];
+  let bw = b[3];
+  let cos = ax * bx + ay * by + az * bz + aw * bw;
+  if (cos < 0) {
+    cos = -cos;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+  let s0;
+  let s1;
+  if (1 - cos > 1e-6) {
+    const omega = Math.acos(cos);
+    const sin = Math.sin(omega);
+    s0 = Math.sin((1 - t) * omega) / sin;
+    s1 = Math.sin(t * omega) / sin;
+  } else {
+    s0 = 1 - t;
+    s1 = t;
+  }
+  out[0] = s0 * ax + s1 * bx;
+  out[1] = s0 * ay + s1 * by;
+  out[2] = s0 * az + s1 * bz;
+  out[3] = s0 * aw + s1 * bw;
+  return out;
+}
+function fromBasis(out, x, y, z) {
+  const m00 = x[0];
+  const m10 = x[1];
+  const m20 = x[2];
+  const m01 = y[0];
+  const m11 = y[1];
+  const m21 = y[2];
+  const m02 = z[0];
+  const m12 = z[1];
+  const m22 = z[2];
+  const trace = m00 + m11 + m22;
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1);
+    out[3] = 0.25 / s;
+    out[0] = (m21 - m12) * s;
+    out[1] = (m02 - m20) * s;
+    out[2] = (m10 - m01) * s;
+  } else if (m00 > m11 && m00 > m22) {
+    const s = 2 * Math.sqrt(1 + m00 - m11 - m22);
+    out[3] = (m21 - m12) / s;
+    out[0] = 0.25 * s;
+    out[1] = (m01 + m10) / s;
+    out[2] = (m02 + m20) / s;
+  } else if (m11 > m22) {
+    const s = 2 * Math.sqrt(1 + m11 - m00 - m22);
+    out[3] = (m02 - m20) / s;
+    out[0] = (m01 + m10) / s;
+    out[1] = 0.25 * s;
+    out[2] = (m12 + m21) / s;
+  } else {
+    const s = 2 * Math.sqrt(1 + m22 - m00 - m11);
+    out[3] = (m10 - m01) / s;
+    out[0] = (m02 + m20) / s;
+    out[1] = (m12 + m21) / s;
+    out[2] = 0.25 * s;
+  }
+  return out;
+}
+function lookRotation(out, forward, up) {
+  let zx = -forward[0];
+  let zy = -forward[1];
+  let zz = -forward[2];
+  let len = Math.sqrt(zx * zx + zy * zy + zz * zz) || 1;
+  zx /= len;
+  zy /= len;
+  zz /= len;
+  let xx = up[1] * zz - up[2] * zy;
+  let xy = up[2] * zx - up[0] * zz;
+  let xz = up[0] * zy - up[1] * zx;
+  len = Math.sqrt(xx * xx + xy * xy + xz * xz);
+  if (len < 1e-6) {
+    const hx = Math.abs(zy) < 0.99 ? 0 : 1;
+    const hy = Math.abs(zy) < 0.99 ? 1 : 0;
+    xx = hy * zz;
+    xy = -hx * zz;
+    xz = hx * zy - hy * zx;
+    len = Math.sqrt(xx * xx + xy * xy + xz * xz);
+  }
+  xx /= len;
+  xy /= len;
+  xz /= len;
+  const yx = zy * xz - zz * xy;
+  const yy = zz * xx - zx * xz;
+  const yz = zx * xy - zy * xx;
+  const m00 = xx;
+  const m10 = xy;
+  const m20 = xz;
+  const m01 = yx;
+  const m11 = yy;
+  const m21 = yz;
+  const m02 = zx;
+  const m12 = zy;
+  const m22 = zz;
+  const trace = m00 + m11 + m22;
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1);
+    out[3] = 0.25 / s;
+    out[0] = (m21 - m12) * s;
+    out[1] = (m02 - m20) * s;
+    out[2] = (m10 - m01) * s;
+  } else if (m00 > m11 && m00 > m22) {
+    const s = 2 * Math.sqrt(1 + m00 - m11 - m22);
+    out[3] = (m21 - m12) / s;
+    out[0] = 0.25 * s;
+    out[1] = (m01 + m10) / s;
+    out[2] = (m02 + m20) / s;
+  } else if (m11 > m22) {
+    const s = 2 * Math.sqrt(1 + m11 - m00 - m22);
+    out[3] = (m02 - m20) / s;
+    out[0] = (m01 + m10) / s;
+    out[1] = 0.25 * s;
+    out[2] = (m12 + m21) / s;
+  } else {
+    const s = 2 * Math.sqrt(1 + m22 - m00 - m11);
+    out[3] = (m10 - m01) / s;
+    out[0] = (m02 + m20) / s;
+    out[1] = (m12 + m21) / s;
+    out[2] = 0.25 * s;
+  }
+  return out;
+}
+export {
+  conjugate,
+  copy,
+  create,
+  dot,
+  fromAxisAngle,
+  fromBasis,
+  fromEuler,
+  identity,
+  lookRotation,
+  multiply,
+  normalize,
+  set,
+  slerp
+};

package/dist/math/ray.d.ts

@@ -0,0 +1,10 @@
+import type { Readable, Writable } from './types.js';
+/** Ray as 6 floats: `[originX, originY, originZ, dirX, dirY, dirZ]` (direction normalized). */
+export declare const create: () => Float32Array;
+/**
+ * Ray through a pixel. `x`, `y` in pixels from the top-left; `inverseViewProjection` is the inverse
+ * of projection · view. `reversedZ` must match the projection (the engine default is true).
+ */
+export declare function fromScreen<T extends Writable>(out: T, x: number, y: number, width: number, height: number, inverseViewProjection: Readable, reversedZ?: boolean): T;
+/** Distance along the ray to the box, or -1 on a miss. 0 if the origin is inside. */
+export declare function intersectAabb(ray: Readable, box: Readable): number;

package/dist/math/ray.js

@@ -0,0 +1,54 @@
+const create = () => new Float32Array([0, 0, 0, 0, 0, -1]);
+function fromScreen(out, x, y, width, height, inverseViewProjection, reversedZ = true) {
+  const nx = x / width * 2 - 1;
+  const ny = 1 - y / height * 2;
+  const m = inverseViewProjection;
+  const nearZ = reversedZ ? 0.75 : 0.25;
+  const farZ = reversedZ ? 0.25 : 0.75;
+  const wn = m[3] * nx + m[7] * ny + m[11] * nearZ + m[15];
+  const ox = (m[0] * nx + m[4] * ny + m[8] * nearZ + m[12]) / wn;
+  const oy = (m[1] * nx + m[5] * ny + m[9] * nearZ + m[13]) / wn;
+  const oz = (m[2] * nx + m[6] * ny + m[10] * nearZ + m[14]) / wn;
+  const wf = m[3] * nx + m[7] * ny + m[11] * farZ + m[15];
+  const dx = (m[0] * nx + m[4] * ny + m[8] * farZ + m[12]) / wf - ox;
+  const dy = (m[1] * nx + m[5] * ny + m[9] * farZ + m[13]) / wf - oy;
+  const dz = (m[2] * nx + m[6] * ny + m[10] * farZ + m[14]) / wf - oz;
+  const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+  out[0] = ox;
+  out[1] = oy;
+  out[2] = oz;
+  out[3] = dx / len;
+  out[4] = dy / len;
+  out[5] = dz / len;
+  return out;
+}
+function intersectAabb(ray, box) {
+  let tMin = 0;
+  let tMax = Infinity;
+  for (let i = 0; i < 3; i++) {
+    const o = ray[i];
+    const d = ray[i + 3];
+    const lo = box[i];
+    const hi = box[i + 3];
+    if (Math.abs(d) < 1e-12) {
+      if (o < lo || o > hi) return -1;
+      continue;
+    }
+    let t0 = (lo - o) / d;
+    let t1 = (hi - o) / d;
+    if (t0 > t1) {
+      const tmp = t0;
+      t0 = t1;
+      t1 = tmp;
+    }
+    if (t0 > tMin) tMin = t0;
+    if (t1 < tMax) tMax = t1;
+    if (tMin > tMax) return -1;
+  }
+  return tMin;
+}
+export {
+  create,
+  fromScreen,
+  intersectAabb
+};

package/dist/math/rng.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Seeded random numbers (xoshiro128**: 32-bit operations only, fast in JS, good statistical
+ * quality). Same seed, same sequence, on every platform.
+ */
+export declare class Rng {
+    readonly seed: number;
+    private a;
+    private b;
+    private c;
+    private d;
+    private named;
+    constructor(seed?: number);
+    /** Uniform 32-bit unsigned integer. */
+    nextU32(): number;
+    /** Uniform in [0, 1). */
+    float(): number;
+    /** Uniform in [min, max). */
+    range(min: number, max: number): number;
+    /** Uniform integer in [min, max] (inclusive). */
+    int(min: number, max: number): number;
+    bool(probability?: number): boolean;
+    pick<T>(items: readonly T[]): T;
+    /** Standard normal sample (Box-Muller). */
+    gaussian(mean?: number, stdDev?: number): number;
+    /**
+     * An independent stream derived from this generator's seed and a label. It doesn't depend on how
+     * many numbers this generator has produced, so adding draws elsewhere never changes a fork.
+     */
+    fork(label: string): Rng;
+    /**
+     * A named fork this generator keeps: the same object on every call with the label. Saves record
+     * each stream's state (0038), so draws after a load match draws without one.
+     */
+    stream(label: string): Rng;
+    /** The streams made with `stream`, by label. */
+    streams(): ReadonlyMap<string, Rng>;
+    /** The four state words: where the sequence is now. */
+    getState(): [number, number, number, number];
+    /** Continues from a state `getState` returned. */
+    setState(state: readonly number[]): void;
+}

package/dist/math/rng.js

@@ -0,0 +1,102 @@
+import { hashSeed } from "./hash.js";
+function splitmix32(state) {
+  state.s = state.s + 2654435769 | 0;
+  let z = state.s;
+  z = Math.imul(z ^ z >>> 16, 2246822507);
+  z = Math.imul(z ^ z >>> 13, 3266489909);
+  return (z ^ z >>> 16) >>> 0;
+}
+class Rng {
+  seed;
+  a;
+  b;
+  c;
+  d;
+  named;
+  constructor(seed = 0) {
+    this.seed = seed >>> 0;
+    const state = { s: this.seed };
+    this.a = splitmix32(state);
+    this.b = splitmix32(state);
+    this.c = splitmix32(state);
+    this.d = splitmix32(state);
+  }
+  /** Uniform 32-bit unsigned integer. */
+  nextU32() {
+    const result = Math.imul(rotl(Math.imul(this.b, 5), 7), 9) >>> 0;
+    const t = this.b << 9;
+    this.c ^= this.a;
+    this.d ^= this.b;
+    this.b ^= this.c;
+    this.a ^= this.d;
+    this.c ^= t;
+    this.d = rotl(this.d, 11);
+    return result;
+  }
+  /** Uniform in [0, 1). */
+  float() {
+    return this.nextU32() / 4294967296;
+  }
+  /** Uniform in [min, max). */
+  range(min, max) {
+    return min + (max - min) * this.float();
+  }
+  /** Uniform integer in [min, max] (inclusive). */
+  int(min, max) {
+    return min + Math.floor(this.float() * (max - min + 1));
+  }
+  bool(probability = 0.5) {
+    return this.float() < probability;
+  }
+  pick(items) {
+    return items[Math.floor(this.float() * items.length)];
+  }
+  /** Standard normal sample (Box-Muller). */
+  gaussian(mean = 0, stdDev = 1) {
+    const u = 1 - this.float();
+    const v = this.float();
+    return mean + stdDev * Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  }
+  /**
+   * An independent stream derived from this generator's seed and a label. It doesn't depend on how
+   * many numbers this generator has produced, so adding draws elsewhere never changes a fork.
+   */
+  fork(label) {
+    return new Rng(hashSeed(this.seed, label));
+  }
+  /**
+   * A named fork this generator keeps: the same object on every call with the label. Saves record
+   * each stream's state (0038), so draws after a load match draws without one.
+   */
+  stream(label) {
+    this.named ??= /* @__PURE__ */ new Map();
+    let rng = this.named.get(label);
+    if (!rng) {
+      rng = this.fork(label);
+      this.named.set(label, rng);
+    }
+    return rng;
+  }
+  /** The streams made with `stream`, by label. */
+  streams() {
+    return this.named ?? EMPTY;
+  }
+  /** The four state words: where the sequence is now. */
+  getState() {
+    return [this.a >>> 0, this.b >>> 0, this.c >>> 0, this.d >>> 0];
+  }
+  /** Continues from a state `getState` returned. */
+  setState(state) {
+    this.a = state[0] | 0;
+    this.b = state[1] | 0;
+    this.c = state[2] | 0;
+    this.d = state[3] | 0;
+  }
+}
+const EMPTY = /* @__PURE__ */ new Map();
+function rotl(x, k) {
+  return x << k | x >>> 32 - k;
+}
+export {
+  Rng
+};

package/dist/math/types.d.ts

@@ -0,0 +1,8 @@
+/** Anything readable by index: tuples, TypedArrays, column views. */
+export type Readable = ArrayLike<number>;
+/** Anything writable by index. Math functions write results into one of these. */
+export interface Writable {
+    readonly length: number;
+    [index: number]: number;
+}
+export declare const EPSILON = 0.000001;

package/dist/math/types.js

@@ -0,0 +1,4 @@
+const EPSILON = 1e-6;
+export {
+  EPSILON
+};