MCAP TypeScript SDK

https://mcap.dev/docs/
Admin
The MCAP TypeScript SDK provides NPM packages for JavaScript and TypeScript to interact with MCAP, a...
Tokens:10,208
Snippets:127
Trust Score:7.5
Update:10 months ago
Show doc for...
Tokens:
Raw
### TempBuffer Methods - MCAP TypeScript SDK

Source: https://mcap.dev/docs/typescript/classes/_mcap_core

Provides an overview of the methods available for interacting with the TempBuffer. These include setting capacity, getting the buffer content as Uint8Array, retrieving the current position, reading data, seeking to a specific position, getting the buffer size, truncating data, and writing data.

```typescript
#setCapacity(capacity: number): void
get(): Uint8Array
position(): bigint
read(offset: bigint, size: bigint): Promise<Uint8Array>
seek(position: bigint): Promise<void>
size(): Promise<bigint>
truncate(): Promise<void>
write(data: Uint8Array): Promise<void>
```

--------------------------------

### IWritable Interface

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core.IWritable

Documentation for the IWritable interface, which describes a writer interface and is implemented by TempBuffer. It includes methods for getting the current position and writing data.

```APIDOC
## Interface IWritable

IWritable describes a writer interface.

### Hierarchy
  * IWritable
    * ISeekableWriter

### Implemented by
  * TempBuffer

## Methods

### position

Gets the current position of the writer.

- **Method**: GET
- **Endpoint**: N/A (Interface method)

#### Returns
- **bigint**: The current position of the writer.

### write

Writes a buffer to the writer.

- **Method**: POST
- **Endpoint**: N/A (Interface method)

#### Parameters
- **buffer** (Uint8Array) - Required - The data to write.

#### Returns
- **Promise<unknown>**

### Request Example (write method)
```json
{
  "buffer": "Uint8Array"
}
```

### Response Example (write method)
```json
{
  "result": "unknown"
}
```
```

--------------------------------

### Usage Example: Stream MCAP Data with McapStreamReader

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapStreamReader

This example demonstrates how to use the McapStreamReader to process incoming data streams. It appends data chunks and iterates through parsed records, handling potential errors during processing. This is useful for real-time MCAP data ingestion.

```typescript
const reader = new McapStreamReader();
stream.on("data", (data) => {
  try {
    reader.append(data);
    for (let record; (record = reader.nextRecord()); ) {
      // process available records
    }
  } catch (e) {
    // handle errors
  }
});
```

--------------------------------

### TempBuffer Implementation Example (TypeScript)

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core.McapTypes.IReadable

Illustrates how the TempBuffer class implements the IReadable interface. It provides concrete implementations for reading data chunks and determining the total size of the buffer.

```typescript
class TempBuffer implements IReadable {
  private buffer: Uint8Array;

  constructor(data: Uint8Array) {
    this.buffer = data;
  }

  async read(offset: bigint, size: bigint): Promise<Uint8Array> {
    const start = Number(offset);
    const end = Number(offset + size);
    if (start < 0 || end > this.buffer.length) {
      throw new Error('Read out of bounds');
    }
    return this.buffer.slice(start, end);
  }

  async size(): Promise<bigint> {
    return BigInt(this.buffer.length);
  }
}
```

--------------------------------

### Read MCAP files in Node.js

Source: https://mcap.dev/docs/typescript/modules/_mcap_nodejs

This example demonstrates how to read MCAP files using the @mcap/nodejs package. It initializes an McapIndexedReader with a FileHandleReadable, which requires dependencies like @mcap/support, @mcap/nodejs, @mcap/core, and fs/promises. The output is an McapIndexedReader instance ready for querying.

```typescript
import { loadDecompressHandlers } from "@mcap/support";
import { FileHandleReadable } from "@mcap/nodejs";
import { McapIndexedReader } from "@mcap/core";
import { open } from "fs/promises";

const decompressHandlers = await loadDecompressHandlers();
const fileHandle = await open("file.mcap", "r");
const reader = await McapIndexedReader.Initialize({
  readable: new FileHandleReadable(fileHandle),
  decompressHandlers,
});
```

--------------------------------

### TypeScript: IWritable Interface Definition

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core

Defines the IWritable interface for the MCAP TypeScript SDK. It includes methods for getting the current position and writing a buffer. The 'write' method takes a Uint8Array and returns a Promise.

```typescript
interface IWritable {
  position(): bigint;
  write(buffer: Uint8Array): Promise<unknown>;
}
```

--------------------------------

### Write MCAP files in Node.js

Source: https://mcap.dev/docs/typescript/modules/_mcap_nodejs

This example shows how to write MCAP files in Node.js using the @mcap/nodejs package. It sets up an McapWriter with a FileHandleWritable and a compression function for zstd. Dependencies include @foxglove/wasm-zstd, @mcap/nodejs, @mcap/core, and fs/promises. The output is an McapWriter instance for appending data.

