@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-KIZOA5LX.mjs

@@ -0,0 +1,140 @@
+// src/game/math/mat4.ts
+function mat4Identity(out, o) {
+  out[o] = 1, out[o + 1] = 0, out[o + 2] = 0, out[o + 3] = 0, out[o + 4] = 0, out[o + 5] = 1, out[o + 6] = 0, out[o + 7] = 0, out[o + 8] = 0, out[o + 9] = 0, out[o + 10] = 1, out[o + 11] = 0, out[o + 12] = 0, out[o + 13] = 0, out[o + 14] = 0, out[o + 15] = 1;
+}
+function mat4Compose(out, o, px, py, pz, qx, qy, qz, qw, sx, sy, sz) {
+  let x2 = qx + qx, y2 = qy + qy, z2 = qz + qz, xx = qx * x2, xy = qx * y2, xz = qx * z2, yy = qy * y2, yz = qy * z2, zz = qz * z2, wx = qw * x2, wy = qw * y2, wz = qw * z2;
+  out[o] = (1 - (yy + zz)) * sx, out[o + 1] = (xy + wz) * sx, out[o + 2] = (xz - wy) * sx, out[o + 3] = 0, out[o + 4] = (xy - wz) * sy, out[o + 5] = (1 - (xx + zz)) * sy, out[o + 6] = (yz + wx) * sy, out[o + 7] = 0, out[o + 8] = (xz + wy) * sz, out[o + 9] = (yz - wx) * sz, out[o + 10] = (1 - (xx + yy)) * sz, out[o + 11] = 0, out[o + 12] = px, out[o + 13] = py, out[o + 14] = pz, out[o + 15] = 1;
+}
+function mat4Multiply(out, o, a, ao, b, bo) {
+  let a00 = a[ao], a01 = a[ao + 1], a02 = a[ao + 2], a03 = a[ao + 3], a10 = a[ao + 4], a11 = a[ao + 5], a12 = a[ao + 6], a13 = a[ao + 7], a20 = a[ao + 8], a21 = a[ao + 9], a22 = a[ao + 10], a23 = a[ao + 11], a30 = a[ao + 12], a31 = a[ao + 13], a32 = a[ao + 14], a33 = a[ao + 15];
+  for (let col = 0; col < 4; col++) {
+    let c = bo + col * 4, b0 = b[c], b1 = b[c + 1], b2 = b[c + 2], b3 = b[c + 3], r = o + col * 4;
+    out[r] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30, out[r + 1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31, out[r + 2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32, out[r + 3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  }
+}
+function mat4TransformPoint(m, o, v) {
+  let x = v.x, y = v.y, z = v.z, w = m[o + 3] * x + m[o + 7] * y + m[o + 11] * z + m[o + 15], inv = Math.abs(w) > 1e-6 ? 1 / w : 1;
+  return v.set(
+    (m[o] * x + m[o + 4] * y + m[o + 8] * z + m[o + 12]) * inv,
+    (m[o + 1] * x + m[o + 5] * y + m[o + 9] * z + m[o + 13]) * inv,
+    (m[o + 2] * x + m[o + 6] * y + m[o + 10] * z + m[o + 14]) * inv
+  );
+}
+function mat4Translation(m, o, out) {
+  return out.set(m[o + 12], m[o + 13], m[o + 14]);
+}
+function mat4ComposeArrays(out, o, position, po, rotation, ro, scale, so) {
+  let qx = rotation[ro], qy = rotation[ro + 1], qz = rotation[ro + 2], qw = rotation[ro + 3], sx = scale[so], sy = scale[so + 1], sz = scale[so + 2], x2 = qx + qx, y2 = qy + qy, z2 = qz + qz, xx = qx * x2, xy = qx * y2, xz = qx * z2, yy = qy * y2, yz = qy * z2, zz = qz * z2, wx = qw * x2, wy = qw * y2, wz = qw * z2;
+  out[o] = (1 - (yy + zz)) * sx, out[o + 1] = (xy + wz) * sx, out[o + 2] = (xz - wy) * sx, out[o + 3] = 0, out[o + 4] = (xy - wz) * sy, out[o + 5] = (1 - (xx + zz)) * sy, out[o + 6] = (yz + wx) * sy, out[o + 7] = 0, out[o + 8] = (xz + wy) * sz, out[o + 9] = (yz - wx) * sz, out[o + 10] = (1 - (xx + yy)) * sz, out[o + 11] = 0, out[o + 12] = position[po], out[o + 13] = position[po + 1], out[o + 14] = position[po + 2], out[o + 15] = 1;
+}
+function quatSlerpArrays(out, o, a, ao, b, bo, weights, wi) {
+  let t = weights[wi], ax = a[ao], ay = a[ao + 1], az = a[ao + 2], aw = a[ao + 3], bx = b[bo], by = b[bo + 1], bz = b[bo + 2], bw = b[bo + 3], cos = ax * bx + ay * by + az * bz + aw * bw;
+  cos < 0 && (cos = -cos, bx = -bx, by = -by, bz = -bz, bw = -bw);
+  let wa, wb;
+  if (cos > 0.9995)
+    wa = 1 - t, wb = t;
+  else {
+    let angle = Math.acos(cos), sin = Math.sin(angle);
+    wa = Math.sin((1 - t) * angle) / sin, wb = Math.sin(t * angle) / sin;
+  }
+  let x = ax * wa + bx * wb, y = ay * wa + by * wb, z = az * wa + bz * wb, w = aw * wa + bw * wb, len = Math.sqrt(x * x + y * y + z * z + w * w);
+  if (len > 1e-6) {
+    let inv = 1 / len;
+    x *= inv, y *= inv, z *= inv, w *= inv;
+  }
+  out[o] = x, out[o + 1] = y, out[o + 2] = z, out[o + 3] = w;
+}
+function mat4Copy(out, o, m, mo) {
+  for (let i = 0; i < 16; i++) out[o + i] = m[mo + i];
+}
+function mat4Transpose(out, o, m, mo) {
+  let m01 = m[mo + 1], m02 = m[mo + 2], m03 = m[mo + 3], m12 = m[mo + 6], m13 = m[mo + 7], m23 = m[mo + 11];
+  out[o] = m[mo], out[o + 1] = m[mo + 4], out[o + 2] = m[mo + 8], out[o + 3] = m[mo + 12], out[o + 4] = m01, out[o + 5] = m[mo + 5], out[o + 6] = m[mo + 9], out[o + 7] = m[mo + 13], out[o + 8] = m02, out[o + 9] = m12, out[o + 10] = m[mo + 10], out[o + 11] = m[mo + 14], out[o + 12] = m03, out[o + 13] = m13, out[o + 14] = m23, out[o + 15] = m[mo + 15];
+}
+function mat4Determinant(m, mo) {
+  let n11 = m[mo], n21 = m[mo + 1], n31 = m[mo + 2], n41 = m[mo + 3], n12 = m[mo + 4], n22 = m[mo + 5], n32 = m[mo + 6], n42 = m[mo + 7], n13 = m[mo + 8], n23 = m[mo + 9], n33 = m[mo + 10], n43 = m[mo + 11], n14 = m[mo + 12], n24 = m[mo + 13], n34 = m[mo + 14], n44 = m[mo + 15], t1 = n11 * n22 - n21 * n12, t2 = n11 * n32 - n31 * n12, t3 = n11 * n42 - n41 * n12, t4 = n21 * n32 - n31 * n22, t5 = n21 * n42 - n41 * n22, t6 = n31 * n42 - n41 * n32, t7 = n13 * n24 - n23 * n14, t8 = n13 * n34 - n33 * n14, t9 = n13 * n44 - n43 * n14, t10 = n23 * n34 - n33 * n24, t11 = n23 * n44 - n43 * n24, t12 = n33 * n44 - n43 * n34;
+  return t1 * t12 - t2 * t11 + t3 * t10 + t4 * t9 - t5 * t8 + t6 * t7;
+}
+function mat4Invert(out, o, m, mo) {
+  let n11 = m[mo], n21 = m[mo + 1], n31 = m[mo + 2], n41 = m[mo + 3], n12 = m[mo + 4], n22 = m[mo + 5], n32 = m[mo + 6], n42 = m[mo + 7], n13 = m[mo + 8], n23 = m[mo + 9], n33 = m[mo + 10], n43 = m[mo + 11], n14 = m[mo + 12], n24 = m[mo + 13], n34 = m[mo + 14], n44 = m[mo + 15], t1 = n11 * n22 - n21 * n12, t2 = n11 * n32 - n31 * n12, t3 = n11 * n42 - n41 * n12, t4 = n21 * n32 - n31 * n22, t5 = n21 * n42 - n41 * n22, t6 = n31 * n42 - n41 * n32, t7 = n13 * n24 - n23 * n14, t8 = n13 * n34 - n33 * n14, t9 = n13 * n44 - n43 * n14, t10 = n23 * n34 - n33 * n24, t11 = n23 * n44 - n43 * n24, t12 = n33 * n44 - n43 * n34, det = t1 * t12 - t2 * t11 + t3 * t10 + t4 * t9 - t5 * t8 + t6 * t7;
+  if (det === 0) {
+    for (let i = 0; i < 16; i++) out[o + i] = 0;
+    return false;
+  }
+  let inv = 1 / det;
+  return out[o] = (n22 * t12 - n32 * t11 + n42 * t10) * inv, out[o + 1] = (n31 * t11 - n21 * t12 - n41 * t10) * inv, out[o + 2] = (n24 * t6 - n34 * t5 + n44 * t4) * inv, out[o + 3] = (n33 * t5 - n23 * t6 - n43 * t4) * inv, out[o + 4] = (n32 * t9 - n12 * t12 - n42 * t8) * inv, out[o + 5] = (n11 * t12 - n31 * t9 + n41 * t8) * inv, out[o + 6] = (n34 * t3 - n14 * t6 - n44 * t2) * inv, out[o + 7] = (n13 * t6 - n33 * t3 + n43 * t2) * inv, out[o + 8] = (n12 * t11 - n22 * t9 + n42 * t7) * inv, out[o + 9] = (n21 * t9 - n11 * t11 - n41 * t7) * inv, out[o + 10] = (n14 * t5 - n24 * t3 + n44 * t1) * inv, out[o + 11] = (n23 * t3 - n13 * t5 - n43 * t1) * inv, out[o + 12] = (n22 * t8 - n12 * t10 - n32 * t7) * inv, out[o + 13] = (n11 * t10 - n21 * t8 + n31 * t7) * inv, out[o + 14] = (n24 * t2 - n14 * t4 - n34 * t1) * inv, out[o + 15] = (n13 * t4 - n23 * t2 + n33 * t1) * inv, true;
+}
+function quatFromRotationColumns(out, o, m11, m21, m31, m12, m22, m32, m13, m23, m33) {
+  let trace = m11 + m22 + m33, x, y, z, w;
+  if (trace > 0) {
+    let s = 0.5 / Math.sqrt(trace + 1);
+    w = 0.25 / s, x = (m32 - m23) * s, y = (m13 - m31) * s, z = (m21 - m12) * s;
+  } else if (m11 > m22 && m11 > m33) {
+    let s = 2 * Math.sqrt(1 + m11 - m22 - m33);
+    w = (m32 - m23) / s, x = 0.25 * s, y = (m12 + m21) / s, z = (m13 + m31) / s;
+  } else if (m22 > m33) {
+    let s = 2 * Math.sqrt(1 + m22 - m11 - m33);
+    w = (m13 - m31) / s, x = (m12 + m21) / s, y = 0.25 * s, z = (m23 + m32) / s;
+  } else {
+    let s = 2 * Math.sqrt(1 + m33 - m11 - m22);
+    w = (m21 - m12) / s, x = (m13 + m31) / s, y = (m23 + m32) / s, z = 0.25 * s;
+  }
+  out[o] = x, out[o + 1] = y, out[o + 2] = z, out[o + 3] = w;
+}
+function mat4Decompose(m, mo, position, po, rotation, ro, scale, so) {
+  position[po] = m[mo + 12], position[po + 1] = m[mo + 13], position[po + 2] = m[mo + 14];
+  let a = m[mo], b = m[mo + 1], c = m[mo + 2], d = m[mo + 4], e = m[mo + 5], f = m[mo + 6], g = m[mo + 8], h = m[mo + 9], i = m[mo + 10], det = a * (e * i - f * h) - d * (b * i - c * h) + g * (b * f - c * e);
+  if (det === 0) {
+    scale[so] = 1, scale[so + 1] = 1, scale[so + 2] = 1, rotation[ro] = 0, rotation[ro + 1] = 0, rotation[ro + 2] = 0, rotation[ro + 3] = 1;
+    return;
+  }
+  let sx = Math.sqrt(a * a + b * b + c * c), sy = Math.sqrt(d * d + e * e + f * f), sz = Math.sqrt(g * g + h * h + i * i);
+  det < 0 && (sx = -sx);
+  let ix = 1 / sx, iy = 1 / sy, iz = 1 / sz;
+  quatFromRotationColumns(rotation, ro, a * ix, b * ix, c * ix, d * iy, e * iy, f * iy, g * iz, h * iz, i * iz), scale[so] = sx, scale[so + 1] = sy, scale[so + 2] = sz;
+}
+function mat4LookAt(out, o, eyeX, eyeY, eyeZ, targetX, targetY, targetZ, upX, upY, upZ) {
+  let zx = eyeX - targetX, zy = eyeY - targetY, zz = eyeZ - targetZ, len = Math.sqrt(zx * zx + zy * zy + zz * zz);
+  len < 1e-6 && (zz = 1, len = 1), zx /= len, zy /= len, zz /= len;
+  let xx = upY * zz - upZ * zy, xy = upZ * zx - upX * zz, xz = upX * zy - upY * zx;
+  if (len = Math.sqrt(xx * xx + xy * xy + xz * xz), len < 1e-6) {
+    Math.abs(upZ) === 1 ? zx += 1e-4 : zz += 1e-4;
+    let zl = Math.sqrt(zx * zx + zy * zy + zz * zz);
+    zx /= zl, zy /= zl, zz /= zl, xx = upY * zz - upZ * zy, xy = upZ * zx - upX * zz, xz = upX * zy - upY * zx, len = Math.sqrt(xx * xx + xy * xy + xz * xz);
+  }
+  xx /= len, xy /= len, xz /= len;
+  let yx = zy * xz - zz * xy, yy = zz * xx - zx * xz, yz = zx * xy - zy * xx;
+  out[o] = xx, out[o + 1] = xy, out[o + 2] = xz, out[o + 3] = 0, out[o + 4] = yx, out[o + 5] = yy, out[o + 6] = yz, out[o + 7] = 0, out[o + 8] = zx, out[o + 9] = zy, out[o + 10] = zz, out[o + 11] = 0, out[o + 12] = eyeX, out[o + 13] = eyeY, out[o + 14] = eyeZ, out[o + 15] = 1;
+}
+function mat4Perspective(out, o, fovYRadians, aspect, near, far) {
+  let f = 1 / Math.tan(fovYRadians / 2), range = 1 / (near - far);
+  for (let i = 0; i < 16; i++) out[o + i] = 0;
+  out[o] = f / aspect, out[o + 5] = f, out[o + 10] = (far + near) * range, out[o + 11] = -1, out[o + 14] = 2 * far * near * range;
+}
+function mat4Frustum(out, o, left, right, bottom, top, near, far) {
+  for (let i = 0; i < 16; i++) out[o + i] = 0;
+  out[o] = 2 * near / (right - left), out[o + 5] = 2 * near / (top - bottom), out[o + 8] = (right + left) / (right - left), out[o + 9] = (top + bottom) / (top - bottom), out[o + 10] = -(far + near) / (far - near), out[o + 11] = -1, out[o + 14] = -2 * far * near / (far - near);
+}
+function mat4Orthographic(out, o, left, right, bottom, top, near, far) {
+  for (let i = 0; i < 16; i++) out[o + i] = 0;
+  out[o] = 2 / (right - left), out[o + 5] = 2 / (top - bottom), out[o + 10] = -2 / (far - near), out[o + 12] = -(right + left) / (right - left), out[o + 13] = -(top + bottom) / (top - bottom), out[o + 14] = -(far + near) / (far - near), out[o + 15] = 1;
+}
+function mat4TransformPointArrays(m, mo, v, vo, out, oo) {
+  let x = v[vo], y = v[vo + 1], z = v[vo + 2], w = m[mo + 3] * x + m[mo + 7] * y + m[mo + 11] * z + m[mo + 15], inv = Math.abs(w) > 1e-6 ? 1 / w : 1;
+  out[oo] = (m[mo] * x + m[mo + 4] * y + m[mo + 8] * z + m[mo + 12]) * inv, out[oo + 1] = (m[mo + 1] * x + m[mo + 5] * y + m[mo + 9] * z + m[mo + 13]) * inv, out[oo + 2] = (m[mo + 2] * x + m[mo + 6] * y + m[mo + 10] * z + m[mo + 14]) * inv;
+}
+function mat4TransformDirection(m, o, v) {
+  let x = v.x, y = v.y, z = v.z;
+  return v.set(m[o] * x + m[o + 4] * y + m[o + 8] * z, m[o + 1] * x + m[o + 5] * y + m[o + 9] * z, m[o + 2] * x + m[o + 6] * y + m[o + 10] * z), v.normalize();
+}
+function mat4MaxScale(m, mo) {
+  let sx = m[mo] * m[mo] + m[mo + 1] * m[mo + 1] + m[mo + 2] * m[mo + 2], sy = m[mo + 4] * m[mo + 4] + m[mo + 5] * m[mo + 5] + m[mo + 6] * m[mo + 6], sz = m[mo + 8] * m[mo + 8] + m[mo + 9] * m[mo + 9] + m[mo + 10] * m[mo + 10];
+  return Math.sqrt(Math.max(sx, sy, sz));
+}
+var slerpScratchA = new Float32Array(4), slerpScratchB = new Float32Array(4), slerpWeight = new Float64Array(1);
+function slerpInto(out, o, ax, ay, az, aw, bx, by, bz, bw, t) {
+  slerpScratchA[0] = ax, slerpScratchA[1] = ay, slerpScratchA[2] = az, slerpScratchA[3] = aw, slerpScratchB[0] = bx, slerpScratchB[1] = by, slerpScratchB[2] = bz, slerpScratchB[3] = bw, slerpWeight[0] = t, quatSlerpArrays(out, o, slerpScratchA, 0, slerpScratchB, 0, slerpWeight, 0);
+}
+
+export { mat4Compose, mat4ComposeArrays, mat4Copy, mat4Decompose, mat4Determinant, mat4Frustum, mat4Identity, mat4Invert, mat4LookAt, mat4MaxScale, mat4Multiply, mat4Orthographic, mat4Perspective, mat4TransformDirection, mat4TransformPoint, mat4TransformPointArrays, mat4Translation, mat4Transpose, quatFromRotationColumns, quatSlerpArrays, slerpInto };

package/dist/chunk-KK6HYVBI.mjs

@@ -0,0 +1,242 @@
+import { cageDisplacement, blendCage, styliseColours, quantiseIdentity, NEUTRAL_LEVEL, NEUTRAL_HAIR, toneFromColour, snapTone } from './chunk-XD2PMH46.mjs';
+
+// src/game/kit/identity/fit.ts
+var FIT_ITERATIONS = 12, LANDMARK_NOISE = 0.01, RIDGE = 1e-9, PLANE = 2;
+function fittedTone(skin, stylise) {
+  let tone = toneFromColour(skin);
+  return stylise >= 1 ? snapTone(tone) : tone;
+}
+var IdentityFitError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "IdentityFitError";
+  }
+};
+function choleskySolve(matrix, n, rhs, out) {
+  let l = matrix;
+  for (let j = 0; j < n; j++) {
+    let d = l[j * n + j];
+    for (let k = 0; k < j; k++) d -= l[j * n + k] * l[j * n + k];
+    if (d <= 0) throw new IdentityFitError("normal equations are not positive definite");
+    let root = Math.sqrt(d);
+    l[j * n + j] = root;
+    for (let i = j + 1; i < n; i++) {
+      let s = l[i * n + j];
+      for (let k = 0; k < j; k++) s -= l[i * n + k] * l[j * n + k];
+      l[i * n + j] = s / root;
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    let s = rhs[i];
+    for (let k = 0; k < i; k++) s -= l[i * n + k] * out[k];
+    out[i] = s / l[i * n + i];
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    let s = out[i];
+    for (let k = i + 1; k < n; k++) s -= l[k * n + i] * out[k];
+    out[i] = s / l[i * n + i];
+  }
+}
+function invert3(m, out) {
+  let [a, b, c, d, e, f, g, h, i] = [m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]], A = e * i - f * h, B = -(d * i - f * g), C = d * h - e * g, det = a * A + b * B + c * C;
+  if (det === 0) throw new IdentityFitError("landmark anchors are degenerate");
+  out[0] = A / det, out[1] = -(b * i - c * h) / det, out[2] = (b * f - c * e) / det, out[3] = B / det, out[4] = (a * i - c * g) / det, out[5] = -(a * f - c * d) / det, out[6] = C / det, out[7] = -(a * h - b * g) / det, out[8] = (a * e - b * d) / det;
+}
+var IdentityFitter = class {
+  constructor(base) {
+    this.base = base, this.anchors = base.anchors.names.length;
+    let k = base.components, cage = new Float64Array(base.basis.cage.length), unit = new Float32Array(k), at = new Float64Array(3), all = new Float64Array(this.anchors * k * 3);
+    for (let c = 0; c < k; c++) {
+      unit.fill(0), unit[c] = 1, cageDisplacement(base, unit, cage);
+      for (let l = 0; l < this.anchors; l++) {
+        blendCage(cage, base.anchors.cageIndex, base.anchors.cageWeight, l, at);
+        for (let a = 0; a < 3; a++) all[(l * k + c) * 3 + a] = at[a];
+      }
+    }
+    let face = base.basis.face, body = base.basis.body;
+    this.faceBasis = new Float64Array(this.anchors * face * 3), this.bodyBasis = new Float64Array(this.anchors * body * 3);
+    for (let l = 0; l < this.anchors; l++)
+      for (let c = 0; c < k; c++)
+        for (let a = 0; a < 3; a++) {
+          let v = all[(l * k + c) * 3 + a];
+          c < face ? this.faceBasis[(l * face + c) * 3 + a] = v : this.bodyBasis[(l * body + c - face) * 3 + a] = v;
+        }
+  }
+  anchorPositions(face, body, out) {
+    let { rest } = this.base.anchors, nf = this.base.basis.face, nb = this.base.basis.body;
+    for (let l = 0; l < this.anchors; l++)
+      for (let a = 0; a < 3; a++) {
+        let v = rest[l * 3 + a];
+        for (let c = 0; c < nf; c++) v += this.faceBasis[(l * nf + c) * 3 + a] * face[c];
+        for (let c = 0; c < nb; c++) v += this.bodyBasis[(l * nb + c) * 3 + a] * body[c];
+        out[l * 3 + a] = v;
+      }
+  }
+  observations(capture) {
+    let { layout } = this.base.anchors, points = new Float64Array(this.anchors * (2));
+    for (let l = 0; l < this.anchors; l++) {
+      let index = layout[l];
+      if ((index + 1) * 3 > capture.landmarks.length) throw new IdentityFitError("capture is missing a landmark the identity base needs");
+      let x = capture.landmarks[index * 3] * capture.aspect, y = capture.landmarks[index * 3 + 1];
+      if (!Number.isFinite(x) || !Number.isFinite(y)) throw new IdentityFitError("capture landmarks must be finite");
+      points[l * (2)] = x, points[l * (2) + 1] = y;
+    }
+    let mx = 0, my = 0;
+    for (let l = 0; l < this.anchors; l++)
+      mx += points[l * (2)], my += points[l * (2) + 1];
+    mx /= this.anchors, my /= this.anchors;
+    let spread = 0;
+    for (let l = 0; l < this.anchors; l++)
+      points[l * (2)] -= mx, points[l * (2) + 1] -= my, spread += points[l * (2)] * points[l * (2)] + points[l * (2) + 1] * points[l * (2) + 1];
+    let radius = Math.sqrt(spread / this.anchors);
+    if (radius === 0) throw new IdentityFitError("capture landmarks collapse to a point");
+    for (let i = 0; i < points.length; i++) points[i] /= radius;
+    return points;
+  }
+  fit(capture, options = {}) {
+    let base = this.base, nf = base.basis.face, n = this.anchors, body = options.body ?? new Float32Array(base.basis.body);
+    if (body.length !== base.basis.body) throw new IdentityFitError("body coefficients do not match the identity base");
+    let p = this.observations(capture), face = new Float64Array(nf), anchors = new Float64Array(n * 3), centred = new Float64Array(n * 3), gram = new Float64Array(9), inverse = new Float64Array(9), rows = new Float64Array((2) * 3), cross = new Float64Array((2) * 3), restOnly = new Float64Array(n * 3), zero = new Float64Array(nf), normal = new Float64Array(nf * nf), rhs = new Float64Array(nf), jacobian = new Float64Array(n * (2) * nf), projected = new Float64Array((2)), scale = 1, prior = (0.01) * (0.01), meanBasis = new Float64Array(nf * 3);
+    for (let c = 0; c < nf; c++)
+      for (let a = 0; a < 3; a++) {
+        let s = 0;
+        for (let l = 0; l < n; l++) s += this.faceBasis[(l * nf + c) * 3 + a];
+        meanBasis[c * 3 + a] = s / n;
+      }
+    for (let iteration = 0; iteration < (12); iteration++) {
+      this.anchorPositions(face, body, anchors), centre(anchors, n, centred), gram.fill(0), cross.fill(0);
+      for (let l = 0; l < n; l++)
+        for (let r = 0; r < 3; r++) {
+          for (let c = 0; c < 3; c++) gram[r * 3 + c] += centred[l * 3 + r] * centred[l * 3 + c];
+          cross[r] += p[l * (2)] * centred[l * 3 + r], cross[3 + r] += p[l * (2) + 1] * centred[l * 3 + r];
+        }
+      for (let r = 0; r < 3; r++) gram[r * 3 + r] += (1e-9);
+      invert3(gram, inverse);
+      for (let row = 0; row < (2); row++)
+        for (let c = 0; c < 3; c++) {
+          let s = 0;
+          for (let k = 0; k < 3; k++) s += cross[row * 3 + k] * inverse[k * 3 + c];
+          rows[row * 3 + c] = s;
+        }
+      scale = orthonormalise(rows), this.anchorPositions(zero, body, restOnly), centre(restOnly, n, restOnly);
+      for (let l = 0; l < n; l++)
+        for (let row = 0; row < (2); row++)
+          for (let c = 0; c < nf; c++) {
+            let s = 0;
+            for (let a = 0; a < 3; a++) s += rows[row * 3 + a] * (this.faceBasis[(l * nf + c) * 3 + a] - meanBasis[c * 3 + a]);
+            jacobian[(l * (2) + row) * nf + c] = scale * s;
+          }
+      normal.fill(0), rhs.fill(0);
+      for (let i = 0; i < n * (2); i++) {
+        let l = i >> 1, row = i & 1, model = 0;
+        for (let a = 0; a < 3; a++) model += rows[row * 3 + a] * restOnly[l * 3 + a];
+        let residual2 = p[i] - scale * model;
+        for (let c = 0; c < nf; c++) {
+          let j = jacobian[i * nf + c];
+          rhs[c] += j * residual2;
+          for (let d = 0; d <= c; d++) normal[c * nf + d] += j * jacobian[i * nf + d];
+        }
+      }
+      for (let c = 0; c < nf; c++) {
+        normal[c * nf + c] += prior;
+        for (let d = 0; d < c; d++) normal[d * nf + c] = normal[c * nf + d];
+      }
+      choleskySolve(normal, nf, rhs, face);
+    }
+    this.anchorPositions(face, body, anchors), centre(anchors, n, centred);
+    let error = 0, residual = options.residual ? new Float32Array(n * 3) : null;
+    for (let l = 0; l < n; l++) {
+      for (let row = 0; row < (2); row++) {
+        let s = 0;
+        for (let a = 0; a < 3; a++) s += rows[row * 3 + a] * centred[l * 3 + a];
+        projected[row] = p[l * (2) + row] - scale * s, error += projected[row] * projected[row];
+      }
+      if (residual !== null)
+        for (let a = 0; a < 3; a++) residual[l * 3 + a] = (rows[a] * projected[0] + rows[3 + a] * projected[1]) / scale;
+    }
+    let stylise = options.stylise ?? 1, colours = styliseColours(capture.colours, base.palettes, stylise), tone = options.continuousTone === true && capture.colours !== null ? fittedTone(capture.colours.skin, stylise) : null;
+    return { params: quantiseIdentity({
+      basis: base.id,
+      face: Float32Array.from(face),
+      body: Float32Array.from(body),
+      skin: colours.skin,
+      tone,
+      condition: "plain",
+      conditionAmount: 0,
+      conditionSeed: 0,
+      hair: colours.hair,
+      hairTip: colours.hair,
+      eye: colours.eye,
+      hairStyle: options.hairStyle ?? 0,
+      hairBlock: NEUTRAL_HAIR,
+      brows: options.brows ?? 0,
+      facialHair: options.facialHair ?? 0,
+      stylise,
+      height: NEUTRAL_LEVEL,
+      assistive: [],
+      fromPhoto: true,
+      residual
+    }), error: Math.sqrt(error / (n * (2))), camera: { scale, rows, translation: [0, 0] } };
+  }
+};
+function centre(points, n, out) {
+  for (let a = 0; a < 3; a++) {
+    let s = 0;
+    for (let l = 0; l < n; l++) s += points[l * 3 + a];
+    let mean = s / n;
+    for (let l = 0; l < n; l++) out[l * 3 + a] = points[l * 3 + a] - mean;
+  }
+}
+function orthonormalise(rows) {
+  let a = Math.sqrt(rows[0] * rows[0] + rows[1] * rows[1] + rows[2] * rows[2]), b = Math.sqrt(rows[3] * rows[3] + rows[4] * rows[4] + rows[5] * rows[5]);
+  if (a === 0 || b === 0) throw new IdentityFitError("camera is degenerate");
+  for (let i = 0; i < 3; i++) rows[i] /= a;
+  let dot = 0;
+  for (let i = 0; i < 3; i++) dot += rows[i] * rows[3 + i];
+  for (let i = 0; i < 3; i++) rows[3 + i] -= dot * rows[i];
+  let c = Math.sqrt(rows[3] * rows[3] + rows[4] * rows[4] + rows[5] * rows[5]);
+  for (let i = 0; i < 3; i++) rows[3 + i] /= c;
+  return (a + b) / 2;
+}
+function anchorWeightSum(base, anchor) {
+  let s = 0;
+  for (let k = 0; k < 4; k++) {
+    let w = base.anchors.cageWeight[anchor * 4 + k] / 65535;
+    s += w * w;
+  }
+  return s;
+}
+
+// src/game/kit/identity/policy.ts
+function refuse(refusal) {
+  return { allowed: false, refusal, minStylise: 1, residual: false, shareable: false };
+}
+function identityCapturePolicy(context) {
+  if (!context.consented) return refuse("consent_required");
+  if (context.ageRange === "under_16") return refuse("age_restricted");
+  if (context.ageRange === "undeclared") return refuse("age_undeclared");
+  if (context.subject !== "self") return refuse("self_only");
+  if (context.source !== "camera") return refuse("live_camera_only");
+  if (context.faces !== 1) return refuse("one_face_only");
+  if (Math.abs(context.yaw) > 0.35 || Math.abs(context.pitch) > 0.35) return refuse("face_turned");
+  if (context.faceWidth < 0.18) return refuse("face_too_small");
+  let adult = context.ageRange === "adult";
+  return { allowed: true, refusal: null, minStylise: adult ? 0 : 1, residual: adult, shareable: adult };
+}
+
+// src/game/kit/identity/from-capture.ts
+function identityFromCapture(base, capture, context, options = {}) {
+  let policy = identityCapturePolicy(context);
+  if (!policy.allowed) return { policy, fit: null };
+  let fitter = base instanceof IdentityFitter ? base : new IdentityFitter(base), stylise = Math.max(policy.minStylise, Math.min(1, options.stylise ?? 1));
+  if (!Number.isFinite(stylise)) throw new IdentityFitError("stylise must be finite");
+  return {
+    policy,
+    fit: fitter.fit(capture, {
+      ...options,
+      stylise,
+      residual: policy.residual && options.residual === true
+    })
+  };
+}
+
+export { IdentityFitter, anchorWeightSum, identityCapturePolicy, identityFromCapture };