@atproto/common 0.0.1 → 0.1.0

package/dist/index.js

@@ -4014,31 +4014,45 @@ var require_pino = __commonJS({
 // src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
+  AsyncBuffer: () => AsyncBuffer,
+  AsyncBufferFullError: () => AsyncBufferFullError,
+  DAY: () => DAY,
+  HOUR: () => HOUR,
+  MINUTE: () => MINUTE,
   MaxSizeChecker: () => MaxSizeChecker,
+  SECOND: () => SECOND,
   TID: () => TID,
+  allComplete: () => allComplete,
   asyncFilter: () => asyncFilter,
+  bailableWait: () => bailableWait,
   bytesToStream: () => bytesToStream,
+  cborBytesToRecord: () => cborBytesToRecord,
+  cborDecode: () => cborDecode,
+  cborEncode: () => cborEncode,
   check: () => check_exports,
-  cidForData: () => cidForData,
+  chunkArray: () => chunkArray,
+  cidForCbor: () => cidForCbor,
   cloneStream: () => cloneStream,
+  createDeferrable: () => createDeferrable,
+  createDeferrables: () => createDeferrables,
+  dataToCborBlock: () => dataToCborBlock,
   def: () => def,
   errHasMsg: () => errHasMsg,
   flattenUint8Arrays: () => flattenUint8Arrays,
   forwardStreamErrors: () => forwardStreamErrors,
-  ipldBytesToRecord: () => ipldBytesToRecord,
-  ipldBytesToValue: () => ipldBytesToValue,
-  isCid: () => isCid,
   isErrnoException: () => isErrnoException,
   noUndefinedVals: () => noUndefinedVals,
+  range: () => range,
+  readFromGenerator: () => readFromGenerator,
   s32decode: () => s32decode,
   s32encode: () => s32encode,
+  schema: () => schema,
   sha256RawToCid: () => sha256RawToCid,
   streamSize: () => streamSize,
   streamToArray: () => streamToArray,
   subsystemLogger: () => subsystemLogger,
   util: () => util_exports,
-  valueToIpldBlock: () => valueToIpldBlock,
-  valueToIpldBytes: () => valueToIpldBytes,
+  verifyCidForBytes: () => verifyCidForBytes,
   wait: () => wait
 });
 module.exports = __toCommonJS(src_exports2);