```typescript
import zstd from "@foxglove/wasm-zstd";
import { FileHandleWritable } from "@mcap/nodejs";
import { McapWriter } from "@mcap/core";
import { open } from "fs/promises";

await zstd.isLoaded;
const fileHandle = await open("file.mcap", "wx");
const writer = new McapWriter({
  writable: new FileHandleWritable(fileHandle),
  compressChunk: (data) => ({
    compression: "zstd",
    compressedData: zstd.compress(data),
  }),
});
```

--------------------------------

### Load Chunk Data in TypeScript

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapIndexedReader

Provides an example of loading specific chunk data using McapIndexedReader. The `loadChunkData` method takes a chunk index and optional options for CRC validation, returning a Promise that resolves to a DataView of the chunk data.

```typescript
import { McapIndexedReader, ChunkIndex } from "@mcap/core";

async function loadChunk(reader: McapIndexedReader, chunkIndex: ChunkIndex & { type: "ChunkIndex" }) {
  try {
    const chunkData = await reader.loadChunkData(chunkIndex, {
      validateCrcs: true,
    });
    console.log("Chunk data loaded successfully:", chunkData);
  } catch (error) {
    console.error("Error loading chunk data:", error);
  }
}
```

--------------------------------

### FileHandleReadable read Method (TypeScript)

Source: https://mcap.dev/docs/typescript/classes/_mcap_nodejs.FileHandleReadable

Reads a specified number of bytes from the file handle starting at a given offset. It returns a Promise that resolves to a Uint8Array containing the read data.

```typescript
read(offset: bigint, length: bigint): Promise<Uint8Array>
```

--------------------------------

### Get MCAP Buffer

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Retrieves the complete MCAP data as a Uint8Array. This represents the serialized content written to the buffer.

```typescript
get buffer(): Uint8Array
```

--------------------------------

### IReadable Interface Definition (TypeScript)

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core.McapTypes.IReadable

Defines the IReadable interface for MCAP files, specifying methods to read data and get the total size. This interface is implemented by TempBuffer and other readers.

```typescript
interface IReadable {
  read(offset: bigint, size: bigint): Promise<Uint8Array>;
  size(): Promise<bigint>;
}
```

--------------------------------

### Get Buffer Length

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Returns the current length of the internal buffer in bytes as a number.

```typescript
get length(): number
```

--------------------------------

### Define MCAP Chunk Type in TypeScript

Source: https://mcap.dev/docs/typescript/types/_mcap_core.McapTypes.Chunk

This snippet defines the 'Chunk' type alias used in the MCAP TypeScript SDK. It specifies the data types for compression, message start and end times, record data, uncompressed CRC, and uncompressed size. This structure is essential for handling MCAP file segments.

```typescript
/**
 * Represents a chunk within an MCAP file.
 */
type Chunk = {
  /** Compression used for the chunk's records. */
  compression: string;
  /** The timestamp of the last message in the chunk. */
  messageEndTime: bigint;
  /** The timestamp of the first message in the chunk. */
  messageStartTime: bigint;
  /** The raw, uncompressed record data for the chunk. */
  records: Uint8Array;
  /** CRC32 checksum of the uncompressed records. */
  uncompressedCrc: number;
  /** The size of the uncompressed records in bytes. */
  uncompressedSize: bigint;
};
```

--------------------------------

### Initialize McapRecordBuilder

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Constructs a new McapRecordBuilder instance. Optionally accepts configuration options. Returns the McapRecordBuilder instance.

```typescript
new McapRecordBuilder(options?): McapRecordBuilder
```

--------------------------------

### TempBuffer Methods

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.TempBuffer

Documentation for the public and private methods of the TempBuffer class.

```APIDOC
## Methods

### `Private` #setCapacity
  * #setCapacity(capacity): void
  * #### Parameters
    * ##### capacity: number
#### Returns void

### get
  * get(): Uint8Array
  * #### Returns Uint8Array

### position
  * position(): bigint
  * #### Returns bigint

### read
  * read(offset, size): Promise<Uint8Array>
  * #### Parameters
    * ##### offset: bigint
    * ##### size: bigint
#### Returns Promise<Uint8Array>

### seek
  * seek(position): Promise<void>
  * Move the cursor to the given position
#### Parameters
    * ##### position: bigint
#### Returns Promise<void>

### size
  * size(): Promise<bigint>
  * #### Returns Promise<bigint>

### truncate
  * truncate(): Promise<void>
  * Remove data after the current write position
#### Returns Promise<void>

### write
  * write(data): Promise<void>
  * #### Parameters
    * ##### data: Uint8Array
#### Returns Promise<void>
```

--------------------------------

### FileHandleReadable Constructor (TypeScript)

Source: https://mcap.dev/docs/typescript/classes/_mcap_nodejs.FileHandleReadable

Initializes a new instance of the FileHandleReadable class. It requires a FileHandle object as a parameter and returns a FileHandleReadable instance.

