@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-WHYKAT7G.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var chunkY4K22JL6_js = require('./chunk-Y4K22JL6.js');
+var chunkAZ5BGWHB_js = require('./chunk-AZ5BGWHB.js');
+
+// src/game/kit/templates/boxes.ts
+var BOX_X = 0, BOX_Y = 1, BOX_Z = 2, BOX_ROTATION = 3, BOX_SX = 7, BOX_SY = 8, BOX_SZ = 9, POSE = 10, COLOR_CHANNELS = 3, MAT4 = 16, CHANNEL_MAX = 255, HALF_EXTENT = 0.5, BoxBatch = class {
+  constructor(game, capacity, roughness = 0.7) {
+    this.box = new Float32Array((10));
+    this.count = 0;
+    this.game = game;
+    let geometry = game.graphics.createGeometry(chunkY4K22JL6_js.boxGeometry(1, 1, 1)), material = game.graphics.createMaterial({ kind: "standard", color: 16777215, roughness });
+    this.batch = game.graphics.instanced({ geometry, material, capacity, colors: true }), this.box[(3) + 3] = 1, this.box[(7)] = 1, this.box[(8)] = 1, this.box[(9)] = 1;
+  }
+  begin() {
+    this.count = 0;
+  }
+  add(rgb) {
+    if (this.count >= this.batch.capacity) return;
+    let p = this.box, i = this.count++;
+    chunkAZ5BGWHB_js.mat4ComposeArrays(this.batch.matrices, i * (16), p, (0), p, (3), p, (7));
+    let colors = this.batch.colors;
+    if (colors === null) return;
+    let c = i * (3);
+    colors[c] = (rgb >> 16 & (255)) / (255), colors[c + 1] = (rgb >> 8 & (255)) / (255), colors[c + 2] = (rgb & (255)) / (255);
+  }
+  sizes(sx, sy, sz) {
+    let p = this.box;
+    return p[(7)] = sx, p[(8)] = sy, p[(9)] = sz, this;
+  }
+  addAt(source, at, rgb, lift = 0) {
+    let p = this.box;
+    p[(0)] = source[at], p[(1)] = source[at + 1] + lift, p[(2)] = source[at + 2], this.add(rgb);
+  }
+  standAt(source, at, rgb) {
+    let p = this.box;
+    p[(0)] = source[at], p[(1)] = source[at + 1] + p[(8)] * (0.5), p[(2)] = source[at + 2], this.add(rgb);
+  }
+  end() {
+    this.game.graphics.setInstanceCount(this.batch, this.count), this.game.graphics.markInstancesDirty(this.batch);
+  }
+};
+function addSceneCamera(game, x, y, z, fov, pitch) {
+  let camera = game.world.spawn();
+  game.transforms.add(camera, x, y, z);
+  let half = pitch / 2;
+  game.transforms.setRotation(camera, Math.sin(half), 0, 0, Math.cos(half)), game.graphics.camera(camera, fov), game.audio.setListener(camera);
+  let sun = game.world.spawn();
+  game.transforms.add(sun, 3, 10, 4), game.graphics.create(sun, { kind: "light", light: "directional", intensity: 2 });
+  let sky = game.world.spawn();
+  return game.transforms.add(sky), game.graphics.create(sky, { kind: "light", light: "hemisphere", intensity: 0.7 }), camera;
+}
+
+exports.BOX_ROTATION = (3);
+exports.BOX_SX = (7);
+exports.BOX_SY = (8);
+exports.BOX_SZ = (9);
+exports.BOX_X = (0);
+exports.BOX_Y = (1);
+exports.BOX_Z = (2);
+exports.BoxBatch = BoxBatch;
+exports.addSceneCamera = addSceneCamera;

package/dist/{chunk-YOIVZ6OA.mjs → chunk-WIZRUIZB.mjs}