@@ -4064,10 +4078,13 @@ var isObject = (obj) => {
 var util_exports = {};
 __export(util_exports, {
   asyncFilter: () => asyncFilter,
+  bailableWait: () => bailableWait,
+  chunkArray: () => chunkArray,
   errHasMsg: () => errHasMsg,
   flattenUint8Arrays: () => flattenUint8Arrays,
   isErrnoException: () => isErrnoException,
   noUndefinedVals: () => noUndefinedVals,
+  range: () => range,
   s32decode: () => s32decode,
   s32encode: () => s32encode,
   streamToArray: () => streamToArray,
@@ -4084,6 +4101,17 @@ var noUndefinedVals = (obj) => {
 var wait = (ms) => {
   return new Promise((res) => setTimeout(res, ms));
 };
+var bailableWait = (ms) => {
+  let bail;
+  const waitPromise = new Promise((res) => {
+    const timeout = setTimeout(res, ms);
+    bail = () => {
+      clearTimeout(timeout);
+      res();
+    };
+  });
+  return { bail, wait: () => waitPromise };
+};
 var flattenUint8Arrays = (arrs) => {
   const length2 = arrs.reduce((acc, cur) => {
     return acc + cur.length;
@@ -4125,11 +4153,106 @@ var asyncFilter = async (arr, fn) => {
   return arr.filter((_, i) => results[i]);
 };
 var isErrnoException = (err) => {
-  return !!err && "code" in err;
+  return !!err && err["code"];
 };
 var errHasMsg = (err, msg) => {
   return !!err && typeof err === "object" && err["message"] === msg;
 };
+var chunkArray = (arr, chunkSize) => {
+  return arr.reduce((acc, cur, i) => {
+    const chunkI = Math.floor(i / chunkSize);
+    if (!acc[chunkI]) {
+      acc[chunkI] = [];
+    }
+    acc[chunkI].push(cur);
+    return acc;
+  }, []);
+};
+var range = (num) => {
+  const nums = [];
+  for (let i = 0; i < num; i++) {
+    nums.push(i);
+  }
+  return nums;
+};
+
+// src/async.ts
+var readFromGenerator = async (gen, maxLength = Number.MAX_SAFE_INTEGER, timeout = 2e3) => {
+  const evts = [];
+  while (evts.length < maxLength) {
+    const { bail, wait: wait2 } = bailableWait(timeout);
+    const maybeEvt = await Promise.race([gen.next(), wait2()]);
+    bail();
+    if (!maybeEvt)
+      break;
+    const evt = maybeEvt;
+    if (evt.done)
+      break;
+    evts.push(evt.value);
+  }
+  return evts;
+};
+var createDeferrable = () => {
+  let resolve;
+  const promise = new Promise((res) => {
+    resolve = () => res();
+  });
+  return { resolve, complete: promise };
+};
+var createDeferrables = (count) => {
+  const list = [];
+  for (let i = 0; i < count; i++) {
+    list.push(createDeferrable());
+  }
+  return list;
+};
+var allComplete = async (deferrables) => {
+  await Promise.all(deferrables.map((d) => d.complete));
+};
+var AsyncBuffer = class {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.buffer = [];
+    this.resetPromise();
+  }
+  get curr() {
+    return this.buffer;
+  }
+  get size() {
+    return this.buffer.length;
+  }
+  resetPromise() {
+    this.promise = new Promise((r) => this.resolve = r);
+  }
+  push(item) {
+    this.buffer.push(item);
+    this.resolve();
+  }
+  pushMany(items) {
+    items.forEach((i) => this.buffer.push(i));
+    this.resolve();
+  }
+  async *events() {
+    while (true) {
+      await this.promise;
+      if (this.maxSize && this.size > this.maxSize) {
+        throw new AsyncBufferFullError(this.maxSize);
+      }
+      const [first, ...rest] = this.buffer;
+      if (first) {
+        this.buffer = rest;
+        yield first;
+      } else {
+        this.resetPromise();
+      }
+    }
+  }
+};
+var AsyncBufferFullError = class extends Error {
+  constructor(maxSize) {
+    super(`ReachedMaxBufferSize: ${maxSize}`);
+  }
+};
 
 // src/tid.ts
 var lastTimestamp = 0;
@@ -4330,21 +4453,21 @@ var create = (code3, digest) => {
   const size = digest.byteLength;
   const sizeOffset = encodingLength(code3);
   const digestOffset = sizeOffset + encodingLength(size);
-  const bytes2 = new Uint8Array(digestOffset + size);
-  encodeTo(code3, bytes2, 0);
-  encodeTo(size, bytes2, sizeOffset);
-  bytes2.set(digest, digestOffset);
-  return new Digest(code3, size, digest, bytes2);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code3, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code3, size, digest, bytes);
 };
 var decode3 = (multihash) => {
-  const bytes2 = coerce(multihash);
-  const [code3, sizeOffset] = decode2(bytes2);
-  const [size, digestOffset] = decode2(bytes2.subarray(sizeOffset));
-  const digest = bytes2.subarray(sizeOffset + digestOffset);
+  const bytes = coerce(multihash);
+  const [code3, sizeOffset] = decode2(bytes);
+  const [size, digestOffset] = decode2(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
   if (digest.byteLength !== size) {
     throw new Error("Incorrect length");
   }
-  return new Digest(code3, size, digest, bytes2);
+  return new Digest(code3, size, digest, bytes);
 };
 var equals2 = (a, b) => {
   if (a === b) {
@@ -4354,11 +4477,11 @@ var equals2 = (a, b) => {
   }
 };
 var Digest = class {
-  constructor(code3, size, digest, bytes2) {
+  constructor(code3, size, digest, bytes) {
     this.code = code3;
     this.size = size;
     this.digest = digest;
-    this.bytes = bytes2;
+    this.bytes = bytes;
   }
 };
 
@@ -4505,9 +4628,9 @@ var Encoder = class {
     this.prefix = prefix;
     this.baseEncode = baseEncode;
   }
-  encode(bytes2) {
-    if (bytes2 instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes2)}`;
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
     } else {
       throw Error("Unknown type, must be binary type");
     }
@@ -4721,13 +4844,13 @@ var base32z = rfc4648({
 
 // ../../node_modules/multiformats/esm/src/cid.js
 var CID = class {
-  constructor(version2, code3, multihash, bytes2) {
+  constructor(version2, code3, multihash, bytes) {
     this.code = code3;
     this.version = version2;
     this.multihash = multihash;
-    this.bytes = bytes2;
-    this.byteOffset = bytes2.byteOffset;
-    this.byteLength = bytes2.byteLength;
+    this.bytes = bytes;
+    this.byteOffset = bytes.byteOffset;
+    this.byteLength = bytes.byteLength;
     this.asCID = this;
     this._baseCache = /* @__PURE__ */ new Map();
     Object.defineProperties(this, {
@@ -4777,12 +4900,12 @@ var CID = class {
     return other && this.code === other.code && this.version === other.version && equals2(this.multihash, other.multihash);
   }
   toString(base2) {
-    const { bytes: bytes2, version: version2, _baseCache } = this;
+    const { bytes, version: version2, _baseCache } = this;
     switch (version2) {
       case 0:
-        return toStringV0(bytes2, _baseCache, base2 || base58btc.encoder);
+        return toStringV0(bytes, _baseCache, base2 || base58btc.encoder);
       default:
-        return toStringV1(bytes2, _baseCache, base2 || base32.encoder);
+        return toStringV1(bytes, _baseCache, base2 || base32.encoder);
     }
   }
   toJSON() {
@@ -4821,8 +4944,8 @@ var CID = class {
     if (value instanceof CID) {
       return value;
     } else if (value != null && value.asCID === value) {
-      const { version: version2, code: code3, multihash, bytes: bytes2 } = value;
-      return new CID(version2, code3, multihash, bytes2 || encodeCID(version2, code3, multihash.bytes));
+      const { version: version2, code: code3, multihash, bytes } = value;
+      return new CID(version2, code3, multihash, bytes || encodeCID(version2, code3, multihash.bytes));
     } else if (value != null && value[cidSymbol] === true) {
       const { version: version2, multihash, code: code3 } = value;
       const digest = decode3(multihash);
@@ -4844,8 +4967,8 @@ var CID = class {
         }
       }
       case 1: {
-        const bytes2 = encodeCID(version2, code3, digest.bytes);
-        return new CID(version2, code3, digest, bytes2);
+        const bytes = encodeCID(version2, code3, digest.bytes);
+        return new CID(version2, code3, digest, bytes);
       }
       default: {
         throw new Error("Invalid version");
@@ -4858,26 +4981,26 @@ var CID = class {
   static createV1(code3, digest) {
     return CID.create(1, code3, digest);
   }
-  static decode(bytes2) {
-    const [cid2, remainder] = CID.decodeFirst(bytes2);
+  static decode(bytes) {
+    const [cid, remainder] = CID.decodeFirst(bytes);
     if (remainder.length) {
       throw new Error("Incorrect length");
     }
-    return cid2;
+    return cid;
   }
-  static decodeFirst(bytes2) {
-    const specs = CID.inspectBytes(bytes2);
+  static decodeFirst(bytes) {
+    const specs = CID.inspectBytes(bytes);
     const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce(bytes2.subarray(prefixSize, prefixSize + specs.multihashSize));
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
     if (multihashBytes.byteLength !== specs.multihashSize) {
       throw new Error("Incorrect length");
     }
     const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
     const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
-    const cid2 = specs.version === 0 ? CID.createV0(digest) : CID.createV1(specs.codec, digest);
+    const cid = specs.version === 0 ? CID.createV0(digest) : CID.createV1(specs.codec, digest);
     return [
-      cid2,
-      bytes2.subarray(specs.size)
+      cid,
+      bytes.subarray(specs.size)
     ];
   }
   static inspectBytes(initialBytes) {
@@ -4913,10 +5036,10 @@ var CID = class {
     };
   }
   static parse(source, base2) {
-    const [prefix, bytes2] = parseCIDtoBytes(source, base2);
-    const cid2 = CID.decode(bytes2);
-    cid2._baseCache.set(prefix, source);
-    return cid2;
+    const [prefix, bytes] = parseCIDtoBytes(source, base2);
+    const cid = CID.decode(bytes);
+    cid._baseCache.set(prefix, source);
+    return cid;
   }
 };
 var parseCIDtoBytes = (source, base2) => {
@@ -4953,29 +5076,29 @@ var parseCIDtoBytes = (source, base2) => {
     }
   }
 };
-var toStringV0 = (bytes2, cache, base2) => {
+var toStringV0 = (bytes, cache, base2) => {
   const { prefix } = base2;
   if (prefix !== base58btc.prefix) {
     throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
   }
-  const cid2 = cache.get(prefix);
-  if (cid2 == null) {
-    const cid3 = base2.encode(bytes2).slice(1);
-    cache.set(prefix, cid3);
-    return cid3;
-  } else {
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes).slice(1);
+    cache.set(prefix, cid2);
     return cid2;
+  } else {
+    return cid;
   }
 };
-var toStringV1 = (bytes2, cache, base2) => {
+var toStringV1 = (bytes, cache, base2) => {
   const { prefix } = base2;
-  const cid2 = cache.get(prefix);
-  if (cid2 == null) {
-    const cid3 = base2.encode(bytes2);
-    cache.set(prefix, cid3);
-    return cid3;
-  } else {
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes);
+    cache.set(prefix, cid2);
     return cid2;
+  } else {
+    return cid;
   }
 };
 var DAG_PB_CODE = 112;
@@ -4983,11 +5106,11 @@ var SHA_256_CODE = 18;
 var encodeCID = (version2, code3, multihash) => {
   const codeOffset = encodingLength(version2);
   const hashOffset = codeOffset + encodingLength(code3);
-  const bytes2 = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version2, bytes2, 0);
-  encodeTo(code3, bytes2, codeOffset);
-  bytes2.set(multihash, hashOffset);
-  return bytes2;
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version2, bytes, 0);
+  encodeTo(code3, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
 };
 var cidSymbol = Symbol.for("@ipld/js-cid/CID");
 var readonly = {
@@ -5001,8 +5124,8 @@ var hidden = {
   configurable: false
 };
 var version = "0.0.0-dev";
-var deprecate = (range, message) => {
-  if (range.test(version)) {
+var deprecate = (range2, message) => {
+  if (range2.test(version)) {
     console.warn(message);
   } else {
     throw new Error(message);
@@ -5065,22 +5188,22 @@ var links = function* (source, base2) {
             ...path,
             index
           ];
-          const cid2 = CID.asCID(element);
-          if (cid2) {
+          const cid = CID.asCID(element);
+          if (cid) {
             yield [
               elementPath.join("/"),
-              cid2
+              cid
             ];
           } else if (typeof element === "object") {
             yield* links(element, elementPath);
           }
         }
       } else {
-        const cid2 = CID.asCID(value);
-        if (cid2) {
+        const cid = CID.asCID(value);
+        if (cid) {
           yield [
             path.join("/"),
-            cid2
+            cid
           ];
         } else {
           yield* links(value, path);
@@ -5123,10 +5246,10 @@ var get = (source, path) => {
     if (node == null) {
       throw new Error(`Object has no property at ${path.slice(0, index + 1).map((part) => `[${JSON.stringify(part)}]`).join("")}`);
     }
-    const cid2 = CID.asCID(node);
-    if (cid2) {
+    const cid = CID.asCID(node);
+    if (cid) {
       return {
-        value: cid2,
+        value: cid,
         remaining: path.slice(index + 1).join("/")
       };
     }
@@ -5134,11 +5257,11 @@ var get = (source, path) => {
   return { value: node };
 };
 var Block = class {
-  constructor({ cid: cid2, bytes: bytes2, value }) {
-    if (!cid2 || !bytes2 || typeof value === "undefined")
+  constructor({ cid, bytes, value }) {
+    if (!cid || !bytes || typeof value === "undefined")
       throw new Error("Missing required argument");
-    this.cid = cid2;
-    this.bytes = bytes2;
+    this.cid = cid;
+    this.bytes = bytes;
     this.value = value;
     this.asBlock = this;
     Object.defineProperties(this, {
@@ -5163,13 +5286,13 @@ var encode3 = async ({ value, codec, hasher }) => {
     throw new Error('Missing required argument "value"');
   if (!codec || !hasher)
     throw new Error("Missing required argument: codec or hasher");
-  const bytes2 = codec.encode(value);
-  const hash = await hasher.digest(bytes2);
-  const cid2 = CID.create(1, codec.code, hash);
+  const bytes = codec.encode(value);
+  const hash = await hasher.digest(bytes);
+  const cid = CID.create(1, codec.code, hash);
   return new Block({
     value,
-    bytes: bytes2,
-    cid: cid2
+    bytes,
+    cid
   });
 };
 
@@ -5335,10 +5458,10 @@ function asU8A(buf2) {
   }
   return isBuffer2(buf2) ? new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength) : buf2;
 }
-var toString = useBuffer ? (bytes2, start, end) => {
-  return end - start > 64 ? globalThis.Buffer.from(bytes2.subarray(start, end)).toString("utf8") : utf8Slice(bytes2, start, end);
-} : (bytes2, start, end) => {
-  return end - start > 64 ? textDecoder.decode(bytes2.subarray(start, end)) : utf8Slice(bytes2, start, end);
+var toString = useBuffer ? (bytes, start, end) => {
+  return end - start > 64 ? globalThis.Buffer.from(bytes.subarray(start, end)).toString("utf8") : utf8Slice(bytes, start, end);
+} : (bytes, start, end) => {
+  return end - start > 64 ? textDecoder.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end);
 };
 var fromString = useBuffer ? (string) => {
   return string.length > 64 ? globalThis.Buffer.from(string) : utf8ToBytes(string);
@@ -5348,13 +5471,13 @@ var fromString = useBuffer ? (string) => {
 var fromArray = (arr) => {
   return Uint8Array.from(arr);
 };
-var slice = useBuffer ? (bytes2, start, end) => {
-  if (isBuffer2(bytes2)) {
-    return new Uint8Array(bytes2.subarray(start, end));
+var slice = useBuffer ? (bytes, start, end) => {
+  if (isBuffer2(bytes)) {
+    return new Uint8Array(bytes.subarray(start, end));
   }
-  return bytes2.slice(start, end);
-} : (bytes2, start, end) => {
-  return bytes2.slice(start, end);
+  return bytes.slice(start, end);
+} : (bytes, start, end) => {
+  return bytes.slice(start, end);
 };
 var concat = useBuffer ? (chunks, length2) => {
   chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
@@ -5392,18 +5515,18 @@ function utf8ToBytes(string, units = Infinity) {
   let codePoint;
   const length2 = string.length;
   let leadSurrogate = null;
-  const bytes2 = [];
+  const bytes = [];
   for (let i = 0; i < length2; ++i) {
     codePoint = string.charCodeAt(i);
     if (codePoint > 55295 && codePoint < 57344) {
       if (!leadSurrogate) {
         if (codePoint > 56319) {
           if ((units -= 3) > -1)
-            bytes2.push(239, 191, 189);
+            bytes.push(239, 191, 189);
           continue;
         } else if (i + 1 === length2) {
           if ((units -= 3) > -1)
-            bytes2.push(239, 191, 189);
+            bytes.push(239, 191, 189);
           continue;
         }
         leadSurrogate = codePoint;
@@ -5411,37 +5534,37 @@ function utf8ToBytes(string, units = Infinity) {
       }
       if (codePoint < 56320) {
         if ((units -= 3) > -1)
-          bytes2.push(239, 191, 189);
+          bytes.push(239, 191, 189);
         leadSurrogate = codePoint;
         continue;
       }
       codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
     } else if (leadSurrogate) {
       if ((units -= 3) > -1)
-        bytes2.push(239, 191, 189);
+        bytes.push(239, 191, 189);
     }
     leadSurrogate = null;
     if (codePoint < 128) {
       if ((units -= 1) < 0)
         break;
-      bytes2.push(codePoint);
+      bytes.push(codePoint);
     } else if (codePoint < 2048) {
       if ((units -= 2) < 0)
         break;
-      bytes2.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+      bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
     } else if (codePoint < 65536) {
       if ((units -= 3) < 0)
         break;
-      bytes2.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+      bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
     } else if (codePoint < 1114112) {
       if ((units -= 4) < 0)
         break;
-      bytes2.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+      bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
     } else {
       throw new Error("Invalid code point");
     }
   }
-  return bytes2;
+  return bytes;
 }
 function utf8Slice(buf2, offset, end) {
   const res = [];
@@ -5536,12 +5659,12 @@ var Bl = class {
       this.maxCursor = this._initReuseChunk.length - 1;
     }
   }
-  push(bytes2) {
+  push(bytes) {
     let topChunk = this.chunks[this.chunks.length - 1];
-    const newMax = this.cursor + bytes2.length;
+    const newMax = this.cursor + bytes.length;
     if (newMax <= this.maxCursor + 1) {
       const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-      topChunk.set(bytes2, chunkPos);
+      topChunk.set(bytes, chunkPos);
     } else {
       if (topChunk) {
         const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
@@ -5550,20 +5673,20 @@ var Bl = class {
           this.maxCursor = this.cursor - 1;
         }
       }
-      if (bytes2.length < 64 && bytes2.length < this.chunkSize) {
+      if (bytes.length < 64 && bytes.length < this.chunkSize) {
         topChunk = alloc(this.chunkSize);
         this.chunks.push(topChunk);
         this.maxCursor += topChunk.length;
         if (this._initReuseChunk === null) {
           this._initReuseChunk = topChunk;
         }
-        topChunk.set(bytes2, 0);
+        topChunk.set(bytes, 0);
       } else {
-        this.chunks.push(bytes2);
-        this.maxCursor += bytes2.length;
+        this.chunks.push(bytes);
+        this.maxCursor += bytes.length;
       }
     }
-    this.cursor += bytes2.length;
+    this.cursor += bytes.length;
   }
   toBytes(reset = false) {
     let byts;
@@ -5830,13 +5953,13 @@ function tokenBytes(token) {
   return token.encodedBytes;
 }
 function encodeBytes(buf2, token) {
-  const bytes2 = tokenBytes(token);
-  encodeUintValue(buf2, token.type.majorEncoded, bytes2.length);
-  buf2.push(bytes2);
+  const bytes = tokenBytes(token);
+  encodeUintValue(buf2, token.type.majorEncoded, bytes.length);
+  buf2.push(bytes);
 }
 encodeBytes.encodedSize = function encodedSize4(token) {
-  const bytes2 = tokenBytes(token);
-  return encodeUintValue.encodedSize(bytes2.length) + bytes2.length;
+  const bytes = tokenBytes(token);
+  return encodeUintValue.encodedSize(bytes.length) + bytes.length;
 };
 encodeBytes.compareTokens = function compareTokens3(tok1, tok2) {
   return compareBytes(tokenBytes(tok1), tokenBytes(tok2));
@@ -5993,7 +6116,7 @@ function decodeBreak(_data, _pos, _minor, options) {
   }
   return new Token(Type.break, void 0, 1);
 }
-function createToken(value, bytes2, options) {
+function createToken(value, bytes, options) {
   if (options) {
     if (options.allowNaN === false && Number.isNaN(value)) {
       throw new Error(`${decodeErrPrefix} NaN values are not supported`);
@@ -6002,7 +6125,7 @@ function createToken(value, bytes2, options) {
       throw new Error(`${decodeErrPrefix} Infinity values are not supported`);
     }
   }
-  return new Token(Type.float, value, bytes2);
+  return new Token(Type.float, value, bytes);
 }
 function decodeFloat16(data, pos, _minor, options) {
   return createToken(readFloat16(data, pos + 1), 3, options);
@@ -6661,15 +6784,15 @@ function cidEncoder(obj) {
   if (obj.asCID !== obj) {
     return null;
   }
-  const cid2 = CID.asCID(obj);
-  if (!cid2) {
+  const cid = CID.asCID(obj);
+  if (!cid) {
     return null;
   }
-  const bytes2 = new Uint8Array(cid2.bytes.byteLength + 1);
-  bytes2.set(cid2.bytes, 1);
+  const bytes = new Uint8Array(cid.bytes.byteLength + 1);
+  bytes.set(cid.bytes, 1);
   return [
     new Token(Type.tag, CID_CBOR_TAG),
-    new Token(Type.bytes, bytes2)
+    new Token(Type.bytes, bytes)
   ];
 }
 function undefinedEncoder() {
@@ -6692,11 +6815,11 @@ var encodeOptions = {
     number: numberEncoder
   }
 };
-function cidDecoder(bytes2) {
-  if (bytes2[0] !== 0) {
+function cidDecoder(bytes) {
+  if (bytes[0] !== 0) {
     throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
   }
-  return CID.decode(bytes2.subarray(1));
+  return CID.decode(bytes.subarray(1));
 }
 var decodeOptions = {
   allowIndefinite: false,
@@ -6714,31 +6837,36 @@ var code2 = 113;
 var encode5 = (node) => encode4(node, encodeOptions);
 var decode6 = (data) => decode5(data, decodeOptions);
 
-// src/blocks.ts
-var valueToIpldBlock = async (data) => {
+// src/ipld.ts
+var dataToCborBlock = async (data) => {
   return encode3({
     value: data,
     codec: esm_exports,
     hasher: sha256
   });
 };
+var verifyCidForBytes = async (cid, bytes) => {
+  const digest = await sha256.digest(bytes);
+  const expected = CID.createV1(cid.code, digest);
+  if (!cid.equals(expected)) {
+    throw new Error(
+      `Not a valid CID for bytes. Expected: ${expected.toString()} Got: ${cid.toString()}`
+    );
+  }
+};
 var sha256RawToCid = (hash) => {
   const digest = digest_exports.create(sha256.code, hash);
   return CID.createV1(code, digest);
 };
-var cidForData = async (data) => {
-  const block = await valueToIpldBlock(data);
+var cidForCbor = async (data) => {
+  const block = await dataToCborBlock(data);
   return block.cid;
 };
-var valueToIpldBytes = (value) => {
-  return encode5(value);
-};
-var ipldBytesToValue = (bytes2) => {
-  return decode6(bytes2);
-};
-var ipldBytesToRecord = (bytes2) => {
-  const val = ipldBytesToValue(bytes2);
-  if (typeof val !== "object" || val === null) {
+var cborEncode = encode5;
+var cborDecode = decode6;
+var cborBytesToRecord = (bytes) => {
+  const val = cborDecode(bytes);
+  if (!check_exports.is(val, schema.record)) {
     throw new Error(`Expected object, got: ${val}`);
   }
   return val;
@@ -8203,9 +8331,9 @@ var ZodArray = class extends ZodType {
     return this.min(1, message);
   }
 };
-ZodArray.create = (schema, params) => {
+ZodArray.create = (schema2, params) => {
   return new ZodArray({
-    type: schema,
+    type: schema2,
     minLength: null,
     maxLength: null,
     typeName: ZodFirstPartyTypeKind.ZodArray,
@@ -8230,27 +8358,27 @@ var AugmentFactory = (def2) => (augmentation) => {
     })
   });
 };
-function deepPartialify(schema) {
-  if (schema instanceof ZodObject) {
+function deepPartialify(schema2) {
+  if (schema2 instanceof ZodObject) {
     const newShape = {};
-    for (const key in schema.shape) {
-      const fieldSchema = schema.shape[key];
+    for (const key in schema2.shape) {
+      const fieldSchema = schema2.shape[key];
       newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
     }
     return new ZodObject({
-      ...schema._def,
+      ...schema2._def,
       shape: () => newShape
     });
-  } else if (schema instanceof ZodArray) {
-    return ZodArray.create(deepPartialify(schema.element));
-  } else if (schema instanceof ZodOptional) {
-    return ZodOptional.create(deepPartialify(schema.unwrap()));
-  } else if (schema instanceof ZodNullable) {
-    return ZodNullable.create(deepPartialify(schema.unwrap()));
-  } else if (schema instanceof ZodTuple) {
-    return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
+  } else if (schema2 instanceof ZodArray) {
+    return ZodArray.create(deepPartialify(schema2.element));
+  } else if (schema2 instanceof ZodOptional) {
+    return ZodOptional.create(deepPartialify(schema2.unwrap()));
+  } else if (schema2 instanceof ZodNullable) {
+    return ZodNullable.create(deepPartialify(schema2.unwrap()));
+  } else if (schema2 instanceof ZodTuple) {
+    return ZodTuple.create(schema2.items.map((item) => deepPartialify(item)));
   } else {
-    return schema;
+    return schema2;
   }
 }
 var ZodObject = class extends ZodType {
@@ -8388,8 +8516,8 @@ var ZodObject = class extends ZodType {
       unknownKeys: "passthrough"
     });
   }
-  setKey(key, schema) {
-    return this.augment({ [key]: schema });
+  setKey(key, schema2) {
+    return this.augment({ [key]: schema2 });
   }
   merge(merging) {
     const merged = new ZodObject({
@@ -8782,10 +8910,10 @@ var ZodTuple = class extends ZodType {
       status.dirty();
     }
     const items = ctx.data.map((item, itemIndex) => {
-      const schema = this._def.items[itemIndex] || this._def.rest;
-      if (!schema)
+      const schema2 = this._def.items[itemIndex] || this._def.rest;
+      if (!schema2)
         return null;
-      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+      return schema2._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
     }).filter((x) => !!x);
     if (ctx.common.async) {
       return Promise.all(items).then((results) => {
@@ -9276,9 +9404,9 @@ var ZodPromise = class extends ZodType {
     }));
   }
 };
-ZodPromise.create = (schema, params) => {
+ZodPromise.create = (schema2, params) => {
   return new ZodPromise({
-    type: schema,
+    type: schema2,
     typeName: ZodFirstPartyTypeKind.ZodPromise,
     ...processCreateParams(params)
   });
@@ -9382,17 +9510,17 @@ var ZodEffects = class extends ZodType {
     util.assertNever(effect);
   }
 };
-ZodEffects.create = (schema, effect, params) => {
+ZodEffects.create = (schema2, effect, params) => {
   return new ZodEffects({
-    schema,
+    schema: schema2,
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     effect,
     ...processCreateParams(params)
   });
 };
-ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+ZodEffects.createWithPreprocess = (preprocess, schema2, params) => {
   return new ZodEffects({
-    schema,
+    schema: schema2,
     effect: { type: "preprocess", transform: preprocess },
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     ...processCreateParams(params)
@@ -9691,30 +9819,37 @@ var mod = /* @__PURE__ */ Object.freeze({
 });
 
 // src/types.ts
-var cid = mod.any().refine((obj) => CID.asCID(obj) !== null, {
+var cidSchema = mod.any().refine((obj) => CID.asCID(obj) !== null, {
   message: "Not a CID"
 }).transform((obj) => CID.asCID(obj));
-var isCid = (str) => {
-  try {
-    CID.parse(str);
-    return true;
-  } catch (err) {
-    return false;
-  }
+var schema = {
+  cid: cidSchema,
+  bytes: mod.instanceof(Uint8Array),
+  string: mod.string(),
+  record: mod.record(mod.string(), mod.unknown()),
+  unknown: mod.unknown()
 };
-var strToCid = mod.string().refine(isCid, { message: "Not a valid CID" }).transform((str) => CID.parse(str));
-var bytes = mod.instanceof(Uint8Array);
-var strToInt = mod.string().refine((str) => !isNaN(parseInt(str)), {
-  message: "Cannot parse string to integer"
-}).transform((str) => parseInt(str));
-var strToBool = mod.string().transform((str) => str === "true" || str === "t");
 var def = {
-  string: mod.string(),
-  cid,
-  strToCid,
-  bytes,
-  strToInt,
-  strToBool
+  cid: {
+    name: "cid",
+    schema: schema.cid
+  },
+  bytes: {
+    name: "bytes",
+    schema: schema.bytes
+  },
+  string: {
+    name: "string",
+    schema: schema.string
+  },
+  record: {
+    name: "record",
+    schema: schema.record
+  },
+  unknown: {
+    name: "unknown",
+    schema: schema.unknown
+  }
 };
 
 // src/streams.ts
@@ -9740,9 +9875,9 @@ var streamSize = async (stream) => {
   }
   return size;
 };
-var bytesToStream = (bytes2) => {
+var bytesToStream = (bytes) => {
   const stream = new import_stream.Readable();
-  stream.push(bytes2);
+  stream.push(bytes);
   stream.push(null);
   return stream;
 };
@@ -9761,33 +9896,53 @@ var MaxSizeChecker = class extends import_stream.Transform {
     return cb(null, chunk);
   }
 };
+
+// src/times.ts
+var SECOND = 1e3;
+var MINUTE = SECOND * 60;
+var HOUR = MINUTE * 60;
+var DAY = HOUR * 24;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AsyncBuffer,
+  AsyncBufferFullError,
+  DAY,
+  HOUR,
+  MINUTE,
   MaxSizeChecker,
+  SECOND,
   TID,
+  allComplete,
   asyncFilter,
+  bailableWait,
   bytesToStream,
+  cborBytesToRecord,
+  cborDecode,
+  cborEncode,
   check,
-  cidForData,
+  chunkArray,
+  cidForCbor,
   cloneStream,
+  createDeferrable,
+  createDeferrables,
+  dataToCborBlock,
   def,
   errHasMsg,
   flattenUint8Arrays,
   forwardStreamErrors,
-  ipldBytesToRecord,
-  ipldBytesToValue,
-  isCid,
   isErrnoException,
   noUndefinedVals,
+  range,
+  readFromGenerator,
   s32decode,
   s32encode,
+  schema,
   sha256RawToCid,
   streamSize,
   streamToArray,
   subsystemLogger,
   util,
-  valueToIpldBlock,
-  valueToIpldBytes,
+  verifyCidForBytes,
   wait
 });
 //# sourceMappingURL=index.js.map