@fireproof/vendor 1.1.1 → 1.2.0

package/src/@ipld/car/dist/src/reader-browser.d.ts

@@ -0,0 +1,151 @@
+/**
+ * @private
+ * @param {BytesReader} reader
+ * @returns {Promise<CarReader>}
+ */
+export function decodeReaderComplete(reader: BytesReader): Promise<CarReader>;
+/**
+ * @typedef {import('multiformats').CID} CID
+ * @typedef {import('./api').Block} Block
+ * @typedef {import('./api').CarReader} CarReaderIface
+ * @typedef {import('./coding').BytesReader} BytesReader
+ * @typedef {import('./coding').CarHeader} CarHeader
+ * @typedef {import('./coding').CarV2Header} CarV2Header
+ */
+/**
+ * Provides blockstore-like access to a CAR.
+ *
+ * Implements the `RootsReader` interface:
+ * {@link CarReader.getRoots `getRoots()`}. And the `BlockReader` interface:
+ * {@link CarReader.get `get()`}, {@link CarReader.has `has()`},
+ * {@link CarReader.blocks `blocks()`} (defined as a `BlockIterator`) and
+ * {@link CarReader.cids `cids()`} (defined as a `CIDIterator`).
+ *
+ * Load this class with either `import { CarReader } from '@ipld/car/reader'`
+ * (`const { CarReader } = require('@ipld/car/reader')`). Or
+ * `import { CarReader } from '@ipld/car'` (`const { CarReader } = require('@ipld/car')`).
+ * The former will likely result in smaller bundle sizes where this is
+ * important.
+ *
+ * @name CarReader
+ * @class
+ * @implements {CarReaderIface}
+ * @property {number} version The version number of the CAR referenced by this
+ * reader (should be `1` or `2`).
+ */
+export class CarReader implements CarReaderIface {
+    /**
+     * Instantiate a {@link CarReader} from a `Uint8Array` blob. This performs a
+     * decode fully in memory and maintains the decoded state in memory for full
+     * access to the data via the `CarReader` API.
+     *
+     * @async
+     * @static
+     * @memberof CarReader
+     * @param {Uint8Array} bytes
+     * @returns {Promise<CarReader>}
+     */
+    static fromBytes(bytes: Uint8Array): Promise<CarReader>;
+    /**
+     * Instantiate a {@link CarReader} from a `AsyncIterable<Uint8Array>`, such as
+     * a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
+     * This performs a decode fully in memory and maintains the decoded state in
+     * memory for full access to the data via the `CarReader` API.
+     *
+     * Care should be taken for large archives; this API may not be appropriate
+     * where memory is a concern or the archive is potentially larger than the
+     * amount of memory that the runtime can handle.
+     *
+     * @async
+     * @static
+     * @memberof CarReader
+     * @param {AsyncIterable<Uint8Array>} asyncIterable
+     * @returns {Promise<CarReader>}
+     */
+    static fromIterable(asyncIterable: AsyncIterable<Uint8Array>): Promise<CarReader>;
+    /**
+     * @constructs CarReader
+     * @param {CarHeader|CarV2Header} header
+     * @param {Block[]} blocks
+     */
+    constructor(header: CarHeader | CarV2Header, blocks: Block[]);
+    _header: import("./coding").CarHeader | import("./coding").CarV2Header;
+    _blocks: import("./api").Block[];
+    _keys: string[];
+    /**
+     * @property
+     * @memberof CarReader
+     * @instance
+     */
+    get version(): 1 | 2;
+    /**
+     * Get the list of roots defined by the CAR referenced by this reader. May be
+     * zero or more `CID`s.
+     *
+     * @function
+     * @memberof CarReader
+     * @instance
+     * @async
+     * @returns {Promise<CID[]>}
+     */
+    getRoots(): Promise<CID[]>;
+    /**
+     * Check whether a given `CID` exists within the CAR referenced by this
+     * reader.
+     *
+     * @function
+     * @memberof CarReader
+     * @instance
+     * @async
+     * @param {CID} key
+     * @returns {Promise<boolean>}
+     */
+    has(key: CID): Promise<boolean>;
+    /**
+     * Fetch a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) from the CAR
+     * referenced by this reader matching the provided `CID`. In the case where
+     * the provided `CID` doesn't exist within the CAR, `undefined` will be
+     * returned.
+     *
+     * @function
+     * @memberof CarReader
+     * @instance
+     * @async
+     * @param {CID} key
+     * @returns {Promise<Block | undefined>}
+     */
+    get(key: CID): Promise<Block | undefined>;
+    /**
+     * Returns a `BlockIterator` (`AsyncIterable<Block>`) that iterates over all
+     * of the `Block`s (`{ cid:CID, bytes:Uint8Array }` pairs) contained within
+     * the CAR referenced by this reader.
+     *
+     * @function
+     * @memberof CarReader
+     * @instance
+     * @async
+     * @generator
+     * @returns {AsyncGenerator<Block>}
+     */
+    blocks(): AsyncGenerator<Block>;
+    /**
+     * Returns a `CIDIterator` (`AsyncIterable<CID>`) that iterates over all of
+     * the `CID`s contained within the CAR referenced by this reader.
+     *
+     * @function
+     * @memberof CarReader
+     * @instance
+     * @async
+     * @generator
+     * @returns {AsyncGenerator<CID>}
+     */
+    cids(): AsyncGenerator<CID>;
+}
+export const __browser: true;
+export type CID = import('multiformats').CID;
+export type Block = import('./api').Block;
+export type CarReaderIface = import('./api').CarReader;
+export type BytesReader = import('./coding').BytesReader;
+export type CarHeader = import('./coding').CarHeader;
+export type CarV2Header = import('./coding').CarV2Header;
+//# sourceMappingURL=reader-browser.d.ts.map

