@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-ZR5ULMN2.mjs

@@ -0,0 +1,337 @@
+import { SHA256_BYTES, sha256Matches, sha256Into } from './chunk-5YWN6H5Q.mjs';
+import { unhexAt, DIGEST_BYTES, hexAt } from './chunk-V7ZRH3PY.mjs';
+import { decodeBase64 } from './chunk-2IC4H6OV.mjs';
+
+// src/interactives/audio-worklet.ts
+var ENGINE_AUDIO_UNIT = "@cimplify/engine-audio", AUDIO_WORKLET_GROUP = "audio:worklet", AUDIO_WORKLET_PATH = "runtime/engine-audio.wasm", AUDIO_WORKLET_FILE = "engine_audio_web.wasm", AUDIO_RELAY_EXPORT = "engine_audio_relay_create";
+
+// src/interactives/parts/weave.ts
+var WEAVE_VERSION = 1, WEAVE_NODE_MAGIC = 1314281283, WEAVE_NODE_HEADER_BYTES = 16, WEAVE_LEAF_ENTRY_BYTES = 40, WEAVE_CHILD_ENTRY_BYTES = 48, WEAVE_MIN_NODE_ENTRIES = 16, WEAVE_MAX_NODE_ENTRIES = 256, WEAVE_BOUNDARY_MASK = 63, WEAVE_MAX_HEIGHT = 8, WEAVE_MAX_NODE_BYTES = (16) + (256) * (48), WEAVE_LEAF_DECORATED = 1, WEAVE_LEAF_TWINNED = 2, WEAVE_HEAD_DOMAIN = `cimplify-weave-head-v1
+`, WEAVE_NODE_ZONE = "weave:nodes", LEAF_LEVEL = 0, BOUNDARY_BYTE = DIGEST_BYTES - 1, VERSION_AT = 4, LEVEL_AT = 5, COUNT_AT = 6, RESERVED_AT = 8, LEAF_FLAGS_AT = 2, LEAF_PAD_AT = 3, LEAF_LENGTH_AT = 4, LEAF_DIGEST_AT = 8, CHILD_LAST_ZONE_AT = 2, CHILD_PARTS_AT = 4, CHILD_BYTES_AT = 8, CHILD_DIGEST_AT = 16, TWO_32 = 4294967296, FETCH_WINDOW = 8, WeaveRefusal = {
+  digest: "digest",
+  malformed: "malformed",
+  summary: "summary",
+  height: "height",
+  missing: "missing",
+  head: "head"
+}, WeaveVerifyError = class extends Error {
+  constructor(refusal, digest) {
+    super(`weave node ${digest} is refused: ${refusal}`);
+    this.refusal = refusal;
+    this.digest = digest;
+    this.name = "WeaveVerifyError";
+  }
+};
+function view(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function boundary(digest, at, count) {
+  return count >= (16) && (digest[at + BOUNDARY_BYTE] & (63)) === 0;
+}
+function seal(level, entryBytes, count, body, nodes, summary) {
+  let node = new Uint8Array((16) + count * entryBytes), v = view(node);
+  v.setUint32(0, (1314281283), true), node[(4)] = (1), node[(5)] = level, v.setUint16((6), count, true), node.set(body.subarray(0, count * entryBytes), (16));
+  let digest = new Uint8Array(SHA256_BYTES);
+  return sha256Into(node, digest), nodes.set(hexAt(digest, 0, SHA256_BYTES), node), { ...summary, digest };
+}
+function buildWeave(leaves) {
+  if (leaves.length === 0) throw new WeaveVerifyError(WeaveRefusal.malformed, "");
+  let nodes = /* @__PURE__ */ new Map(), body = new Uint8Array((256) * (48)), bv = view(body), level = [], count = 0, summary = { firstZone: 0, lastZone: 0, parts: 0, bytes: 0 };
+  for (let i = 0; i < leaves.length; i++) {
+    let leaf = leaves[i];
+    count === 0 && (summary = { firstZone: leaf.zone, lastZone: leaf.zone, parts: 0, bytes: 0 });
+    let at = count * (40);
+    if (bv.setUint16(at, leaf.zone, true), body[at + (2)] = leaf.flags, body[at + (3)] = 0, bv.setUint32(at + (4), leaf.length, true), !unhexAt(leaf.digest, body, at + (8), DIGEST_BYTES)) throw new WeaveVerifyError(WeaveRefusal.malformed, leaf.digest);
+    count++, summary.parts++, summary.bytes += leaf.length;
+    let next = leaves[i + 1];
+    (count === (256) || next === void 0 || next.zone !== leaf.zone || boundary(body, at + (8), count)) && (level.push(seal((0), (40), count, body, nodes, summary)), count = 0);
+  }
+  let height = 1;
+  for (; level.length > 1; ) {
+    if (height === (8)) throw new WeaveVerifyError(WeaveRefusal.height, "");
+    let parents = [];
+    count = 0;
+    for (let i = 0; i < level.length; i++) {
+      let child = level[i];
+      count === 0 && (summary = { firstZone: child.firstZone, lastZone: child.lastZone, parts: 0, bytes: 0 });
+      let at = count * (48);
+      bv.setUint16(at, child.firstZone, true), bv.setUint16(at + (2), child.lastZone, true), bv.setUint32(at + (4), child.parts, true), bv.setUint32(at + (8), child.bytes % (4294967296), true), bv.setUint32(at + (8) + 4, Math.floor(child.bytes / (4294967296)), true), body.set(child.digest, at + (16)), count++, summary.lastZone = child.lastZone, summary.parts += child.parts, summary.bytes += child.bytes, (count === (256) || i + 1 === level.length || boundary(child.digest, 0, count)) && (parents.push(seal(height, (48), count, body, nodes, summary)), count = 0);
+    }
+    level = parents, height++;
+  }
+  let top = level[0];
+  return { root: { version: (1), root: hexAt(top.digest, 0, SHA256_BYTES), parts: top.parts, bytes: top.bytes, height }, nodes };
+}
+function nodeMatches(node, expected, at) {
+  return node.length <= WEAVE_MAX_NODE_BYTES && sha256Matches(node, expected, at);
+}
+function weaveNodeLevel(node) {
+  return node[(5)];
+}
+function weaveNodeCount(node) {
+  return node[(6)] | node[(6) + 1] << 8;
+}
+function u16(node, at) {
+  return node[at] | node[at + 1] << 8;
+}
+function u32(node, at) {
+  return (node[at] | node[at + 1] << 8 | node[at + 2] << 16 | node[at + 3] << 24) >>> 0;
+}
+function weaveNodeValid(node) {
+  if (node.length < (16) || u32(node, 0) !== (1314281283) || node[(4)] !== (1)) return false;
+  for (let i = (8); i < (16); i++) if (node[i] !== 0) return false;
+  let level = node[(5)], count = weaveNodeCount(node), entry = level === (0) ? (40) : (48);
+  if (level >= (8) || count === 0 || count > (256) || node.length !== (16) + count * entry) return false;
+  if (level !== (0)) return true;
+  let zone = u16(node, (16));
+  for (let i = 0; i < count; i++) {
+    let at = (16) + i * (40);
+    if ((node[at + (2)] & -4) !== 0 || node[at + (3)] !== 0 || u16(node, at) !== zone) return false;
+  }
+  return true;
+}
+function leafAt(index) {
+  return (16) + index * (40);
+}
+function leafZone(node, index) {
+  return u16(node, leafAt(index));
+}
+function leafFlags(node, index) {
+  return node[leafAt(index) + (2)];
+}
+function leafLength(node, index) {
+  return u32(node, leafAt(index) + (4));
+}
+function leafDigestAt(index) {
+  return leafAt(index) + (8);
+}
+function leafDigest(node, index) {
+  return hexAt(node, leafDigestAt(index), DIGEST_BYTES);
+}
+function childAt(index) {
+  return (16) + index * (48);
+}
+function childDigestAt(index) {
+  return childAt(index) + (16);
+}
+function childBytes(node, at) {
+  return u32(node, at + (8)) + u32(node, at + (8) + 4) * (4294967296);
+}
+function summaryMatches(node, firstZone, lastZone, parts, bytes) {
+  let count = weaveNodeCount(node);
+  if (weaveNodeLevel(node) === (0)) {
+    let total = 0;
+    for (let i = 0; i < count; i++) total += leafLength(node, i);
+    let zone2 = leafZone(node, 0);
+    return zone2 === firstZone && zone2 === lastZone && count === parts && total === bytes;
+  }
+  let zone = u16(node, childAt(0));
+  if (zone !== firstZone) return false;
+  let sumParts = 0, sumBytes = 0;
+  for (let i = 0; i < count; i++) {
+    let at = childAt(i), first = u16(node, at), last = u16(node, at + (2));
+    if (first < zone || last < first) return false;
+    zone = last, sumParts += u32(node, at + (4)), sumBytes += childBytes(node, at);
+  }
+  return zone === lastZone && sumParts === parts && sumBytes === bytes;
+}
+function verifyChild(node, parent, index) {
+  let at = childAt(index);
+  return nodeMatches(node, parent, at + (16)) ? weaveNodeValid(node) ? weaveNodeLevel(node) !== weaveNodeLevel(parent) - 1 || !summaryMatches(node, u16(parent, at), u16(parent, at + (2)), u32(parent, at + (4)), childBytes(parent, at)) ? WeaveRefusal.summary : null : WeaveRefusal.malformed : WeaveRefusal.digest;
+}
+var rootDigest = new Uint8Array(SHA256_BYTES);
+function verifyRoot(node, root) {
+  if (root.version !== (1) || !unhexAt(root.root, rootDigest, 0, SHA256_BYTES)) return WeaveRefusal.malformed;
+  if (root.height < 1 || root.height > (8)) return WeaveRefusal.height;
+  if (!nodeMatches(node, rootDigest, 0)) return WeaveRefusal.digest;
+  if (!weaveNodeValid(node)) return WeaveRefusal.malformed;
+  if (weaveNodeLevel(node) !== root.height - 1) return WeaveRefusal.summary;
+  let leaf = weaveNodeLevel(node) === (0), first = leaf ? leafZone(node, 0) : u16(node, childAt(0)), last = leaf ? first : u16(node, childAt(weaveNodeCount(node) - 1) + (2));
+  return summaryMatches(node, first, last, root.parts, root.bytes) ? null : WeaveRefusal.summary;
+}
+function ignore() {
+}
+async function load(source, digest, tally) {
+  let local = await source.local(digest);
+  if (local !== null) return { node: local, fetched: false };
+  let node = await source.fetch(digest);
+  return tally.fetchedNodes++, tally.fetchedBytes += node.length, { node, fetched: true };
+}
+async function descend(node, digest, source, known, visit, tally) {
+  tally.nodes++, tally.digests.push(digest);
+  let changed = known === null || !known.has(digest);
+  changed && tally.changedNodes++;
+  let count = weaveNodeCount(node);
+  if (weaveNodeLevel(node) === (0)) {
+    for (let i = 0; i < count; i++) visit(node, i, changed);
+    tally.parts += count;
+    return;
+  }
+  let digests = [];
+  for (let i = 0; i < count; i++) digests.push(hexAt(node, childDigestAt(i), DIGEST_BYTES));
+  let pending = new Array(count).fill(null), started = 0;
+  for (let i = 0; i < count; i++) {
+    for (; started < count && started < i + (8); ) {
+      let loading = load(source, digests[started], tally);
+      loading.catch(ignore), pending[started++] = loading;
+    }
+    let { node: child, fetched } = await pending[i];
+    pending[i] = null;
+    let refusal = verifyChild(child, node, i);
+    if (refusal !== null) throw new WeaveVerifyError(refusal, digests[i]);
+    fetched && await source.admit?.(digests[i], child), await descend(child, digests[i], source, known, visit, tally);
+  }
+}
+async function knownNodes(old, source) {
+  let known = /* @__PURE__ */ new Set(), top = await source.local(old.root);
+  if (top === null || verifyRoot(top, old) !== null) return known;
+  let stack = [[top, old.root]];
+  for (; stack.length > 0; ) {
+    let [node, digest] = stack.pop();
+    if (known.add(digest), weaveNodeLevel(node) !== (0))
+      for (let i = weaveNodeCount(node) - 1; i >= 0; i--) {
+        let child = hexAt(node, childDigestAt(i), DIGEST_BYTES);
+        if (known.has(child)) continue;
+        let bytes = await source.local(child);
+        bytes !== null && verifyChild(bytes, node, i) === null && stack.push([bytes, child]);
+      }
+  }
+  return known;
+}
+async function walkWeave(root, source, visit, old = null) {
+  let tally = { nodes: 0, fetchedNodes: 0, fetchedBytes: 0, changedNodes: 0, parts: 0, digests: [] }, known = old === null ? null : await knownNodes(old, source), { node, fetched } = await load(source, root.root, tally), refusal = verifyRoot(node, root);
+  if (refusal !== null) throw new WeaveVerifyError(refusal, root.root);
+  if (fetched && await source.admit?.(root.root, node), await descend(node, root.root, source, known, visit, tally), tally.parts !== root.parts) throw new WeaveVerifyError(WeaveRefusal.summary, root.root);
+  return {
+    nodes: tally.nodes,
+    fetched_nodes: tally.fetchedNodes,
+    fetched_bytes: tally.fetchedBytes,
+    changed_nodes: tally.changedNodes,
+    parts: tally.parts,
+    node_digests: tally.digests
+  };
+}
+function weaveHeadMessage(head) {
+  let domain = new TextEncoder().encode(WEAVE_HEAD_DOMAIN), out = new Uint8Array(domain.length + head.length);
+  return out.set(domain, 0), out.set(head, domain.length), out;
+}
+function validWeaveRoot(value) {
+  let r = value;
+  return typeof r == "object" && r !== null && r.version === (1) && typeof r.root == "string" && /^[0-9a-f]{64}$/.test(r.root) && Number.isSafeInteger(r.parts) && r.parts > 0 && Number.isSafeInteger(r.bytes) && r.bytes >= 0 && Number.isInteger(r.height) && r.height >= 1 && r.height <= (8);
+}
+var KEY_ID_HEX = 16, ED25519_KEY_BYTES = 32, ED25519_SIGNATURE_BYTES = 64;
+var HEX = "0123456789abcdef", NIBBLE = 4, LOW_NIBBLE = 15;
+function hex(bytes) {
+  let out = "";
+  for (let byte of bytes) out += HEX[byte >> (4) & (15)] + HEX[byte & (15)];
+  return out;
+}
+function sha256Hex(bytes) {
+  let out = new Uint8Array(SHA256_BYTES);
+  return sha256Into(bytes, out), hex(out);
+}
+function keyIdOf(rawPublicKey) {
+  return sha256Hex(rawPublicKey).slice(0, (16));
+}
+function decodeKey(base64) {
+  try {
+    let bytes = decodeBase64(base64);
+    return bytes.length === (32) ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+function decodeSignature(base64) {
+  try {
+    let bytes = decodeBase64(base64);
+    return bytes.length === (64) ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/interactives/parts/weave-delivery.ts
+var LAZY_GROUP_PREFIX = "lazy:";
+function validHead(value) {
+  let h = value;
+  return typeof h == "object" && h !== null && typeof h.interactive_id == "string" && typeof h.revision_id == "string" && Array.isArray(h.asset_groups) && h.asset_groups.every((g) => typeof g?.name == "string" && typeof g.before_play == "boolean") && Array.isArray(h.chunks) && h.chunks.every((c) => typeof c?.digest == "string" && Number.isSafeInteger(c.size) && Number.isInteger(c.group)) && validWeaveRoot(h.weave);
+}
+function sameRoot(a, b) {
+  return a.version === b.version && a.root === b.root && a.parts === b.parts && a.bytes === b.bytes && a.height === b.height;
+}
+function openWeaveHead(weave, trust = null) {
+  let bytes, parsed;
+  try {
+    bytes = decodeBase64(weave.head), parsed = JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    throw new WeaveVerifyError(WeaveRefusal.head, weave.root.root);
+  }
+  if (!validHead(parsed) || !validWeaveRoot(weave.root) || !sameRoot(parsed.weave, weave.root)) throw new WeaveVerifyError(WeaveRefusal.head, weave.root.root);
+  if (trust !== null) {
+    let encoded = trust.keys[weave.key_id], key = encoded === void 0 ? null : decodeKey(encoded), signature = decodeSignature(weave.signature);
+    if (key === null || keyIdOf(key) !== weave.key_id || signature === null || !trust.verify(key, weaveHeadMessage(bytes), signature))
+      throw new WeaveVerifyError(WeaveRefusal.head, weave.root.root);
+  }
+  return parsed;
+}
+function storeWeaveSource(store, upstream) {
+  return {
+    local: (digest) => store.peek(digest),
+    fetch: (digest) => upstream.fetch(digest),
+    admit: (digest, node) => store.admit(digest, node)
+  };
+}
+function chunkWeaveSource(upstream) {
+  return {
+    local: () => Promise.resolve(null),
+    fetch: (digest) => upstream.fetch(digest)
+  };
+}
+function planWeave(head, store, upstream, old = null) {
+  return collectWeave(head, storeWeaveSource(store, upstream), old, (digest) => !store.has(digest));
+}
+function woven(index) {
+  return index.weave !== void 0 && index.chunks.length === 0;
+}
+async function unweaveIndex(index, nodes, trust = null, old = null) {
+  let weave = index.weave;
+  if (weave === void 0) throw new WeaveVerifyError(WeaveRefusal.head, "");
+  let plan = await collectWeave(openWeaveHead(weave, trust), nodes, old, null);
+  return { index: { ...index, chunks: plan.chunks }, plan };
+}
+async function collectWeave(head, source, old, missing) {
+  let chunks = [], schedule = [], scheduled = /* @__PURE__ */ new Set(), scheduleBytes = 0, decorated = 0, visit = (node, index, changed) => {
+    let digest = leafDigest(node, index), zone = leafZone(node, index), size = leafLength(node, index), group = head.asset_groups[zone];
+    if (group === void 0) throw new WeaveVerifyError(WeaveRefusal.summary, digest);
+    let runtime = null, payload = null, flags = leafFlags(node, index), twinned = (flags & (2)) !== 0;
+    if ((flags & (1)) !== 0) {
+      let extra = head.chunks[decorated++];
+      if (extra === void 0 || extra.digest !== digest || extra.group !== zone || extra.size !== size) throw new WeaveVerifyError(WeaveRefusal.head, digest);
+      if (typeof extra.brotli_bytes == "number" !== twinned) throw new WeaveVerifyError(WeaveRefusal.head, digest);
+      if (typeof extra.guest == "string") return;
+      runtime = extra.runtime ?? null, payload = extra.payload_digest ?? null;
+    }
+    chunks.push({ digest, size, asset_group: group.name, before_play: group.before_play, lazy: group.name.startsWith(LAZY_GROUP_PREFIX), runtime, payload_digest: payload, ...twinned ? { twinned: true } : {} }), !(missing === null || old !== null && !changed || scheduled.has(digest) || !missing(digest)) && (scheduled.add(digest), schedule.push({ digest, size, zone: group.name }), scheduleBytes += size);
+  }, walk = await walkWeave(head.weave, source, visit, old);
+  if (decorated !== head.chunks.length) throw new WeaveVerifyError(WeaveRefusal.head, head.weave.root);
+  return { head, chunks, schedule, schedule_bytes: scheduleBytes, walk };
+}
+function weaveParts(plan) {
+  let parts = plan.chunks.map((chunk) => ({ digest: chunk.digest, zone: chunk.asset_group }));
+  for (let digest of plan.walk.node_digests) parts.push({ digest, zone: WEAVE_NODE_ZONE });
+  return parts;
+}
+async function openWeaveSession(store, game, head, upstream, old = null, options = {}) {
+  let plan = await planWeave(head, store, upstream, old), session = store.session(game, weaveParts(plan), { keep_on_device: options.keep_on_device ?? head.keep_on_device === true });
+  return await session.installed, { plan, session };
+}
+async function deliverSchedule(session, upstream, schedule, signal) {
+  let source = session.source(upstream), bytes = 0;
+  for (let part of schedule) {
+    let body = await source.fetch(part.digest, signal);
+    bytes += body.length;
+  }
+  return bytes;
+}
+
+export { AUDIO_RELAY_EXPORT, AUDIO_WORKLET_FILE, AUDIO_WORKLET_GROUP, AUDIO_WORKLET_PATH, ENGINE_AUDIO_UNIT, WEAVE_BOUNDARY_MASK, WEAVE_CHILD_ENTRY_BYTES, WEAVE_HEAD_DOMAIN, WEAVE_LEAF_DECORATED, WEAVE_LEAF_ENTRY_BYTES, WEAVE_LEAF_TWINNED, WEAVE_MAX_HEIGHT, WEAVE_MAX_NODE_BYTES, WEAVE_MAX_NODE_ENTRIES, WEAVE_MIN_NODE_ENTRIES, WEAVE_NODE_HEADER_BYTES, WEAVE_NODE_MAGIC, WEAVE_NODE_ZONE, WEAVE_VERSION, WeaveRefusal, WeaveVerifyError, buildWeave, childDigestAt, chunkWeaveSource, deliverSchedule, leafAt, leafDigest, leafDigestAt, leafFlags, leafLength, leafZone, nodeMatches, openWeaveHead, openWeaveSession, planWeave, storeWeaveSource, unweaveIndex, validWeaveRoot, verifyChild, verifyRoot, walkWeave, weaveHeadMessage, weaveNodeCount, weaveNodeLevel, weaveNodeValid, weaveParts, woven };

package/dist/chunk-ZXREOYOW.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var chunkWWKMOA76_js = require('./chunk-WWKMOA76.js');
+
+// src/interactives/runtime/camera-wire.ts
+var CAMERA_TAG_BYTES = 1, CAMERA_WORD_BYTES = 4, CAMERA_ID_AT = (1), CAMERA_SECOND_AT = CAMERA_ID_AT + (4), CAMERA_HANDLE_BYTES = (1) + (4), CAMERA_PAIR_BYTES = CAMERA_HANDLE_BYTES + (4), CAMERA_COLOURED_BYTES = CAMERA_HANDLE_BYTES + (4) * 3, CAMERA_IDENTITY_CODE_AT = CAMERA_HANDLE_BYTES, CAMERA_IDENTIFIED_BYTES = CAMERA_IDENTITY_CODE_AT + 1, IDENTITY_CAPTURED = 0, IDENTITY_CODES = chunkWWKMOA76_js.CAMERA_LAYOUT.identity_codes;
+function identityCodeByte(code) {
+  return IDENTITY_CODES.indexOf(code) + 1;
+}
+var NO_CAMERA = 0, NO_FACE_COLOUR = -1, CameraOpenPurpose = { track: 0, view: 1 }, CAMERA_PURPOSE_AT = CAMERA_HANDLE_BYTES, CAMERA_OPEN_BYTES = CAMERA_HANDLE_BYTES + 1, CameraViewFlag = { shown: 1, mirror: 2, over: 4 }, CAMERA_PLACE_X_AT = CAMERA_HANDLE_BYTES, CAMERA_PLACE_FLAGS_AT = CAMERA_PLACE_X_AT + (4) * 4, CAMERA_PLACE_BYTES = CAMERA_PLACE_FLAGS_AT + 1, FACE_FRAME = {
+  sequence: 0,
+  faces: 1,
+  measured: 2,
+  header_words: 3,
+  expression_floats: chunkWWKMOA76_js.FACE_LAYOUT.expressions.length,
+  arkit_floats: chunkWWKMOA76_js.FACE_LAYOUT.arkit.length,
+  pose_floats: chunkWWKMOA76_js.FACE_LAYOUT.head_pose.length
+}, FACE_FLOATS = FACE_FRAME.expression_floats + FACE_FRAME.arkit_floats + FACE_FRAME.pose_floats, FACE_ARKIT_AT = FACE_FRAME.expression_floats, FACE_POSE_AT = FACE_ARKIT_AT + FACE_FRAME.arkit_floats, FACE_FRAME_BYTES = (FACE_FRAME.header_words + FACE_FLOATS) * (4), FACE_PAYLOAD_OFFSET = FACE_FRAME.faces * (4), FACE_PAYLOAD_BYTES = FACE_FRAME_BYTES - FACE_PAYLOAD_OFFSET, FACE_FLOATS_AT = (FACE_FRAME.header_words - FACE_FRAME.faces) * (4), CAMERA_FACE_BYTES = CAMERA_HANDLE_BYTES + FACE_PAYLOAD_BYTES, CameraRefusal = {
+  noGrant: "no_face_tracking_grant",
+  noPreview: "no_preview_grant",
+  denied: "camera_denied",
+  unavailable: "camera_unavailable",
+  busy: "camera_busy",
+  notOpen: "stream_not_open",
+  badPlacement: "camera_bad_placement"
+}; ({
+  mirror: chunkWWKMOA76_js.CAMERA_LAYOUT.view_default_mirror,
+  layer: chunkWWKMOA76_js.CAMERA_LAYOUT.view_default_layer
+});
+function readSigned(bytes, at) {
+  return bytes[at] | bytes[at + 1] << 8 | bytes[at + 2] << 16 | bytes[at + 3] << 24;
+}
+function readWord(bytes, at) {
+  return readSigned(bytes, at) >>> 0;
+}
+function writeWord(bytes, at, value) {
+  bytes[at] = value & 255, bytes[at + 1] = value >>> 8 & 255, bytes[at + 2] = value >>> 16 & 255, bytes[at + 3] = value >>> 24 & 255;
+}
+var floatScratch = new Float32Array(1), floatBytes = new Uint8Array(floatScratch.buffer);
+function readFloat(bytes, at) {
+  return floatBytes[0] = bytes[at], floatBytes[1] = bytes[at + 1], floatBytes[2] = bytes[at + 2], floatBytes[3] = bytes[at + 3], floatScratch[0];
+}
+
+// src/interactives/runtime/jsc-camera.ts
+({
+  expression_floats: chunkWWKMOA76_js.FACE_LAYOUT.expressions.length,
+  pose_floats: chunkWWKMOA76_js.FACE_LAYOUT.head_pose.length
+});
+var IdentityCaptureError = class extends Error {
+  constructor(code) {
+    super(`the identity capture ended: ${code}`);
+    this.code = code;
+    this.name = "IdentityCaptureError";
+  }
+};
+
+exports.CAMERA_COLOURED_BYTES = CAMERA_COLOURED_BYTES;
+exports.CAMERA_FACE_BYTES = CAMERA_FACE_BYTES;
+exports.CAMERA_HANDLE_BYTES = CAMERA_HANDLE_BYTES;
+exports.CAMERA_IDENTIFIED_BYTES = CAMERA_IDENTIFIED_BYTES;
+exports.CAMERA_IDENTITY_CODE_AT = CAMERA_IDENTITY_CODE_AT;
+exports.CAMERA_ID_AT = CAMERA_ID_AT;
+exports.CAMERA_OPEN_BYTES = CAMERA_OPEN_BYTES;
+exports.CAMERA_PAIR_BYTES = CAMERA_PAIR_BYTES;
+exports.CAMERA_PLACE_BYTES = CAMERA_PLACE_BYTES;
+exports.CAMERA_PLACE_FLAGS_AT = CAMERA_PLACE_FLAGS_AT;
+exports.CAMERA_PLACE_X_AT = CAMERA_PLACE_X_AT;
+exports.CAMERA_PURPOSE_AT = CAMERA_PURPOSE_AT;
+exports.CAMERA_SECOND_AT = CAMERA_SECOND_AT;
+exports.CAMERA_WORD_BYTES = (4);
+exports.CameraOpenPurpose = CameraOpenPurpose;
+exports.CameraRefusal = CameraRefusal;
+exports.CameraViewFlag = CameraViewFlag;
+exports.FACE_ARKIT_AT = FACE_ARKIT_AT;
+exports.FACE_FLOATS = FACE_FLOATS;
+exports.FACE_FLOATS_AT = FACE_FLOATS_AT;
+exports.FACE_FRAME = FACE_FRAME;
+exports.FACE_PAYLOAD_BYTES = FACE_PAYLOAD_BYTES;
+exports.FACE_POSE_AT = FACE_POSE_AT;
+exports.IDENTITY_CAPTURED = (0);
+exports.IdentityCaptureError = IdentityCaptureError;
+exports.NO_CAMERA = (0);
+exports.NO_FACE_COLOUR = (-1);
+exports.identityCodeByte = identityCodeByte;
+exports.readFloat = readFloat;
+exports.readWord = readWord;
+exports.writeWord = writeWord;

package/dist/{client-BSP9U1O1.d.mts → client-CX_WR0-J.d.mts}

@@ -1,5 +1,5 @@
-import { C as CimplifyClient } from './catalogue-OT89_Ifs.mjs';
-import { A as AppHandle, C as CreateAppOptions } from './server-B6dW7-Lj.mjs';
+import { C as CimplifyClient } from './catalogue-CPTMyBUz.mjs';
+import { A as AppHandle, C as CreateAppOptions } from './server-DQMWPnc8.mjs';
 
 /**
  * Test client + fixtures.

package/dist/client-Dytx_ZTC.d.ts

@@ -0,0 +1,230 @@
+import { T as TransportKind, R as RoomDialer } from './link-BUTqGmyi.js';
+
+interface Motion {
+    readonly toleranceUnits: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    spawn(slot: number): void;
+    steer(axisX: number, axisZ: number, buttons: number): void;
+    step(): void;
+    place(x: number, y: number, z: number): void;
+}
+type MotionFactory = (simulationHz: number, physicsHz: number) => Motion;
+declare class LocomotionMotion implements Motion {
+    readonly toleranceUnits = 0;
+    private readonly body;
+    private readonly locomotion;
+    constructor(simulationHz: number, physicsHz: number);
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    spawn(slot: number): void;
+    steer(axisX: number, axisZ: number, buttons: number): void;
+    step(): void;
+    place(x: number, _y: number, z: number): void;
+}
+declare const locomotionMotion: MotionFactory;
+
+interface NetworkMemory {
+    recall(network: string, nowMs: number): TransportKind | null;
+    remember(network: string, transport: TransportKind, nowMs: number): void;
+}
+declare class InMemoryNetworkMemory implements NetworkMemory {
+    private readonly entries;
+    recall(network: string, nowMs: number): TransportKind | null;
+    remember(network: string, transport: TransportKind, nowMs: number): void;
+}
+declare class StorageNetworkMemory implements NetworkMemory {
+    private readonly fallback;
+    recall(network: string, nowMs: number): TransportKind | null;
+    remember(network: string, transport: TransportKind, nowMs: number): void;
+}
+declare function currentNetwork(): string;
+
+declare const RoomPhase: {
+    readonly Idle: 0;
+    readonly Ticketing: 1;
+    readonly Connecting: 2;
+    readonly Joined: 3;
+    readonly Waiting: 4;
+    readonly Refused: 5;
+    readonly Closed: 6;
+};
+type RoomPhase = (typeof RoomPhase)[keyof typeof RoomPhase];
+interface ChannelSink {
+    deliver(slot: number, sender: number, view: DataView, offset: number, length: number): void;
+}
+interface RoomClientOptions {
+    readonly tickets: () => Promise<Uint8Array>;
+    readonly primary?: RoomDialer | null;
+    readonly fallback?: RoomDialer | null;
+    readonly physicsHz?: number;
+    readonly memory?: NetworkMemory;
+    readonly network?: () => string;
+    readonly channels?: ChannelSink | null;
+    readonly motion?: MotionFactory;
+    readonly spectatorAckEvery?: number;
+}
+declare const GAME_CHANNEL_SLOTS: 64;
+declare const GAME_CHANNEL_RELIABLE_BASE: 32;
+interface RoomPose {
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+    animation: number;
+}
+interface RoomPresence {
+    tick: number;
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+    animation: number;
+    flags: number;
+}
+interface RoomStats {
+    slot: number;
+    transport: TransportKind | null;
+    corrections: number;
+    maxCorrectionM: number;
+    meanCorrectionM: number;
+    inputsSent: number;
+    snapshots: number;
+    deltas: number;
+    keyframes: number;
+    missingBaselines: number;
+    rttMs: number;
+    interpolationDelayMs: number;
+    extrapolatingFrames: number;
+    paceChanges: number;
+    reconnects: number;
+    dropped: number;
+    sendFailures: number;
+    sendStride: number;
+    statesShed: number;
+}
+declare class RoomClient {
+    private readonly tickets;
+    private readonly physicsHz;
+    private readonly connector;
+    private readonly queue;
+    private readonly outbound;
+    private readonly reply;
+    private readonly ack;
+    private readonly streamAcks;
+    private readonly clock;
+    private readonly ticker;
+    private readonly governor;
+    private seenSendFailures;
+    private leadBoost;
+    private readonly log;
+    private readonly store;
+    private readonly tracks;
+    private readonly units;
+    private readonly appliedShort;
+    private readonly appliedSequence;
+    private readonly remoteSlots;
+    private readonly roomInput;
+    private readonly channelSink;
+    private readonly channelHeader;
+    private readonly channelMessage;
+    private channelSequence;
+    private readonly statistics;
+    private readonly motionFactory;
+    private predictor;
+    private predictorRates;
+    private link;
+    private stateValue;
+    private pendingTicket;
+    private ticketFailed;
+    private resumeToken;
+    private joinVersion;
+    private request;
+    private admittedAt;
+    private dialStartedAt;
+    private retryAt;
+    private lastUpdate;
+    private outboundNext;
+    private appliedNext;
+    private remoteCountValue;
+    private joins;
+    private slotValue;
+    private watcher;
+    private started;
+    private freshSnapshot;
+    private lastReconciled;
+    private extrapolating;
+    private ownTick;
+    private ownX;
+    private ownY;
+    private ownZ;
+    private ownVelocityX;
+    private ownVelocityZ;
+    private inputAxisX;
+    private inputAxisZ;
+    private inputYaw;
+    private inputButtons;
+    private inputSubtick;
+    private commandSequence;
+    private cameraSequence;
+    private cameraX;
+    private cameraZ;
+    private cameraRadius;
+    private cameraDirty;
+    private cameraSentAt;
+    private readonly spectatorAckEvery;
+    private unackedSnapshots;
+    constructor(options: RoomClientOptions);
+    get state(): RoomPhase;
+    get slot(): number;
+    ackStream(slot: number, sequence: () => number): void;
+    get watching(): boolean;
+    get extrapolatingLocal(): boolean;
+    get serverTick(): number;
+    get remoteCount(): number;
+    remoteSlot(index: number): number;
+    get stats(): RoomStats;
+    start(nowMs: number): void;
+    close(): void;
+    setInput(axisX: number, axisZ: number, yawRadians: number, buttons: number, nowMs: number): void;
+    setCamera(xMetres: number, zMetres: number, radiusMetres: number): void;
+    sendCommand(action: number, payload: Uint8Array, length: number): number;
+    sendChannel(slot: number, payload: Uint8Array, length: number): number;
+    update(nowMs: number): void;
+    localPose(out: RoomPose, nowMs: number): boolean;
+    presence(slot: number, out: RoomPresence): boolean;
+    remotePose(slot: number, out: RoomPose, nowMs: number): boolean;
+    private capTicks;
+    private fetchTicket;
+    private readonly ticketArrived;
+    private readonly ticketRefused;
+    private dial;
+    private begin;
+    private connecting;
+    private waitAndRetry;
+    private reconnect;
+    private joined;
+    private govern;
+    private drain;
+    private channel;
+    private snapshot;
+    private observeOwn;
+    private acknowledged;
+    private applied;
+    private beginSession;
+    private reconcile;
+    private play;
+    private leadDebt;
+    private cameraDue;
+    private packet;
+    private send;
+    private writeCamera;
+    private receivedMask;
+    private watchLatency;
+}
+declare function sendsOn(tick: number, simulationHz: number, sendHz: number): boolean;
+declare function previousSend(tick: number, simulationHz: number, sendHz: number): number;
+
+export { type ChannelSink as C, GAME_CHANNEL_RELIABLE_BASE as G, InMemoryNetworkMemory as I, LocomotionMotion as L, type Motion as M, type NetworkMemory as N, RoomClient as R, StorageNetworkMemory as S, type RoomClientOptions as a, GAME_CHANNEL_SLOTS as b, type MotionFactory as c, RoomPhase as d, type RoomPose as e, type RoomPresence as f, type RoomStats as g, currentNetwork as h, locomotionMotion as l, previousSend as p, sendsOn as s };

package/dist/{client-B878xeAP.d.ts → client-dqOhP9Nc.d.ts}

@@ -1,5 +1,5 @@
-import { C as CimplifyClient } from './catalogue-B4eLL8Mi.js';
-import { A as AppHandle, C as CreateAppOptions } from './server-Dckg4Vdr.js';
+import { C as CimplifyClient } from './catalogue-OTuS5zp-.js';
+import { A as AppHandle, C as CreateAppOptions } from './server-D29IIuDV.js';
 
 /**
  * Test client + fixtures.