@irtio/schema 4.7.1 → 4.8.0

package/dist/index.js

@@ -13,7 +13,8 @@ var TypeImpl = class _TypeImpl {
     }
     const err = validateValue(this.desc, value);
     if (err) throw new Error(`invalid default for ${describeType(this.desc)}: ${err}`);
-    return new _TypeImpl({ ...this.desc, hasDefault: true, default: value });
+    const stored = value instanceof Uint8Array ? copyBytes(value) : value;
+    return new _TypeImpl({ ...this.desc, hasDefault: true, default: stored });
   }
 };
 function make(desc) {
@@ -39,8 +40,32 @@ function enumOf(...values) {
 function ref(entity2) {
   return make({ kind: "ref", entity: entity2 });
 }
+var BYTES_MAX = 65535;
+function bytes(n) {
+  if (!Number.isInteger(n) || n < 1 || n > BYTES_MAX) {
+    throw new Error(`bytes(n): n must be an integer from 1 to ${BYTES_MAX}, got ${String(n)}`);
+  }
+  return make({ kind: "bytes", n });
+}
+function containsBytes(d) {
+  switch (d.kind) {
+    case "bytes":
+      return true;
+    case "list":
+      return containsBytes(d.item);
+    case "struct":
+      return Object.values(d.fields).some(containsBytes);
+    default:
+      return false;
+  }
+}
 function list(item, max) {
   assertMax(max, "list");
+  if (containsBytes(item.desc)) {
+    throw new Error(
+      "list items may not contain bytes(n) \u2014 a list is whole-replace; model chunks as an entity collection"
+    );
+  }
   return make({ kind: "list", item: item.desc, max });
 }
 function struct(fields) {
@@ -73,6 +98,9 @@ function describeType(d) {
     case "ref":
       s = `ref(${JSON.stringify(d.entity)})`;
       break;
+    case "bytes":
+      s = `bytes(${d.n})`;
+      break;
     case "list":
       s = `list(${describeType(d.item)}, ${d.max})`;
       break;
@@ -123,6 +151,8 @@ function validateValue(d, v, path = "") {
     }
     case "enum":
       return typeof v === "string" && d.values.includes(v) ? null : `${at} must be one of ${d.values.join("|")}`;
+    case "bytes":
+      return v instanceof Uint8Array && v.length === d.n ? null : `${at} must be a Uint8Array of length ${d.n} (got ${describeBytesValue(v)})`;
     case "list": {
       if (!Array.isArray(v)) return `${at} must be an array`;
       if (v.length > d.max) return `${at} exceeds max length ${d.max} (${v.length})`;
@@ -160,6 +190,8 @@ function defaultValue(d) {
       return "";
     case "enum":
       return d.values[0];
+    case "bytes":
+      return new Uint8Array(d.n);
     case "list":
       return [];
     case "struct": {
@@ -170,6 +202,7 @@ function defaultValue(d) {
   }
 }
 function cloneValue(v) {
+  if (v instanceof Uint8Array) return copyBytes(v);
   if (Array.isArray(v)) return v.map(cloneValue);
   if (v !== null && typeof v === "object") {
     const o = {};
@@ -199,6 +232,11 @@ function normalizeValue(d, v, path = "") {
       if (v.length > d.max) throw new Error(`${at} exceeds max length ${d.max} (${v.length})`);
       return v.map((x, i) => normalizeValue(d.item, x, `${at}[${i}]`));
     }
+    case "bytes": {
+      const err = validateValue(d, v, path);
+      if (err) throw new Error(err);
+      return copyBytes(v);
+    }
     case "struct": {
       if (typeof v !== "object" || v === null || Array.isArray(v))
         throw new Error(`${at} must be an object`);
@@ -215,6 +253,83 @@ function normalizeValue(d, v, path = "") {
     }
   }
 }
+function copyBytes(v) {
+  return ArrayBuffer.isView(v) ? new Uint8Array(v) : v.slice();
+}
+function describeBytesValue(v) {
+  if (v instanceof Uint8Array) return `a Uint8Array of length ${v.length}`;
+  if (Array.isArray(v)) return `an array of length ${v.length}`;
+  if (v === null) return "null";
+  if (ArrayBuffer.isView(v)) return `a ${v.constructor.name}`;
+  return typeof v;
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(b) {
+  let out = "";
+  let i = 0;
+  for (; i + 2 < b.length; i += 3) {
+    const x = b[i] << 16 | b[i + 1] << 8 | b[i + 2];
+    out += B64[x >> 18] + B64[x >> 12 & 63] + B64[x >> 6 & 63] + B64[x & 63];
+  }
+  const rest = b.length - i;
+  if (rest === 1) {
+    const x = b[i] << 16;
+    out += `${B64[x >> 18]}${B64[x >> 12 & 63]}==`;
+  } else if (rest === 2) {
+    const x = b[i] << 16 | b[i + 1] << 8;
+    out += `${B64[x >> 18]}${B64[x >> 12 & 63]}${B64[x >> 6 & 63]}=`;
+  }
+  return out;
+}
+function base64ToBytes(s) {
+  if (s.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(s)) {
+    throw new Error("invalid base64");
+  }
+  const pad = s.endsWith("==") ? 2 : s.endsWith("=") ? 1 : 0;
+  const out = new Uint8Array(s.length / 4 * 3 - pad);
+  let o = 0;
+  for (let i = 0; i < s.length; i += 4) {
+    const x = B64.indexOf(s[i]) << 18 | B64.indexOf(s[i + 1]) << 12 | (s[i + 2] === "=" ? 0 : B64.indexOf(s[i + 2])) << 6 | (s[i + 3] === "=" ? 0 : B64.indexOf(s[i + 3]));
+    out[o++] = x >> 16;
+    if (o < out.length) out[o++] = x >> 8 & 255;
+    if (o < out.length) out[o++] = x & 255;
+  }
+  return out;
+}
+function jsonDefault(d, v) {
+  if (v === void 0 || v === null) return v;
+  switch (d.kind) {
+    case "bytes":
+      return v instanceof Uint8Array ? bytesToBase64(v) : v;
+    case "struct": {
+      const o = {};
+      for (const [k, fd] of Object.entries(d.fields)) {
+        o[k] = jsonDefault(fd, v[k]);
+      }
+      return o;
+    }
+    default:
+      return v;
+  }
+}
+function defaultFromJson(d, v) {
+  if (v === void 0 || v === null) return v;
+  switch (d.kind) {
+    case "bytes":
+      return typeof v === "string" ? base64ToBytes(v) : v;
+    case "struct": {
+      if (typeof v !== "object") return v;
+      const o = {};
+      for (const [k, fd] of Object.entries(d.fields)) {
+        const x = v[k];
+        if (x !== void 0) o[k] = defaultFromJson(fd, x);
+      }
+      return o;
+    }
+    default:
+      return v;
+  }
+}
 
 // src/physics.ts
 var PHYSICS_BODY_CHANNELS = [
@@ -647,9 +762,9 @@ function sha256(data) {
 function sha256Hex(data) {
   return toHex(sha256(data));
 }
-function toHex(bytes) {
+function toHex(bytes2) {
   let s = "";
-  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, "0");
+  for (let i = 0; i < bytes2.length; i++) s += bytes2[i].toString(16).padStart(2, "0");
   return s;
 }
 
@@ -715,13 +830,13 @@ function maxEncodedBytes(fields, names) {
   return total;
 }
 function varintBytes(max) {
-  let bytes = 1;
+  let bytes2 = 1;
   let v = Math.max(0, Math.floor(max));
   while (v > 127) {
     v = Math.floor(v / 128);
-    bytes++;
+    bytes2++;
   }
-  return bytes;
+  return bytes2;
 }
 function worstCase(d) {
   const presence = d.opt ? 1 : 0;
@@ -742,6 +857,8 @@ function worstCase(d) {
       return presence + varintBytes(d.max) + d.max;
     case "ref":
       return presence + varintBytes(ID_MAX_BYTES) + ID_MAX_BYTES;
+    case "bytes":
+      return presence + d.n;
     case "list":
       return presence + varintBytes(d.max) + d.max * worstCase(d.item);
     case "struct": {
@@ -778,12 +895,17 @@ function compilePersist(name, fields, perPlayer, declared) {
         `${name}: persist names ${field}, an entity ref \u2014 a ref is an id inside one room and means nothing in the next one`
       );
     }
+    if (containsBytes(known.get(field).type)) {
+      throw new Error(
+        `${name}: persist names ${field}, a bytes field \u2014 the persistence blob is JSON and does not carry binary`
+      );
+    }
     out.push(field);
   }
-  const bytes = maxEncodedBytes(fields, out);
-  if (bytes > PERSIST_BLOB_BYTES) {
+  const bytes2 = maxEncodedBytes(fields, out);
+  if (bytes2 > PERSIST_BLOB_BYTES) {
     throw new Error(
-      `${name}: persist fields can encode up to ${bytes} bytes, over the 4 KB persistence cap`
+      `${name}: persist fields can encode up to ${bytes2} bytes, over the 4 KB persistence cap`
     );
   }
   return out.sort();
@@ -848,6 +970,7 @@ function defineSchema(defs, options = {}) {
     const ownership = o.ownership || perPlayer ? compileOwnership(name, def.kind, fields, o.ownership ?? {}, perPlayer) : void 0;
     const persist = compilePersist(name, fields, perPlayer, o.persist);
     const serverFields = compileServerFields(name, def.kind, fields, o);
+    checkBytesWriters(name, def.kind, fields, o, serverFields);
     return {
       name,
       index,
@@ -988,6 +1111,15 @@ function defineSchema(defs, options = {}) {
     hash8: hashBytes.slice(0, 8)
   };
 }
+function checkBytesWriters(name, kind, fields, o, serverFields) {
+  if (kind !== "entity" || o.serverOwned === true) return;
+  for (const f of fields) {
+    if (!containsBytes(f.type) || serverFields?.has(f.name)) continue;
+    throw new Error(
+      `${name}.${f.name}: bytes(n) fields are server-written only in this release \u2014 declare the collection serverOwned: true or list ${JSON.stringify(f.name)} in serverFields`
+    );
+  }
+}
 function compileFields(fields) {
   return Object.entries(fields).map(([name, t], index) => ({ name, index, type: t.desc }));
 }
@@ -1011,7 +1143,7 @@ var CANONICAL_VERSION = 1;
 function canonicalType(d) {
   const o = { kind: d.kind };
   if (d.opt) o.opt = true;
-  if (d.hasDefault) o.default = d.default;
+  if (d.hasDefault) o.default = containsBytes(d) ? jsonDefault(d, d.default) : d.default;
   switch (d.kind) {
     case "str":
       o.max = d.max;
@@ -1022,6 +1154,9 @@ function canonicalType(d) {
     case "ref":
       o.entity = d.entity;
       break;
+    case "bytes":
+      o.n = d.n;
+      break;
     case "list":
       o.item = canonicalType(d.item);
       o.max = d.max;
@@ -1332,6 +1467,9 @@ function typeOf(t, at) {
     case "ref":
       base = ref(stringAt(t, "entity"));
       break;
+    case "bytes":
+      base = bytes(numberAt(t, "n"));
+      break;
     case "list":
       base = list(typeOf(objectAt(t, "item"), `${at}[]`), numberAt(t, "max"));
       break;
@@ -1342,7 +1480,10 @@ function typeOf(t, at) {
       throw new Error(`${at}: unknown type kind ${JSON.stringify(kind)}`);
   }
   if (t.opt === true) base = base.opt;
-  if (Object.hasOwn(t, "default")) base = base.default(t.default);
+  if (Object.hasOwn(t, "default")) {
+    const value = containsBytes(base.desc) ? defaultFromJson(base.desc, t.default) : t.default;
+    base = base.default(value);
+  }
   return base;
 }
 function entityOptions(e, name) {
@@ -1565,6 +1706,7 @@ function createState(schema, init) {
 }
 
 // src/dirty.ts
+var MAX_BYTE_RANGES = 16;
 function createDirtySet() {
   return /* @__PURE__ */ new Map();
 }
@@ -1610,6 +1752,87 @@ function markPath(mask, path) {
   const last = path[path.length - 1];
   m.fields.add(last);
   m.nested.delete(last);
+  m.ranges?.delete(last);
+}
+function markBytes(dirty, collection, id, path, start, end, n) {
+  const r = recordDirty(dirty, collection, id);
+  if (r) markBytesPath(r.mask, path, start, end, n);
+}
+function markBytesPath(mask, path, start, end, n) {
+  if (path.length === 0 || end <= start) return;
+  let m = mask;
+  for (let i = 0; i < path.length - 1; i++) {
+    const idx = path[i];
+    if (isWhole(m, idx)) return;
+    m.fields.add(idx);
+    let nm = m.nested.get(idx);
+    if (!nm) {
+      nm = createFieldMask();
+      m.nested.set(idx, nm);
+    }
+    m = nm;
+  }
+  const last = path[path.length - 1];
+  if (m.fields.has(last) && !m.ranges?.has(last)) return;
+  m.fields.add(last);
+  const ranges = m.ranges ??= /* @__PURE__ */ new Map();
+  const merged = unionRanges(ranges.get(last) ?? [], [{ start, end }]);
+  const settled = settleRanges(merged, n);
+  if (settled) ranges.set(last, settled);
+  else ranges.delete(last);
+}
+function varintSize(v) {
+  let n = 1;
+  let x = v;
+  while (x >= 128) {
+    x = Math.floor(x / 128);
+    n++;
+  }
+  return n;
+}
+function rangesPatchBytes(ranges) {
+  let total = varintSize(ranges.length);
+  for (const r of ranges) {
+    const len = r.end - r.start;
+    total += varintSize(r.start) + varintSize(len) + len;
+  }
+  return total;
+}
+function settleRanges(ranges, n) {
+  if (ranges.length === 0 || ranges.length > MAX_BYTE_RANGES) return void 0;
+  if (n !== void 0 && rangesPatchBytes(ranges) >= n) return void 0;
+  return ranges;
+}
+function unionRanges(a, b) {
+  const all = [...a, ...b].sort((x, y) => x.start - y.start);
+  const out = [];
+  for (const r of all) {
+    const last = out[out.length - 1];
+    if (last && last.end >= r.start) {
+      if (r.end > last.end) out[out.length - 1] = { start: last.start, end: r.end };
+    } else {
+      out.push({ start: r.start, end: r.end });
+    }
+  }
+  return out;
+}
+function diffByteRanges(a, b, gap = 4) {
+  const out = [];
+  const n = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < n) {
+    if (a[i] === b[i]) {
+      i++;
+      continue;
+    }
+    let end = i + 1;
+    while (end < n && a[end] !== b[end]) end++;
+    const last = out[out.length - 1];
+    if (last && i - last.end < gap) out[out.length - 1] = { start: last.start, end };
+    else out.push({ start: i, end });
+    i = end;
+  }
+  return out;
 }
 function markOwner(dirty, collection, id) {
   const r = recordDirty(dirty, collection, id);
@@ -1634,7 +1857,7 @@ function isDirtyEmpty(dirty) {
   return true;
 }
 function isWhole(mask, idx) {
-  return mask.fields.has(idx) && !mask.nested.has(idx);
+  return mask.fields.has(idx) && !mask.nested.has(idx) && !mask.ranges?.has(idx);
 }
 function mergeDirty(dst, src) {
   for (const [name, sc] of src) {
@@ -1651,9 +1874,18 @@ function mergeDirty(dst, src) {
 function mergeMask(dst, src) {
   for (const idx of src.fields) {
     const n = src.nested.get(idx);
-    if (!n) {
+    const sr = src.ranges?.get(idx);
+    if (sr) {
+      if (dst.fields.has(idx) && !dst.ranges?.has(idx)) continue;
+      dst.fields.add(idx);
+      const ranges = dst.ranges ??= /* @__PURE__ */ new Map();
+      const settled = settleRanges(unionRanges(ranges.get(idx) ?? [], sr));
+      if (settled) ranges.set(idx, settled);
+      else ranges.delete(idx);
+    } else if (!n) {
       dst.fields.add(idx);
       dst.nested.delete(idx);
+      dst.ranges?.delete(idx);
     } else if (!isWhole(dst, idx)) {
       dst.fields.add(idx);
       let dn = dst.nested.get(idx);
@@ -1773,11 +2005,11 @@ var ByteWriter = class {
     return this.buf.slice(0, this.pos);
   }
 };
-function utf82(bytes) {
+function utf82(bytes2) {
   try {
-    return decoder.decode(bytes);
+    return decoder.decode(bytes2);
   } catch {
-    throw new Error(`invalid UTF-8 in string (${bytes.length} bytes)`);
+    throw new Error(`invalid UTF-8 in string (${bytes2.length} bytes)`);
   }
 }
 var ByteReader = class {
@@ -1889,7 +2121,7 @@ function bytesEqual(a, b) {
 }
 
 // src/codec.ts
-function varintSize(v) {
+function varintSize2(v) {
   let n = 1;
   let x = v;
   while (x >= 128) {
@@ -1924,14 +2156,14 @@ var CountingSink = class {
   varint(v) {
     if (!Number.isInteger(v) || v < 0 || v > 4294967295)
       throw new Error(`varint out of range: ${v}`);
-    this.length += varintSize(v);
+    this.length += varintSize2(v);
   }
   bytes(b) {
     this.length += b.length;
   }
   str(s) {
     const n = utf8Length(s);
-    this.length += varintSize(n) + n;
+    this.length += varintSize2(n) + n;
     return n;
   }
 };
@@ -2000,6 +2232,9 @@ function writeValue(w, desc, v, path = "value") {
       w.u8(i);
       return;
     }
+    case "bytes":
+      w.bytes(checkBytes(value, desc.n, path));
+      return;
     case "list": {
       if (!Array.isArray(value)) fail(path, "must be an array");
       if (value.length > desc.max) fail(path, `exceeds max length ${desc.max} (${value.length})`);
@@ -2016,6 +2251,14 @@ function writeValue(w, desc, v, path = "value") {
     }
   }
 }
+function checkBytes(value, n, path) {
+  if (!(value instanceof Uint8Array) || value.length !== n) {
+    fail(path, `must be a Uint8Array of length ${n} (got ${describeBytesValue(value)})`);
+  }
+  return value;
+}
+var BYTES_WHOLE = 0;
+var BYTES_PATCH = 1;
 function warnNonFinite(path, value) {
   console.warn(
     `irtio: snapshot field ${path} held ${value}; restored as the field's default. The value predates the finiteness checks on write and encode.`
@@ -2054,6 +2297,8 @@ function readValue(r, desc, opts, path = "value") {
         throw new Error(`unknown enum index ${i} (${desc.values.length} values)`);
       return v;
     }
+    case "bytes":
+      return copyBytes(r.bytes(desc.n));
     case "list": {
       const n = r.varint();
       if (n > desc.max) throw new Error(`list exceeds max length ${desc.max} (${n})`);
@@ -2085,8 +2330,8 @@ function encodeFields(fields, value) {
   writeRecord(w, fields, value, "fields");
   return w.finish();
 }
-function decodeFields(fields, bytes) {
-  const r = bytes instanceof ByteReader ? bytes : new ByteReader(bytes);
+function decodeFields(fields, bytes2) {
+  const r = bytes2 instanceof ByteReader ? bytes2 : new ByteReader(bytes2);
   return readRecord(r, fields);
 }
 function entityOf(state, name) {
@@ -2137,8 +2382,8 @@ function encodeSnapshot(schema, state, header, options) {
   writeSnapshot(w, schema, state, header.tick, options);
   return w.finish();
 }
-function decodeSnapshot(schema, bytes, options = {}) {
-  const r = new ByteReader(bytes);
+function decodeSnapshot(schema, bytes2, options = {}) {
+  const r = new ByteReader(bytes2);
   const opts = { onNonFinite: options.onNonFinite ?? warnNonFinite };
   const tick = r.u32();
   const hash8 = r.bytes(8).slice();
@@ -2182,14 +2427,18 @@ function planCollection(c, state, dirty) {
   return ops.length > 0 ? ops : void 0;
 }
 function maskBytesFor(indices, bits) {
-  const bytes = new Uint8Array(bits + 7 >> 3);
-  for (const i of indices) bytes[i >> 3] |= 1 << (i & 7);
-  return bytes;
+  const bytes2 = new Uint8Array(bits + 7 >> 3);
+  for (const i of indices) bytes2[i >> 3] |= 1 << (i & 7);
+  return bytes2;
 }
 function sortedIndices(mask, limit) {
   return [...mask.fields].filter((i) => i >= 0 && i < limit).sort((a, b) => a - b);
 }
-function writeDirtyField(w, desc, v, nested, path) {
+function writeDirtyField(w, desc, v, nested, ranges, path) {
+  if (desc.kind === "bytes") {
+    writeDirtyBytes(w, desc, v, ranges, path);
+    return;
+  }
   if (desc.kind !== "struct") {
     writeValue(w, desc, v, path);
     return;
@@ -2214,8 +2463,41 @@ function writeDirtyField(w, desc, v, nested, path) {
   for (const i of indices) {
     const name = names[i];
     const fd = desc.fields[name];
-    writeDirtyField(w, fd, o[name], nested?.nested.get(i), `${path}.${name}`);
+    writeDirtyField(
+      w,
+      fd,
+      o[name],
+      nested?.nested.get(i),
+      nested?.ranges?.get(i),
+      `${path}.${name}`
+    );
+  }
+}
+function writeDirtyBytes(w, desc, v, ranges, path) {
+  let value = v;
+  if (value === void 0 && desc.hasDefault && desc.default !== void 0) value = desc.default;
+  if (desc.opt) {
+    if (value === void 0) {
+      w.u8(0);
+      return;
+    }
+    w.u8(1);
+  } else if (value === void 0) {
+    fail(path, "is required");
+  }
+  const b = checkBytes(value, desc.n, path);
+  if (ranges && ranges.length > 0 && ranges.length <= MAX_BYTE_RANGES && rangesPatchBytes(ranges) < desc.n) {
+    w.u8(BYTES_PATCH);
+    w.varint(ranges.length);
+    for (const r of ranges) {
+      w.varint(r.start);
+      w.varint(r.end - r.start);
+      w.bytes(b.subarray(r.start, r.end));
+    }
+    return;
   }
+  w.u8(BYTES_WHOLE);
+  w.bytes(b);
 }
 function writeDelta(w, schema, state, dirty, tick) {
   w.u32(tick);
@@ -2258,6 +2540,7 @@ function writeDelta(w, schema, state, dirty, tick) {
           f.type,
           value[f.name],
           op.mask.nested.get(i),
+          op.mask.ranges?.get(i),
           `${c.name}[${op.id}].${f.name}`
         );
       }
@@ -2278,6 +2561,7 @@ function readBit(mask, i) {
   return ((mask[i >> 3] ?? 0) & 1 << (i & 7)) !== 0;
 }
 function readDirtyField(r, desc) {
+  if (desc.kind === "bytes") return readDirtyBytes(r, desc);
   if (desc.kind !== "struct") return { value: readValue(r, desc) };
   if (desc.opt && r.u8() === 0) return { value: void 0 };
   const names = structNames(desc);
@@ -2292,41 +2576,78 @@ function readDirtyField(r, desc) {
     out[name] = got.value;
     mask.fields.add(i);
     if (got.nested) mask.nested.set(i, got.nested);
+    if (got.ranges) (mask.ranges ??= /* @__PURE__ */ new Map()).set(i, got.ranges);
   }
   return { value: out, nested: mask };
 }
-function decodeDelta(schema, bytes) {
-  return decodeDeltaFrom(schema, new ByteReader(bytes));
+function readDirtyBytes(r, desc) {
+  if (desc.opt && r.u8() === 0) return { value: void 0 };
+  const tag = r.u8();
+  if (tag === BYTES_WHOLE) return { value: copyBytes(r.bytes(desc.n)) };
+  if (tag !== BYTES_PATCH) throw new Error(`unknown bytes tag ${tag}`);
+  const count = r.varint();
+  if (count < 1 || count > MAX_BYTE_RANGES) {
+    throw new Error(`bytes patch has ${count} spans (1..${MAX_BYTE_RANGES} allowed)`);
+  }
+  const spans = [];
+  const ranges = [];
+  let floor = 0;
+  for (let i = 0; i < count; i++) {
+    const offset = r.varint();
+    const length = r.varint();
+    if (length < 1) throw new Error("bytes patch span has length 0");
+    if (offset < floor || offset + length > desc.n) {
+      throw new Error(
+        `bytes patch span [${offset}, ${offset + length}) is out of order or outside bytes(${desc.n})`
+      );
+    }
+    spans.push({ offset, bytes: copyBytes(r.bytes(length)) });
+    ranges.push({ start: offset, end: offset + length });
+    floor = offset + length;
+  }
+  const patch = { spans };
+  return { value: patch, ranges };
+}
+function decodeDelta(schema, bytes2, options) {
+  return decodeDeltaFrom(schema, new ByteReader(bytes2), options);
 }
-function decodeDeltaFrom(schema, r) {
+function decodeDeltaFrom(schema, r, options = {}) {
   const tick = r.u32();
   const hash8 = r.bytes(8).slice();
   const collections = [];
   const count = r.varint();
+  const known = schema.collections.length;
+  if (count > known) throw new Error(`delta names ${count} collections; the schema has ${known}`);
+  let total = 0;
   for (let ci = 0; ci < count; ci++) {
     const index = r.varint();
     const c = schema.collections[index];
     if (!c) throw new Error(`delta references unknown collection index ${index}`);
     const opCount = r.varint();
+    if (opCount > r.remaining)
+      throw new Error(`delta claims ${opCount} ops in ${c.name} with ${r.remaining} bytes left`);
+    total += opCount;
+    if (options.maxOps !== void 0 && total > options.maxOps)
+      throw new Error(`delta carries ${total} ops; the limit is ${options.maxOps}`);
     const ops = [];
     for (let oi = 0; oi < opCount; oi++) {
       const op = r.u8();
       if (op === OP_REMOVE) {
-        ops.push({ op: "remove", id: r.str() });
+        ops.push({ op: "remove", id: r.str(ID_MAX_BYTES) });
         continue;
       }
       if (op === OP_ADD) {
-        const id2 = r.str();
-        const owner2 = r.str();
+        const id2 = r.str(ID_MAX_BYTES);
+        const owner2 = r.str(ID_MAX_BYTES);
         ops.push({ op: "add", id: id2, owner: owner2, value: readRecord(r, c.fields) });
         continue;
       }
       if (op !== OP_UPDATE) throw new Error(`unknown delta op byte ${op} in ${c.name}`);
-      const id = r.str();
+      const id = r.str(ID_MAX_BYTES);
       const n = c.fields.length;
       const maskBytes = r.bytes(n + 1 + 7 >> 3);
       const ownerDirty = readBit(maskBytes, n);
-      const owner = ownerDirty ? r.str() : void 0;
+      const owner = ownerDirty ? r.str(ID_MAX_BYTES) : void 0;
       const mask = createFieldMask();
       const patch = {};
       for (let i = 0; i < n; i++) {
@@ -2336,6 +2657,7 @@ function decodeDeltaFrom(schema, r) {
         patch[f.name] = got.value;
         mask.fields.add(i);
         if (got.nested) mask.nested.set(i, got.nested);
+        if (got.ranges) (mask.ranges ??= /* @__PURE__ */ new Map()).set(i, got.ranges);
       }
       ops.push(
         owner === void 0 ? { op: "update", id, mask, patch } : { op: "update", id, owner, mask, patch }
@@ -2366,9 +2688,23 @@ function applyPatch(fieldTypes, target, patch, mask) {
         continue;
       }
     }
+    if (mask.ranges?.has(i) && f.type.kind === "bytes" && isBytesPatch(value)) {
+      const current = target[f.name];
+      if (current instanceof Uint8Array && current.length === f.type.n) {
+        for (const span of value.spans) current.set(span.bytes, span.offset);
+        continue;
+      }
+      const fresh = new Uint8Array(f.type.n);
+      for (const span of value.spans) fresh.set(span.bytes, span.offset);
+      target[f.name] = fresh;
+      continue;
+    }
     target[f.name] = value;
   }
 }
+function isBytesPatch(v) {
+  return typeof v === "object" && v !== null && Array.isArray(v.spans);
+}
 function applyDelta(schema, state, delta) {
   for (const dc of delta.collections) {
     const c = schema.collection(dc.name);
@@ -2397,6 +2733,9 @@ function applyDelta(schema, state, delta) {
 }
 function valueEquals(a, b) {
   if (Object.is(a, b)) return true;
+  if (a instanceof Uint8Array || b instanceof Uint8Array) {
+    return a instanceof Uint8Array && b instanceof Uint8Array && bytesEqual(a, b);
+  }
   if (Array.isArray(a) || Array.isArray(b)) {
     if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) if (!valueEquals(a[i], b[i])) return false;
@@ -2422,6 +2761,14 @@ function diffField(desc, a, b, mask, idx) {
     mask.nested.set(idx, nested);
     return;
   }
+  if (desc.kind === "bytes" && a instanceof Uint8Array && b instanceof Uint8Array && a.length === desc.n && b.length === desc.n) {
+    const found = diffByteRanges(a, b);
+    if (found.length === 0) return;
+    mask.fields.add(idx);
+    const settled = settleRanges(found, desc.n);
+    if (settled) (mask.ranges ??= /* @__PURE__ */ new Map()).set(idx, settled);
+    return;
+  }
   if (!valueEquals(a, b)) mask.fields.add(idx);
 }
 function diffRecord(c, a, b, mask) {
@@ -2491,6 +2838,9 @@ function skipValue(r, desc) {
     case "ref":
       skip(r, r.varint());
       return;
+    case "bytes":
+      skip(r, desc.n);
+      return;
     case "list": {
       const n = r.varint();
       if (n > desc.max) throw new Error(`list exceeds max length ${desc.max} (${n})`);
@@ -2507,6 +2857,33 @@ function readBit2(mask, i) {
   return ((mask[i >> 3] ?? 0) & 1 << (i & 7)) !== 0;
 }
 function skipDirtyField(r, desc) {
+  if (desc.kind === "bytes") {
+    if (desc.opt && r.u8() === 0) return;
+    const tag = r.u8();
+    if (tag === 0) {
+      skip(r, desc.n);
+      return;
+    }
+    if (tag !== 1) throw new Error(`unknown bytes tag ${tag}`);
+    const count = r.varint();
+    if (count < 1 || count > MAX_BYTE_RANGES) {
+      throw new Error(`bytes patch has ${count} spans (1..${MAX_BYTE_RANGES} allowed)`);
+    }
+    let floor = 0;
+    for (let i = 0; i < count; i++) {
+      const offset = r.varint();
+      const length = r.varint();
+      if (length < 1) throw new Error("bytes patch span has length 0");
+      if (offset < floor || offset + length > desc.n) {
+        throw new Error(
+          `bytes patch span [${offset}, ${offset + length}) is out of order or outside bytes(${desc.n})`
+        );
+      }
+      skip(r, length);
+      floor = offset + length;
+    }
+    return;
+  }
   if (desc.kind !== "struct") {
     skipValue(r, desc);
     return;
@@ -2519,11 +2896,11 @@ function skipDirtyField(r, desc) {
     skipDirtyField(r, desc.fields[names[i]]);
   }
 }
-function readerFor(bytes) {
-  return bytes instanceof ByteReader ? bytes : new ByteReader(bytes);
+function readerFor(bytes2) {
+  return bytes2 instanceof ByteReader ? bytes2 : new ByteReader(bytes2);
 }
-function walkDelta(schema, bytes, events) {
-  const r = readerFor(bytes);
+function walkDelta(schema, bytes2, events) {
+  const r = readerFor(bytes2);
   const from = r.pos;
   let at = r.pos;
   skip(r, 12);
@@ -2570,8 +2947,8 @@ function walkDelta(schema, bytes, events) {
   }
   return r.pos - from;
 }
-function walkSnapshot(schema, bytes, events) {
-  const r = readerFor(bytes);
+function walkSnapshot(schema, bytes2, events) {
+  const r = readerFor(bytes2);
   const from = r.pos;
   skip(r, 12);
   events.header(12);
@@ -2631,8 +3008,9 @@ function mark(root, path) {
 }
 function assertLive(root) {
   if (!root.live) {
+    const id = JSON.stringify(root.id);
     throw new Error(
-      `${root.collection}: instance ${JSON.stringify(root.id)} was removed; its proxy is stale`
+      root.reason === "replaced" ? `${root.collection}: instance ${id} was replaced (re-added) since this handle was taken; re-read it with .get(${id})` : `${root.collection}: instance ${id} was removed; its proxy is stale`
     );
   }
 }
@@ -2653,6 +3031,7 @@ function objHandler(node) {
         return structProxy(node, f, v);
       }
       if (f.type.kind === "list") return listProxy(node, f, v);
+      if (f.type.kind === "bytes") return bytesProxy(node, f, v);
       return v;
     },
     set(target, prop, value) {
@@ -2665,6 +3044,16 @@ function objHandler(node) {
       const at = `${node.label}.${f.name}`;
       const next = value === void 0 && f.type.opt ? void 0 : normalizeValue(f.type, value, at);
       if (valueEquals(target[f.name], next)) return true;
+      const current = target[f.name];
+      if (f.type.kind === "bytes" && !node.whole && current instanceof Uint8Array && next instanceof Uint8Array) {
+        const path = childPath(node.path, node.whole, f.index);
+        const root = node.root;
+        for (const r of diffByteRanges(current, next)) {
+          markBytes(root.ctx.dirty, root.collection, root.id, path, r.start, r.end, f.type.n);
+        }
+        current.set(next);
+        return true;
+      }
       target[f.name] = next;
       mark(node.root, childPath(node.path, node.whole, f.index));
       return true;
@@ -2832,6 +3221,177 @@ function listElemProxy(parent, prop, value) {
     label: `${parent.label}[${prop}]`
   });
 }
+var BYTES_MUTATORS = /* @__PURE__ */ new Set(["set", "fill", "copyWithin", "sort", "reverse"]);
+function isNumericProp(prop) {
+  return prop === "-0" || String(Number(prop)) === prop;
+}
+function relIndex(x, len, dflt) {
+  if (x === void 0) return dflt;
+  const v = Math.trunc(Number(x)) || 0;
+  return v < 0 ? Math.max(len + v, 0) : Math.min(v, len);
+}
+function checkByte(label, i, v) {
+  if (typeof v !== "number" || !Number.isInteger(v) || v < 0 || v > 255) {
+    throw new Error(`${label}[${i}]: must be an integer 0..255 (got ${String(v)})`);
+  }
+}
+function reportDiff(t, before, start, hooks) {
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < before.length; i++) {
+    if (before[i] !== t[start + i]) {
+      if (first < 0) first = i;
+      last = i;
+    }
+  }
+  if (first >= 0) hooks.changed(start + first, start + last + 1);
+}
+function bytesView(target, label, hooks) {
+  const n = target.length;
+  const bound = /* @__PURE__ */ new Map();
+  const mutator = (name) => {
+    const t = target;
+    switch (name) {
+      case "set":
+        return (src, offset) => {
+          if (!hooks.begin("set")) return void 0;
+          const source = src;
+          const len = Number(source?.length ?? 0) || 0;
+          const off = Math.trunc(Number(offset ?? 0)) || 0;
+          if (off < 0 || off + len > n) {
+            throw new Error(
+              `${label}.set: a source of length ${len} at offset ${off} overflows bytes(${n})`
+            );
+          }
+          if (!(src instanceof Uint8Array) && !(src instanceof Uint8ClampedArray)) {
+            for (let i = 0; i < len; i++) checkByte(label, off + i, source[i]);
+          }
+          const before = t.slice(off, off + len);
+          try {
+            t.set(src, off);
+          } catch (e) {
+            if (e instanceof RangeError) {
+              throw new Error(`${label}.set: ${e.message} (bytes(${n}))`);
+            }
+            throw e;
+          }
+          reportDiff(t, before, off, hooks);
+          return void 0;
+        };
+      case "fill":
+        return (v, start, end) => {
+          if (!hooks.begin("fill")) return proxy;
+          checkByte(label, "fill", v);
+          const s = relIndex(start, n, 0);
+          const e = relIndex(end, n, n);
+          if (e > s) {
+            const before = t.slice(s, e);
+            t.fill(v, s, e);
+            reportDiff(t, before, s, hooks);
+          }
+          return proxy;
+        };
+      case "copyWithin":
+        return (to, start, end) => {
+          if (!hooks.begin("copyWithin")) return proxy;
+          const dst = relIndex(to, n, 0);
+          const from = relIndex(start, n, 0);
+          const fin = relIndex(end, n, n);
+          const count = Math.min(fin - from, n - dst);
+          if (count > 0) {
+            const before = t.slice(dst, dst + count);
+            t.copyWithin(dst, from, fin);
+            reportDiff(t, before, dst, hooks);
+          }
+          return proxy;
+        };
+      default:
+        return (...args) => {
+          if (!hooks.begin(name)) return proxy;
+          const before = t.slice();
+          Uint8Array.prototype[name].apply(t, args);
+          for (let i = 0; i < n; i++) {
+            if (before[i] !== t[i]) {
+              hooks.changed(0, n);
+              break;
+            }
+          }
+          return proxy;
+        };
+    }
+  };
+  const selfValue = () => proxy;
+  const proxy = new Proxy(target, {
+    get(t, prop) {
+      if (typeof prop === "string") {
+        if (isIndexProp(prop)) return t[prop];
+        if (BYTES_MUTATORS.has(prop)) {
+          let fn = bound.get(prop);
+          if (!fn) {
+            fn = mutator(prop);
+            bound.set(prop, fn);
+          }
+          return fn;
+        }
+      }
+      if (prop === "valueOf") return selfValue;
+      const v = Reflect.get(t, prop, t);
+      if (typeof v === "function" && prop !== "constructor") {
+        let fn = bound.get(prop);
+        if (!fn) {
+          fn = v.bind(t);
+          bound.set(prop, fn);
+        }
+        return fn;
+      }
+      return v;
+    },
+    set(t, prop, value) {
+      if (typeof prop === "string" && isNumericProp(prop)) {
+        if (!hooks.begin(prop)) return true;
+        const i = Number(prop);
+        if (!Number.isInteger(i) || i < 0 || i >= n || prop === "-0") {
+          throw new Error(`${label}[${prop}]: index out of range for bytes(${n})`);
+        }
+        checkByte(label, i, value);
+        if (t[i] !== value) {
+          t[i] = value;
+          hooks.changed(i, i + 1);
+        }
+        return true;
+      }
+      if (!hooks.begin(String(prop))) return true;
+      throw new Error(`${label}: cannot set ${String(prop)} on a bytes(${n}) field`);
+    },
+    deleteProperty(_t, prop) {
+      if (!hooks.begin(String(prop))) return true;
+      throw new Error(`${label}: cannot delete ${String(prop)} from a bytes(${n}) field`);
+    },
+    defineProperty(_t, prop) {
+      if (!hooks.begin(String(prop))) return true;
+      throw new Error(`${label}: cannot defineProperty ${String(prop)} on a bytes(${n}) field`);
+    }
+  });
+  return proxy;
+}
+function bytesProxy(parent, f, value) {
+  const root = parent.root;
+  const cached = root.ctx.proxies.get(value);
+  if (cached) return cached;
+  const path = childPath(parent.path, parent.whole, f.index);
+  const n = f.type.n;
+  const p = bytesView(value, `${parent.label}.${f.name}`, {
+    begin() {
+      assertLive(root);
+      return true;
+    },
+    // `whole` (a bytes field inside a list element) cannot happen today — `list()` refuses bytes
+    // items — but if it ever can, the list field is what has to be marked.
+    changed: parent.whole ? () => mark(root, path) : (start, end) => markBytes(root.ctx.dirty, root.collection, root.id, path, start, end, n)
+  });
+  root.ctx.proxies.set(value, p);
+  return p;
+}
 var TrackedCollection = class {
   constructor(ctx, desc, inner) {
     this.ctx = ctx;
@@ -2842,10 +3402,11 @@ var TrackedCollection = class {
   desc;
   inner;
   roots = /* @__PURE__ */ new Map();
-  invalidate(id) {
+  invalidate(id, reason) {
     const root = this.roots.get(id);
     if (root) {
       root.live = false;
+      root.reason = reason;
       this.roots.delete(id);
     }
   }
@@ -2854,7 +3415,10 @@ var TrackedCollection = class {
     if (cached) return cached;
     let root = this.roots.get(id);
     if (!root || root.target !== value) {
-      if (root) root.live = false;
+      if (root) {
+        root.live = false;
+        root.reason = "replaced";
+      }
       root = { ctx: this.ctx, collection: this.desc.name, id, target: value, live: true };
       this.roots.set(id, root);
     }
@@ -2868,7 +3432,7 @@ var TrackedCollection = class {
     });
   }
   add(id, values, options) {
-    this.invalidate(id);
+    this.invalidate(id, this.inner.has(id) ? "replaced" : "removed");
     const value = this.inner.add(id, values, options);
     markAdd(this.ctx.dirty, this.desc.name, id);
     return this.proxyFor(id, value);
@@ -2876,7 +3440,7 @@ var TrackedCollection = class {
   remove(id) {
     const had = this.inner.remove(id);
     if (had) {
-      this.invalidate(id);
+      this.invalidate(id, "removed");
       markRemove(this.ctx.dirty, this.desc.name, id);
     }
     return had;
@@ -3001,6 +3565,18 @@ function frozenProxy(value, ownershipHint) {
 function freeze(target, hint, prefix, warned, cache) {
   const cached = cache.get(target);
   if (cached) return cached;
+  if (target instanceof Uint8Array) {
+    const view = bytesView(target, prefix, {
+      begin(member) {
+        warnFrozen(hint, prefix, member, warned);
+        return false;
+      },
+      changed() {
+      }
+    });
+    cache.set(target, view);
+    return view;
+  }
   const p = new Proxy(target, {
     get(t, prop, receiver) {
       const v = Reflect.get(t, prop, receiver);
@@ -3035,17 +3611,34 @@ function warnFrozen(hint, prefix, prop, warned) {
 // src/diff.ts
 function diffSchemas(oldSchema, newSchema) {
   const changes = [];
-  diffCollections(
-    oldSchema.collections,
-    newSchema.collections,
-    changes
+  const section = (scope, diff) => {
+    const out = [];
+    diff(out);
+    for (const c of out) changes.push({ ...c, scope });
+  };
+  section(
+    "collection",
+    (out) => diffCollections(
+      oldSchema.collections,
+      newSchema.collections,
+      out
+    )
   );
-  diffRpcs(oldSchema.rpcs, newSchema.rpcs, changes);
-  diffRoles(oldSchema.roles, newSchema.roles, changes);
-  diffMessages(
-    oldSchema.messages ?? [],
-    newSchema.messages ?? [],
-    changes
+  section(
+    "rpc",
+    (out) => diffRpcs(oldSchema.rpcs, newSchema.rpcs, out)
+  );
+  section(
+    "roles",
+    (out) => diffRoles(oldSchema.roles, newSchema.roles, out)
+  );
+  section(
+    "message",
+    (out) => diffMessages(
+      oldSchema.messages ?? [],
+      newSchema.messages ?? [],
+      out
+    )
   );
   changes.sort(
     (a, b) => a.path === b.path ? a.code.localeCompare(b.code) : a.path.localeCompare(b.path)
@@ -3054,9 +3647,7 @@ function diffSchemas(oldSchema, newSchema) {
 }
 function breakingIsWireOnly(changes) {
   const breaking = changes.filter((c) => c.kind === "breaking");
-  return breaking.length > 0 && breaking.every(
-    (c) => c.path === "rpc" || c.path.startsWith("rpc.") || c.path.startsWith("message.")
-  );
+  return breaking.length > 0 && breaking.every((c) => c.scope === "rpc" || c.scope === "message");
 }
 function diffCollections(oldCollections, newCollections, changes) {
   const oldByName = new Map(oldCollections.map((c) => [c.name, c]));
@@ -3250,6 +3841,24 @@ function diffRoles(oldRoles, newRoles, changes) {
     }
   }
 }
+function defaultHint(t) {
+  switch (t.kind) {
+    case "bool":
+      return "add `.default(false)`, or make it .opt";
+    case "str":
+      return "add `.default('')`, or make it .opt";
+    case "enum":
+      return `add \`.default(${JSON.stringify(t.values[0])})\`, or make it .opt`;
+    case "list":
+      return "add `.default([])`, or make it .opt";
+    case "struct":
+      return "make it .opt, or add `.default({ ... })` with every field filled";
+    case "ref":
+      return "make it .opt (a ref names an instance; there is no default worth inventing)";
+    default:
+      return `add \`.default(0)\` to the ${t.kind}, or make it .opt`;
+  }
+}
 function diffFields(oldFields, newFields, basePath, changes) {
   const oldByName = new Map(oldFields.map((f) => [f.name, f]));
   const newByName = new Map(newFields.map((f) => [f.name, f]));
@@ -3270,7 +3879,7 @@ function diffFields(oldFields, newFields, basePath, changes) {
       kind: additive ? "additive" : "breaking",
       code: "field.added",
       path: `${basePath}.${name}`,
-      message: additive ? `${basePath}.${name}: new field added (has a default/opt, safe for existing snapshots)` : `${basePath}.${name}: new required field without a default (breaking) \u2014 add .default(...) or make it .opt`
+      message: additive ? `${basePath}.${name}: new field added (has a default/opt, safe for existing snapshots)` : `${basePath}.${name}: new required field without a default (breaking) \u2014 ${defaultHint(f.type)}`
     });
   }
   if (removedNames.length === 1 && addedNames.length === 1) {
@@ -3347,6 +3956,18 @@ function diffType(oldT, newT, path, changes) {
     case "enum":
       diffEnum(oldT.values, newT.values, path, changes);
       break;
+    case "bytes": {
+      const newN = newT.n;
+      if (oldT.n !== newN) {
+        changes.push({
+          kind: "breaking",
+          code: "field.bytes_length_changed",
+          path,
+          message: `${path}: bytes length changed from ${oldT.n} to ${newN} \u2014 the length is implied by the schema, so every stored snapshot would be misread (breaking)`
+        });
+      }
+      break;
+    }
     case "list": {
       const newList = newT;
       diffMax(oldT.max, newList.max, path, changes);
@@ -3413,7 +4034,7 @@ function diffDefault(oldT, newT, path, changes) {
       path,
       message: `${path}: .default(...) removed; existing snapshots already have values, so this is safe`
     });
-  } else if (oldT.hasDefault && newT.hasDefault && stableStringify(oldT.default) !== stableStringify(newT.default)) {
+  } else if (oldT.hasDefault && newT.hasDefault && !defaultsEqual(oldT, newT)) {
     changes.push({
       kind: "additive",
       code: "field.default_changed",
@@ -3422,6 +4043,15 @@ function diffDefault(oldT, newT, path, changes) {
     });
   }
 }
+function defaultsEqual(oldT, newT) {
+  if (oldT.default instanceof Uint8Array && newT.default instanceof Uint8Array) {
+    return bytesEqual(oldT.default, newT.default);
+  }
+  if (containsBytes(oldT) || containsBytes(newT)) {
+    return stableStringify(jsonDefault(oldT, oldT.default)) === stableStringify(jsonDefault(newT, newT.default));
+  }
+  return stableStringify(oldT.default) === stableStringify(newT.default);
+}
 function structFieldDescs(fields) {
   return Object.entries(fields).map(([name, type], index) => ({ name, index, type }));
 }
@@ -3448,6 +4078,9 @@ function typeSignature(d) {
     case "ref":
       o.entity = d.entity;
       break;
+    case "bytes":
+      o.n = d.n;
+      break;
     case "list":
       o.max = d.max;
       o.item = typeSignature(d.item);
@@ -3461,11 +4094,13 @@ function typeSignature(d) {
   return stableStringify(o);
 }
 export {
+  BYTES_MAX,
   ByteReader,
   ByteWriter,
   CANONICAL_VERSION,
   EntityCollection,
   ID_MAX_BYTES,
+  MAX_BYTE_RANGES,
   MAX_MESSAGES,
   MAX_USER_RPCS,
   PERSIST_BLOB_BYTES,
@@ -3478,9 +4113,12 @@ export {
   angleFrom2d,
   applyChannel2d,
   applyDelta,
+  base64ToBytes,
   bool,
   breakingIsWireOnly,
+  bytes,
   bytesEqual,
+  bytesToBase64,
   canonicalOwnership,
   canonicalPhysics,
   canonicalType,
@@ -3491,6 +4129,8 @@ export {
   compileOwnership,
   compilePhysics,
   computeDirty,
+  containsBytes,
+  copyBytes,
   createDirtySet,
   createFieldMask,
   createState,
@@ -3502,6 +4142,7 @@ export {
   defaultValue,
   defineSchema,
   describeType,
+  diffByteRanges,
   diffSchemas,
   encodeDelta,
   encodeFields,
@@ -3518,6 +4159,8 @@ export {
   isWhole,
   list,
   markAdd,
+  markBytes,
+  markBytesPath,
   markField,
   markOwner,
   markPath,
@@ -3530,11 +4173,13 @@ export {
   ownershipFromCanonical,
   parseHold,
   physicsFromCanonical,
+  rangesPatchBytes,
   readValue,
   reconcileCollection,
   ref,
   schemaFromCanonical,
   server,
+  settleRanges,
   sha256,
   sha256Hex,
   singleton,
@@ -3546,6 +4191,7 @@ export {
   u16,
   u32,
   u8,
+  unionRanges,
   utf8Length,
   validateForDeploy,
   validateValue,