@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-PQTQKNKD.js

@@ -0,0 +1,539 @@
+'use strict';
+
+// src/game/kit/identity/base.ts
+var MESH_SLOTS = ["body", "hair", "brows", "facialHair"], KIND_BYTES = { f32: 4, i16: 2, u16: 2, u32: 4, u8: 1 };
+function weldPositions(positions) {
+  let seen = /* @__PURE__ */ new Map(), out = new Uint32Array(positions.length / 3);
+  for (let v = 0; v < out.length; v++) {
+    let key = `${positions[v * 3]},${positions[v * 3 + 1]},${positions[v * 3 + 2]}`, first = seen.get(key);
+    first === void 0 ? (seen.set(key, v), out[v] = v) : out[v] = first;
+  }
+  return out;
+}
+var IdentityFormatError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "IdentityFormatError";
+  }
+};
+function fnv1a(bytes) {
+  let hash = 2166136261;
+  for (let i = 0; i < bytes.length; i++)
+    hash ^= bytes[i], hash = Math.imul(hash, 16777619);
+  return hash >>> 0;
+}
+function typed(bytes, start, ref) {
+  let size = KIND_BYTES[ref.kind], begin = start + ref.offset, end = begin + ref.count * size;
+  if (!Number.isInteger(ref.offset) || !Number.isInteger(ref.count) || ref.offset < 0 || ref.count < 0 || end > bytes.byteLength)
+    throw new IdentityFormatError("array outside the identity base");
+  let copy = bytes.slice(begin, end);
+  switch (ref.kind) {
+    case "f32":
+      return new Float32Array(copy.buffer, 0, ref.count);
+    case "i16":
+      return new Int16Array(copy.buffer, 0, ref.count);
+    case "u16":
+      return new Uint16Array(copy.buffer, 0, ref.count);
+    case "u32":
+      return new Uint32Array(copy.buffer, 0, ref.count);
+    case "u8":
+      return copy;
+  }
+}
+function expect(value, ctor, length, what) {
+  if (!(value instanceof ctor) || value.length !== length) throw new IdentityFormatError(`${what} has the wrong size`);
+  return value;
+}
+function parseIdentityBase(bytes) {
+  if (bytes.byteLength < 12) throw new IdentityFormatError("identity base is truncated");
+  let view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(0, true) !== 1111771459) throw new IdentityFormatError("not an identity base");
+  if (view.getUint32(4, true) !== 1) throw new IdentityFormatError("unsupported identity base version");
+  let jsonBytes = view.getUint32(8, true);
+  if (12 + jsonBytes > bytes.byteLength) throw new IdentityFormatError("identity base is truncated");
+  let raw = JSON.parse(new TextDecoder().decode(bytes.subarray(12, 12 + jsonBytes))), start = 12 + jsonBytes, get = (ref) => typed(bytes, start, ref), jointCount = raw.joints.length, cageCount = get(raw.basis.cage).length / 3, components = raw.basis.face + raw.basis.body;
+  raw.joints.forEach((joint, j) => {
+    if (joint.parent >= j || joint.parent < -1) throw new IdentityFormatError("joints must follow their parents");
+  });
+  for (let joint of raw.skin) if (joint < 0 || joint >= jointCount) throw new IdentityFormatError("skin joint out of range");
+  let meshes = raw.meshes.map((m) => {
+    let positions = get(m.positions), vertices = positions.length / 3, lods = m.lods.map((ref) => {
+      let lod = get(ref);
+      if (!(lod instanceof Uint16Array || lod instanceof Uint32Array)) throw new IdentityFormatError("lod indices must be u16 or u32");
+      for (let i = 0; i < lod.length; i++) if (lod[i] >= vertices) throw new IdentityFormatError("lod index out of range");
+      return lod;
+    }), cageIndex = expect(get(m.cage.index), Uint16Array, vertices * 4, "mesh cage index");
+    for (let i = 0; i < cageIndex.length; i++) if (cageIndex[i] >= cageCount) throw new IdentityFormatError("cage index out of range");
+    let normals = expect(get(m.normals), Int16Array, vertices * 3, "mesh normals"), joints = expect(get(m.joints), Uint8Array, vertices * 4, "mesh joints");
+    for (let i = 0; i < joints.length; i++) if (joints[i] >= raw.skin.length) throw new IdentityFormatError("skin joint out of range");
+    if (!MESH_SLOTS.includes(m.slot)) throw new IdentityFormatError("unknown mesh slot");
+    return {
+      name: m.name,
+      material: m.material,
+      slot: m.slot,
+      style: m.style,
+      positions: expect(positions, Float32Array, vertices * 3, "mesh positions"),
+      normals: Float32Array.from(normals, (v) => v / 32767),
+      uvs: expect(get(m.uvs), Float32Array, vertices * 2, "mesh uvs"),
+      joints,
+      weights: expect(get(m.weights), Uint8Array, vertices * 4, "mesh weights"),
+      lods,
+      cageIndex,
+      cageWeight: expect(get(m.cage.weight), Uint16Array, vertices * 4, "mesh cage weight"),
+      weld: weldPositions(positions)
+    };
+  }), anchorCount = raw.anchors.names.length, base = {
+    id: fnv1a(bytes),
+    components,
+    name: raw.name,
+    joints: raw.joints,
+    skin: raw.skin,
+    inverseBind: expect(get(raw.inverseBind), Float32Array, raw.skin.length * 16, "inverse bind matrices"),
+    jointCageIndex: expect(get(raw.jointCage.index), Uint16Array, jointCount * 4, "joint cage index"),
+    jointCageWeight: expect(get(raw.jointCage.weight), Uint16Array, jointCount * 4, "joint cage weight"),
+    meshes,
+    materials: raw.materials,
+    images: raw.images.map((image) => ({ role: image.role, bytes: expect(get(image.bytes), Uint8Array, image.bytes.count, "image") })),
+    styles: raw.styles,
+    palettes: raw.palettes,
+    basis: {
+      face: raw.basis.face,
+      body: raw.basis.body,
+      names: raw.basis.names,
+      scale: expect(get(raw.basis.scale), Float32Array, components, "basis scale"),
+      cage: expect(get(raw.basis.cage), Float32Array, cageCount * 3, "cage"),
+      rows: expect(get(raw.basis.rows), Int16Array, components * cageCount * 3, "basis rows")
+    },
+    anchors: {
+      names: raw.anchors.names,
+      layout: raw.anchors.layout,
+      rest: expect(get(raw.anchors.rest), Float32Array, anchorCount * 3, "anchor rest"),
+      cageIndex: expect(get(raw.anchors.cage.index), Uint16Array, anchorCount * 4, "anchor cage index"),
+      cageWeight: expect(get(raw.anchors.cage.weight), Uint16Array, anchorCount * 4, "anchor cage weight")
+    },
+    humanoid: raw.humanoid
+  };
+  for (let m of base.materials)
+    if (m.image >= base.images.length || m.normal >= base.images.length) throw new IdentityFormatError("material image out of range");
+  for (let m of meshes) if (m.material < 0 || m.material >= base.materials.length) throw new IdentityFormatError("mesh material out of range");
+  for (let index of [base.jointCageIndex, base.anchors.cageIndex])
+    for (let i = 0; i < index.length; i++) if (index[i] >= cageCount) throw new IdentityFormatError("cage index out of range");
+  if (base.anchors.layout.length !== anchorCount) throw new IdentityFormatError("anchor layout does not match the anchors");
+  return base;
+}
+function cageDisplacement(base, coefficients, out) {
+  let cage = base.basis.cage.length;
+  out.fill(0);
+  let { rows, scale } = base.basis;
+  for (let k = 0; k < base.components; k++) {
+    let c = coefficients[k] * scale[k];
+    if (c === 0) continue;
+    let row = k * cage;
+    for (let i = 0; i < cage; i++) out[i] += rows[row + i] * c;
+  }
+}
+function blendCage(displacement, index, weight, item, out) {
+  let x = 0, y = 0, z = 0;
+  for (let k = 0; k < 4; k++) {
+    let w = weight[item * 4 + k] / 65535;
+    if (w === 0) continue;
+    let c = index[item * 4 + k] * 3;
+    x += displacement[c] * w, y += displacement[c + 1] * w, z += displacement[c + 2] * w;
+  }
+  out[0] = x, out[1] = y, out[2] = z;
+}
+
+// src/game/kit/identity/colour.ts
+function fifthRoot(a) {
+  let r = 1;
+  for (let step = 0; step < 48; step++) {
+    let r2 = r * r;
+    r = (4 * r + a / (r2 * r2)) / 5;
+  }
+  return r;
+}
+function srgbToLinear(byte2) {
+  let c = byte2 / 255;
+  if (c <= 0.04045) return Math.fround(c / 12.92);
+  let y = (c + 0.055) / 1.055, y2 = y * y;
+  return Math.fround(y2 * fifthRoot(y2));
+}
+function luma(c) {
+  return (0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]) / 255;
+}
+function distance(a, b) {
+  let dr = srgbToLinear(a[0]) - srgbToLinear(b[0]), dg = srgbToLinear(a[1]) - srgbToLinear(b[1]), db = srgbToLinear(a[2]) - srgbToLinear(b[2]);
+  return dr * dr * 0.2126 + dg * dg * 0.7152 + db * db * 0.0722 + (luma(a) - luma(b)) * (luma(a) - luma(b));
+}
+function mix(a, b, t) {
+  return [Math.round(a[0] + (b[0] - a[0]) * t), Math.round(a[1] + (b[1] - a[1]) * t), Math.round(a[2] + (b[2] - a[2]) * t)];
+}
+function nearestOnRamp(colour, ramp) {
+  let best = ramp[0], bestDistance = distance(colour, best);
+  for (let i = 0; i + 1 < ramp.length; i++)
+    for (let s = 0; s <= 16; s++) {
+      let candidate = mix(ramp[i], ramp[i + 1], s / 16), d = distance(colour, candidate);
+      d < bestDistance && (bestDistance = d, best = candidate);
+    }
+  return best;
+}
+function nearestInPalette(colour, palette) {
+  let best = 0, bestDistance = distance(colour, palette[0]);
+  for (let i = 1; i < palette.length; i++) {
+    let d = distance(colour, palette[i]);
+    d < bestDistance && (bestDistance = d, best = i);
+  }
+  return best;
+}
+function styliseColours(captured, palettes, stylise) {
+  let defaultSkin = palettes.skin[palettes.skin.length >> 1];
+  if (captured === null) return { skin: defaultSkin, hair: palettes.hair[0], eye: palettes.eye[0] };
+  let skinTarget = nearestOnRamp(captured.skin, palettes.skin), hairTarget = captured.hair === null ? palettes.hair[0] : palettes.hair[nearestInPalette(captured.hair, palettes.hair)], eyeTarget = captured.eye === null ? palettes.eye[0] : palettes.eye[nearestInPalette(captured.eye, palettes.eye)];
+  return {
+    skin: mix(captured.skin, skinTarget, stylise),
+    hair: captured.hair === null ? hairTarget : mix(captured.hair, hairTarget, stylise),
+    eye: eyeTarget
+  };
+}
+
+// src/game/kit/identity/tone.ts
+var MONK_STOPS = 10, TONE_PER_STOP = 7280, TONE_MAX = (7280) * ((10) - 1), TONE_AMOUNT_MAX = 255, MONK_TONES = [
+  [246, 237, 228],
+  [243, 231, 219],
+  [247, 234, 208],
+  [234, 218, 186],
+  [215, 189, 150],
+  [160, 126, 86],
+  [130, 92, 67],
+  [96, 65, 52],
+  [58, 49, 42],
+  [41, 36, 32]
+], UNDERTONES = ["neutral", "warm", "cool", "olive"], UNDERTONE_SHIFT = {
+  neutral: [0, 0, 0],
+  warm: [14, 4, -16],
+  cool: [-10, -2, 14],
+  olive: [-8, 8, -10]
+}, CHANNELS = 3, BYTE_MAX = 255, SHIFT_DENOMINATOR = (255) * (255) * (3), SEARCH_STEP = 16, SEARCH_AMOUNTS = [0, 85, 170, 255];
+function toneRamp(value) {
+  let v = Math.min(Math.max(Math.round(value), 0), TONE_MAX), segment = Math.min(Math.floor(v / (7280)), (10) - 2), rem = v - segment * (7280), low = MONK_TONES[segment], high = MONK_TONES[segment + 1], channel = (c) => Math.floor((low[c] * ((7280) - rem) + high[c] * rem + (7280) / 2) / (7280));
+  return [channel(0), channel(1), channel(2)];
+}
+function divideRounded(numerator, denominator) {
+  let half = Math.floor(denominator / 2);
+  return numerator >= 0 ? Math.floor((numerator + half) / denominator) : -Math.floor((half - numerator) / denominator);
+}
+function toneColour(tone) {
+  let base = toneRamp(tone.value), sum = base[0] + base[1] + base[2], shift = UNDERTONE_SHIFT[tone.undertone], amount = Math.min(Math.max(Math.round(tone.amount), 0), (255)), channel = (c) => Math.min(Math.max(base[c] + divideRounded(shift[c] * amount * sum, SHIFT_DENOMINATOR), 0), (255));
+  return [channel(0), channel(1), channel(2)];
+}
+function monkTone(stop) {
+  return { value: Math.min(Math.max(Math.floor(stop), 0), (10) - 1) * (7280), undertone: "neutral", amount: 0 };
+}
+function snapTone(tone) {
+  let value = Math.min(Math.max(Math.round(tone.value), 0), TONE_MAX), stop = Math.min(Math.floor((value + (7280) / 2) / (7280)), (10) - 1);
+  return { ...tone, value: stop * (7280) };
+}
+function linearDistance(a, b) {
+  let sum = 0;
+  for (let c = 0; c < (3); c++) {
+    let d = srgbToLinear(a[c]) - srgbToLinear(b[c]);
+    sum += d * d;
+  }
+  return sum;
+}
+function toneFromColour(colour) {
+  let best = monkTone(0), bestDistance = Number.POSITIVE_INFINITY;
+  for (let value = 0; value <= TONE_MAX; value += (16))
+    for (let undertone of UNDERTONES)
+      for (let amount of SEARCH_AMOUNTS) {
+        if (undertone === "neutral" && amount !== 0) continue;
+        let tone = { value, undertone, amount }, d = linearDistance(colour, toneColour(tone));
+        d < bestDistance && (bestDistance = d, best = tone);
+      }
+  return best;
+}
+
+// src/game/kit/identity/params.ts
+var IDENTITY_PARAMS_MAGIC = 1346652483, IDENTITY_PARAMS_VERSION = 2, IDENTITY_PARAMS_V1 = 1, COEFFICIENT_STEPS = 1024, MAX_SIGMA = 31, RESIDUAL_STEP_METRES = 5e-4, MAX_RESIDUAL_STEPS = 127, STYLISE_STEPS = 255;
+var NEUTRAL_LEVEL = 128, NO_PART = 65535, CATALOGUE_PART = 32768, MAX_ASSISTIVE = 8, SKIN_CONDITIONS = ["plain", "vitiligo", "albinism"], CURL_PATTERNS = ["1A", "1B", "1C", "2A", "2B", "2C", "3A", "3B", "3C", "4A", "4B", "4C"], ASSISTIVE_KINDS = ["wheelchair", "prosthetic_arm", "prosthetic_leg", "hearing_aid", "cochlear_implant", "glasses", "cane"], ASSISTIVE_SIDES = ["centre", "left", "right", "both"], FLAG_RESIDUAL = 1, FLAG_PHOTO = 2, HEADER_BYTES = 12, V1_COLOUR_BYTES = 9, V1_STYLE_BYTES = 4, SKIN_BYTES = 8, HAIR_COLOUR_BYTES = 6, EYE_BYTES = 3, HAIR_BLOCK_BYTES = 10, STYLE_BYTES = 4, ASSISTIVE_COUNT_BYTES = 1, ASSISTIVE_BYTES = 4, FIXED_BLOCK_BYTES = (8) + (6) + (3) + (10) + (4) + (1), CHECK_BYTES = 2, I16_BYTES = 2, AXES = 3, CHECK_MASK = 65535, CHECK_SHIFT = 16, MAX_COUNT = 255, MAX_U16 = 65535, SKIN_MODE_TONE = 0, SKIN_MODE_RGB = 1, NEUTRAL_HAIR = {
+  pattern: "1A",
+  volume: (128),
+  density: (128),
+  hairline: (128),
+  edges: (128),
+  length: (128),
+  covering: (65535)
+}, IdentityParamsError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "IdentityParamsError";
+  }
+};
+function quantiseCoefficient(value) {
+  let steps = Math.round(value * (1024)), limit = (31) * (1024);
+  return Math.max(-limit, Math.min(limit, steps)) + 0;
+}
+function quantiseResidual(value) {
+  return Math.max(-(127), Math.min((127), Math.round(value / (5e-4)))) + 0;
+}
+function byte(value) {
+  return Math.max(0, Math.min((255), Math.round(value)));
+}
+function word(value) {
+  return Math.max(0, Math.min((65535), Math.round(value)));
+}
+function rgb(colour) {
+  return [byte(colour[0]), byte(colour[1]), byte(colour[2])];
+}
+function quantiseTone(tone) {
+  return { value: Math.min(word(tone.value), TONE_MAX), undertone: tone.undertone, amount: byte(tone.amount) };
+}
+function isCatalogueHair(style) {
+  return style >= (32768) && style !== (65535);
+}
+function catalogueHair(part) {
+  return (32768) + Math.max(0, Math.min((65535) - (32768) - 1, Math.round(part)));
+}
+function quantiseIdentity(params) {
+  let tone = params.tone === null ? null : quantiseTone(params.tone), block = params.hairBlock;
+  return {
+    ...params,
+    basis: params.basis >>> 0,
+    face: Float32Array.from(params.face, (v) => quantiseCoefficient(v) / (1024)),
+    body: Float32Array.from(params.body, (v) => quantiseCoefficient(v) / (1024)),
+    skin: tone === null ? rgb(params.skin) : toneColour(tone),
+    tone,
+    conditionAmount: byte(params.conditionAmount),
+    conditionSeed: byte(params.conditionSeed),
+    hair: rgb(params.hair),
+    hairTip: rgb(params.hairTip),
+    eye: rgb(params.eye),
+    hairStyle: word(params.hairStyle),
+    hairBlock: { pattern: block.pattern, volume: byte(block.volume), density: byte(block.density), hairline: byte(block.hairline), edges: byte(block.edges), length: byte(block.length), covering: word(block.covering) },
+    brows: byte(params.brows),
+    facialHair: byte(params.facialHair),
+    stylise: byte(params.stylise * (255)) / (255),
+    height: byte(params.height),
+    assistive: params.assistive.map((a) => ({ kind: a.kind, side: a.side, part: word(a.part) })),
+    residual: params.residual === null ? null : Float32Array.from(params.residual, (v) => quantiseResidual(v) * (5e-4))
+  };
+}
+function identityParamsBytes(face, body, residualAnchors, assistive = 0) {
+  let residual = residualAnchors > 0 ? 1 + residualAnchors * (3) : 0;
+  return (12) + (face + body) * (2) + FIXED_BLOCK_BYTES + assistive * (4) + residual + (2);
+}
+function check(bytes) {
+  let hash = fnv1a(bytes);
+  return (hash ^ hash >>> (16)) & (65535);
+}
+function indexOf(values, value) {
+  let at = values.indexOf(value);
+  if (at < 0) throw new IdentityParamsError("identity parameters hold an out-of-range field");
+  return at;
+}
+function valueAt(values, at) {
+  if (at >= values.length) throw new IdentityParamsError("identity parameters hold an out-of-range field");
+  return values[at];
+}
+function encodeIdentity(params) {
+  let face = params.face.length, body = params.body.length;
+  if (face > (255) || body > (255)) throw new IdentityParamsError("too many coefficients");
+  let residual = params.residual;
+  if (residual !== null && (residual.length % (3) !== 0 || residual.length / (3) > (255))) throw new IdentityParamsError("residual must hold up to 255 anchors");
+  if (params.assistive.length > (8)) throw new IdentityParamsError("too many assistive parts");
+  let anchors = residual === null ? 0 : residual.length / (3), length = identityParamsBytes(face, body, anchors, params.assistive.length) + (residual !== null && anchors === 0 ? 1 : 0), out = new Uint8Array(length), view = new DataView(out.buffer);
+  view.setUint32(0, (1346652483), true), out[4] = (2), out[5] = (residual !== null ? (1) : 0) | (params.fromPhoto ? (2) : 0), view.setUint32(6, params.basis >>> 0, true), out[10] = face, out[11] = body;
+  let at = (12);
+  for (let i = 0; i < face; i++, at += (2)) view.setInt16(at, quantiseCoefficient(params.face[i]), true);
+  for (let i = 0; i < body; i++, at += (2)) view.setInt16(at, quantiseCoefficient(params.body[i]), true);
+  if (params.tone !== null) {
+    let tone = quantiseTone(params.tone);
+    out[at++] = (0), view.setUint16(at, tone.value, true), at += (2), out[at++] = indexOf(UNDERTONES, tone.undertone), out[at++] = tone.amount;
+  } else {
+    out[at++] = (1);
+    for (let c = 0; c < (3); c++) out[at++] = byte(params.skin[c]);
+    out[at++] = 0;
+  }
+  out[at++] = indexOf(SKIN_CONDITIONS, params.condition), out[at++] = byte(params.conditionAmount), out[at++] = byte(params.conditionSeed);
+  for (let colour of [params.hair, params.hairTip, params.eye]) for (let c = 0; c < (3); c++) out[at++] = byte(colour[c]);
+  let block = params.hairBlock;
+  out[at++] = indexOf(CURL_PATTERNS, block.pattern);
+  for (let level of [block.volume, block.density, block.hairline, block.edges, block.length]) out[at++] = byte(level);
+  view.setUint16(at, word(params.hairStyle), true), at += (2), view.setUint16(at, word(block.covering), true), at += (2), out[at++] = byte(params.brows), out[at++] = byte(params.facialHair), out[at++] = byte(params.stylise * (255)), out[at++] = byte(params.height), out[at++] = params.assistive.length;
+  for (let part of params.assistive)
+    out[at++] = indexOf(ASSISTIVE_KINDS, part.kind), out[at++] = indexOf(ASSISTIVE_SIDES, part.side), view.setUint16(at, word(part.part), true), at += (2);
+  if (residual !== null) {
+    out[at++] = anchors;
+    for (let i = 0; i < residual.length; i++) view.setInt8(at++, quantiseResidual(residual[i]));
+  }
+  return view.setUint16(at, check(out.subarray(0, at)), true), out;
+}
+var ParamReader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.at = (12);
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  need(n) {
+    if (this.at + n + (2) > this.bytes.byteLength) throw new IdentityParamsError("identity parameters are truncated");
+  }
+  byte() {
+    return this.bytes[this.at++];
+  }
+  word() {
+    let value = this.view.getUint16(this.at, true);
+    return this.at += (2), value;
+  }
+  colour() {
+    let c = [this.bytes[this.at], this.bytes[this.at + 1], this.bytes[this.at + 2]];
+    return this.at += (3), c;
+  }
+  coefficients(count) {
+    this.need(count * (2));
+    let values = new Float32Array(count);
+    for (let i = 0; i < count; i++, this.at += (2)) values[i] = this.view.getInt16(this.at, true) / (1024);
+    return values;
+  }
+  residual(flags) {
+    if ((flags & (1)) === 0) return null;
+    this.need(1);
+    let anchors = this.byte();
+    this.need(anchors * (3));
+    let residual = new Float32Array(anchors * (3));
+    for (let i = 0; i < residual.length; i++) residual[i] = this.view.getInt8(this.at++) * (5e-4);
+    return residual;
+  }
+  finish() {
+    if (this.at + (2) !== this.bytes.byteLength) throw new IdentityParamsError("identity parameters have trailing bytes");
+    if (this.view.getUint16(this.at, true) !== check(this.bytes.subarray(0, this.at))) throw new IdentityParamsError("identity parameter checksum mismatch");
+  }
+};
+function decodeV1(r, basis, flags, face, body) {
+  let faceValues = r.coefficients(face), bodyValues = r.coefficients(body);
+  r.need((9) + (4));
+  let skin = r.colour(), hair = r.colour(), eye = r.colour(), hairStyle = r.byte(), brows = r.byte(), facialHair = r.byte(), stylise = r.byte() / (255), residual = r.residual(flags);
+  return r.finish(), {
+    basis,
+    face: faceValues,
+    body: bodyValues,
+    skin,
+    tone: null,
+    condition: "plain",
+    conditionAmount: 0,
+    conditionSeed: 0,
+    hair,
+    hairTip: hair,
+    eye,
+    hairStyle,
+    hairBlock: NEUTRAL_HAIR,
+    brows,
+    facialHair,
+    stylise,
+    height: (128),
+    assistive: [],
+    fromPhoto: (flags & (2)) !== 0,
+    residual
+  };
+}
+function decodeV2(r, basis, flags, face, body) {
+  if ((flags & -4) !== 0) throw new IdentityParamsError("identity parameters hold an out-of-range field");
+  let faceValues = r.coefficients(face), bodyValues = r.coefficients(body);
+  r.need(FIXED_BLOCK_BYTES);
+  let tone = null, skin, mode = r.byte();
+  if (mode === (0)) {
+    let value = r.word();
+    if (tone = { value, undertone: valueAt(UNDERTONES, r.byte()), amount: r.byte() }, value > TONE_MAX) throw new IdentityParamsError("identity parameters hold an out-of-range field");
+    skin = toneColour(tone);
+  } else if (mode === (1)) {
+    if (skin = r.colour(), r.byte() !== 0) throw new IdentityParamsError("identity parameters hold an out-of-range field");
+  } else throw new IdentityParamsError("identity parameters hold an out-of-range field");
+  let condition = valueAt(SKIN_CONDITIONS, r.byte()), conditionAmount = r.byte(), conditionSeed = r.byte(), hair = r.colour(), hairTip = r.colour(), eye = r.colour(), pattern = valueAt(CURL_PATTERNS, r.byte()), volume = r.byte(), density = r.byte(), hairline = r.byte(), edges = r.byte(), length = r.byte(), hairStyle = r.word(), covering = r.word(), brows = r.byte(), facialHair = r.byte(), stylise = r.byte() / (255), height = r.byte(), count = r.byte();
+  if (count > (8)) throw new IdentityParamsError("identity parameters hold an out-of-range field");
+  r.need(count * (4));
+  let assistive = [];
+  for (let i = 0; i < count; i++) assistive.push({ kind: valueAt(ASSISTIVE_KINDS, r.byte()), side: valueAt(ASSISTIVE_SIDES, r.byte()), part: r.word() });
+  let residual = r.residual(flags);
+  return r.finish(), {
+    basis,
+    face: faceValues,
+    body: bodyValues,
+    skin,
+    tone,
+    condition,
+    conditionAmount,
+    conditionSeed,
+    hair,
+    hairTip,
+    eye,
+    hairStyle,
+    hairBlock: { pattern, volume, density, hairline, edges, length, covering },
+    brows,
+    facialHair,
+    stylise,
+    height,
+    assistive,
+    fromPhoto: (flags & (2)) !== 0,
+    residual
+  };
+}
+function decodeIdentity(bytes) {
+  if (bytes.byteLength < (12) + (2)) throw new IdentityParamsError("identity parameters are truncated");
+  let r = new ParamReader(bytes);
+  if (r.view.getUint32(0, true) !== (1346652483)) throw new IdentityParamsError("not identity parameters");
+  let basis = r.view.getUint32(6, true), flags = bytes[5], face = bytes[10], body = bytes[11];
+  if (bytes[4] === (1)) return decodeV1(r, basis, flags, face, body);
+  if (bytes[4] === (2)) return decodeV2(r, basis, flags, face, body);
+  throw new IdentityParamsError("unsupported identity parameter version");
+}
+function checkIdentityFits(base, params) {
+  if (params.basis !== base.id) throw new IdentityParamsError("parameters were made for a different identity base");
+  if (params.face.length !== base.basis.face || params.body.length !== base.basis.body) throw new IdentityParamsError("coefficient counts do not match the identity base");
+  if (params.residual !== null && params.residual.length !== base.anchors.names.length * (3)) throw new IdentityParamsError("residual does not match the identity anchors");
+  if (params.hairStyle < (32768) && params.hairStyle >= base.styles.hair.length || params.brows >= base.styles.brows.length || params.facialHair >= base.styles.facialHair.length)
+    throw new IdentityParamsError("style index out of range");
+}
+function neutralIdentity(base) {
+  let hair = base.palettes.hair[0];
+  return {
+    basis: base.id,
+    face: new Float32Array(base.basis.face),
+    body: new Float32Array(base.basis.body),
+    skin: base.palettes.skin[Math.floor(base.palettes.skin.length / 2)],
+    tone: null,
+    condition: "plain",
+    conditionAmount: 0,
+    conditionSeed: 0,
+    hair,
+    hairTip: hair,
+    eye: base.palettes.eye[0],
+    hairStyle: 0,
+    hairBlock: NEUTRAL_HAIR,
+    brows: 0,
+    facialHair: 0,
+    stylise: 1,
+    height: (128),
+    assistive: [],
+    fromPhoto: false,
+    residual: null
+  };
+}
+
+exports.CURL_PATTERNS = CURL_PATTERNS;
+exports.MONK_TONES = MONK_TONES;
+exports.NEUTRAL_HAIR = NEUTRAL_HAIR;
+exports.NEUTRAL_LEVEL = (128);
+exports.NO_PART = (65535);
+exports.blendCage = blendCage;
+exports.cageDisplacement = cageDisplacement;
+exports.catalogueHair = catalogueHair;
+exports.checkIdentityFits = checkIdentityFits;
+exports.decodeIdentity = decodeIdentity;
+exports.encodeIdentity = encodeIdentity;
+exports.isCatalogueHair = isCatalogueHair;
+exports.monkTone = monkTone;
+exports.neutralIdentity = neutralIdentity;
+exports.parseIdentityBase = parseIdentityBase;
+exports.quantiseIdentity = quantiseIdentity;
+exports.snapTone = snapTone;
+exports.srgbToLinear = srgbToLinear;
+exports.styliseColours = styliseColours;
+exports.toneColour = toneColour;
+exports.toneFromColour = toneFromColour;

