@ipld/car 4.0.0 → 4.1.2

package/README.md

@@ -240,6 +240,15 @@ be directly fed to a
  * [`async CarWriter.createAppender()`](#CarWriter__createAppender)
  * [`async CarWriter.updateRootsInBytes(bytes, roots)`](#CarWriter__updateRootsInBytes)
  * [`async CarWriter.updateRootsInFile(fd, roots)`](#CarWriter__updateRootsInFile)
+ * [`class CarBufferWriter`](#CarBufferWriter)
+ * [`CarBufferWriter#addRoot(root, options)`](#CarBufferWriter_addRoot)
+ * [`CarBufferWriter#write(block)`](#CarBufferWriter_write)
+ * [`CarBufferWriter#close([options])`](#CarBufferWriter_close)
+ * [`CarBufferWriter.blockLength(Block)`](#CarBufferWriter__blockLength__Block__)
+ * [`CarBufferWriter.calculateHeaderLength(rootLengths)`](#CarBufferWriter__calculateHeaderLength__rootLengths__)
+ * [`CarBufferWriter.headerLength({ roots })`](#CarBufferWriter__headerLength______roots______)
+ * [`CarBufferWriter.estimateHeaderLength(rootCount[, rootByteLength])`](#CarBufferWriter__estimateHeaderLength__rootCount______rootByteLength____)
+ * [`CarBufferWriter.createWriter(buffer[, options])`](#CarBufferWriter__createWriter__buffer______options____)
  * [`async decoder.readHeader(reader)`](#async__decoder__readHeader__reader__)
  * [`async decoder.readBlockHead(reader)`](#async__decoder__readBlockHead__reader__)
  * [`decoder.createDecoder(reader)`](#decoder__createDecoder__reader__)
@@ -766,6 +775,106 @@ replaced encode as the same length as the new roots.
 This function is **only available in Node.js** and not a browser
 environment.
 
+<a name="CarBufferWriter"></a>
+### `class CarBufferWriter`
+
+A simple CAR writer that writes to a pre-allocated buffer.
+
+<a name="CarBufferWriter_addRoot"></a>
+### `CarBufferWriter#addRoot(root, options)`
+
+* `root` `(CID)`
+* `options`
+
+* Returns:  `CarBufferWriter`
+
+Add a root to this writer, to be used to create a header when the CAR is
+finalized with [`close()`](#CarBufferWriter__close)
+
+<a name="CarBufferWriter_write"></a>
+### `CarBufferWriter#write(block)`
+
+* `block` `(Block)`: A `{ cid:CID, bytes:Uint8Array }` pair.
+
+* Returns:  `CarBufferWriter`
+
+Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
+Throws if there is not enough capacity.
+
+<a name="CarBufferWriter_close"></a>
+### `CarBufferWriter#close([options])`
+
+* `options` `(object, optional)`
+  * `options.resize` `(boolean, optional)`
+
+* Returns:  `Uint8Array`
+
+Finalize the CAR and return it as a `Uint8Array`.
+
+<a name="CarBufferWriter__blockLength__Block__"></a>
+### `CarBufferWriter.blockLength(Block)`
+
+* `block` `(Block)`
+
+* Returns:  `number`
+
+Calculates number of bytes required for storing given block in CAR. Useful in
+estimating size of an `ArrayBuffer` for the `CarBufferWriter`.
+
+<a name="CarBufferWriter__calculateHeaderLength__rootLengths__"></a>
+### `CarBufferWriter.calculateHeaderLength(rootLengths)`
+
+* `rootLengths` `(number[])`
+
+* Returns:  `number`
+
+Calculates header size given the array of byteLength for roots.
+
+<a name="CarBufferWriter__headerLength______roots______"></a>
+### `CarBufferWriter.headerLength({ roots })`
+
+* `options` `(object)`
+  * `options.roots` `(CID[])`
+
+* Returns:  `number`
+
+Calculates header size given the array of roots.
+
+<a name="CarBufferWriter__estimateHeaderLength__rootCount______rootByteLength____"></a>
+### `CarBufferWriter.estimateHeaderLength(rootCount[, rootByteLength])`
+
+* `rootCount` `(number)`
+* `rootByteLength` `(number, optional)`
+
+* Returns:  `number`
+
+Estimates header size given a count of the roots and the expected byte length
+of the root CIDs. The default length works for a standard CIDv1 with a
+single-byte multihash code, such as SHA2-256 (i.e. the most common CIDv1).
+
+<a name="CarBufferWriter__createWriter__buffer______options____"></a>
+### `CarBufferWriter.createWriter(buffer[, options])`
+
+* `buffer` `(ArrayBuffer)`
+* `options` `(object, optional)`
+  * `options.roots` `(CID[], optional)`
+  * `options.byteOffset` `(number, optional)`
+  * `options.byteLength` `(number, optional)`
+  * `options.headerSize` `(number, optional)`
+
+* Returns:  `CarBufferWriter`
+
+Creates synchronous CAR writer that can be used to encode blocks into a given
+buffer. Optionally you could pass `byteOffset` and `byteLength` to specify a
+range inside buffer to write into. If car file is going to have `roots` you
+need to either pass them under `options.roots` (from which header size will
+be calculated) or provide `options.headerSize` to allocate required space
+in the buffer. You may also provide known `roots` and `headerSize` to
+allocate space for the roots that may not be known ahead of time.
+
+Note: Incorrect `headerSize` may lead to copying bytes inside a buffer
+which will have a negative impact on performance.
+
 <a name="async__decoder__readHeader__reader__"></a>
 ### `async decoder.readHeader(reader)`
 

package/api.ts

@@ -1,17 +1,21 @@
 import { CID } from 'multiformats/cid'
 
+export type { CID }
 /* Generic types for interfacing with block storage */
 
-export type Block = { cid: CID, bytes: Uint8Array }
+export type Block = {
+  cid: CID
+  bytes: Uint8Array
+}
 
 export type BlockHeader = {
-  cid: CID,
-  length: number,
+  cid: CID
+  length: number
   blockLength: number
 }
 
 export type BlockIndex = BlockHeader & {
-  offset: number,
+  offset: number
   blockOffset: number
 }
 
@@ -36,6 +40,20 @@ export interface BlockWriter {
   close(): Promise<void>
 }
 
+export interface CarBufferWriter {
+  addRoot(root:CID, options?:{ resize?: boolean }):CarBufferWriter
+  write(block: Block): CarBufferWriter
+  close(options?:{ resize?: boolean }): Uint8Array
+}
+
+export interface CarBufferWriterOptions {
+  roots?: CID[] // defaults to []
+  byteOffset?: number // defaults to 0
+  byteLength?: number // defaults to buffer.byteLength
+
+  headerSize?: number // defaults to size needed for provided roots
+}
+
 export interface WriterChannel {
   writer: BlockWriter
   out: AsyncIterable<Uint8Array>

package/buffer-writer

@@ -0,0 +1 @@
+module.exports = require('./cjs/lib/buffer-writer.js')

package/cjs/browser-test/common.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var multiformats = require('multiformats');
 var sha2 = require('multiformats/hashes/sha2');
 var raw = require('multiformats/codecs/raw');
-var dagCbor = require('@ipld/dag-cbor');
+var CBOR = require('@ipld/dag-cbor');
 var dagPb = require('@ipld/dag-pb');
 var chai = require('chai');
 var chaiAsPromised = require('chai-as-promised');
@@ -31,7 +31,7 @@ function _interopNamespace(e) {
 }
 
 var raw__namespace = /*#__PURE__*/_interopNamespace(raw);
-var dagCbor__namespace = /*#__PURE__*/_interopNamespace(dagCbor);
+var CBOR__namespace = /*#__PURE__*/_interopNamespace(CBOR);
 var dagPb__namespace = /*#__PURE__*/_interopNamespace(dagPb);
 var chai__default = /*#__PURE__*/_interopDefaultLegacy(chai);
 var chaiAsPromised__default = /*#__PURE__*/_interopDefaultLegacy(chaiAsPromised);
@@ -101,7 +101,7 @@ async function makeData() {
       cborBlocks.push(await toBlock({
         name: b[0],
         link: b[1]
-      }, dagCbor__namespace));
+      }, CBOR__namespace));
     }
     allBlocks = [
       [

package/cjs/browser-test/node-test-large.js

@@ -4,7 +4,7 @@ var fs = require('fs');
 var stream = require('stream');
 var ipldGarbage = require('ipld-garbage');
 var varint = require('varint');
-var dagCbor = require('@ipld/dag-cbor');
+var CBOR = require('@ipld/dag-cbor');
 var sha2 = require('multiformats/hashes/sha2');
 var cid = require('multiformats/cid');
 require('../car-browser.js');
@@ -36,7 +36,7 @@ function _interopNamespace(e) {
 
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var dagCbor__namespace = /*#__PURE__*/_interopNamespace(dagCbor);
+var CBOR__namespace = /*#__PURE__*/_interopNamespace(CBOR);
 
 describe('Large CAR', () => {
   const objects = [];
@@ -45,7 +45,7 @@ describe('Large CAR', () => {
   it('create, no roots', async () => {
     const {writer, out} = writerBrowser.CarWriter.create([]);
     stream.Readable.from(out).pipe(fs__default["default"].createWriteStream('./test.car'));
-    let offset = dagCbor__namespace.encode({
+    let offset = CBOR__namespace.encode({
       version: 1,
       roots: []
     }).length;
@@ -53,9 +53,9 @@ describe('Large CAR', () => {
     for (let i = 0; i < 500; i++) {
       const obj = ipldGarbage.garbage(1000);
       objects.push(obj);
-      const bytes = dagCbor__namespace.encode(obj);
+      const bytes = CBOR__namespace.encode(obj);
       const hash = await sha2.sha256.digest(bytes);
-      const cid$1 = cid.CID.create(1, dagCbor__namespace.code, hash);
+      const cid$1 = cid.CID.create(1, CBOR__namespace.code, hash);
       cids.push(cid$1.toString());
       const blockLength = bytes.length;
       let length = cid$1.bytes.length + blockLength;
@@ -101,7 +101,7 @@ describe('Large CAR', () => {
     let i = 0;
     for await (const {cid, bytes} of reader.blocks()) {
       common.assert.strictEqual(cid.toString(), cids[i], `cid #${ i } ${ cid } <> ${ cids[i] }`);
-      const obj = dagCbor__namespace.decode(bytes);
+      const obj = CBOR__namespace.decode(bytes);
       common.assert.deepStrictEqual(obj, objects[i], `object #${ i }`);
       i++;
     }
@@ -112,7 +112,7 @@ describe('Large CAR', () => {
     let i = 0;
     for await (const {cid, bytes} of reader.blocks()) {
       common.assert.strictEqual(cid.toString(), cids[i], `cid #${ i } ${ cid } <> ${ cids[i] }`);
-      const obj = dagCbor__namespace.decode(bytes);
+      const obj = CBOR__namespace.decode(bytes);
       common.assert.deepStrictEqual(obj, objects[i], `object #${ i }`);
       i++;
     }
@@ -123,7 +123,7 @@ describe('Large CAR', () => {
     let i = 0;
     for await (const {cid, bytes} of reader.blocks()) {
       common.assert.strictEqual(cid.toString(), cids[i], `cid #${ i } ${ cid } <> ${ cids[i] }`);
-      const obj = dagCbor__namespace.decode(bytes);
+      const obj = CBOR__namespace.decode(bytes);
       common.assert.deepStrictEqual(obj, objects[i], `object #${ i }`);
       i++;
     }

package/cjs/browser-test/test-buffer-writer.js

@@ -0,0 +1,330 @@
+'use strict';
+
+var bufferWriter = require('../lib/buffer-writer.js');
+var readerBrowser = require('../lib/reader-browser.js');
+var encoder = require('../lib/encoder.js');
+var common = require('./common.js');
+var multiformats = require('multiformats');
+var CBOR = require('@ipld/dag-cbor');
+var sha2 = require('multiformats/hashes/sha2');
+var identity = require('multiformats/hashes/identity');
+var raw = require('multiformats/codecs/raw');
+var Block = require('multiformats/block');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var CBOR__namespace = /*#__PURE__*/_interopNamespace(CBOR);
+var raw__namespace = /*#__PURE__*/_interopNamespace(raw);
+var Block__namespace = /*#__PURE__*/_interopNamespace(Block);
+
+describe('CarBufferWriter', () => {
+  const cid = multiformats.CID.parse('bafkreifuosuzujyf4i6psbneqtwg2fhplc2wxptc5euspa2gn3bwhnihfu');
+  describe('calculateHeaderLength', async () => {
+    for (const count of [
+        0,
+        1,
+        10,
+        18,
+        24,
+        48,
+        124,
+        255,
+        258,
+        65536 - 1,
+        65536
+      ]) {
+      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
+        const roots = new Array(count).fill(cid);
+        const sizes = new Array(count).fill(cid.bytes.byteLength);
+        common.assert.deepEqual(bufferWriter.calculateHeaderLength(sizes), encoder.createHeader(roots).byteLength);
+      });
+      it(`calculateHeaderLength(new Array(${ count }).fill(36))`, () => {
+        const roots = new Array(count).fill(cid);
+        const rootLengths = roots.map(c => c.bytes.byteLength);
+        common.assert.deepEqual(bufferWriter.calculateHeaderLength(rootLengths), encoder.createHeader(roots).byteLength);
+      });
+    }
+    it('estimate on large CIDs', () => {
+      const largeCID = multiformats.CID.parse(`bafkqbbac${ 'a'.repeat(416) }`);
+      common.assert.equal(bufferWriter.calculateHeaderLength([
+        cid.bytes.byteLength,
+        largeCID.bytes.byteLength
+      ]), encoder.createHeader([
+        cid,
+        largeCID
+      ]).byteLength);
+    });
+    it('estimate on large CIDs 2', () => {
+      const largeCID = multiformats.CID.createV1(raw__namespace.code, identity.identity.digest(new Uint8Array(512).fill(1)));
+      common.assert.equal(bufferWriter.calculateHeaderLength([
+        cid.bytes.byteLength,
+        largeCID.bytes.byteLength
+      ]), encoder.createHeader([
+        cid,
+        largeCID
+      ]).byteLength);
+    });
+  });
+  describe('writer', () => {
+    it('estimate header and write blocks', async () => {
+      const headerSize = bufferWriter.estimateHeaderLength(1);
+      const dataSize = 256;
+      const buffer = new ArrayBuffer(headerSize + dataSize);
+      const writer = bufferWriter.createWriter(buffer, { headerSize });
+      const b1 = await Block__namespace.encode({
+        value: { hello: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b1);
+      const b2 = await Block__namespace.encode({
+        value: { bye: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b2);
+      writer.addRoot(b1.cid);
+      const bytes = writer.close();
+      const reader = await readerBrowser.CarReader.fromBytes(bytes);
+      common.assert.deepEqual(await reader.getRoots(), [b1.cid]);
+      common.assert.deepEqual(reader._blocks, [
+        {
+          cid: b1.cid,
+          bytes: b1.bytes
+        },
+        {
+          cid: b2.cid,
+          bytes: b2.bytes
+        }
+      ]);
+    });
+    it('overestimate header', async () => {
+      const headerSize = bufferWriter.estimateHeaderLength(2);
+      const dataSize = 256;
+      const buffer = new ArrayBuffer(headerSize + dataSize);
+      const writer = bufferWriter.createWriter(buffer, { headerSize });
+      const b1 = await Block__namespace.encode({
+        value: { hello: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b1);
+      const b2 = await Block__namespace.encode({
+        value: { bye: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b2);
+      writer.addRoot(b1.cid);
+      common.assert.throws(() => writer.close(), /Header size was overestimate/);
+      const bytes = writer.close({ resize: true });
+      const reader = await readerBrowser.CarReader.fromBytes(bytes);
+      common.assert.deepEqual(await reader.getRoots(), [b1.cid]);
+      common.assert.deepEqual(reader._blocks, [
+        {
+          cid: b1.cid,
+          bytes: b1.bytes
+        },
+        {
+          cid: b2.cid,
+          bytes: b2.bytes
+        }
+      ]);
+    });
+    it('underestimate header', async () => {
+      const headerSize = bufferWriter.estimateHeaderLength(2);
+      const dataSize = 300;
+      const buffer = new ArrayBuffer(headerSize + dataSize);
+      const writer = bufferWriter.createWriter(buffer, { headerSize });
+      const b1 = await Block__namespace.encode({
+        value: { hello: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha256
+      });
+      writer.write(b1);
+      writer.addRoot(b1.cid);
+      const b2 = await Block__namespace.encode({
+        value: { bye: 'world' },
+        codec: CBOR__namespace,
+        hasher: sha2.sha512
+      });
+      writer.write(b2);
+      common.assert.throws(() => writer.addRoot(b2.cid), /has no capacity/);
+      writer.addRoot(b2.cid, { resize: true });
+      const bytes = writer.close();
+      const reader = await readerBrowser.CarReader.fromBytes(bytes);
+      common.assert.deepEqual(await reader.getRoots(), [
+        b1.cid,
+        b2.cid
+      ]);
+      common.assert.deepEqual(reader._blocks, [
+        {
+          cid: b1.cid,
+          bytes: b1.bytes
+        },
+        {
+          cid: b2.cid,
+          bytes: b2.bytes
+        }
+      ]);
+    });
+  });
+  it('has no space for the root', async () => {
+    const headerSize = bufferWriter.estimateHeaderLength(1);
+    const dataSize = 100;
+    const buffer = new ArrayBuffer(headerSize + dataSize);
+    const writer = bufferWriter.createWriter(buffer, { headerSize });
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    writer.write(b1);
+    writer.addRoot(b1.cid);
+    const b2 = await Block__namespace.encode({
+      value: { bye: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    writer.write(b2);
+    common.assert.throws(() => writer.addRoot(b2.cid), /Buffer has no capacity for a new root/);
+    common.assert.throws(() => writer.addRoot(b2.cid, { resize: true }), /Buffer has no capacity for a new root/);
+    const bytes = writer.close();
+    const reader = await readerBrowser.CarReader.fromBytes(bytes);
+    common.assert.deepEqual(await reader.getRoots(), [b1.cid]);
+    common.assert.deepEqual(reader._blocks, [
+      {
+        cid: b1.cid,
+        bytes: b1.bytes
+      },
+      {
+        cid: b2.cid,
+        bytes: b2.bytes
+      }
+    ]);
+  });
+  it('has no space for the block', async () => {
+    const headerSize = bufferWriter.estimateHeaderLength(1);
+    const dataSize = 58;
+    const buffer = new ArrayBuffer(headerSize + dataSize);
+    const writer = bufferWriter.createWriter(buffer, { headerSize });
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    writer.write(b1);
+    writer.addRoot(b1.cid);
+    const b2 = await Block__namespace.encode({
+      value: { bye: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    common.assert.throws(() => writer.write(b2), /Buffer has no capacity for this block/);
+    const bytes = writer.close();
+    const reader = await readerBrowser.CarReader.fromBytes(bytes);
+    common.assert.deepEqual(await reader.getRoots(), [b1.cid]);
+    common.assert.deepEqual(reader._blocks, [{
+        cid: b1.cid,
+        bytes: b1.bytes
+      }]);
+  });
+  it('provide roots', async () => {
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    const b2 = await Block__namespace.encode({
+      value: { bye: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha512
+    });
+    const buffer = new ArrayBuffer(300);
+    const writer = bufferWriter.createWriter(buffer, {
+      roots: [
+        b1.cid,
+        b2.cid
+      ]
+    });
+    writer.write(b1);
+    writer.write(b2);
+    const bytes = writer.close();
+    const reader = await readerBrowser.CarReader.fromBytes(bytes);
+    common.assert.deepEqual(await reader.getRoots(), [
+      b1.cid,
+      b2.cid
+    ]);
+    common.assert.deepEqual(reader._blocks, [
+      {
+        cid: b1.cid,
+        bytes: b1.bytes
+      },
+      {
+        cid: b2.cid,
+        bytes: b2.bytes
+      }
+    ]);
+  });
+  it('provide large CID root', async () => {
+    const bytes = new Uint8Array(512).fill(1);
+    const b1 = await Block__namespace.encode({
+      value: { hello: 'world' },
+      codec: CBOR__namespace,
+      hasher: sha2.sha256
+    });
+    const b2 = {
+      cid: multiformats.CID.createV1(raw__namespace.code, identity.identity.digest(bytes)),
+      bytes
+    };
+    const headerSize = CBOR__namespace.encode({
+      version: 1,
+      roots: [
+        b1.cid,
+        b2.cid
+      ]
+    }).byteLength;
+    const bodySize = bufferWriter.blockLength(b1) + bufferWriter.blockLength(b2);
+    const varintSize = multiformats.varint.encodingLength(headerSize);
+    const writer = bufferWriter.createWriter(new ArrayBuffer(varintSize + headerSize + bodySize), {
+      roots: [
+        b1.cid,
+        b2.cid
+      ]
+    });
+    writer.write(b1);
+    writer.write(b2);
+    const car = writer.close();
+    const reader = await readerBrowser.CarReader.fromBytes(car);
+    common.assert.deepEqual(await reader.getRoots(), [
+      b1.cid,
+      b2.cid
+    ]);
+    common.assert.deepEqual(reader._blocks, [
+      {
+        cid: b1.cid,
+        bytes: b1.bytes
+      },
+      {
+        cid: b2.cid,
+        bytes: b2.bytes
+      }
+    ]);
+  });
+});

package/cjs/browser-test/test-errors.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var multiformats = require('multiformats');
-var dagCbor = require('@ipld/dag-cbor');
+var CBOR = require('@ipld/dag-cbor');
 var varint = require('varint');
 var readerBrowser = require('../lib/reader-browser.js');
 var common = require('./common.js');
 
 function makeHeader(block) {
-  const u = dagCbor.encode(block);
+  const u = CBOR.encode(block);
   const l = varint.encode(u.length);
   const u2 = new Uint8Array(u.length + l.length);
   u2.set(l, 0);

package/cjs/browser-test/test-indexer.js

@@ -19,7 +19,7 @@ describe('CarIndexer fromBytes()', () => {
     const indexer$1 = await indexer.CarIndexer.fromBytes(common.goCarV2Bytes);
     const roots = await indexer$1.getRoots();
     common.assert.strictEqual(roots.length, 1);
-    common.assert(common.goCarV2Roots[0].equals(roots[0]));
+    common.assert.ok(common.goCarV2Roots[0].equals(roots[0]));
     common.assert.strictEqual(indexer$1.version, 2);
     const indexData = [];
     for await (const index of indexer$1) {

package/cjs/browser-test/test-reader.js

@@ -76,13 +76,13 @@ describe('CarReader fromBytes()', () => {
     const reader = await readerBrowser.CarReader.fromBytes(common.goCarV2Bytes);
     const roots = await reader.getRoots();
     common.assert.strictEqual(roots.length, 1);
-    common.assert(common.goCarV2Roots[0].equals(roots[0]));
+    common.assert.ok(common.goCarV2Roots[0].equals(roots[0]));
     common.assert.strictEqual(reader.version, 2);
     for (const {cid} of common.goCarV2Index) {
       const block = await reader.get(cid);
       common.assert.isDefined(block);
       if (block) {
-        common.assert(cid.equals(block.cid));
+        common.assert.ok(cid.equals(block.cid));
         let content;
         if (cid.code === dagPb__namespace.code) {
           content = dagPb__namespace.decode(block.bytes);

package/cjs/browser-test/test-writer.js

@@ -182,9 +182,9 @@ describe('CarWriter', () => {
     const rawBytes = await append(0);
     const pbBytes = await append(1);
     const cborBytes = await append(2);
-    common.assert(rawBytes.length > 0);
-    common.assert(pbBytes.length > 0);
-    common.assert(cborBytes.length > 0);
+    common.assert.ok(rawBytes.length > 0);
+    common.assert.ok(pbBytes.length > 0);
+    common.assert.ok(cborBytes.length > 0);
     const reassembled = concatBytes([
       headerBytes,
       rawBytes,