@@ -47,8 +47,7 @@ var ISO3_TO_COUNTRY_CODE = {
   VNM: "VN",
   ZAF: "ZA",
   ZMB: "ZM"
-};
-var CURRENCY_TO_COUNTRY_CODE = {
+}, CURRENCY_TO_COUNTRY_CODE = {
   AED: "AE",
   AOA: "AO",
   AUD: "AU",
@@ -94,84 +93,53 @@ var CURRENCY_TO_COUNTRY_CODE = {
   VND: "VN",
   ZAR: "ZA",
   ZMW: "ZM"
-};
-var CURRENCY_TO_CANDIDATE_COUNTRIES = {
+}, CURRENCY_TO_CANDIDATE_COUNTRIES = {
   EUR: ["DE", "FR", "IT", "ES", "NL", "BE", "AT", "PT", "IE", "FI", "GR"],
   USD: ["US", "EC", "PA", "SV"],
   XOF: ["SN", "CI", "BF", "ML", "NE", "TG", "BJ", "GW"],
   XAF: ["CM", "GA", "CG", "TD", "CF", "GQ"]
 };
 function normalizeCountryCode(value) {
-  const normalized = value?.trim().toUpperCase();
-  if (!normalized) {
-    return void 0;
-  }
-  if (normalized.length === 2) {
-    return normalized;
-  }
-  return ISO3_TO_COUNTRY_CODE[normalized];
+  let normalized = value?.trim().toUpperCase();
+  if (normalized)
+    return normalized.length === 2 ? normalized : ISO3_TO_COUNTRY_CODE[normalized];
 }
 function parsePhoneCandidate(value, country) {
   try {
     return country ? parsePhoneNumberFromString(value, country) : parsePhoneNumberFromString(value);
   } catch {
-    return void 0;
+    return;
   }
 }
 function resolvePhoneCountryCode(options = {}) {
-  const explicitCountry = normalizeCountryCode(options.country);
-  if (explicitCountry) {
+  let explicitCountry = normalizeCountryCode(options.country);
+  if (explicitCountry)
     return explicitCountry;
-  }
-  const currency = options.currency?.trim().toUpperCase();
-  if (!currency) {
-    return void 0;
-  }
-  return CURRENCY_TO_COUNTRY_CODE[currency];
+  let currency = options.currency?.trim().toUpperCase();
+  if (currency)
+    return CURRENCY_TO_COUNTRY_CODE[currency];
 }
 function normalizePhoneToE164(raw, options = {}) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
+  let trimmed = raw.trim();
+  if (!trimmed)
     return null;
-  }
-  const country = resolvePhoneCountryCode(options);
-  const digits = trimmed.replace(/\D/g, "");
-  const internationalDigits = digits.startsWith("00") ? digits.slice(2) : digits;
-  const attempts = [];
-  const seen = /* @__PURE__ */ new Set();
+  let country = resolvePhoneCountryCode(options), digits = trimmed.replace(/\D/g, ""), internationalDigits = digits.startsWith("00") ? digits.slice(2) : digits, attempts = [], seen = /* @__PURE__ */ new Set();
   function addAttempt(value, nextCountry) {
-    const key = `${nextCountry || ""}:${value}`;
-    if (seen.has(key)) {
-      return;
-    }
-    seen.add(key);
-    attempts.push({ value, country: nextCountry });
-  }
-  if (country) {
-    addAttempt(trimmed, country);
-  }
-  addAttempt(trimmed);
-  if (country && digits) {
-    addAttempt(digits, country);
-  }
-  if (internationalDigits) {
-    addAttempt(`+${internationalDigits}`);
+    let key = `${nextCountry || ""}:${value}`;
+    seen.has(key) || (seen.add(key), attempts.push({ value, country: nextCountry }));
   }
-  const currency = options.currency?.trim().toUpperCase();
+  country && addAttempt(trimmed, country), addAttempt(trimmed), country && digits && addAttempt(digits, country), internationalDigits && addAttempt(`+${internationalDigits}`);
+  let currency = options.currency?.trim().toUpperCase();
   if (currency) {
-    const candidates = CURRENCY_TO_CANDIDATE_COUNTRIES[currency];
-    if (candidates) {
-      for (const candidate of candidates) {
-        addAttempt(trimmed, candidate);
-        if (digits) addAttempt(digits, candidate);
-      }
-    }
+    let candidates = CURRENCY_TO_CANDIDATE_COUNTRIES[currency];
+    if (candidates)
+      for (let candidate of candidates)
+        addAttempt(trimmed, candidate), digits && addAttempt(digits, candidate);
   }
-  for (const attempt of attempts) {
-    const parsed = parsePhoneCandidate(attempt.value, attempt.country);
-    if (parsed?.isValid()) {
+  for (let attempt of attempts) {
+    let parsed = parsePhoneCandidate(attempt.value, attempt.country);
+    if (parsed?.isValid())
       return parsed.format("E.164");
-    }
   }
   return null;
 }

package/dist/chunk-WKWTDZS7.js