package/dist/chunk-PRSR4FAV.mjs

@@ -0,0 +1,81 @@
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/backends/engine/policy.ts
+var ENGINE_RAGDOLL_POLICY_EXPORT_NAMES = [
+  "engine_ragdoll_mjcf",
+  "engine_ragdoll_observe",
+  "engine_ragdoll_act",
+  "engine_ragdoll_policy_create",
+  "engine_ragdoll_policy_destroy",
+  "engine_ragdoll_policy_control"
+], RAGDOLL_POLICY_SPEC_VERSION = 1, POLICY_SPEC_VERSION_WORD = 0, POLICY_SPEC_MODE = 1, POLICY_SPEC_PRESET = 2, POLICY_SPEC_SUBSTEPS = 3, POLICY_SPEC_GOAL = 4, POLICY_SPEC_GROUND = 5, POLICY_SPEC_FOOT_COUNT = 6, POLICY_SPEC_FEET = 7, POLICY_MAX_FEET = 4, POLICY_MAX_HEADS = 4, POLICY_SPEC_WORDS = (7) + (4), POLICY_JOINT_OBSERVATIONS = 6, POLICY_ROOT_OBSERVATIONS = 11, POLICY_JOINT_ACTIONS = 3, POLICY_ACTION_MODES = ["orientation", "axes"], POLICY_DRIVE_PRESETS = ["soft", "firm", "stiff"], POLICY_NO_GROUND = 4294967295, POLICY_DEFAULT_SUBSTEPS = 2, NULL = 0, BYTE = 1;
+function engineRagdollPolicyExports(symbols) {
+  for (let name of ENGINE_RAGDOLL_POLICY_EXPORT_NAMES) if (typeof symbols[name] != "function") return null;
+  return symbols;
+}
+function writePolicySpec(out, spec) {
+  let feet = spec.feet ?? [];
+  if (feet.length > (4)) throw new GameError("invalid_argument", `a policy watches at most ${(4)} feet`);
+  out.fill(0, 0, POLICY_SPEC_WORDS), out[(0)] = (1), out[(1)] = POLICY_ACTION_MODES.indexOf(spec.mode ?? "axes"), out[(2)] = POLICY_DRIVE_PRESETS.indexOf(spec.preset ?? "firm"), out[(3)] = spec.substeps ?? (2), out[(4)] = spec.goal ?? 0, out[(5)] = spec.ground ?? (4294967295), out[(6)] = feet.length;
+  for (let k = 0; k < feet.length; k++) out[(7) + k] = feet[k];
+}
+function policyObservationSize(joints, spec) {
+  return joints * (6) + (11) + (spec.feet?.length ?? 0) + (spec.goal ?? 0);
+}
+function policyActionSize(joints) {
+  return joints * (3);
+}
+var RagdollPolicy = class {
+  constructor(session, exports, handle, goalSize) {
+    this.session = session;
+    this.exports = exports;
+    this.handle = handle;
+    this.closed = false;
+    this.goal = session.memory.allocate("f32", Math.max(goalSize, 1));
+  }
+  control(goal = []) {
+    if (this.closed) throw new GameError("unknown_resource", "this ragdoll policy was destroyed");
+    for (let k = 0; k < goal.length && k < this.goal.length; k++) this.goal[k] = goal[k];
+    let s = this.session;
+    s.flush(), s.check(this.exports.engine_ragdoll_policy_control(this.handle, s.require(), this.goal.byteOffset), "ragdoll policy");
+  }
+  destroy() {
+    this.closed || (this.closed = true, this.exports.engine_ragdoll_policy_destroy(this.handle));
+  }
+}, RagdollPolicies = class _RagdollPolicies {
+  constructor(session, exports) {
+    this.session = session;
+    this.exports = exports;
+    this.spec = session.memory.allocate("u32", POLICY_SPEC_WORDS);
+  }
+  static of(session) {
+    let exports = engineRagdollPolicyExports(session.symbols);
+    return exports ? new _RagdollPolicies(session, exports) : null;
+  }
+  world() {
+    return this.session.flush(), this.session.require();
+  }
+  mjcf(ragdoll, spec = {}) {
+    writePolicySpec(this.spec, spec);
+    let world = this.world(), length = this.session.check(this.exports.engine_ragdoll_mjcf(world, ragdoll.id, this.spec.byteOffset, (0), 0), "ragdoll mjcf"), out = this.session.memory.allocate("u8", Math.max(length, (1)));
+    return this.session.check(this.exports.engine_ragdoll_mjcf(world, ragdoll.id, this.spec.byteOffset, out.byteOffset, length), "ragdoll mjcf"), new TextDecoder().decode(out.subarray(0, length));
+  }
+  observe(ragdoll, spec, goal, out) {
+    return writePolicySpec(this.spec, spec), this.session.check(this.exports.engine_ragdoll_observe(this.world(), ragdoll.id, this.spec.byteOffset, goal.byteOffset, out.byteOffset, out.length), "ragdoll observe");
+  }
+  act(ragdoll, spec, action) {
+    writePolicySpec(this.spec, spec), this.session.check(this.exports.engine_ragdoll_act(this.world(), ragdoll.id, this.spec.byteOffset, action.byteOffset, action.length), "ragdoll act");
+  }
+  create(ragdoll, spec, heads) {
+    if (heads.length === 0 || heads.length > (4)) throw new GameError("invalid_argument", `a policy has 1 to ${(4)} heads`);
+    writePolicySpec(this.spec, spec);
+    let words = heads.reduce((sum, head) => sum + head.length + 1, 0), blobs = this.session.memory.allocate("u32", words), at = 0;
+    for (let head of heads)
+      blobs[at] = head.length, blobs.set(head, at + 1), at += head.length + 1;
+    let handle = this.exports.engine_ragdoll_policy_create(this.world(), ragdoll.id, this.spec.byteOffset, blobs.byteOffset, words, heads.length);
+    if (handle === (0)) throw new GameError("invalid_argument", "the engine refused the policy for that ragdoll");
+    return new RagdollPolicy(this.session, this.exports, handle, spec.goal ?? 0);
+  }
+};
+
+export { ENGINE_RAGDOLL_POLICY_EXPORT_NAMES, POLICY_ACTION_MODES, POLICY_DRIVE_PRESETS, RagdollPolicies, RagdollPolicy, policyActionSize, policyObservationSize };