```typescript
new FileHandleReadable(handle: FileHandle): FileHandleReadable
```

--------------------------------

### Initialize McapIndexedReader in TypeScript

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapIndexedReader

Demonstrates how to initialize an McapIndexedReader. This method takes a readable data source and optional decompress handlers for compressed chunks. It returns a Promise that resolves to an McapIndexedReader instance.

```typescript
import { McapIndexedReader, IReadable, DecompressHandlers } from "@mcap/core";

async function initializeReader(readable: IReadable, decompressHandlers?: DecompressHandlers): Promise<McapIndexedReader> {
  const reader = await McapIndexedReader.Initialize({
    readable: readable,
    decompressHandlers: decompressHandlers,
  });
  return reader;
}
```

--------------------------------

### FileHandleWritable Class

Source: https://mcap.dev/docs/typescript/classes/_mcap_nodejs.FileHandleWritable

Details about the FileHandleWritable class, its constructors, properties, and methods.

```APIDOC
## Class FileHandleWritable

IWritable implementation for FileHandle.

### Hierarchy
* FileHandleWritable

### Implements
* IWritable

## Constructors
### constructor
  * new FileHandleWritable(handle: FileHandle): FileHandleWritable
  * #### Parameters
    * ##### handle: FileHandle
  * #### Returns FileHandleWritable

## Properties
### `#handle`
* `#handle`: FileHandle

### `#totalBytesWritten`
* `#totalBytesWritten`: number = 0

## Methods
### `position`
  * position(): bigint
  * #### Returns bigint

### `write`
  * write(buffer: Uint8Array): Promise<void>
  * #### Parameters
    * ##### buffer: Uint8Array
  * #### Returns Promise<void>
```

--------------------------------

### McapStreamReader Constructor Options

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapStreamReader

Initializes a new instance of the McapStreamReader. The constructor accepts an optional configuration object for customizing reader behavior, such as validation or chunk inclusion. Defaults are applied if no options are provided.

```typescript
new McapStreamReader(__namedParameters?: McapReaderOptions)
```

--------------------------------

### FileHandleWritable Constructor (TypeScript)

Source: https://mcap.dev/docs/typescript/classes/_mcap_nodejs

Initializes a new instance of the FileHandleWritable class. It requires a FileHandle object to operate on. This constructor sets up the internal state for writing to a file.

```typescript
new FileHandleWritable(handle: FileHandle)
```

--------------------------------

### TempBuffer Constructor

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.TempBuffer

Initializes a new instance of the TempBuffer class, optionally with source data.

```APIDOC
## Constructors

### constructor
  * new TempBuffer(source?): TempBuffer
  * #### Parameters
    * ##### `Optional` source: ArrayBuffer | ArrayBufferView
#### Returns TempBuffer
```

--------------------------------

### FileHandleWritable Methods (TypeScript)

Source: https://mcap.dev/docs/typescript/classes/_mcap_nodejs

Describes the methods available on the FileHandleWritable class. The 'position' method returns the current write position as a BigInt, and the 'write' method asynchronously writes a Uint8Array buffer to the file, returning a Promise that resolves when the operation is complete.

```typescript
position(): bigint
write(buffer: Uint8Array): Promise<void>
```

--------------------------------

### Read MCAP files in Browser with TypeScript

Source: https://mcap.dev/docs/typescript/modules/_mcap_support

Demonstrates how to read MCAP files in a browser environment using the @mcap/support package. It handles file input from 'change' or 'drop' events and initializes an McapIndexedReader with decompress handlers and a BlobReadable. Dependencies include '@mcap/support', '@mcap/browser', and '@mcap/core'.

```typescript
import { loadDecompressHandlers } from "@mcap/support";
import { BlobReadable } from "@mcap/browser";
import { McapIndexedReader } from "@mcap/core";

/**
 * For <input type="file"/>, listen for "change" events.
 * 
 * For drag & drop, listen for "drop" events. (Note that you must also listen for "dragover" events
 * and call event.preventDefault(), to enable listening for drop events.)
 */
async function onChangeOrDrop(event: Event) {
  let file: File | undefined;
  if (event instanceof DragEvent) {
    file = event.dataTransfer?.files[0];
    event.preventDefault();
  } else if (event.target instanceof HTMLInputElement) {
    file = event.target.files?.[0];
  } else {
    throw new Error(`Unexpected event type: ${event.type}`);
  }
  if (!file) {
    throw new Error("No file selected");
  }
  const decompressHandlers = await loadDecompressHandlers();
  const reader = await McapIndexedReader.Initialize({
    readable: new BlobReadable(file),
    decompressHandlers,
  });
}
```

--------------------------------

### TempBuffer Class

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.TempBuffer

Overview of the TempBuffer class, its hierarchy, and implemented interfaces.

```APIDOC
## Class TempBuffer

In-memory buffer used for reading and writing MCAP files in tests. Can be used as both an IReadable and an IWritable.

#### Hierarchy
  * TempBuffer