package/src/@ipld/car/dist/src/reader-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader-browser.d.ts","sourceRoot":"","sources":["../../src/reader-browser.js"],"names":[],"mappings":"AAiLA;;;;GAIG;AACH,6CAHW,WAAW,GACT,QAAQ,SAAS,CAAC,CAW9B;AA7LD;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAuGE;;;;;;;;;;OAUG;IACH,wBAHW,UAAU,GACR,QAAQ,SAAS,CAAC,CAO9B;IAED;;;;;;;;;;;;;;;OAeG;IACH,mCAHW,cAAc,UAAU,CAAC,GACvB,QAAQ,SAAS,CAAC,CAO9B;IA7ID;;;;OAIG;IACH,oBAHW,SAAS,GAAC,WAAW,UACrB,KAAK,EAAE,EAMjB;IAHC,uEAAqB;IACrB,iCAAqB;IACrB,gBAAgD;IAGlD;;;;OAIG;IACH,qBAEC;IAED;;;;;;;;;OASG;IACH,YAFa,QAAQ,GAAG,EAAE,CAAC,CAI1B;IAED;;;;;;;;;;OAUG;IACH,SAHW,GAAG,GACD,QAAQ,OAAO,CAAC,CAI5B;IAED;;;;;;;;;;;;OAYG;IACH,SAHW,GAAG,GACD,QAAQ,KAAK,GAAG,SAAS,CAAC,CAKtC;IAED;;;;;;;;;;;OAWG;IACH,UAFa,eAAe,KAAK,CAAC,CAMjC;IAED;;;;;;;;;;OAUG;IACH,QAFa,eAAe,GAAG,CAAC,CAM/B;CA0CF;AAkBD,6BAA6B;kBA9LhB,OAAO,cAAc,EAAE,GAAG;oBAC1B,OAAO,OAAO,EAAE,KAAK;6BACrB,OAAO,OAAO,EAAE,SAAS;0BACzB,OAAO,UAAU,EAAE,WAAW;wBAC9B,OAAO,UAAU,EAAE,SAAS;0BAC5B,OAAO,UAAU,EAAE,WAAW"}

package/src/@ipld/car/dist/src/reader.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @typedef {import('./api').Block} Block
+ * @typedef {import('./api').BlockIndex} BlockIndex
+ * @typedef {import('./api').CarReader} CarReaderIface
+ * @typedef {import('fs').promises.FileHandle} FileHandle
+ */
+/**
+ * @class
+ * @implements {CarReaderIface}
+ */
+export class CarReader extends BrowserCarReader implements CarReaderIface {
+    /**
+     * Reads a block directly from a file descriptor for an open CAR file. This
+     * function is **only available in Node.js** and not a browser environment.
+     *
+     * This function can be used in connection with {@link CarIndexer} which emits
+     * the `BlockIndex` objects that are required by this function.
+     *
+     * The user is responsible for opening and closing the file used in this call.
+     *
+     * @async
+     * @static
+     * @memberof CarReader
+     * @param {FileHandle | number} fd - A file descriptor from the
+     * Node.js `fs` module. Either an integer, from `fs.open()` or a `FileHandle`
+     * from `fs.promises.open()`.
+     * @param {BlockIndex} blockIndex - An index pointing to the location of the
+     * Block required. This `BlockIndex` should take the form:
+     * `{cid:CID, blockLength:number, blockOffset:number}`.
+     * @returns {Promise<Block>} A `{ cid:CID, bytes:Uint8Array }` pair.
+     */
+    static readRaw(fd: FileHandle | number, blockIndex: BlockIndex): Promise<Block>;
+}
+export const __browser: boolean;
+export type Block = import('./api').Block;
+export type BlockIndex = import('./api').BlockIndex;
+export type CarReaderIface = import('./api').CarReader;
+export type FileHandle = import('fs').promises.FileHandle;
+import { CarReader as BrowserCarReader } from './reader-browser.js';
+//# sourceMappingURL=reader.d.ts.map

