@osmix/pbf 0.0.3 → 0.0.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @osmix/pbf
 
+## 0.0.5
+
+### Patch Changes
+
+- f468db5: Fix publishing (2)
+
+## 0.0.4
+
+### Patch Changes
+
+- 68d6bd8: Fix publishing for packages.
+
 ## 0.0.3
 
 ### Patch Changes

package/dist/blobs-to-blocks.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Blob-to-block conversion utilities.
+ *
+ * Handles decompression and protobuf decoding of raw OSM PBF blobs into
+ * typed header and primitive block structures.
+ *
+ * @module
+ */
+import { type OsmPbfBlock, type OsmPbfHeaderBlock } from "./proto/osmformat";
+/**
+ * Decompress and decode a stream of raw PBF blobs into typed blocks.
+ *
+ * This async generator handles the transition from compressed bytes to parsed
+ * protobuf structures. The first blob is always decoded as a header block;
+ * subsequent blobs are decoded as primitive blocks containing OSM entities.
+ *
+ * @param blobs - Async or sync generator yielding compressed blob payloads.
+ * @param decompress - Optional decompression function (defaults to Web Streams zlib).
+ * @yields Header block first, then primitive blocks.
+ *
+ * @example
+ * ```ts
+ * import { osmPbfBlobsToBlocksGenerator, createOsmPbfBlobGenerator } from "@osmix/pbf"
+ *
+ * const generateBlobs = createOsmPbfBlobGenerator()
+ * const blobsGen = (async function* () {
+ *   for await (const chunk of stream) {
+ *     yield* generateBlobs(chunk)
+ *   }
+ * })()
+ *
+ * for await (const block of osmPbfBlobsToBlocksGenerator(blobsGen)) {
+ *   // First iteration yields header, rest yield primitive blocks
+ * }
+ * ```
+ */
+export declare function osmPbfBlobsToBlocksGenerator(blobs: AsyncGenerator<Uint8Array<ArrayBuffer>> | Generator<Uint8Array<ArrayBuffer>>, decompress?: (data: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>): AsyncGenerator<OsmPbfHeaderBlock | OsmPbfBlock, void, unknown>;
+/**
+ * Decompress and parse a header block from a compressed blob.
+ *
+ * @param compressedBlob - Zlib-compressed protobuf header blob.
+ * @param decompress - Optional decompression function.
+ * @returns Parsed header block with required/optional features and bbox.
+ */
+export declare function readOsmHeaderBlock(compressedBlob: Uint8Array<ArrayBuffer>, decompress?: (data: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>): Promise<OsmPbfHeaderBlock>;
+/**
+ * Decompress and parse a primitive block from a compressed blob.
+ *
+ * @param compressedBlob - Zlib-compressed protobuf primitive blob.
+ * @param decompress - Optional decompression function.
+ * @returns Parsed primitive block with string table and primitive groups.
+ */
+export declare function readOsmPrimitiveBlock(compressedBlob: Uint8Array<ArrayBuffer>, decompress?: (data: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>): Promise<OsmPbfBlock>;
+//# sourceMappingURL=blobs-to-blocks.d.ts.map

package/dist/blobs-to-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobs-to-blocks.d.ts","sourceRoot":"","sources":["../src/blobs-to-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,iBAAiB,EAGtB,MAAM,mBAAmB,CAAA;AAG1B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAuB,4BAA4B,CAClD,KAAK,EACF,cAAc,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,GACvC,SAAS,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,EACrC,UAAU,GAAE,CACX,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,KACzB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAiB,kEAWrD;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACvC,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,EACvC,UAAU,GAAE,CACX,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,KACzB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAiB,GACnD,OAAO,CAAC,iBAAiB,CAAC,CAI5B;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAC1C,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,EACvC,UAAU,GAAE,CACX,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,KACzB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAiB,GACnD,OAAO,CAAC,WAAW,CAAC,CAItB"}

package/dist/blobs-to-blocks.js

@@ -0,0 +1,75 @@
+/**
+ * Blob-to-block conversion utilities.
+ *
+ * Handles decompression and protobuf decoding of raw OSM PBF blobs into
+ * typed header and primitive block structures.
+ *
+ * @module
+ */
+import Pbf from "pbf";
+import { readHeaderBlock, readPrimitiveBlock, } from "./proto/osmformat";
+import { webDecompress } from "./utils";
+/**
+ * Decompress and decode a stream of raw PBF blobs into typed blocks.
+ *
+ * This async generator handles the transition from compressed bytes to parsed
+ * protobuf structures. The first blob is always decoded as a header block;
+ * subsequent blobs are decoded as primitive blocks containing OSM entities.
+ *
+ * @param blobs - Async or sync generator yielding compressed blob payloads.
+ * @param decompress - Optional decompression function (defaults to Web Streams zlib).
+ * @yields Header block first, then primitive blocks.
+ *
+ * @example
+ * ```ts
+ * import { osmPbfBlobsToBlocksGenerator, createOsmPbfBlobGenerator } from "@osmix/pbf"
+ *
+ * const generateBlobs = createOsmPbfBlobGenerator()
+ * const blobsGen = (async function* () {
+ *   for await (const chunk of stream) {
+ *     yield* generateBlobs(chunk)
+ *   }
+ * })()
+ *
+ * for await (const block of osmPbfBlobsToBlocksGenerator(blobsGen)) {
+ *   // First iteration yields header, rest yield primitive blocks
+ * }
+ * ```
+ */
+export async function* osmPbfBlobsToBlocksGenerator(blobs, decompress = webDecompress) {
+    let headerRead = false;
+    for await (const blob of blobs) {
+        if (!headerRead) {
+            headerRead = true;
+            yield readOsmHeaderBlock(blob, decompress);
+        }
+        else {
+            yield readOsmPrimitiveBlock(blob, decompress);
+        }
+    }
+}
+/**
+ * Decompress and parse a header block from a compressed blob.
+ *
+ * @param compressedBlob - Zlib-compressed protobuf header blob.
+ * @param decompress - Optional decompression function.
+ * @returns Parsed header block with required/optional features and bbox.
+ */
+export async function readOsmHeaderBlock(compressedBlob, decompress = webDecompress) {
+    const decompressedBlob = await decompress(compressedBlob);
+    const pbf = new Pbf(decompressedBlob);
+    return readHeaderBlock(pbf);
+}
+/**
+ * Decompress and parse a primitive block from a compressed blob.
+ *
+ * @param compressedBlob - Zlib-compressed protobuf primitive blob.
+ * @param decompress - Optional decompression function.
+ * @returns Parsed primitive block with string table and primitive groups.
+ */
+export async function readOsmPrimitiveBlock(compressedBlob, decompress = webDecompress) {
+    const decompressedBlob = await decompress(compressedBlob);
+    const pbf = new Pbf(decompressedBlob);
+    return readPrimitiveBlock(pbf);
+}
+//# sourceMappingURL=blobs-to-blocks.js.map

package/dist/blobs-to-blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobs-to-blocks.js","sourceRoot":"","sources":["../src/blobs-to-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,GAAG,MAAM,KAAK,CAAA;AACrB,OAAO,EAGN,eAAe,EACf,kBAAkB,GAClB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,4BAA4B,CAClD,KAEqC,EACrC,aAEwC,aAAa;IAErD,IAAI,UAAU,GAAG,KAAK,CAAA;IACtB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QAChC,IAAI,CAAC,UAAU,EAAE,CAAC;YACjB,UAAU,GAAG,IAAI,CAAA;YACjB,MAAM,kBAAkB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAC3C,CAAC;aAAM,CAAC;YACP,MAAM,qBAAqB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAC9C,CAAC;IACF,CAAC;AACF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACvC,cAAuC,EACvC,aAEwC,aAAa;IAErD,MAAM,gBAAgB,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,CAAA;IACzD,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,gBAAgB,CAAC,CAAA;IACrC,OAAO,eAAe,CAAC,GAAG,CAAC,CAAA;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAC1C,cAAuC,EACvC,aAEwC,aAAa;IAErD,MAAM,gBAAgB,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,CAAA;IACzD,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,gBAAgB,CAAC,CAAA;IACrC,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAA;AAC/B,CAAC"}

package/dist/blocks-to-pbf.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Block-to-PBF serialization utilities.
+ *
+ * Converts parsed OSM header and primitive blocks back into spec-compliant
+ * PBF byte sequences with proper framing, compression, and size validation.
+ *
+ * @module
+ */
+import type { OsmPbfBlock, OsmPbfHeaderBlock } from "./proto/osmformat";
+/**
+ * Serialize a header or primitive block into spec-compliant PBF bytes.
+ *
+ * Handles protobuf encoding, zlib compression, blob wrapping, and length prefixing.
+ * Validates output against OSM PBF specification size limits and logs warnings
+ * if recommended sizes are exceeded.
+ *
+ * @param block - Parsed header or primitive block to encode.
+ * @param compress - Optional compression function (defaults to Web Streams zlib).
+ * @returns Complete blob bytes: 4-byte length prefix + BlobHeader + Blob.
+ * @throws If blob exceeds maximum size limits (64 KiB header, 32 MiB data).
+ *
+ * @example
+ * ```ts
+ * import { osmBlockToPbfBlobBytes } from "@osmix/pbf"
+ *
+ * const headerBytes = await osmBlockToPbfBlobBytes({
+ *   required_features: ["OsmSchema-V0.6", "DenseNodes"],
+ *   optional_features: [],
+ * })
+ * ```
+ */
+export declare function osmBlockToPbfBlobBytes(block: OsmPbfBlock | OsmPbfHeaderBlock, compress?: (data: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>): Promise<Uint8Array<ArrayBufferLike>>;
+/**
+ * Web `TransformStream` that encodes OSM blocks into PBF byte chunks.
+ *
+ * Accepts a stream of header and primitive blocks and outputs spec-compliant
+ * PBF bytes. The header block must be the first item in the stream.
+ *
+ * @throws If a primitive block is received before the header.
+ *
+ * @example
+ * ```ts
+ * import { OsmBlocksToPbfBytesTransformStream } from "@osmix/pbf"
+ *
+ * const pbfStream = blocksStream.pipeThrough(new OsmBlocksToPbfBytesTransformStream())
+ * await pbfStream.pipeTo(writableFile)
+ * ```
+ */
+export declare class OsmBlocksToPbfBytesTransformStream extends TransformStream<OsmPbfHeaderBlock | OsmPbfBlock, Uint8Array> {
+    headerEnqueued: boolean;
+    constructor();
+}
+//# sourceMappingURL=blocks-to-pbf.d.ts.map

package/dist/blocks-to-pbf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks-to-pbf.d.ts","sourceRoot":"","sources":["../src/blocks-to-pbf.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAUvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,sBAAsB,CAC3C,KAAK,EAAE,WAAW,GAAG,iBAAiB,EACtC,QAAQ,GAAE,CACT,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,KACzB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAe,wCAqDnD;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,kCAAmC,SAAQ,eAAe,CACtE,iBAAiB,GAAG,WAAW,EAC/B,UAAU,CACV;IACA,cAAc,UAAQ;;CAYtB"}

package/dist/blocks-to-pbf.js

@@ -0,0 +1,110 @@
+/**
+ * Block-to-PBF serialization utilities.
+ *
+ * Converts parsed OSM header and primitive blocks back into spec-compliant
+ * PBF byte sequences with proper framing, compression, and size validation.
+ *
+ * @module
+ */
+import Pbf from "pbf";
+import { writeBlob, writeBlobHeader } from "./proto/fileformat";
+import { writeHeaderBlock, writePrimitiveBlock } from "./proto/osmformat";
+import { MAX_BLOB_SIZE_BYTES, MAX_HEADER_SIZE_BYTES, RECOMMENDED_BLOB_SIZE_BYTES, RECOMMENDED_HEADER_SIZE_BYTES, } from "./spec";
+import { concatUint8, uint32BE, webCompress } from "./utils";
+/**
+ * Serialize a header or primitive block into spec-compliant PBF bytes.
+ *
+ * Handles protobuf encoding, zlib compression, blob wrapping, and length prefixing.
+ * Validates output against OSM PBF specification size limits and logs warnings
+ * if recommended sizes are exceeded.
+ *
+ * @param block - Parsed header or primitive block to encode.
+ * @param compress - Optional compression function (defaults to Web Streams zlib).
+ * @returns Complete blob bytes: 4-byte length prefix + BlobHeader + Blob.
+ * @throws If blob exceeds maximum size limits (64 KiB header, 32 MiB data).
+ *
+ * @example
+ * ```ts
+ * import { osmBlockToPbfBlobBytes } from "@osmix/pbf"
+ *
+ * const headerBytes = await osmBlockToPbfBlobBytes({
+ *   required_features: ["OsmSchema-V0.6", "DenseNodes"],
+ *   optional_features: [],
+ * })
+ * ```
+ */
+export async function osmBlockToPbfBlobBytes(block, compress = webCompress) {
+    const contentPbf = new Pbf();
+    let type;
+    if ("primitivegroup" in block) {
+        type = "OSMData";
+        writePrimitiveBlock(block, contentPbf);
+    }
+    else {
+        type = "OSMHeader";
+        writeHeaderBlock(block, contentPbf);
+    }
+    const contentData = contentPbf.finish();
+    const raw_size = contentData.length;
+    const compressedBuffer = await compress(contentData);
+    const blobPbf = new Pbf();
+    writeBlob({
+        raw_size,
+        zlib_data: compressedBuffer,
+    }, blobPbf);
+    const blob = blobPbf.finish();
+    const blobHeaderPbf = new Pbf();
+    writeBlobHeader({
+        type,
+        datasize: blob.length,
+    }, blobHeaderPbf);
+    const blobHeader = blobHeaderPbf.finish();
+    const blobHeaderSize = uint32BE(blobHeader.byteLength);
+    // Check the BlobHeader and Blob sizes, log error if over the recommended size, throw error if over the maximum size
+    if (blobHeader.byteLength > RECOMMENDED_HEADER_SIZE_BYTES) {
+        const sizeKiB = (blobHeader.byteLength / 1024).toFixed(2);
+        if (blobHeader.byteLength > MAX_HEADER_SIZE_BYTES) {
+            throw new Error(`BlobHeader is ${sizeKiB} KiB, the maximum size is 64KiB`);
+        }
+        console.warn(`BlobHeader is ${sizeKiB} KiB, the recommended size is 32KiB`);
+    }
+    if (blob.byteLength > RECOMMENDED_BLOB_SIZE_BYTES) {
+        const sizeMiB = (blob.byteLength / 1024 / 1024).toFixed(2);
+        if (blob.byteLength > MAX_BLOB_SIZE_BYTES) {
+            throw new Error(`Blob is ${sizeMiB} MiB, the maximum size is 32MiB`);
+        }
+        console.warn(`Blob is ${sizeMiB} MiB, the recommended size is 16MiB`);
+    }
+    return concatUint8(blobHeaderSize, blobHeader, blob);
+}
+/**
+ * Web `TransformStream` that encodes OSM blocks into PBF byte chunks.
+ *
+ * Accepts a stream of header and primitive blocks and outputs spec-compliant
+ * PBF bytes. The header block must be the first item in the stream.
+ *
+ * @throws If a primitive block is received before the header.
+ *
+ * @example
+ * ```ts
+ * import { OsmBlocksToPbfBytesTransformStream } from "@osmix/pbf"
+ *
+ * const pbfStream = blocksStream.pipeThrough(new OsmBlocksToPbfBytesTransformStream())
+ * await pbfStream.pipeTo(writableFile)
+ * ```
+ */
+export class OsmBlocksToPbfBytesTransformStream extends TransformStream {
+    headerEnqueued = false;
+    constructor() {
+        super({
+            transform: async (block, controller) => {
+                if ("primitivegroup" in block && !this.headerEnqueued) {
+                    throw Error("Header first in ReadableStream of blocks.");
+                }
+                this.headerEnqueued = true;
+                controller.enqueue(await osmBlockToPbfBlobBytes(block));
+            },
+        });
+    }
+}
+//# sourceMappingURL=blocks-to-pbf.js.map

package/dist/blocks-to-pbf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks-to-pbf.js","sourceRoot":"","sources":["../src/blocks-to-pbf.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @osmix/pbf - Low-level OSM PBF parsing and serialization.
+ *
+ * Provides streaming primitives for reading and writing OpenStreetMap PBF files
+ * using Web Streams and native compression APIs. Stays close to the official
+ * protobuf schema (`osmformat.proto`, `fileformat.proto`) while exposing
+ * predictable TypeScript types.
+ *
+ * Key capabilities:
+ * - **Parse**: Read headers and primitive blocks from `ArrayBuffer`, async iterables, or `ReadableStream`.
+ * - **Stream**: Use `TransformStream` helpers to process large files without buffering entirely in memory.
+ * - **Serialize**: Write header and primitive blocks back to spec-compliant blobs with size guardrails.
+ * - **Types**: Generated protobuf readers/writers and TypeScript interfaces for OSM data structures.
+ *
+ * @example
+ * ```ts
+ * import { readOsmPbf } from "@osmix/pbf"
+ *
+ * const { header, blocks } = await readOsmPbf(Bun.file('./monaco.pbf').stream())
+ * console.log(header.required_features)
+ *
+ * for await (const block of blocks) {
+ *   console.log(block.primitivegroup.length, "groups")
+ * }
+ * ```
+ *
+ * @module @osmix/pbf
+ */
+export * from "./blobs-to-blocks";
+export * from "./blocks-to-pbf";
+export * from "./pbf-to-blobs";
+export * from "./pbf-to-blocks";
+export * from "./proto/fileformat";
+export * from "./proto/osmformat";
+export * from "./spec";
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,37 @@
+/**
+ * @osmix/pbf - Low-level OSM PBF parsing and serialization.
+ *
+ * Provides streaming primitives for reading and writing OpenStreetMap PBF files
+ * using Web Streams and native compression APIs. Stays close to the official
+ * protobuf schema (`osmformat.proto`, `fileformat.proto`) while exposing
+ * predictable TypeScript types.
+ *
+ * Key capabilities:
+ * - **Parse**: Read headers and primitive blocks from `ArrayBuffer`, async iterables, or `ReadableStream`.
+ * - **Stream**: Use `TransformStream` helpers to process large files without buffering entirely in memory.
+ * - **Serialize**: Write header and primitive blocks back to spec-compliant blobs with size guardrails.
+ * - **Types**: Generated protobuf readers/writers and TypeScript interfaces for OSM data structures.
+ *
+ * @example
+ * ```ts
+ * import { readOsmPbf } from "@osmix/pbf"
+ *
+ * const { header, blocks } = await readOsmPbf(Bun.file('./monaco.pbf').stream())
+ * console.log(header.required_features)
+ *
+ * for await (const block of blocks) {
+ *   console.log(block.primitivegroup.length, "groups")
+ * }
+ * ```
+ *
+ * @module @osmix/pbf
+ */
+export * from "./blobs-to-blocks";
+export * from "./blocks-to-pbf";
+export * from "./pbf-to-blobs";
+export * from "./pbf-to-blocks";
+export * from "./proto/fileformat";
+export * from "./proto/osmformat";
+export * from "./spec";
+export * from "./utils";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA"}

package/dist/pbf-to-blobs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Create a stateful parser that extracts compressed blobs from raw PBF bytes.
+ *
+ * OSM PBF files consist of length-prefixed blobs. This function returns a generator
+ * that accumulates incoming byte chunks and yields complete compressed blobs as they
+ * become available. The caller is responsible for decompression.
+ *
+ * The first yielded blob contains the file header; subsequent blobs contain primitive data.
+ *
+ * @returns A generator function that accepts byte chunks and yields compressed blob payloads.
+ *
+ * @example
+ * ```ts
+ * import { createOsmPbfBlobGenerator } from "@osmix/pbf"
+ *
+ * const generateBlobs = createOsmPbfBlobGenerator()
+ *
+ * for await (const chunk of stream) {
+ *   for (const compressedBlob of generateBlobs(chunk)) {
+ *     // Decompress and parse blob...
+ *   }
+ * }
+ * ```
+ */
+export declare function createOsmPbfBlobGenerator(): (chunk: Uint8Array) => Generator<Uint8Array<ArrayBuffer>, void, unknown>;
+//# sourceMappingURL=pbf-to-blobs.d.ts.map

package/dist/pbf-to-blobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbf-to-blobs.d.ts","sourceRoot":"","sources":["../src/pbf-to-blobs.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,KAWb,OAAO,UAAU,uDAiC5C"}

package/dist/pbf-to-blobs.js

@@ -0,0 +1,70 @@
+import Pbf from "pbf";
+import { HEADER_LENGTH_BYTES } from "./pbf-to-blocks";
+import { readBlob, readBlobHeader, } from "./proto/fileformat";
+/**
+ * Create a stateful parser that extracts compressed blobs from raw PBF bytes.
+ *
+ * OSM PBF files consist of length-prefixed blobs. This function returns a generator
+ * that accumulates incoming byte chunks and yields complete compressed blobs as they
+ * become available. The caller is responsible for decompression.
+ *
+ * The first yielded blob contains the file header; subsequent blobs contain primitive data.
+ *
+ * @returns A generator function that accepts byte chunks and yields compressed blob payloads.
+ *
+ * @example
+ * ```ts
+ * import { createOsmPbfBlobGenerator } from "@osmix/pbf"
+ *
+ * const generateBlobs = createOsmPbfBlobGenerator()
+ *
+ * for await (const chunk of stream) {
+ *   for (const compressedBlob of generateBlobs(chunk)) {
+ *     // Decompress and parse blob...
+ *   }
+ * }
+ * ```
+ */
+export function createOsmPbfBlobGenerator() {
+    let pbf = new Pbf(new Uint8Array(0));
+    let state = "header-length";
+    let bytesNeeded = HEADER_LENGTH_BYTES;
+    let blobHeader = null;
+    /**
+     * Feed the parser with the next chunk of bytes and yield any complete compressed blobs.
+     * @param chunk - Raw bytes from the PBF file.
+     * @yields Compressed blob payloads (zlib-compressed protobuf data).
+     */
+    return function* nextChunk(chunk) {
+        const currentBuffer = pbf.buf.slice(pbf.pos);
+        const tmpBuffer = new Uint8Array(currentBuffer.buffer.byteLength + chunk.byteLength);
+        tmpBuffer.set(currentBuffer.subarray(0));
+        tmpBuffer.set(new Uint8Array(chunk), currentBuffer.byteLength);
+        pbf = new Pbf(tmpBuffer);
+        while (pbf.pos + bytesNeeded <= pbf.length) {
+            if (state === "header-length") {
+                const dataView = new DataView(pbf.buf.buffer);
+                bytesNeeded = dataView.getInt32(pbf.pos, false); // network byte order
+                pbf.pos += HEADER_LENGTH_BYTES;
+                state = "header";
+            }
+            else if (state === "header") {
+                blobHeader = readBlobHeader(pbf, pbf.pos + bytesNeeded);
+                bytesNeeded = blobHeader.datasize;
+                state = "blob";
+            }
+            else if (state === "blob") {
+                if (blobHeader == null)
+                    throw Error("Blob header has not been read");
+                const blob = readBlob(pbf, pbf.pos + bytesNeeded);
+                if (blob.zlib_data === undefined || blob.zlib_data.length === 0)
+                    throw Error("Blob has no zlib data. Format is unsupported.");
+                yield blob.zlib_data;
+                state = "header-length";
+                bytesNeeded = HEADER_LENGTH_BYTES;
+                blobHeader = null;
+            }
+        }
+    };
+}
+//# sourceMappingURL=pbf-to-blobs.js.map

package/dist/pbf-to-blobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbf-to-blobs.js","sourceRoot":"","sources":["../src/pbf-to-blobs.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAA;AACrB,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAEN,QAAQ,EACR,cAAc,GACd,MAAM,oBAAoB,CAAA;AAE3B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,yBAAyB;IACxC,IAAI,GAAG,GAAQ,IAAI,GAAG,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;IACzC,IAAI,KAAK,GAAwC,eAAe,CAAA;IAChE,IAAI,WAAW,GAAW,mBAAmB,CAAA;IAC7C,IAAI,UAAU,GAA4B,IAAI,CAAA;IAE9C;;;;OAIG;IACH,OAAO,QAAQ,CAAC,CAAC,SAAS,CAAC,KAAiB;QAC3C,MAAM,aAAa,GAAe,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACxD,MAAM,SAAS,GAAG,IAAI,UAAU,CAC/B,aAAa,CAAC,MAAM,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAClD,CAAA;QACD,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;QACxC,SAAS,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;QAC9D,GAAG,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAA;QAExB,OAAO,GAAG,CAAC,GAAG,GAAG,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;YAC5C,IAAI,KAAK,KAAK,eAAe,EAAE,CAAC;gBAC/B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;gBAC7C,WAAW,GAAG,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA,CAAC,qBAAqB;gBACrE,GAAG,CAAC,GAAG,IAAI,mBAAmB,CAAA;gBAC9B,KAAK,GAAG,QAAQ,CAAA;YACjB,CAAC;iBAAM,IAAI,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC/B,UAAU,GAAG,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,GAAG,WAAW,CAAC,CAAA;gBACvD,WAAW,GAAG,UAAU,CAAC,QAAQ,CAAA;gBACjC,KAAK,GAAG,MAAM,CAAA;YACf,CAAC;iBAAM,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;gBAC7B,IAAI,UAAU,IAAI,IAAI;oBAAE,MAAM,KAAK,CAAC,+BAA+B,CAAC,CAAA;gBACpE,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,GAAG,WAAW,CAAC,CAAA;gBACjD,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;oBAC9D,MAAM,KAAK,CAAC,+CAA+C,CAAC,CAAA;gBAE7D,MAAM,IAAI,CAAC,SAAoC,CAAA;gBAE/C,KAAK,GAAG,eAAe,CAAA;gBACvB,WAAW,GAAG,mBAAmB,CAAA;gBACjC,UAAU,GAAG,IAAI,CAAA;YAClB,CAAC;QACF,CAAC;IACF,CAAC,CAAA;AACF,CAAC"}

package/dist/pbf-to-blocks.d.ts

@@ -0,0 +1,63 @@
+import { type OsmPbfBlock, type OsmPbfHeaderBlock } from "./proto/osmformat";
+import { type AsyncGeneratorValue } from "./utils";
+/** Number of bytes used to encode the BlobHeader length prefix (big-endian uint32). */
+export declare const HEADER_LENGTH_BYTES = 4;
+/**
+ * Parse an OSM PBF file from various input sources.
+ *
+ * Accepts `ArrayBuffer`, `Uint8Array`, `ReadableStream<Uint8Array>`, or async generators.
+ * Returns the file header and a lazy async generator of primitive blocks for on-demand parsing.
+ *
+ * @param data - PBF bytes as buffer, stream, or async iterable.
+ * @returns Object with `header` (file metadata) and `blocks` (async generator of primitive blocks).
+ * @throws If the header block is missing or malformed.
+ *
+ * @example
+ * ```ts
+ * import { readOsmPbf } from "@osmix/pbf"
+ *
+ * // From a file stream
+ * const { header, blocks } = await readOsmPbf(Bun.file('./monaco.pbf').stream())
+ *
+ * // From a fetch response
+ * const response = await fetch('/data/monaco.pbf')
+ * const { header, blocks } = await readOsmPbf(response.body!)
+ *
+ * // Iterate blocks lazily
+ * for await (const block of blocks) {
+ *   for (const group of block.primitivegroup) {
+ *     console.log(group.dense?.id.length ?? 0, "dense nodes")
+ *   }
+ * }
+ * ```
+ */
+export declare function readOsmPbf(data: AsyncGeneratorValue<Uint8Array<ArrayBufferLike>>): Promise<{
+    header: OsmPbfHeaderBlock;
+    blocks: AsyncGenerator<OsmPbfBlock>;
+}>;
+/**
+ * Web `TransformStream` that decodes raw PBF byte chunks into OSM header and data blocks.
+ *
+ * The first blob in an OSM PBF file is always the header block; subsequent blobs
+ * contain primitive data (nodes, ways, relations). This stream handles the framing,
+ * decompression, and protobuf decoding automatically.
+ *
+ * @example
+ * ```ts
+ * import { OsmPbfBytesToBlocksTransformStream } from "@osmix/pbf"
+ *
+ * const response = await fetch('/data/monaco.pbf')
+ * const blocksStream = response.body!
+ *   .pipeThrough(new OsmPbfBytesToBlocksTransformStream())
+ *
+ * const reader = blocksStream.getReader()
+ * const { value: header } = await reader.read() // First read yields header
+ * // Subsequent reads yield primitive blocks
+ * ```
+ */
+export declare class OsmPbfBytesToBlocksTransformStream extends TransformStream<Uint8Array<ArrayBufferLike>, OsmPbfHeaderBlock | OsmPbfBlock> {
+    generateBlobsFromChunk: (chunk: Uint8Array) => Generator<Uint8Array<ArrayBuffer>, void, unknown>;
+    header: OsmPbfHeaderBlock | null;
+    constructor(decompress?: (data: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>);
+}
+//# sourceMappingURL=pbf-to-blocks.d.ts.map

package/dist/pbf-to-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbf-to-blocks.d.ts","sourceRoot":"","sources":["../src/pbf-to-blocks.ts"],"names":[],"mappings":"AAGA,OAAO,EACN,KAAK,WAAW,EAChB,KAAK,iBAAiB,EAGtB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACN,KAAK,mBAAmB,EAGxB,MAAM,SAAS,CAAA;AAEhB,uFAAuF;AACvF,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAC/B,IAAI,EAAE,mBAAmB,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;;YAkBnC,cAAc,CAAC,WAAW,CAAC;GAE9C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kCAAmC,SAAQ,eAAe,CACtE,UAAU,CAAC,eAAe,CAAC,EAC3B,iBAAiB,GAAG,WAAW,CAC/B;IACA,sBAAsB,2EAA8B;IACpD,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAO;gBAEtC,UAAU,GAAE,CACX,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,KACzB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAiB;CAiBtD"}