#### Implements
  * IReadable
  * IWritable
  * ISeekableWriter
```

--------------------------------

### Read MCAP Files in Browser with TypeScript

Source: https://mcap.dev/docs/typescript/modules/_mcap_browser

Demonstrates how to read MCAP files in a web browser using the @mcap/browser package. It handles file selection via input elements or drag-and-drop events and initializes an McapIndexedReader. Dependencies include @mcap/support, @mcap/browser, and @mcap/core.

```typescript
import { loadDecompressHandlers } from "@mcap/support";  
import { BlobReadable } from "@mcap/browser";  
import { McapIndexedReader } from "@mcap/core";  
  
/**  
 * For <input type="file"/>, listen for "change" events.  
 *  
 * For drag & drop, listen for "drop" events. (Note that you must also listen for "dragover" events  
 * and call event.preventDefault(), to enable listening for drop events.)  
 */  
async function onChangeOrDrop(event: Event) {  
  let file: File | undefined;  
  if (event instanceof DragEvent) {  
    file = event.dataTransfer?.files[0];  
    event.preventDefault();  
  } else if (event.target instanceof HTMLInputElement) {  
    file = event.target.files?.[0];  
  } else {  
    throw new Error(`Unexpected event type: ${event.type}`);  
  }  
  if (!file) {  
    throw new Error("No file selected");  
  }  
  const decompressHandlers = await loadDecompressHandlers();  
  const reader = await McapIndexedReader.Initialize({  
    readable: new BlobReadable(file),  
    decompressHandlers,  
  });  
}
```

--------------------------------

### McapWriter: Initialize for Appending

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Initializes a new McapWriter for appending to an existing MCAP file. This method reuses existing indexes and IDs from the provided file. The writer is already opened but requires an eventual call to `end()`.

```typescript
McapWriter.InitializeForAppending(readWrite, options): Promise<McapWriter>
```

--------------------------------

### McapWriter: Constructor

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Creates a new instance of McapWriter to write messages to MCAP files. Callers must ensure method calls are completed before initiating new ones to prevent file corruption.

```typescript
new McapWriter(options: McapWriterOptions): McapWriter
```

--------------------------------

### McapWriterOptions Type Definition (TypeScript)

Source: https://mcap.dev/docs/typescript/types/_mcap_core

Defines the options for configuring an MCAP writer. This includes settings for chunking, compression, channel and schema repetition, and indexing strategies. The `writable` property is mandatory and specifies the output stream.

```typescript
type McapWriterOptions = {
  chunkSize?: number;
  compressChunk?: (chunkData: Uint8Array) => {
    compressedData: Uint8Array;
    compression: string;
  };
  repeatChannels?: boolean;
  repeatSchemas?: boolean;
  startChannelId?: number;
  useAttachmentIndex?: boolean;
  useChunkIndex?: boolean;
  useChunks?: boolean;
  useMessageIndex?: boolean;
  useMetadataIndex?: boolean;
  useStatistics?: boolean;
  useSummaryOffsets?: boolean;
  writable: IWritable;
};
```

--------------------------------

### Write MCAP Footer

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes the MCAP footer record to the buffer. Requires a Footer object as input. Returns the byte length of the written footer as a bigint.

```typescript
writeFooter(footer: Footer): bigint
```

--------------------------------

### Write MCAP Metadata Index

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a metadata index record to the MCAP buffer. Requires a MetadataIndex object as input. Returns the byte length of the written index as a bigint.

```typescript
writeMetadataIndex(metadataIndex: MetadataIndex): bigint
```

--------------------------------

### McapWriter: Add Metadata

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Appends metadata to the MCAP file. Metadata provides additional information about the recording.

```typescript
addMetadata(metadata: Metadata): Promise<void>
```

--------------------------------

### McapWriterOptions Type Alias

Source: https://mcap.dev/docs/typescript/types/_mcap_core.McapWriterOptions

Defines the configuration options available when creating an McapWriter instance. These options control aspects like chunk size, compression, channel/schema repetition, and the use of various indexes and offsets.

```APIDOC
## McapWriterOptions

### Description
Configuration options for writing MCAP files.

### Type Alias
`McapWriterOptions`

### Properties
- **chunkSize** (`number`): Optional. The size of data chunks to write.
- **compressChunk** (`(chunkData: Uint8Array) => { compressedData: Uint8Array; compression: string; }`): Optional. A function to compress chunk data. It takes raw chunk data and returns compressed data along with the compression type.
- **repeatChannels** (`boolean`): Optional. Whether to repeat channel information.
- **repeatSchemas** (`boolean`): Optional. Whether to repeat schema information.
- **startChannelId** (`number`): Optional. The starting ID for channels.
- **useAttachmentIndex** (`boolean`): Optional. Whether to use an index for attachments.
- **useChunkIndex** (`boolean`): Optional. Whether to use an index for chunks.
- **useChunks** (`boolean`): Optional. Whether to enable chunking.
- **useMessageIndex** (`boolean`): Optional. Whether to use an index for messages.
- **useMetadataIndex** (`boolean`): Optional. Whether to use an index for metadata.
- **useStatistics** (`boolean`): Optional. Whether to include statistics.
- **useSummaryOffsets** (`boolean`): Optional. Whether to use summary offsets.
- **writable** (`IWritable`): Required. The writable stream to write the MCAP data to.
```

--------------------------------

### Class BlobReadable

Source: https://mcap.dev/docs/typescript/classes/_mcap_browser.BlobReadable

Implements the IReadable interface for Blob and File objects, allowing them to be read sequentially.

```APIDOC
## Class BlobReadable