package/src/@ipld/car/dist/src/reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../src/reader.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBARW,UAAU,GAAG,MAAM,cAGnB,UAAU,GAGR,QAAQ,KAAK,CAAC,CAiB1B;CACF;AAED,gCAA+B;oBAjDlB,OAAO,OAAO,EAAE,KAAK;yBACrB,OAAO,OAAO,EAAE,UAAU;6BAC1B,OAAO,OAAO,EAAE,SAAS;yBACzB,OAAO,IAAI,EAAE,QAAQ,CAAC,UAAU;8CANC,qBAAqB"}

package/src/@ipld/car/dist/src/writer-browser.d.ts

@@ -0,0 +1,155 @@
+/**
+ * @typedef {import('./api').Block} Block
+ * @typedef {import('./api').BlockWriter} BlockWriter
+ * @typedef {import('./api').WriterChannel} WriterChannel
+ * @typedef {import('./coding').CarEncoder} CarEncoder
+ * @typedef {import('./coding').IteratorChannel<Uint8Array>} IteratorChannel
+ */
+/**
+ * Provides a writer interface for the creation of CAR files.
+ *
+ * Creation of a `CarWriter` involves the instatiation of an input / output pair
+ * in the form of a `WriterChannel`, which is a
+ * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair. These two
+ * components form what can be thought of as a stream-like interface. The
+ * `writer` component (an instantiated `CarWriter`), has methods to
+ * {@link CarWriter.put `put()`} new blocks and {@link CarWriter.put `close()`}
+ * the writing operation (finalising the CAR archive). The `out` component is
+ * an `AsyncIterable` that yields the bytes of the archive. This can be
+ * redirected to a file or other sink. In Node.js, you can use the
+ * [`Readable.from()`](https://nodejs.org/api/stream.html#stream_stream_readable_from_iterable_options)
+ * API to convert this to a standard Node.js stream, or it can be directly fed
+ * to a
+ * [`stream.pipeline()`](https://nodejs.org/api/stream.html#stream_stream_pipeline_source_transforms_destination_callback).
+ *
+ * The channel will provide a form of backpressure. The `Promise` from a
+ * `write()` won't resolve until the resulting data is drained from the `out`
+ * iterable.
+ *
+ * It is also possible to ignore the `Promise` from `write()` calls and allow
+ * the generated data to queue in memory. This should be avoided for large CAR
+ * archives of course due to the memory costs and potential for memory overflow.
+ *
+ * Load this class with either
+ * `import { CarWriter } from '@ipld/car/writer'`
+ * (`const { CarWriter } = require('@ipld/car/writer')`). Or
+ * `import { CarWriter } from '@ipld/car'`
+ * (`const { CarWriter } = require('@ipld/car')`). The former will likely
+ * result in smaller bundle sizes where this is important.
+ *
+ * @name CarWriter
+ * @class
+ * @implements {BlockWriter}
+ */
+export class CarWriter implements BlockWriter {
+    /**
+     * Create a new CAR writer "channel" which consists of a
+     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
+     *
+     * @async
+     * @static
+     * @memberof CarWriter
+     * @param {CID[] | CID | void} roots
+     * @returns {WriterChannel} The channel takes the form of
+     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
+     */
+    static create(roots: CID[] | CID | void): WriterChannel;
+    /**
+     * Create a new CAR appender "channel" which consists of a
+     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
+     * This appender does not consider roots and does not produce a CAR header.
+     * It is designed to append blocks to an _existing_ CAR archive. It is
+     * expected that `out` will be concatenated onto the end of an existing
+     * archive that already has a properly formatted header.
+     *
+     * @async
+     * @static
+     * @memberof CarWriter
+     * @returns {WriterChannel} The channel takes the form of
+     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
+     */
+    static createAppender(): WriterChannel;
+    /**
+     * Update the list of roots in the header of an existing CAR as represented
+     * in a Uint8Array.
+     *
+     * This operation is an _overwrite_, the total length of the CAR will not be
+     * modified. A rejection will occur if the new header will not be the same
+     * length as the existing header, in which case the CAR will not be modified.
+     * It is the responsibility of the user to ensure that the roots being
+     * replaced encode as the same length as the new roots.
+     *
+     * The byte array passed in an argument will be modified and also returned
+     * upon successful modification.
+     *
+     * @async
+     * @static
+     * @memberof CarWriter
+     * @param {Uint8Array} bytes
+     * @param {CID[]} roots - A new list of roots to replace the existing list in
+     * the CAR header. The new header must take up the same number of bytes as the
+     * existing header, so the roots should collectively be the same byte length
+     * as the existing roots.
+     * @returns {Promise<Uint8Array>}
+     */
+    static updateRootsInBytes(bytes: Uint8Array, roots: CID[]): Promise<Uint8Array>;
+    /**
+     * @param {CID[]} roots
+     * @param {CarEncoder} encoder
+     */
+    constructor(roots: CID[], encoder: CarEncoder);
+    _encoder: import("./coding").CarEncoder;
+    /** @type {Promise<void>} */
+    _mutex: Promise<void>;
+    _ended: boolean;
+    /**
+     * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
+     *
+     * @function
+     * @memberof CarWriter
+     * @instance
+     * @async
+     * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
+     * @returns {Promise<void>} The returned promise will only resolve once the
+     * bytes this block generates are written to the `out` iterable.
+     */
+    put(block: Block): Promise<void>;
+    /**
+     * Finalise the CAR archive and signal that the `out` iterable should end once
+     * any remaining bytes are written.
+     *
+     * @function
+     * @memberof CarWriter
+     * @instance
+     * @async
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the version number of the CAR file being written
+     *
+     * @returns {number}
+     */
+    version(): number;
+}
+/**
+ * @class
+ * @implements {AsyncIterable<Uint8Array>}
+ */
+export class CarWriterOut implements AsyncIterable<Uint8Array> {
+    /**
+     * @param {AsyncIterator<Uint8Array>} iterator
+     */
+    constructor(iterator: AsyncIterator<Uint8Array>);
+    _iterator: AsyncIterator<Uint8Array, any, undefined>;
+    _iterating: boolean | undefined;
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array, any, undefined>;
+}
+export const __browser: true;
+export type Block = import('./api').Block;
+export type BlockWriter = import('./api').BlockWriter;
+export type WriterChannel = import('./api').WriterChannel;
+export type CarEncoder = import('./coding').CarEncoder;
+export type IteratorChannel = import('./coding').IteratorChannel<Uint8Array>;
+import { CID } from 'multiformats/cid';
+//# sourceMappingURL=writer-browser.d.ts.map

