@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-NPSYB6DC.mjs

@@ -0,0 +1,906 @@
+import { RoomClient } from './chunk-M5EXQZYY.mjs';
+
+// src/interactives/worlds/protocol.ts
+var NO_BUILDER = 65535, QUATERNION_SCALE = 32767, SCALE_UNIT_PERMILLE = 1e3, MILLIMETRES_PER_METRE = 1e3, WORLD_EXTENT_MM = 255996, CENTIDEGREES_PER_TURN = 36e3, Action = {
+  Place: 22273,
+  Select: 22274,
+  ClearSelection: 22275,
+  TransformSelection: 22276,
+  SetTransform: 22277,
+  DuplicateSelection: 22278,
+  DeleteSelection: 22279,
+  Undo: 22280,
+  Redo: 22281,
+  Settings: 22282,
+  Moderate: 22283,
+  ShareCopy: 22284,
+  JoinCopy: 22285,
+  Clock: 22286
+}, MessageKind = {
+  Upsert: 1,
+  Remove: 2,
+  Result: 3,
+  Durable: 4,
+  Settings: 5,
+  Begin: 6,
+  End: 7,
+  Lock: 8,
+  Welcome: 9,
+  Author: 10,
+  Palette: 11,
+  Shared: 12,
+  Notice: 13,
+  Clock: 14
+}, Status = {
+  Applied: 0,
+  Denied: 1,
+  Invalid: 2,
+  Conflict: 3,
+  Limit: 4,
+  Unlicensed: 5,
+  Nothing: 6,
+  Full: 7,
+  UnknownCode: 8,
+  Muted: 9
+}, Notice = {
+  Kicked: 0,
+  Banned: 1,
+  Muted: 2,
+  Unmuted: 3,
+  RoleChanged: 4,
+  Moved: 5
+}, SNAP_GRID = 1, SNAP_SURFACE = 2, SelectMode = { Replace: 0, Add: 1, Remove: 2 }, Sanction = { Kick: 0, Mute: 1, Unmute: 2, Ban: 3 }, WorldRoleCode = { Visitor: 0, Builder: 1, CoBuilder: 2, Moderator: 3, Owner: 4 }, Sky = { Clear: 0, Sunset: 1, Overcast: 2, Night: 3 }, Ground = { Grass: 0, Sand: 1, Concrete: 2, Water: 3 }, Lighting = { Day: 0, GoldenHour: 1, Night: 2 }, Visibility = { Private: 0, Friends: 1, Unlisted: 2, Public: 3 }, Likeness = { Fictional: 0, OptedIn: 1, Unclaimed: 2, Landmark: 3 }, POSITION = 0, ROTATION = 3, SCALE = 7, TRANSFORM_WORDS = 10;
+function identityTransform(out = new Float64Array((10))) {
+  return out[0] = 0, out[1] = 0, out[2] = 0, out[3] = 0, out[4] = 0, out[5] = 0, out[6] = 32767, out[7] = 1e3, out[8] = 1e3, out[9] = 1e3, out;
+}
+var LITTLE = true, U8 = 1, U16 = 2, U32 = 4, OP_ID_BYTES = 4, MAX_TEXT_BYTES = 255, UTF8 = new TextEncoder(), CommandWriter = class {
+  constructor(capacity = 256) {
+    this.offset = 0;
+    this.bytes = new Uint8Array(capacity), this.view = new DataView(this.bytes.buffer);
+  }
+  get length() {
+    return this.offset;
+  }
+  begin(opId) {
+    return this.offset = 0, this.u32(opId);
+  }
+  u8(value) {
+    return this.view.setUint8(this.offset, value), this.offset += (1), this;
+  }
+  u16(value) {
+    return this.view.setUint16(this.offset, value, (true)), this.offset += (2), this;
+  }
+  i16(value) {
+    return this.view.setInt16(this.offset, value, (true)), this.offset += (2), this;
+  }
+  u32(value) {
+    return this.view.setUint32(this.offset, value >>> 0, (true)), this.offset += (4), this;
+  }
+  i32(value) {
+    return this.view.setInt32(this.offset, value | 0, (true)), this.offset += (4), this;
+  }
+  transform(t) {
+    return this.i32(t[(0)]).i32(t[(0) + 1]).i32(t[(0) + 2]), this.i16(t[(3)]).i16(t[(3) + 1]).i16(t[(3) + 2]).i16(t[(3) + 3]), this.u16(t[(7)]).u16(t[(7) + 1]).u16(t[(7) + 2]);
+  }
+  text(text) {
+    let start = this.offset + (1), end = Math.min(start + (255), this.bytes.length), written = UTF8.encodeInto(text, this.bytes.subarray(start, end)).written;
+    return this.u8(written), this.offset += written, this;
+  }
+};
+function encodePlace(w, opId, item, snap, transform) {
+  return w.begin(opId).u16(item).u8(snap).u8(0).transform(transform).length;
+}
+function encodeSelect(w, opId, mode, ids, count) {
+  let n = Math.min(count, 62);
+  w.begin(opId).u8(mode).u8(n);
+  for (let i = 0; i < n; i++) w.u32(ids[i]);
+  return w.length;
+}
+function encodeBare(w, opId) {
+  return w.begin(opId).length;
+}
+function encodeTransformSelection(w, opId, snap, dx, dy, dz, rotation, scalePermille) {
+  return w.begin(opId).u8(snap).u8(0).i32(dx).i32(dy).i32(dz), w.i16(rotation[0]).i16(rotation[1]).i16(rotation[2]).i16(rotation[3]), w.u16(scalePermille).length;
+}
+function encodeSetTransform(w, opId, id, snap, transform) {
+  return w.begin(opId).u32(id).u8(snap).u8(0).transform(transform).length;
+}
+function encodeDuplicate(w, opId, dx, dy, dz) {
+  return w.begin(opId).i32(dx).i32(dy).i32(dz).length;
+}
+function encodeSettings(w, opId, s) {
+  return w.begin(opId).u8(s.sky).u8(s.ground).u8(s.lighting).u8(s.visibility).u32(s.gridMm).u16(s.angleStepCentidegrees).length;
+}
+function encodeModerate(w, opId, target, sanction, durationS) {
+  return w.begin(opId).u8(sanction).u32(durationS).text(target).length;
+}
+function encodeJoinCopy(w, opId, code) {
+  return w.begin(opId).u32(code).length;
+}
+function encodeClock(w, opId, scalePermille, historyRatePermille, paused) {
+  return w.begin(opId).u32(scalePermille).u32(historyRatePermille).u8(paused ? 1 : 0).length;
+}
+var COMMAND_OP_ID_BYTES = (4);
+function yawRotation(radians, out, offset = (3)) {
+  let half = radians / 2, s = Math.sin(half), c = Math.cos(half), sign = c < 0 ? -1 : 1;
+  return out[offset] = 0, out[offset + 1] = Math.round(s * sign * 32767), out[offset + 2] = 0, out[offset + 3] = Math.round(c * sign * 32767), out;
+}
+
+// src/interactives/worlds/transform.ts
+var BOUNDS_MIN = 0, BOUNDS_MAX = 3, BOUNDS_WORDS = 6, AXES = 3, QUAT = 4, EPSILON = 11920929e-14, MAX_U16 = 65535, TAU = Math.PI * 2, q = new Float64Array((4)), qd = new Float64Array((4)), qc = new Float64Array((4)), v = new Float64Array((3)), r = new Float64Array((3)), scaled = new Float64Array((3)), centre = new Float64Array((3)), absM = new Float64Array((3) * (3));
+function normalise(out) {
+  let length = Math.sqrt(out[0] * out[0] + out[1] * out[1] + out[2] * out[2] + out[3] * out[3]);
+  if (length <= (11920929e-14)) {
+    out[0] = 0, out[1] = 0, out[2] = 0, out[3] = 1;
+    return;
+  }
+  for (let i = 0; i < (4); i++) out[i] /= length;
+}
+function quatOf(t, offset, out) {
+  for (let i = 0; i < (4); i++) out[i] = t[offset + i] / 32767;
+  normalise(out);
+}
+function quantise(src, out, offset) {
+  normalise(src);
+  let sign = src[3] < 0 ? -1 : 1;
+  for (let i = 0; i < (4); i++) out[offset + i] = Math.round(src[i] * sign * 32767);
+}
+function rotate(quat, vec, out) {
+  let ux = quat[0], uy = quat[1], uz = quat[2], s = quat[3], dotUv = ux * vec[0] + uy * vec[1] + uz * vec[2], dotUu = ux * ux + uy * uy + uz * uz, cx = uy * vec[2] - uz * vec[1], cy = uz * vec[0] - ux * vec[2], cz = ux * vec[1] - uy * vec[0], k = s * s - dotUu;
+  out[0] = 2 * dotUv * ux + k * vec[0] + 2 * s * cx, out[1] = 2 * dotUv * uy + k * vec[1] + 2 * s * cy, out[2] = 2 * dotUv * uz + k * vec[2] + 2 * s * cz;
+}
+function multiply(a, b, out) {
+  let x = a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1], y = a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0], z = a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3], w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+  out[0] = x, out[1] = y, out[2] = z, out[3] = w;
+}
+function canonical(t) {
+  quatOf(t, (3), q), quantise(q, t, (3));
+  for (let i = 0; i < (3); i++) t[(7) + i] = Math.max(1, t[(7) + i]);
+  return t;
+}
+function bounds(t, offset, halfExtentsMm, halfOffset, out) {
+  quatOf(t, offset + (3), q);
+  for (let a = 0; a < (3); a++) scaled[a] = halfExtentsMm[halfOffset + a] * t[offset + (7) + a] / 1e3;
+  v[0] = 0, v[1] = scaled[1], v[2] = 0, rotate(q, v, centre);
+  for (let column = 0; column < (3); column++) {
+    v[0] = column === 0 ? 1 : 0, v[1] = column === 1 ? 1 : 0, v[2] = column === 2 ? 1 : 0, rotate(q, v, r);
+    for (let row = 0; row < (3); row++) absM[row * (3) + column] = Math.abs(r[row]);
+  }
+  for (let row = 0; row < (3); row++) {
+    let reach = absM[row * (3)] * scaled[0] + absM[row * (3) + 1] * scaled[1] + absM[row * (3) + 2] * scaled[2], c = t[offset + (0) + row] + centre[row];
+    out[(0) + row] = c - reach, out[(3) + row] = c + reach;
+  }
+  return out;
+}
+function overlapsFootprint(a, b) {
+  return a[(0)] < b[(3)] && a[(3)] > b[(0)] && a[(0) + 2] < b[(3) + 2] && a[(3) + 2] > b[(0) + 2];
+}
+function divEuclid(value, step) {
+  return Math.floor(value / step);
+}
+function snappedToGrid(t, gridMm, angleStepCentidegrees) {
+  if (gridMm > 0) {
+    let half = Math.trunc(gridMm / 2);
+    t[(0)] = divEuclid(t[(0)] + half, gridMm) * gridMm, t[(0) + 2] = divEuclid(t[(0) + 2] + half, gridMm) * gridMm;
+  }
+  if (angleStepCentidegrees > 0) {
+    let step = angleStepCentidegrees / 36e3 * TAU;
+    quatOf(t, (3), q);
+    let siny = 2 * (q[3] * q[1] + q[0] * q[2]), cosy = 1 - 2 * (q[1] * q[1] + q[2] * q[2]), half = Math.round(Math.atan2(siny, cosy) / step) * step * 0.5;
+    qc[0] = 0, qc[1] = Math.sin(half), qc[2] = 0, qc[3] = Math.cos(half), quantise(qc, t, (3));
+  }
+  return t;
+}
+function snapHeightToGrid(t, gridMm) {
+  gridMm <= 0 || (t[(0) + 1] = divEuclid(t[(0) + 1] + Math.trunc(gridMm / 2), gridMm) * gridMm);
+}
+function movedAbout(t, pivotX, pivotY, pivotZ, dx, dy, dz, rotation, scalePermille, out) {
+  quatOf(rotation, 0, qd);
+  let factor = Math.max(1, scalePermille) / 1e3;
+  v[0] = (t[(0)] - pivotX) * factor, v[1] = (t[(0) + 1] - pivotY) * factor, v[2] = (t[(0) + 2] - pivotZ) * factor, rotate(qd, v, r), out[(0)] = Math.round(pivotX + r[0] + dx), out[(0) + 1] = Math.round(pivotY + r[1] + dy), out[(0) + 2] = Math.round(pivotZ + r[2] + dz), quatOf(t, (3), q), multiply(qd, q, qc), quantise(qc, out, (3));
+  for (let a = 0; a < (3); a++) out[(7) + a] = Math.min((65535), Math.max(1, Math.round(t[(7) + a] * factor)));
+  return out;
+}
+function withinWorld(t) {
+  let x = t[(0)], y = t[(0) + 1], z = t[(0) + 2];
+  return x >= 0 && x <= 255996 && z >= 0 && z <= 255996 && y >= -1e6 && y <= 1e6;
+}
+function copyTransform(src, srcOffset, out, outOffset = 0) {
+  for (let i = 0; i < (10); i++) out[outOffset + i] = src[srcOffset + i];
+  return out;
+}
+
+// src/interactives/worlds/mirror.ts
+var LITTLE2 = true, NO_ROW = -1, INITIAL_ROWS = 1024, INITIAL_IDS = 4096, INITIAL_PALETTE = 64, RESULT_RING = 64, SHARED_RING = 8, AXES2 = 3, FNV_OFFSET_HI = 3421674724, FNV_OFFSET_LO = 2216829733, FNV_PRIME_LOW = 435, FNV_PRIME_SHIFT = 8, TWO_32 = 4294967296, HEX_WORD = 8, HEX_RADIX = 16, DEFAULT_HALF_EXTENT_MM = 500, UTF82 = new TextDecoder();
+function grown(array, length, fill = 0) {
+  let next = new array.constructor(length);
+  return next.set(array), fill !== 0 && next.fill(fill, array.length), next;
+}
+var WorldMirror = class {
+  constructor() {
+    this.ids = new Uint32Array((1024));
+    this.revisions = new Uint32Array((1024));
+    this.items = new Uint16Array((1024));
+    this.authorsOf = new Uint32Array((1024));
+    this.transforms = new Float64Array((1024) * (10));
+    this.locks = new Uint16Array((1024));
+    this.count = 0;
+    this.version = 0;
+    this.rowById = new Int32Array((4096)).fill((-1));
+    this.tombstones = new Uint32Array((4096));
+    this.paletteItems = [];
+    this.paletteHalfExtents = new Float64Array((64) * (3));
+    this.paletteLicence = new Uint8Array((64));
+    this.paletteLikeness = new Uint8Array((64));
+    this.authors = [];
+    this.results = Array.from({ length: (64) }, () => ({ opId: 0, status: 0, affected: 0, conflicts: 0, appliedThrough: 0 }));
+    this.resultCount = 0;
+    this.sharedCodes = new Uint32Array((8));
+    this.sharedCount = 0;
+    this.notices = new Uint8Array((64));
+    this.noticeCount = 0;
+    this.settings = {
+      sky: 0,
+      ground: 0,
+      lighting: 0,
+      visibility: 0,
+      gridMm: 500,
+      angleStepCentidegrees: 1500
+    };
+    this.clock = { simMs: 0, scalePermille: 0, historyRatePermille: 0, dilationPermille: 0, paused: false };
+    this.hasSettings = false;
+    this.hasClock = false;
+    this.durableThrough = 0;
+    this.streamed = false;
+    this.builder = 65535;
+    this.role = -1;
+    this.muted = false;
+    this.copy = -1;
+    this.capacity = 0;
+    this.malformed = 0;
+    this.frames = 0;
+    this.scratchBounds = new Float64Array((6));
+  }
+  deliver(slot, _sender, view, offset, length) {
+    slot === 63 && this.apply(view, offset, length);
+  }
+  applyBytes(bytes) {
+    this.apply(new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), 0, bytes.byteLength);
+  }
+  apply(view, offset, length) {
+    this.frames++;
+    let end = offset + length, at = offset;
+    for (; at < end; ) {
+      let next = this.message(view, at, end);
+      if (next < 0) {
+        this.malformed++;
+        return;
+      }
+      at = next;
+    }
+  }
+  rowOf(id) {
+    return id < this.rowById.length ? this.rowById[id] : (-1);
+  }
+  knownRevision(id) {
+    let row = this.rowOf(id);
+    return row !== (-1) ? this.revisions[row] : id < this.tombstones.length ? this.tombstones[id] : 0;
+  }
+  get lastResult() {
+    return this.resultCount === 0 ? null : this.results[(this.resultCount - 1) % (64)];
+  }
+  resultFor(opId) {
+    let available = Math.min(this.resultCount, (64));
+    for (let i = 1; i <= available; i++) {
+      let result = this.results[(this.resultCount - i) % (64)];
+      if (result.opId === opId) return result;
+    }
+    return null;
+  }
+  get lastSharedCode() {
+    return this.sharedCount === 0 ? 0 : this.sharedCodes[(this.sharedCount - 1) % (8)];
+  }
+  get lastNotice() {
+    return this.noticeCount === 0 ? -1 : this.notices[(this.noticeCount - 1) % (64)];
+  }
+  halfExtents(item, out, offset = 0) {
+    let known = item < this.paletteItems.length;
+    for (let a = 0; a < (3); a++) out[offset + a] = known ? this.paletteHalfExtents[item * (3) + a] : (500);
+    return out;
+  }
+  surfaceHeight(footprint, ignore, ignoreCount) {
+    let top = 0, half = this.scratchBounds;
+    for (let row = 0; row < this.count; row++) {
+      let id = this.ids[row], skip = false;
+      for (let i = 0; i < ignoreCount && !skip; i++) skip = ignore[i] === id;
+      if (skip) continue;
+      this.halfExtents(this.items[row], half, 0);
+      let b = bounds(this.transforms, row * (10), half, 0, BOX);
+      overlapsFootprint(b, footprint) && (top = Math.max(top, b[(3) + 1]));
+    }
+    return top;
+  }
+  digest() {
+    let order = new Uint32Array(this.count);
+    for (let row = 0; row < this.count; row++) order[row] = this.ids[row];
+    order.sort();
+    let hi = (3421674724), lo = (2216829733), mix = (value) => {
+      lo = (lo ^ value >>> 0) >>> 0;
+      let low = lo * (435), carry = Math.floor(low / (4294967296)), nextHi = (hi * (435) + carry + (lo << (8) >>> 0)) % (4294967296);
+      lo = low % (4294967296), hi = nextHi;
+    };
+    for (let i = 0; i < order.length; i++) {
+      let row = this.rowById[order[i]], t = row * (10);
+      mix(this.ids[row]), mix(this.revisions[row]), mix(this.items[row]), mix(this.transforms[t] | 0), mix(this.transforms[t + 1] | 0), mix(this.transforms[t + 2] | 0);
+    }
+    return hi.toString((16)).padStart((8), "0") + lo.toString((16)).padStart((8), "0");
+  }
+  ensureId(id) {
+    if (id < this.rowById.length) return;
+    let length = this.rowById.length;
+    for (; length <= id; ) length *= 2;
+    this.rowById = grown(this.rowById, length, (-1)), this.tombstones = grown(this.tombstones, length);
+  }
+  ensureRows(rows) {
+    if (rows <= this.ids.length) return;
+    let length = Math.max(rows, this.ids.length * 2);
+    this.ids = grown(this.ids, length), this.revisions = grown(this.revisions, length), this.items = grown(this.items, length), this.authorsOf = grown(this.authorsOf, length), this.locks = grown(this.locks, length), this.transforms = grown(this.transforms, length * (10));
+  }
+  ensurePalette(index) {
+    if (index < this.paletteLicence.length) return;
+    let length = this.paletteLicence.length;
+    for (; length <= index; ) length *= 2;
+    this.paletteHalfExtents = grown(this.paletteHalfExtents, length * (3)), this.paletteLicence = grown(this.paletteLicence, length), this.paletteLikeness = grown(this.paletteLikeness, length);
+  }
+  upsert(view, at) {
+    let id = view.getUint32(at, (true)), revision = view.getUint32(at + 4, (true));
+    if (this.ensureId(id), this.tombstones[id] !== 0 && this.tombstones[id] >= revision) return;
+    let row = this.rowById[id];
+    if (row !== (-1) && this.revisions[row] > revision) return;
+    row === (-1) && (this.ensureRows(this.count + 1), row = this.count++, this.rowById[id] = row), this.ids[row] = id, this.revisions[row] = revision, this.items[row] = view.getUint16(at + 8, (true)), this.authorsOf[row] = view.getUint32(at + 10, (true));
+    let t = row * (10), p = at + 14, transforms = this.transforms;
+    transforms[t] = view.getInt32(p, (true)), transforms[t + 1] = view.getInt32(p + 4, (true)), transforms[t + 2] = view.getInt32(p + 8, (true)), transforms[t + 3] = view.getInt16(p + 12, (true)), transforms[t + 4] = view.getInt16(p + 14, (true)), transforms[t + 5] = view.getInt16(p + 16, (true)), transforms[t + 6] = view.getInt16(p + 18, (true)), transforms[t + 7] = view.getUint16(p + 20, (true)), transforms[t + 8] = view.getUint16(p + 22, (true)), transforms[t + 9] = view.getUint16(p + 24, (true)), this.locks[row] = view.getUint16(at + 40, (true)), this.version++;
+  }
+  remove(id, revision) {
+    this.ensureId(id);
+    let row = this.rowById[id];
+    if (row !== (-1) && this.revisions[row] >= revision || (this.tombstones[id] = revision, row === (-1))) return;
+    let last = this.count - 1;
+    if (row !== last) {
+      let lastId = this.ids[last];
+      this.ids[row] = lastId, this.revisions[row] = this.revisions[last], this.items[row] = this.items[last], this.authorsOf[row] = this.authorsOf[last], this.locks[row] = this.locks[last], this.transforms.copyWithin(row * (10), last * (10), last * (10) + (10)), this.rowById[lastId] = row;
+    }
+    this.rowById[id] = (-1), this.count = last, this.version++;
+  }
+  text(view, at, end) {
+    let length = view.getUint8(at);
+    return at + 1 + length > end ? null : UTF82.decode(new Uint8Array(view.buffer, view.byteOffset + at + 1, length));
+  }
+  message(view, at, end) {
+    let kind = view.getUint8(at), body = at + 1;
+    switch (kind) {
+      case MessageKind.Upsert:
+        return body + (42) > end ? -1 : (this.upsert(view, body), body + (42));
+      case MessageKind.Remove:
+        return body + (8) > end ? -1 : (this.remove(view.getUint32(body, (true)), view.getUint32(body + 4, (true))), body + (8));
+      case MessageKind.Result: {
+        if (body + (17) > end) return -1;
+        let result = this.results[this.resultCount % (64)];
+        return result.opId = view.getUint32(body, (true)), result.status = view.getUint8(body + 4), result.affected = view.getUint16(body + 5, (true)), result.conflicts = view.getUint16(body + 7, (true)), result.appliedThrough = view.getUint32(body + 9, (true)) + view.getUint32(body + 13, (true)) * (4294967296), this.resultCount++, body + (17);
+      }
+      case MessageKind.Durable:
+        return body + (8) > end ? -1 : (this.durableThrough = view.getUint32(body, (true)) + view.getUint32(body + 4, (true)) * (4294967296), body + (8));
+      case MessageKind.Settings: {
+        if (body + (10) > end) return -1;
+        let s = this.settings;
+        return s.sky = view.getUint8(body), s.ground = view.getUint8(body + 1), s.lighting = view.getUint8(body + 2), s.visibility = view.getUint8(body + 3), s.gridMm = view.getUint32(body + 4, (true)), s.angleStepCentidegrees = view.getUint16(body + 8, (true)), this.hasSettings = true, this.version++, body + (10);
+      }
+      case MessageKind.Clock: {
+        if (body + (21) > end) return -1;
+        let c = this.clock;
+        return c.simMs = view.getUint32(body, (true)) + view.getUint32(body + 4, (true)) * (4294967296), c.scalePermille = view.getUint32(body + 8, (true)), c.historyRatePermille = view.getUint32(body + 12, (true)), c.dilationPermille = view.getUint32(body + 16, (true)), c.paused = view.getUint8(body + 20) !== 0, this.hasClock = true, body + (21);
+      }
+      case MessageKind.Begin:
+        return body + (12) > end ? -1 : (this.streamed = false, body + (12));
+      case MessageKind.End:
+        return this.streamed = true, body;
+      case MessageKind.Lock: {
+        if (body + (6) > end) return -1;
+        let id = view.getUint32(body, (true)), row = this.rowOf(id);
+        return row !== (-1) && (this.locks[row] = view.getUint16(body + 4, (true)), this.version++), body + (6);
+      }
+      case MessageKind.Welcome:
+        return body + (8) > end ? -1 : (this.builder = view.getUint16(body, (true)), this.role = view.getUint8(body + 2), this.muted = view.getUint8(body + 3) !== 0, this.copy = view.getUint16(body + 4, (true)), this.capacity = view.getUint16(body + 6, (true)), body + (8));
+      case MessageKind.Author: {
+        if (body + (4) + 1 > end) return -1;
+        let index = view.getUint32(body, (true)), name = this.text(view, body + (4), end);
+        return name === null ? -1 : (this.authors[index] = name, body + (4) + 1 + view.getUint8(body + (4)));
+      }
+      case MessageKind.Palette: {
+        if (body + (16) + 1 > end) return -1;
+        let index = view.getUint16(body, (true));
+        this.ensurePalette(index), this.paletteLicence[index] = view.getUint8(body + 2), this.paletteLikeness[index] = view.getUint8(body + 3);
+        for (let a = 0; a < (3); a++) this.paletteHalfExtents[index * (3) + a] = view.getUint32(body + 4 + a * 4, (true));
+        let item = this.text(view, body + (16), end);
+        return item === null ? -1 : (this.paletteItems[index] = item, body + (16) + 1 + view.getUint8(body + (16)));
+      }
+      case MessageKind.Shared:
+        return body + (4) > end ? -1 : (this.sharedCodes[this.sharedCount % (8)] = view.getUint32(body, (true)), this.sharedCount++, body + (4));
+      case MessageKind.Notice:
+        return body + 1 > end ? -1 : (this.notices[this.noticeCount % (64)] = view.getUint8(body), this.noticeCount++, body + 1);
+      default:
+        return -1;
+    }
+  }
+}, U322 = 4, U64 = 8, UPSERT_BODY = 42, REMOVE_BODY = 8, RESULT_BODY = 17, SETTINGS_BODY = 10, CLOCK_BODY = 21, BEGIN_BODY = 12, LOCK_BODY = 6, WELCOME_BODY = 8, AUTHOR_HEAD = 4, PALETTE_HEAD = 16, BOX = new Float64Array((6));
+
+// src/interactives/worlds/builder.ts
+var NOT_SENT = -1, AXES3 = 3, U32_RANGE = 4294967296, WorldBuilder = class {
+  constructor(port, mirror) {
+    this.writer = new CommandWriter();
+    this.footprint = new Float64Array((6));
+    this.half = new Float64Array((3));
+    this.opId = 0;
+    this.port = port, this.mirror = mirror;
+  }
+  get lastOpId() {
+    return this.opId;
+  }
+  next() {
+    return this.opId = (this.opId + 1) % (4294967296), this.opId === 0 && (this.opId = 1), this.opId;
+  }
+  send(action, length) {
+    let opId = this.opId;
+    return this.port.sendCommand(action, this.writer.bytes, length) < 0 ? (-1) : opId;
+  }
+  place(item, snap, transform) {
+    return this.send(Action.Place, encodePlace(this.writer, this.next(), item, snap, transform));
+  }
+  select(mode, ids, count) {
+    return this.send(Action.Select, encodeSelect(this.writer, this.next(), mode, ids, count));
+  }
+  clearSelection() {
+    return this.send(Action.ClearSelection, encodeBare(this.writer, this.next()));
+  }
+  transformSelection(snap, dx, dy, dz, rotation, scalePermille) {
+    return this.send(
+      Action.TransformSelection,
+      encodeTransformSelection(this.writer, this.next(), snap, dx, dy, dz, rotation, scalePermille)
+    );
+  }
+  setTransform(id, snap, transform) {
+    return this.send(Action.SetTransform, encodeSetTransform(this.writer, this.next(), id, snap, transform));
+  }
+  duplicate(dx, dy, dz) {
+    return this.send(Action.DuplicateSelection, encodeDuplicate(this.writer, this.next(), dx, dy, dz));
+  }
+  deleteSelection() {
+    return this.send(Action.DeleteSelection, encodeBare(this.writer, this.next()));
+  }
+  undo() {
+    return this.send(Action.Undo, encodeBare(this.writer, this.next()));
+  }
+  redo() {
+    return this.send(Action.Redo, encodeBare(this.writer, this.next()));
+  }
+  settings(settings) {
+    return this.send(Action.Settings, encodeSettings(this.writer, this.next(), settings));
+  }
+  clock(scalePermille, historyRatePermille, paused) {
+    return this.send(Action.Clock, encodeClock(this.writer, this.next(), scalePermille, historyRatePermille, paused));
+  }
+  moderate(target, sanction, durationS) {
+    return this.send(Action.Moderate, encodeModerate(this.writer, this.next(), target, sanction, durationS));
+  }
+  shareCopy() {
+    return this.send(Action.ShareCopy, encodeBare(this.writer, this.next()));
+  }
+  joinCopy(code) {
+    return this.send(Action.JoinCopy, encodeJoinCopy(this.writer, this.next(), code));
+  }
+  preview(item, snap, transform, ignore, ignoreCount) {
+    let settings = this.mirror.settings;
+    if (canonical(transform), (snap & (1)) !== 0 && snappedToGrid(transform, settings.gridMm, settings.angleStepCentidegrees), (snap & (2)) !== 0) {
+      this.mirror.halfExtents(item, this.half, 0);
+      let footprint = bounds(transform, 0, this.half, 0, this.footprint), resting = this.mirror.surfaceHeight(footprint, ignore, ignoreCount), lift = footprint[(0) + 1] - transform[(0) + 1];
+      transform[(0) + 1] = Math.round(resting - lift);
+    } else (snap & (1)) !== 0 && snapHeightToGrid(transform, settings.gridMm);
+    return transform;
+  }
+};
+
+// src/interactives/worlds/loopback.ts
+var LITTLE3 = true, PAYLOAD_BYTES = 1188, MESSAGE_HEADROOM = 64, BUILDER = 0, AUTHOR = 0, MAX_SELECTION = 2048, UNDO_STEPS = 256, UNDO_EFFECTS = 4096, AXES4 = 3, NO_ROW2 = -1, COPY_CAPACITY = 1, LOCAL_PARTICIPANT = "local", PALETTE_HEAD2 = 17, AUTHOR_HEAD2 = 5, ENCODER = new TextEncoder(), LocalWorld = class {
+  constructor(options) {
+    this.store = new WorldMirror();
+    this.sinks = [];
+    this.payload = new Uint8Array((1188));
+    this.view = new DataView(this.payload.buffer);
+    this.length = 0;
+    this.nextId = 1;
+    this.sequence = 0;
+    this.durable = 0;
+    this.selection = new Uint32Array((2048));
+    this.selected = 0;
+    this.staged = new Float64Array((2048) * (10));
+    this.stagedIds = new Uint32Array((2048));
+    this.stagedCount = 0;
+    this.t = new Float64Array((10));
+    this.rotation = new Float64Array(4);
+    this.half = new Float64Array((3));
+    this.footprint = new Float64Array((6));
+    this.effId = new Uint32Array((4096));
+    this.effBeforePresent = new Uint8Array((4096));
+    this.effBeforeRevision = new Uint32Array((4096));
+    this.effBeforeItem = new Uint16Array((4096));
+    this.effBeforeTransform = new Float64Array((4096) * (10));
+    this.effAfterPresent = new Uint8Array((4096));
+    this.effAfterRevision = new Uint32Array((4096));
+    this.effAfterItem = new Uint16Array((4096));
+    this.effAfterTransform = new Float64Array((4096) * (10));
+    this.written = 0;
+    this.open = -1;
+    this.undoStart = new Float64Array((256));
+    this.undoLength = new Uint32Array((256));
+    this.undoCount = 0;
+    this.undoHead = 0;
+    this.redoStart = new Float64Array((256));
+    this.redoLength = new Uint32Array((256));
+    this.redoCount = 0;
+    this.redoHead = 0;
+    this.popped = new Uint32Array((4096));
+    this.poppedCount = 0;
+    this.applied = 0;
+    this.target = null;
+    this.commandView = null;
+    this.source = new Float64Array((10));
+    this.maxObjects = options.maxObjects ?? Number.MAX_SAFE_INTEGER, this.palette = options.palette, this.hello(), this.flush();
+  }
+  hello() {
+    for (let index = 0; index < this.palette.length; index++) {
+      let entry = this.palette[index], name = ENCODER.encode(entry.item);
+      this.reserve((17) + 1 + name.length), this.u8(MessageKind.Palette).u16(index).u8(0).u8(0);
+      for (let a = 0; a < (3); a++) this.u32(entry.halfExtentsMm[a]);
+      this.bytes(name);
+    }
+    let author = ENCODER.encode(LOCAL_PARTICIPANT);
+    this.reserve((5) + 1 + author.length), this.u8(MessageKind.Author).u32((0)), this.bytes(author), this.reserve((64)), this.u8(MessageKind.Welcome).u16((0)).u8(WorldRoleCode.Owner).u8(0).u16(0).u16((1));
+    let s = this.store.settings;
+    this.u8(MessageKind.Settings).u8(s.sky).u8(s.ground).u8(s.lighting).u8(s.visibility).u32(s.gridMm).u16(s.angleStepCentidegrees), this.u8(MessageKind.Begin).u32(this.store.count).u32(this.sequence).u32(0);
+  }
+  bytes(text) {
+    this.u8(text.length), this.payload.set(text, this.length), this.length += text.length;
+  }
+  attach(mirror) {
+    this.flush(), this.target = mirror, this.hello();
+    let store = this.store;
+    for (let row = 0; row < store.count; row++) {
+      let lock = this.indexOf(store.ids[row]) >= 0 ? (0) : 65535;
+      this.emitUpsert(store.ids[row], store.revisions[row], store.items[row], store.transforms, row * (10), lock);
+    }
+    this.reserve((64)), this.u8(MessageKind.End), this.flush(), this.target = null, this.sinks.push(mirror);
+  }
+  sendCommand(action, payload, length) {
+    return (this.commandView === null || this.commandView.buffer !== payload.buffer || this.commandView.byteOffset !== payload.byteOffset) && (this.commandView = new DataView(payload.buffer, payload.byteOffset, payload.byteLength)), this.apply(action, this.commandView, length), this.flush(), this.sequence;
+  }
+  u8(value) {
+    return this.view.setUint8(this.length, value), this.length += 1, this;
+  }
+  u16(value) {
+    return this.view.setUint16(this.length, value, (true)), this.length += 2, this;
+  }
+  u32(value) {
+    return this.view.setUint32(this.length, value >>> 0, (true)), this.length += 4, this;
+  }
+  i32(value) {
+    return this.view.setInt32(this.length, value | 0, (true)), this.length += 4, this;
+  }
+  i16(value) {
+    return this.view.setInt16(this.length, value, (true)), this.length += 2, this;
+  }
+  reserve(bytes) {
+    this.length + bytes > (1188) && this.flush();
+  }
+  flush() {
+    if (this.length === 0) return;
+    let target = this.target;
+    if (target !== null)
+      target.apply(this.view, 0, this.length);
+    else {
+      this.store.apply(this.view, 0, this.length);
+      for (let i = 0; i < this.sinks.length; i++) this.sinks[i].apply(this.view, 0, this.length);
+    }
+    this.length = 0;
+  }
+  emitUpsert(id, revision, item, t, tOffset, lock) {
+    this.reserve((64)), this.u8(MessageKind.Upsert).u32(id).u32(revision).u16(item).u32((0)), this.i32(t[tOffset + (0)]).i32(t[tOffset + (0) + 1]).i32(t[tOffset + (0) + 2]);
+    for (let i = 0; i < 4; i++) this.i16(t[tOffset + (3) + i]);
+    for (let i = 0; i < (3); i++) this.u16(t[tOffset + (7) + i]);
+    this.u16(lock), this.flush();
+  }
+  emitRemove(id, revision) {
+    this.reserve((64)), this.u8(MessageKind.Remove).u32(id).u32(revision), this.flush();
+  }
+  emitLock(id, builder) {
+    this.reserve((64)), this.u8(MessageKind.Lock).u32(id).u16(builder), this.flush();
+  }
+  emitResult(opId, status, affected, conflicts) {
+    this.reserve((64)), this.u8(MessageKind.Result).u32(opId).u8(status).u16(affected).u16(conflicts).u32(this.sequence).u32(0), this.durable = this.sequence, this.u8(MessageKind.Durable).u32(this.durable).u32(0);
+  }
+  apply(action, c, length) {
+    if (length < 4) return;
+    let opId = c.getUint32(0, (true)), status = Status.Applied, affected = 0, conflicts = 0;
+    switch (action) {
+      case Action.Place: {
+        let item = c.getUint16(4, (true)), snap = c.getUint8(6);
+        if (this.readTransform(c, 8, this.t), item >= this.store.paletteItems.length) {
+          status = Status.Invalid;
+          break;
+        }
+        if (this.store.count >= this.maxObjects) {
+          status = Status.Limit;
+          break;
+        }
+        if (this.snap(this.t, item, snap, 0), !withinWorld(this.t)) {
+          status = Status.Invalid;
+          break;
+        }
+        this.begin();
+        let id = this.nextId++;
+        this.write(id, 1, item, this.t, 0, false, 0), this.commit(), affected = 1;
+        break;
+      }
+      case Action.Select: {
+        let mode = c.getUint8(4), count = Math.min(c.getUint8(5), 62);
+        mode === SelectMode.Replace && this.release();
+        for (let i = 0; i < count; i++) {
+          let id = c.getUint32(6 + i * 4, (true));
+          if (this.store.rowOf(id) === (-1)) {
+            conflicts++;
+            continue;
+          }
+          let at = this.indexOf(id);
+          if (mode === SelectMode.Remove) {
+            at >= 0 && (this.selection[at] = this.selection[--this.selected], this.emitLock(id, 65535), affected++);
+            continue;
+          }
+          if (!(at >= 0)) {
+            if (this.selected >= (2048)) {
+              conflicts++;
+              continue;
+            }
+            this.selection[this.selected++] = id, this.emitLock(id, (0)), affected++;
+          }
+        }
+        break;
+      }
+      case Action.ClearSelection:
+        affected = this.selected, this.release();
+        break;
+      case Action.TransformSelection: {
+        if (this.selected === 0) {
+          status = Status.Nothing;
+          break;
+        }
+        let snap = c.getUint8(4), dx = c.getInt32(6, (true)), dy = c.getInt32(10, (true)), dz = c.getInt32(14, (true));
+        for (let i = 0; i < 4; i++) this.rotation[i] = c.getInt16(18 + i * 2, (true));
+        let scale = c.getUint16(26, (true)), px = 0, py = 0, pz = 0, store = this.store;
+        for (let i = 0; i < this.selected; i++) {
+          let o = store.rowOf(this.selection[i]) * (10);
+          px += store.transforms[o], py += store.transforms[o + 1], pz += store.transforms[o + 2];
+        }
+        px /= this.selected, py /= this.selected, pz /= this.selected, this.stagedCount = 0;
+        for (let i = 0; i < this.selected; i++) {
+          let id = this.selection[i], row = store.rowOf(id), o = this.stagedCount * (10);
+          copyTransform(store.transforms, row * (10), this.source, 0), movedAbout(this.source, px, py, pz, dx, dy, dz, this.rotation, scale, this.t), this.snap(this.t, store.items[row], snap, this.selected), copyTransform(this.t, 0, this.staged, o), this.stagedIds[this.stagedCount++] = id;
+        }
+        let commit = this.commitStaged();
+        status = commit < 0 ? Status.Invalid : Status.Applied, affected = Math.max(0, commit);
+        break;
+      }
+      case Action.SetTransform: {
+        let id = c.getUint32(4, (true)), snap = c.getUint8(8);
+        this.readTransform(c, 10, this.t);
+        let row = this.store.rowOf(id);
+        if (row === (-1)) {
+          status = Status.Conflict;
+          break;
+        }
+        this.snap(this.t, this.store.items[row], snap, 0), copyTransform(this.t, 0, this.staged, 0), this.stagedIds[0] = id, this.stagedCount = 1;
+        let commit = this.commitStaged();
+        status = commit < 0 ? Status.Invalid : Status.Applied, affected = Math.max(0, commit);
+        break;
+      }
+      case Action.DuplicateSelection: {
+        if (this.selected === 0) {
+          status = Status.Nothing;
+          break;
+        }
+        if (this.store.count + this.selected > this.maxObjects) {
+          status = Status.Limit;
+          break;
+        }
+        let dx = c.getInt32(4, (true)), dy = c.getInt32(8, (true)), dz = c.getInt32(12, (true));
+        this.stageSelection(), this.release(), this.begin();
+        let store = this.store;
+        for (let i = 0; i < this.stagedCount; i++) {
+          let row = store.rowOf(this.stagedIds[i]), o = i * (10);
+          if (copyTransform(this.staged, o, this.t, 0), this.t[(0)] += dx, this.t[(0) + 1] += dy, this.t[(0) + 2] += dz, !withinWorld(this.t)) {
+            conflicts++;
+            continue;
+          }
+          let id = this.nextId++;
+          this.write(id, 1, store.items[row], this.t, 0, false, 0), this.selection[this.selected++] = id, this.emitLock(id, (0)), affected++;
+        }
+        this.commit();
+        break;
+      }
+      case Action.DeleteSelection: {
+        if (this.selected === 0) {
+          status = Status.Nothing;
+          break;
+        }
+        this.stageSelection(), this.release(), this.begin();
+        for (let i = 0; i < this.stagedCount; i++) this.erase(this.stagedIds[i]) && affected++;
+        this.commit();
+        break;
+      }
+      case Action.Undo:
+      case Action.Redo: {
+        let undo = action === Action.Undo;
+        if (!this.pop(undo)) {
+          status = Status.Nothing;
+          break;
+        }
+        this.begin();
+        let store = this.store;
+        for (let p = 0; p < this.poppedCount; p++) {
+          let e = this.popped[p], id = this.effId[e], row = store.rowOf(id);
+          if (!(row === (-1) ? this.effAfterPresent[e] === 0 : this.effAfterPresent[e] === 1 && this.sameAsAfter(e, row))) {
+            conflicts++;
+            continue;
+          }
+          if (this.effBeforePresent[e] === 1) {
+            let revision = Math.max(store.knownRevision(id), this.effAfterRevision[e], this.effBeforeRevision[e]) + 1;
+            this.write(id, revision, this.effBeforeItem[e], this.effBeforeTransform, e * (10), row !== (-1), row);
+          } else {
+            let at = this.indexOf(id);
+            at >= 0 && (this.selection[at] = this.selection[--this.selected]), this.erase(id);
+          }
+          affected++;
+        }
+        this.commitReversal(undo), affected === 0 && conflicts > 0 && (status = Status.Conflict);
+        break;
+      }
+      default:
+        status = Status.Nothing;
+    }
+    status === Status.Applied && affected === 0 && conflicts > 0 && (status = Status.Conflict), status === Status.Applied && this.applied++, this.emitResult(opId, status, affected, conflicts);
+  }
+  readTransform(c, at, out) {
+    out[0] = c.getInt32(at, (true)), out[1] = c.getInt32(at + 4, (true)), out[2] = c.getInt32(at + 8, (true));
+    for (let i = 0; i < 4; i++) out[(3) + i] = c.getInt16(at + 12 + i * 2, (true));
+    for (let i = 0; i < (3); i++) out[(7) + i] = c.getUint16(at + 20 + i * 2, (true));
+  }
+  snap(t, item, snap, ignoreSelection) {
+    let settings = this.store.settings;
+    if (canonical(t), (snap & (1)) !== 0 && snappedToGrid(t, settings.gridMm, settings.angleStepCentidegrees), (snap & (2)) !== 0) {
+      this.store.halfExtents(item, this.half, 0);
+      let footprint = bounds(t, 0, this.half, 0, this.footprint), resting = this.store.surfaceHeight(footprint, this.selection, ignoreSelection);
+      t[(0) + 1] = Math.round(resting - (footprint[(0) + 1] - t[(0) + 1]));
+    } else (snap & (1)) !== 0 && snapHeightToGrid(t, settings.gridMm);
+  }
+  indexOf(id) {
+    for (let i = 0; i < this.selected; i++) if (this.selection[i] === id) return i;
+    return -1;
+  }
+  release() {
+    for (let i = 0; i < this.selected; i++) this.emitLock(this.selection[i], 65535);
+    this.selected = 0;
+  }
+  stageSelection() {
+    this.stagedCount = 0;
+    let store = this.store;
+    for (let i = 0; i < this.selected; i++) {
+      let id = this.selection[i], row = store.rowOf(id);
+      row !== (-1) && (copyTransform(store.transforms, row * (10), this.staged, this.stagedCount * (10)), this.stagedIds[this.stagedCount++] = id);
+    }
+  }
+  commitStaged() {
+    for (let i = 0; i < this.stagedCount; i++)
+      if (copyTransform(this.staged, i * (10), this.t, 0), !withinWorld(this.t)) return -1;
+    this.begin();
+    let store = this.store, affected = 0;
+    for (let i = 0; i < this.stagedCount; i++) {
+      let id = this.stagedIds[i], row = store.rowOf(id);
+      row !== (-1) && (this.write(id, store.revisions[row] + 1, store.items[row], this.staged, i * (10), true, row), affected++);
+    }
+    return this.commit(), affected;
+  }
+  sameAsAfter(e, row) {
+    let store = this.store;
+    if (store.items[row] !== this.effAfterItem[e]) return false;
+    let a = e * (10), b = row * (10);
+    for (let i = 0; i < (10); i++) if (store.transforms[b + i] !== this.effAfterTransform[a + i]) return false;
+    return true;
+  }
+  record(id, beforeRow, afterPresent, afterRevision, afterItem, after, afterOffset) {
+    let e = this.written % (4096);
+    this.effId[e] = id;
+    let store = this.store;
+    beforeRow === (-1) ? this.effBeforePresent[e] = 0 : (this.effBeforePresent[e] = 1, this.effBeforeRevision[e] = store.revisions[beforeRow], this.effBeforeItem[e] = store.items[beforeRow], copyTransform(store.transforms, beforeRow * (10), this.effBeforeTransform, e * (10))), this.effAfterPresent[e] = afterPresent ? 1 : 0, this.effAfterRevision[e] = afterRevision, this.effAfterItem[e] = afterItem, afterPresent && copyTransform(after, afterOffset, this.effAfterTransform, e * (10)), this.written++;
+  }
+  write(id, revision, item, t, tOffset, existed, row) {
+    this.sequence++, this.record(id, existed ? row : (-1), true, revision, item, t, tOffset);
+    let lock = this.indexOf(id) >= 0 ? (0) : 65535;
+    this.emitUpsert(id, revision, item, t, tOffset, lock);
+  }
+  erase(id) {
+    let row = this.store.rowOf(id);
+    if (row === (-1)) return false;
+    let revision = this.store.revisions[row] + 1;
+    return this.sequence++, this.record(id, row, false, revision, 0, this.t, 0), this.emitRemove(id, revision), true;
+  }
+  begin() {
+    this.open = this.written;
+  }
+  close() {
+    let start = this.open;
+    if (this.open = -1, start < 0) return 0;
+    let length = this.written - start;
+    return length > 0 && length <= (4096) ? length : 0;
+  }
+  commit() {
+    let start = this.open, length = this.close();
+    length !== 0 && (this.push(true, start, length), this.redoCount = 0);
+  }
+  commitReversal(undo) {
+    let start = this.open, length = this.close();
+    length !== 0 && this.push(!undo, start, length);
+  }
+  push(toUndo, start, length) {
+    let starts = toUndo ? this.undoStart : this.redoStart, lengths = toUndo ? this.undoLength : this.redoLength, head = toUndo ? this.undoHead : this.redoHead, count = toUndo ? this.undoCount : this.redoCount;
+    starts[head] = start, lengths[head] = length, head = (head + 1) % (256), count = Math.min(count + 1, (256)), toUndo ? (this.undoHead = head, this.undoCount = count) : (this.redoHead = head, this.redoCount = count);
+  }
+  pop(undo) {
+    if ((undo ? this.undoCount : this.redoCount) === 0) return false;
+    let head = ((undo ? this.undoHead : this.redoHead) + (256) - 1) % (256), start = undo ? this.undoStart[head] : this.redoStart[head], length = undo ? this.undoLength[head] : this.redoLength[head];
+    if (undo ? (this.undoHead = head, this.undoCount--) : (this.redoHead = head, this.redoCount--), this.written - start > (4096))
+      return this.undoCount = 0, this.redoCount = 0, false;
+    this.poppedCount = 0;
+    for (let offset = length - 1; offset >= 0; offset--) this.popped[this.poppedCount++] = (start + offset) % (4096);
+    return true;
+  }
+  get undoDepth() {
+    return this.undoCount;
+  }
+  get redoDepth() {
+    return this.redoCount;
+  }
+  get selectionCount() {
+    return this.selected;
+  }
+  selectionAt(index) {
+    return this.selection[index];
+  }
+};
+
+// src/interactives/worlds/online.ts
+var EXPIRED = "the world ticket expired and cannot be renewed";
+function connectWorld(realtime, options = {}) {
+  let mirror = options.mirror ?? new WorldMirror(), first = realtime.ticket, renew = options.renew ?? null, tickets = () => {
+    let ticket = first;
+    return ticket !== null ? (first = null, Promise.resolve(ticket)) : renew === null ? Promise.reject(new Error(EXPIRED)) : renew();
+  }, client = new RoomClient({
+    tickets,
+    primary: realtime.primary,
+    fallback: realtime.fallback,
+    physicsHz: options.physicsHz,
+    memory: options.memory,
+    network: options.network,
+    channels: mirror
+  });
+  return { client, mirror, builder: new WorldBuilder(client, mirror) };
+}
+
+export { Action, BOUNDS_MAX, BOUNDS_MIN, BOUNDS_WORDS, CENTIDEGREES_PER_TURN, COMMAND_OP_ID_BYTES, CommandWriter, Ground, Lighting, Likeness, LocalWorld, MILLIMETRES_PER_METRE, MessageKind, NOT_SENT, NO_BUILDER, Notice, POSITION, QUATERNION_SCALE, ROTATION, SCALE, SCALE_UNIT_PERMILLE, SNAP_GRID, SNAP_SURFACE, Sanction, SelectMode, Sky, Status, TRANSFORM_WORDS, Visibility, WORLD_EXTENT_MM, WorldBuilder, WorldMirror, WorldRoleCode, bounds, canonical, connectWorld, copyTransform, encodeBare, encodeClock, encodeDuplicate, encodeJoinCopy, encodeModerate, encodePlace, encodeSelect, encodeSetTransform, encodeSettings, encodeTransformSelection, identityTransform, movedAbout, overlapsFootprint, snapHeightToGrid, snappedToGrid, withinWorld, yawRotation };