IReadable implementation for Blob (and File, which is a Blob).

### Hierarchy
  * BlobReadable

### Implements
  * IReadable

### Constructors

#### constructor

`new BlobReadable(blob: Blob): BlobReadable`

##### Parameters

*   **blob** (Blob) - The Blob or File object to wrap.

##### Returns

*   BlobReadable - A new instance of BlobReadable.

### Properties

#### `#blob`

*   **#blob** (Blob) - The underlying Blob object.

### Methods

#### `read(offset: bigint, size: bigint): Promise<Uint8Array>`

Reads a chunk of data from the BlobReadable.

##### Parameters

*   **offset** (bigint) - The starting byte offset to read from.
*   **size** (bigint) - The number of bytes to read.

##### Returns

*   Promise<Uint8Array> - A promise that resolves with the requested data as a Uint8Array.

#### `size(): Promise<bigint>`

Gets the total size of the BlobReadable in bytes.

##### Returns

*   Promise<bigint> - A promise that resolves with the total size of the BlobReadable.
```

--------------------------------

### TempBuffer Constructor - MCAP TypeScript SDK

Source: https://mcap.dev/docs/typescript/classes/_mcap_core

Initializes a new instance of the TempBuffer class. It can optionally take an ArrayBuffer or ArrayBufferView as a source to pre-populate the buffer. This constructor is part of the MCAP TypeScript SDK and is used for creating in-memory representations of MCAP files.

```typescript
new TempBuffer(source?: ArrayBuffer | ArrayBufferView)
```

--------------------------------

### TypeScript: TempBuffer Implementation of IWritable

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core

Shows that TempBuffer is an implementation of the IWritable interface. This means TempBuffer provides concrete logic for the 'position' and 'write' methods defined in IWritable.

```typescript
import { IWritable } from "@mcap/core";

class TempBuffer implements IWritable {
  // ... implementation details ...

  position(): bigint {
    // ... implementation ...
    return 0n;
  }

  async write(buffer: Uint8Array): Promise<unknown> {
    // ... implementation ...
    return Promise.resolve();
  }
}
```

--------------------------------

### McapStreamReader Class API

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapStreamReader

This section details the constructor, properties, and methods of the McapStreamReader class, used for reading MCAP files via a streaming interface.

```APIDOC
## Class McapStreamReader

A streaming reader for MCAP files.

### Constructor

#### `new McapStreamReader(__namedParameters?: McapReaderOptions): McapStreamReader`

*   **__namedParameters** (`McapReaderOptions`)
    *   Optional
    *   Configuration options for the MCAP reader.

### Properties

*   **#buffer** (`ArrayBuffer`)
    *   Internal buffer holding the received bytes.
*   **#channelsById** (`Map<number, Channel & { type: "Channel"; }> `)
    *   Map storing channel information indexed by channel ID.
*   **#decompressHandlers** (`DecompressHandlers`)
    *   Handlers for decompressing MCAP data chunks.
*   **#doneReading** (`boolean`)
    *   Flag indicating if reading has been completed.
*   **#generator** (`Generator<undefined | TypedMcapRecord, undefined | TypedMcapRecord, void>`)
    *   Internal generator for processing records.
*   **#includeChunks** (`boolean`)
    *   Option to include chunk records during reading.
*   **#noMagicPrefix** (`boolean`)
    *   Option to disable magic prefix validation.
*   **#reader** (`default`)
    *   Internal reader instance.
*   **#validateCrcs** (`boolean`)
    *   Option to validate CRC checksums.
*   **#view** (`DataView`)
    *   DataView for accessing the buffer.

### Methods

*   **#appendOrShift(data: Uint8Array): void**
    *   Appends new data to the internal buffer or shifts existing data to make space.
    *   **Parameters**:
        *   **data** (`Uint8Array`) - The byte array to append.
    *   **Returns**: `void`

*   **#read(): Generator<undefined | TypedMcapRecord, undefined | TypedMcapRecord, void>**
    *   Reads records from the stream using an internal generator.
    *   **Returns**: `Generator<undefined | TypedMcapRecord, undefined | TypedMcapRecord, void>`