package/src/@ipld/car/dist/src/writer-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer-browser.d.ts","sourceRoot":"","sources":["../../src/writer-browser.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAkEE;;;;;;;;;;OAUG;IACH,qBAJW,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,GAChB,aAAa,CASzB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAHa,aAAa,CASzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iCAPW,UAAU,SACV,GAAG,EAAE,GAIH,QAAQ,UAAU,CAAC,CAW/B;IA1ID;;;OAGG;IACH,mBAHW,GAAG,EAAE,WACL,UAAU,EAOpB;IAJC,wCAAuB;IACvB,4BAA4B;IAC5B,QADW,QAAQ,IAAI,CAAC,CACa;IACrC,gBAAmB;IAGrB;;;;;;;;;;OAUG;IACH,WAJW,KAAK,GACH,QAAQ,IAAI,CAAC,CAgBzB;IAED;;;;;;;;;OASG;IACH,SAFa,QAAQ,IAAI,CAAC,CASzB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;CA4EF;AAED;;;GAGG;AACH,mDAF8B,UAAU;IAGtC;;OAEG;IACH,sBAFW,cAAc,UAAU,CAAC,EAInC;IADC,qDAAyB;IAOzB,gCAAsB;IAJxB,oEAMC;CACF;AAuCD,6BAA6B;oBAnPhB,OAAO,OAAO,EAAE,KAAK;0BACrB,OAAO,OAAO,EAAE,WAAW;4BAC3B,OAAO,OAAO,EAAE,aAAa;yBAC7B,OAAO,UAAU,EAAE,UAAU;8BAC7B,OAAO,UAAU,EAAE,eAAe,CAAC,UAAU,CAAC;oBAVvC,kBAAkB"}