@@ -0,0 +1,385 @@
+'use strict';
+
+var chunkTJI3K6RP_js = require('./chunk-TJI3K6RP.js');
+var chunk4ZDR72SG_js = require('./chunk-4ZDR72SG.js');
+var chunkJ2KZXIU3_js = require('./chunk-J2KZXIU3.js');
+
+// 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 = chunk4ZDR72SG_js.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(chunkTJI3K6RP_js.SHA256_BYTES);
+  return chunkTJI3K6RP_js.sha256Into(node, digest), nodes.set(chunk4ZDR72SG_js.hexAt(digest, 0, chunkTJI3K6RP_js.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), !chunk4ZDR72SG_js.unhexAt(leaf.digest, body, at + (8), chunk4ZDR72SG_js.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: chunk4ZDR72SG_js.hexAt(top.digest, 0, chunkTJI3K6RP_js.SHA256_BYTES), parts: top.parts, bytes: top.bytes, height }, nodes };
+}
+function nodeMatches(node, expected, at) {
+  return node.length <= WEAVE_MAX_NODE_BYTES && chunkTJI3K6RP_js.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 chunk4ZDR72SG_js.hexAt(node, leafDigestAt(index), chunk4ZDR72SG_js.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(chunkTJI3K6RP_js.SHA256_BYTES);
+function verifyRoot(node, root) {
+  if (root.version !== (1) || !chunk4ZDR72SG_js.unhexAt(root.root, rootDigest, 0, chunkTJI3K6RP_js.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(chunk4ZDR72SG_js.hexAt(node, childDigestAt(i), chunk4ZDR72SG_js.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 = chunk4ZDR72SG_js.hexAt(node, childDigestAt(i), chunk4ZDR72SG_js.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(chunkTJI3K6RP_js.SHA256_BYTES);
+  return chunkTJI3K6RP_js.sha256Into(bytes, out), hex(out);
+}
+function keyIdOf(rawPublicKey) {
+  return sha256Hex(rawPublicKey).slice(0, (16));
+}
+function decodeKey(base64) {
+  try {
+    let bytes = chunkJ2KZXIU3_js.decodeBase64(base64);
+    return bytes.length === (32) ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+function decodeSignature(base64) {
+  try {
+    let bytes = chunkJ2KZXIU3_js.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 = chunkJ2KZXIU3_js.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;
+}
+
+exports.AUDIO_RELAY_EXPORT = AUDIO_RELAY_EXPORT;
+exports.AUDIO_WORKLET_FILE = AUDIO_WORKLET_FILE;
+exports.AUDIO_WORKLET_GROUP = AUDIO_WORKLET_GROUP;
+exports.AUDIO_WORKLET_PATH = AUDIO_WORKLET_PATH;
+exports.ENGINE_AUDIO_UNIT = ENGINE_AUDIO_UNIT;
+exports.WEAVE_BOUNDARY_MASK = (63);
+exports.WEAVE_CHILD_ENTRY_BYTES = (48);
+exports.WEAVE_HEAD_DOMAIN = WEAVE_HEAD_DOMAIN;
+exports.WEAVE_LEAF_DECORATED = (1);
+exports.WEAVE_LEAF_ENTRY_BYTES = (40);
+exports.WEAVE_LEAF_TWINNED = (2);
+exports.WEAVE_MAX_HEIGHT = (8);
+exports.WEAVE_MAX_NODE_BYTES = WEAVE_MAX_NODE_BYTES;
+exports.WEAVE_MAX_NODE_ENTRIES = (256);
+exports.WEAVE_MIN_NODE_ENTRIES = (16);
+exports.WEAVE_NODE_HEADER_BYTES = (16);
+exports.WEAVE_NODE_MAGIC = (1314281283);
+exports.WEAVE_NODE_ZONE = WEAVE_NODE_ZONE;
+exports.WEAVE_VERSION = (1);
+exports.WeaveRefusal = WeaveRefusal;
+exports.WeaveVerifyError = WeaveVerifyError;
+exports.buildWeave = buildWeave;
+exports.childDigestAt = childDigestAt;
+exports.chunkWeaveSource = chunkWeaveSource;
+exports.deliverSchedule = deliverSchedule;
+exports.leafAt = leafAt;
+exports.leafDigest = leafDigest;
+exports.leafDigestAt = leafDigestAt;
+exports.leafFlags = leafFlags;
+exports.leafLength = leafLength;
+exports.leafZone = leafZone;
+exports.nodeMatches = nodeMatches;
+exports.openWeaveHead = openWeaveHead;
+exports.openWeaveSession = openWeaveSession;
+exports.planWeave = planWeave;
+exports.storeWeaveSource = storeWeaveSource;
+exports.unweaveIndex = unweaveIndex;
+exports.validWeaveRoot = validWeaveRoot;
+exports.verifyChild = verifyChild;
+exports.verifyRoot = verifyRoot;
+exports.walkWeave = walkWeave;
+exports.weaveHeadMessage = weaveHeadMessage;
+exports.weaveNodeCount = weaveNodeCount;
+exports.weaveNodeLevel = weaveNodeLevel;
+exports.weaveNodeValid = weaveNodeValid;
+exports.weaveParts = weaveParts;
+exports.woven = woven;

package/dist/chunk-WLMINRC4.mjs

@@ -0,0 +1,78 @@
+import { UiStyleError, DEFAULT_THEME } from './chunk-RFVRPYR2.mjs';
+
+// src/interactives/game-ui/styling/vars.ts
+var FNV_OFFSET = 2166136261, FNV_PRIME = 16777619, VAR_ID_MASK = 1073741823;
+function varId(namespace, key) {
+  let text = `${namespace}.${key}`, hash = (2166136261);
+  for (let i = 0; i < text.length; i++)
+    hash ^= text.charCodeAt(i), hash = Math.imul(hash, (16777619));
+  return hash >>> 0 & (1073741823);
+}
+var UiVar = class {
+  constructor(id, name, fallback) {
+    this.id = id;
+    this.name = name;
+    this.fallback = fallback;
+  }
+}, UiSlot = class {
+  constructor(index, percent = false) {
+    this.index = index;
+    this.percent = percent;
+  }
+}, defaults = /* @__PURE__ */ new Map(), names = /* @__PURE__ */ new Map();
+function varDefault(id) {
+  return defaults.get(id);
+}
+function defineVars(namespace, values) {
+  let group = {};
+  for (let key of Object.keys(values)) {
+    let name = `${namespace}.${key}`, id = varId(namespace, key), known = names.get(id);
+    if (known !== void 0 && known !== name) throw new UiStyleError(`style variable ${name} collides with ${known}; rename one of them`);
+    names.set(id, name), defaults.set(id, values[key]), group[key] = new UiVar(id, name, values[key]);
+  }
+  return Object.freeze(group);
+}
+var UiTheme = class {
+  constructor(values) {
+    this.values = values;
+  }
+};
+function createTheme(group, overrides) {
+  let values = /* @__PURE__ */ new Map();
+  for (let key of Object.keys(overrides)) {
+    let variable = group[key];
+    if (variable === void 0) throw new UiStyleError(`theme sets ${key}, which the variable group does not define`);
+    let value = overrides[key];
+    value !== void 0 && values.set(variable.id, value);
+  }
+  return new UiTheme(values);
+}
+function mergeThemes(themes) {
+  let values = /* @__PURE__ */ new Map();
+  for (let theme of themes) for (let [id, value] of theme.values) values.set(id, value);
+  return new UiTheme(values);
+}
+
+// src/interactives/game-ui/styling/tokens.ts
+var TOKEN_NAMESPACE = "ui";
+function palette(theme) {
+  return {
+    surface: theme.surface,
+    raised: theme.raised,
+    border: theme.border,
+    accent: theme.accent,
+    onAccent: theme.on_accent,
+    text: theme.text,
+    muted: theme.muted,
+    track: theme.track,
+    danger: theme.danger,
+    success: theme.success,
+    gold: theme.gold
+  };
+}
+var tokens = defineVars(TOKEN_NAMESPACE, palette(DEFAULT_THEME));
+function themeTokens(theme) {
+  return createTheme(tokens, palette(theme));
+}
+
+export { TOKEN_NAMESPACE, UiSlot, UiTheme, UiVar, createTheme, defineVars, mergeThemes, themeTokens, tokens, varDefault, varId };

package/dist/chunk-WOF3AD3J.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// src/genui/segments.ts
+var FENCE_PATTERN = /```genui\s*\n([\s\S]*?)(?:```|$)/g;
+function splitGenUIContent(content) {
+  let segments = [], cursor = 0;
+  for (let match of content.matchAll(FENCE_PATTERN)) {
+    let prose = content.slice(cursor, match.index).trim();
+    prose && segments.push({ kind: "prose", text: prose });
+    let source = match[1].trim();
+    source && segments.push({ kind: "program", source }), cursor = match.index + match[0].length;
+  }
+  let tail = content.slice(cursor).trim();
+  return tail && segments.push({ kind: "prose", text: tail }), segments;
+}
+function messagePreview(content, max = 90) {
+  let prose = splitGenUIContent(content).filter((segment) => segment.kind === "prose").map((segment) => segment.text).join(" ").replace(/\s+/g, " ").trim();
+  return prose ? prose.length > max ? `${prose.slice(0, max)}\u2026` : prose : "Structured answer";
+}
+
+exports.messagePreview = messagePreview;
+exports.splitGenUIContent = splitGenUIContent;