*   **append(data: Uint8Array): void**
    *   Provides the reader with newly received bytes for processing. Call `nextRecord()` after appending to parse available records.
    *   **Parameters**:
        *   **data** (`Uint8Array`) - The byte array to append.
    *   **Returns**: `void`

*   **bytesRemaining(): number**
    *   Returns the number of bytes received by `append()` but not yet parsed.
    *   **Returns**: `number`

*   **done(): boolean**
    *   Returns `true` if a valid, complete MCAP file has been parsed, `false` otherwise.
    *   **Returns**: `boolean`

*   **nextRecord(): undefined | TypedMcapRecord**
    *   Reads the next record from the stream if possible. Returns `undefined` if not enough data is available for a complete record or if reading has terminated with a valid footer.
    *   This method may throw errors during parsing. If an error is thrown, the reader is in an unspecified state and should not be used further.
    *   **Returns**: `undefined | TypedMcapRecord`
```

--------------------------------

### Write MCAP Summary Offset

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a summary offset record to the MCAP buffer. Requires a SummaryOffset object as input. Returns the byte length of the written offset as a bigint.

```typescript
writeSummaryOffset(summaryOffset: SummaryOffset): bigint
```

--------------------------------

### Write MCAP Schema

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a schema record to the MCAP buffer. Requires a Schema object as input. Returns the byte length of the written schema as a bigint.

```typescript
writeSchema(schema: Schema): bigint
```

--------------------------------

### FileHandleReadable size Method (TypeScript)

Source: https://mcap.dev/docs/typescript/classes/_mcap_nodejs.FileHandleReadable

Returns the total size of the file in bytes. This method returns a Promise that resolves to a bigint representing the file size.

```typescript
size(): Promise<bigint>
```

--------------------------------

### Write MCAP Channel

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a channel record to the MCAP buffer. Requires a Channel object as input. Returns the byte length of the written channel as a bigint.

```typescript
writeChannel(info: Channel): bigint
```

--------------------------------

### Write MCAP Chunk Index

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a chunk index record to the MCAP buffer. Requires a ChunkIndex object as input. Returns the byte length of the written index as a bigint.

```typescript
writeChunkIndex(chunkIndex: ChunkIndex): bigint
```

--------------------------------

### Write MCAP Metadata

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a metadata record to the MCAP buffer. Requires a Metadata object as input. Returns the byte length of the written metadata as a bigint.

```typescript
writeMetadata(metadata: Metadata): bigint
```

--------------------------------

### Write MCAP Header

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes the MCAP header record to the buffer. Requires a Header object as input. Returns the byte length of the written header as a bigint.

```typescript
writeHeader(header: Header): bigint
```

--------------------------------

### Write MCAP Message Index

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a message index record to the MCAP buffer. Requires a MessageIndex object as input. Returns the byte length of the written index as a bigint.

```typescript
writeMessageIndex(messageIndex: MessageIndex): bigint
```

--------------------------------

### TempBuffer Properties

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.TempBuffer

Details of the private properties of the TempBuffer class: #buffer and #position.

```APIDOC
## Properties

### `Private` #buffer
#buffer: ArrayBuffer = ...
### `Private` #position
#position: number = 0
```

--------------------------------

### Write MCAP Magic Number

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes the MCAP magic number to the buffer. This method does not take any parameters and returns void.

```typescript
writeMagic(): void
```

--------------------------------

### ISeekableWriter Interface

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core.ISeekableWriter

The ISeekableWriter interface extends IWritable and adds methods for seeking and truncating data within a buffer. It's implemented by TempBuffer.

```APIDOC
## Interface ISeekableWriter

ISeekableWriter describes a writer interface with seek abilities.

### Hierarchy
* IWritable
  * ISeekableWriter

### Implemented by
* TempBuffer

### Methods

#### position

Gets the current position of the writer.

* **Method**
  `position(): bigint`

* **Returns**
  `bigint` - The current position.

#### seek

Moves the cursor to the given position.

* **Method**
  `seek(position: bigint): Promise<void>`

* **Parameters**
  * **position** (`bigint`) - The target position to seek to.

* **Returns**
  `Promise<void>`

#### truncate

Removes data after the current write position.

* **Method**
  `truncate(): Promise<void>`

* **Returns**
  `Promise<void>`

#### write

Writes a buffer to the current position.

* **Method**
  `write(buffer: Uint8Array): Promise<unknown>`

* **Parameters**
  * **buffer** (`Uint8Array`) - The data buffer to write.

* **Returns**
  `Promise<unknown>`