package/src/@ipld/car/dist/src/writer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @typedef {import('multiformats/cid').CID} CID
+ * @typedef {import('./api').BlockWriter} BlockWriter
+ * @typedef {import('fs').promises.FileHandle} FileHandle
+ */
+/**
+ * @class
+ * @implements {BlockWriter}
+ */
+export class CarWriter extends BrowserCarWriter implements BlockWriter {
+    /**
+     * Update the list of roots in the header of an existing CAR file. The first
+     * argument must be a file descriptor for CAR file that is open in read and
+     * write mode (not append), e.g. `fs.open` or `fs.promises.open` with `'r+'`
+     * mode.
+     *
+     * This operation is an _overwrite_, the total length of the CAR will not be
+     * modified. A rejection will occur if the new header will not be the same
+     * length as the existing header, in which case the CAR will not be modified.
+     * It is the responsibility of the user to ensure that the roots being
+     * replaced encode as the same length as the new roots.
+     *
+     * This function is **only available in Node.js** and not a browser
+     * environment.
+     *
+     * @async
+     * @static
+     * @memberof CarWriter
+     * @param {FileHandle | number} fd - A file descriptor from the
+     * Node.js `fs` module. Either an integer, from `fs.open()` or a `FileHandle`
+     * from `fs.promises.open()`.
+     * @param {CID[]} roots - A new list of roots to replace the existing list in
+     * the CAR header. The new header must take up the same number of bytes as the
+     * existing header, so the roots should collectively be the same byte length
+     * as the existing roots.
+     * @returns {Promise<void>}
+     */
+    static updateRootsInFile(fd: FileHandle | number, roots: CID[]): Promise<void>;
+}
+export const __browser: boolean;
+export type CID = import('multiformats/cid').CID;
+export type BlockWriter = import('./api').BlockWriter;
+export type FileHandle = import('fs').promises.FileHandle;
+import { CarWriter as BrowserCarWriter } from './writer-browser.js';
+//# sourceMappingURL=writer.d.ts.map

package/src/@ipld/car/dist/src/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../src/writer.js"],"names":[],"mappings":"AAKA;;;;GAIG;AAEH;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,6BATW,UAAU,GAAG,MAAM,SAGnB,GAAG,EAAE,GAIH,QAAQ,IAAI,CAAC,CAoCzB;CACF;AAED,gCAA+B;kBA1ElB,OAAO,kBAAkB,EAAE,GAAG;0BAC9B,OAAO,OAAO,EAAE,WAAW;yBAC3B,OAAO,IAAI,EAAE,QAAQ,CAAC,UAAU;8CALC,qBAAqB"}

package/src/@ipld/car/src/api.ts

@@ -0,0 +1,90 @@
+import type { CID } from 'multiformats/cid'
+
+/**
+ * Literally any `Iterable` (async or regular).
+ */
+export type AwaitIterable<T> = Iterable<T> | AsyncIterable<T>
+
+export type { CID }
+/* Generic types for interfacing with block storage */
+
+export interface Block {
+  cid: CID
+  bytes: Uint8Array
+}
+
+export interface BlockHeader {
+  cid: CID
+  length: number
+  blockLength: number
+}
+
+export interface BlockIndex extends BlockHeader {
+  offset: number
+  blockOffset: number
+}
+
+export interface RootsReader {
+  version: number
+  getRoots(): Promise<CID[]>
+}
+
+export interface RootsBufferReader {
+  version: number
+  getRoots(): CID[]
+}
+
+export interface BlockIterator extends AsyncIterable<Block> {}
+
+export interface CIDIterator extends AsyncIterable<CID> {}
+
+export interface BlockReader {
+  has(key: CID): Promise<boolean>
+  get(key: CID): Promise<Block | undefined>
+  blocks(): BlockIterator
+  cids(): CIDIterator
+}
+
+export interface BlockBufferReader {
+  has(key: CID): boolean
+  get(key: CID): Block | undefined
+  blocks(): Iterable<Block>
+  cids(): Iterable<CID>
+}
+
+export interface BlockWriter {
+  put(block: Block): Promise<void>
+  close(): Promise<void>
+  version(): number
+}
+
+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>
+}
+
+export interface CarReader extends BlockReader, RootsReader {}
+export interface CarBufferReader extends BlockBufferReader, RootsBufferReader {}
+
+/* Specific implementations for CAR block storage */
+
+/*
+export interface CarBlockIterator extends BlockIterator, RootsReader {}
+export interface CarCIDIterator extends CIDIterator, RootsReader {}
+export interface CarIndexer extends AsyncIterable<BlockIndex>, RootsReader {}
+export interface CarWriter extends BlockWriter {}
+*/