```

--------------------------------

### McapWriter: End

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Completes the MCAP file writing process. This method should be called to ensure the file is properly indexed and finalized.

```typescript
end(): Promise<void>
```

--------------------------------

### Write MCAP Attachment Index

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes an attachment index record to the MCAP buffer. Requires an AttachmentIndex object as input. Returns the byte length of the written index as a bigint.

```typescript
writeAttachmentIndex(attachmentIndex: AttachmentIndex): bigint
```

--------------------------------

### McapStreamReader nextRecord Method

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapStreamReader

Attempts to parse and return the next available record from the stream. If insufficient data is present or the file has ended, it returns `undefined`. Errors during parsing will cause this method to throw, rendering the reader unusable.

```typescript
nextRecord(): undefined | TypedMcapRecord
```

--------------------------------

### FileHandleWritable Properties (TypeScript)

Source: https://mcap.dev/docs/typescript/classes/_mcap_nodejs

Details the private properties of the FileHandleWritable class. '#handle' stores the associated FileHandle, while '#totalBytesWritten' tracks the cumulative number of bytes written to the file. These properties manage the state of the writable stream.

```typescript
#handle: FileHandle
#totalBytesWritten: number = 0
```

--------------------------------

### TempBuffer Implementation of IReadable (TypeScript)

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core.McapTypes

TempBuffer is an implementation of the IReadable interface, providing random-access reading capabilities for MCAP data stored in a temporary buffer. It uses Promises to handle asynchronous read operations.

```typescript
class TempBuffer implements IReadable {
  // ... implementation details ...

  async read(offset: bigint, size: bigint): Promise<Uint8Array> {
    // ... read logic ...
    return new Uint8Array(); // Placeholder
  }

  async size(): Promise<bigint> {
    // ... size logic ...
    return 0n; // Placeholder
  }
}
```

--------------------------------

### Read Messages from MCAP File in TypeScript

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapIndexedReader

Shows how to read messages from an MCAP file using McapIndexedReader. The `readMessages` method returns an async generator that yields messages. Options include filtering by time range, topics, and reverse order, as well as CRC validation.

```typescript
import { McapIndexedReader } from "@mcap/core";

async function* processMessages(reader: McapIndexedReader) {
  for await (const message of reader.readMessages({
    topics: ["/scan", "/odom"],
    validateCrcs: true,
  })) {
    yield message;
  }
}
```

--------------------------------

### TypeScript: ISeekableWriter Interface Inheritance

Source: https://mcap.dev/docs/typescript/interfaces/_mcap_core

Illustrates the hierarchy where IWritable extends ISeekableWriter. This indicates that any implementer of IWritable also inherits the capabilities of ISeekableWriter.

```typescript
interface ISeekableWriter {
  // ... methods for seeking
}

interface IWritable extends ISeekableWriter {
  position(): bigint;
  write(buffer: Uint8Array): Promise<unknown>;
}
```

--------------------------------

### Write MCAP Data End

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a data end record to the MCAP buffer. Requires a DataEnd object as input. Returns the byte length of the written data end record as a bigint.

```typescript
writeDataEnd(dataEnd: DataEnd): bigint
```

--------------------------------

### Write MCAP Chunk

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a chunk record to the MCAP buffer. Requires a Chunk object as input. Returns the byte length of the written chunk as a bigint.

```typescript
writeChunk(chunk: Chunk): bigint
```

--------------------------------

### Write MCAP Message

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a message record to the MCAP buffer. Requires a Message object as input. This method does not return a value.

```typescript
writeMessage(message: Message): void
```

--------------------------------

### Write MCAP Attachment

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes an attachment record to the MCAP buffer. Requires an Attachment object as input. Returns the byte length of the written attachment as a bigint.

```typescript
writeAttachment(attachment: Attachment): bigint
```

--------------------------------

### DecompressHandlers Type

Source: https://mcap.dev/docs/typescript/types/_mcap_core.McapTypes.DecompressHandlers

The DecompressHandlers type defines a mapping from compression names (strings) to decompression functions. Each decompression function takes a buffer and decompressed size and returns a decompressed Uint8Array.

```APIDOC
## Type alias DecompressHandlers

### Description
A map where keys are compression names (strings) and values are functions that decompress a buffer.

### Type Declaration
`DecompressHandlers: { [compression: string]: (buffer: Uint8Array, decompressedSize: bigint) => Uint8Array; }`

### Fields
* **compression** (string) - The name of the compression algorithm.
  * **Type**: `(buffer: Uint8Array, decompressedSize: bigint) => Uint8Array` - A function that takes the compressed buffer and the expected decompressed size, and returns the decompressed data as a `Uint8Array`.

#### Parameters for Decompression Function
* **buffer** (Uint8Array) - The compressed data buffer.
* **decompressedSize** (bigint) - The expected size of the decompressed data.

#### Returns
* **Uint8Array** - The decompressed data.
```

--------------------------------

### Write MCAP Statistics

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Writes a statistics record to the MCAP buffer. Requires a Statistics object as input. Returns the byte length of the written statistics as a bigint.

```typescript
writeStatistics(statistics: Statistics): bigint
```

--------------------------------

### McapStreamReader append Method

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapStreamReader

Appends new bytes to the internal buffer of the McapStreamReader. After calling this method, `nextRecord()` should be invoked to parse any newly available records from the appended data. It takes a Uint8Array as input.

```typescript
append(data: Uint8Array): void
```

--------------------------------

### McapWriter: Register Schema

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Adds a schema definition and returns a unique schema ID. This ID is subsequently used when registering channels.

```typescript
registerSchema(info: Omit<Schema, "id">): Promise<number>
```

--------------------------------

### Read Metadata from MCAP File in TypeScript

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapIndexedReader

Demonstrates how to read metadata from an MCAP file using McapIndexedReader. The `readMetadata` method returns an async generator yielding metadata entries. Metadata can be filtered by name.

```typescript
import { McapIndexedReader } from "@mcap/core";

async function* processMetadata(reader: McapIndexedReader) {
  for await (const metadata of reader.readMetadata({
    name: "/my_metadata",
  })) {
    yield metadata;
  }
}
```

--------------------------------

### TempBuffer Properties - MCAP TypeScript SDK

Source: https://mcap.dev/docs/typescript/classes/_mcap_core

Details the private properties of the TempBuffer class: '#buffer' stores the underlying ArrayBuffer, and '#position' tracks the current cursor position within the buffer. These properties manage the state of the in-memory MCAP file data.

```typescript
#buffer: ArrayBuffer = ...
#position: number = 0
```

--------------------------------

### Channel Type Alias Definition (TypeScript)

Source: https://mcap.dev/docs/typescript/types/_mcap_core.McapTypes.Channel

Defines the 'Channel' type alias used in the MCAP TypeScript SDK. It specifies the structure for channel metadata, including ID, message encoding, schema ID, topic, and custom metadata.

```typescript
type Channel = {
  id: number;
  messageEncoding: string;
  metadata: Map<string, string>;
  schemaId: number;
  topic: string;
}
```

--------------------------------

### McapWriter: Add Attachment

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Appends an attachment to the MCAP file. Attachments can include files or other data related to the recording.

```typescript
addAttachment(attachment: Attachment): Promise<void>
```

--------------------------------

### McapWriter: Compress Chunk Data

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

A function type for compressing chunk data. It takes raw chunk data as Uint8Array and returns compressed data along with the compression method used.

```typescript
compressChunk: (chunkData: Uint8Array) => {
  compressedData: Uint8Array;
  compression: string;
}
```

--------------------------------

### Read Attachments from MCAP File in TypeScript

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapIndexedReader

Illustrates reading attachments from an MCAP file with McapIndexedReader. The `readAttachments` method provides an async generator for attachments. Filtering by time range, name, media type, and CRC validation are supported.

```typescript
import { McapIndexedReader } from "@mcap/core";

async function* processAttachments(reader: McapIndexedReader) {
  for await (const attachment of reader.readAttachments({
    mediaType: "image/png",
    validateCrcs: true,
  })) {
    yield attachment;
  }
}
```

--------------------------------

### McapWriter: Add Message

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Appends a message to the MCAP file. This method requires a valid channel ID, schema ID, and message data.

```typescript
addMessage(message: Message): Promise<void>
```

--------------------------------

### McapStreamReader done Method

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapStreamReader

Checks if the McapStreamReader has finished parsing a complete and valid MCAP file. Returns `true` if parsing is complete, `false` otherwise.

```typescript
done(): boolean
```

--------------------------------

### McapWriter: Register Channel

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Adds a channel definition and returns a unique channel ID. This ID is used when appending messages to the MCAP file.

```typescript
registerChannel(info: Omit<Channel, "id">): Promise<number>
```

--------------------------------

### Reset McapRecordBuilder

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapRecordBuilder

Resets the internal buffer of the McapRecordBuilder, clearing all previously written data. This method returns void.

```typescript
reset(): void
```

--------------------------------

### ChunkIndex Type Alias Definition (TypeScript)

Source: https://mcap.dev/docs/typescript/types/_mcap_core.McapTypes.ChunkIndex

Defines the ChunkIndex type alias used in the MCAP TypeScript SDK. It represents the metadata for a chunk within an MCAP file, including its size, offsets, timing, and compression details. This structure is crucial for efficiently reading and navigating MCAP data.

```typescript
type ChunkIndex = {
  chunkLength: bigint;
  chunkStartOffset: bigint;
  compressedSize: bigint;
  compression: string;
  messageEndTime: bigint;
  messageIndexLength: bigint;
  messageIndexOffsets: Map<number, bigint>;
  messageStartTime: bigint;
  uncompressedSize: bigint;
};
```

--------------------------------

### McapStreamReader bytesRemaining Method

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapStreamReader

Returns the number of bytes that have been provided via `append()` but not yet processed by the reader. This can be useful for monitoring the reader's state or debugging.

```typescript
bytesRemaining(): number
```

--------------------------------

### McapWriter: Finalize Chunk

Source: https://mcap.dev/docs/typescript/classes/_mcap_core.McapWriter

Finalizes the current chunk of data being written to the MCAP file. This operation is crucial for maintaining data integrity.

```typescript
#finalizeChunk(): Promise<void>
```
Tokens:
Raw