Struct PackWriter 

pub struct PackWriter { /* private fields */ }

Writer for the multi-object packed format.

Consumes an (id, payload) stream like ArchiveWriter, buffering every tile until finalize. At finalize it reuses the buffered-writer pipeline — resolve BlobOrdering::Auto, sort by the space-time curve key, per-blob zstd (NO shared dictionary, so the fzstd TS reader can decode), byte-identical dedup via blake3 — then cuts the ordered/deduped blob stream into packs of ≤ pack_target_bytes, never splitting a blob, and writes content-addressed packs/*.sttp + index/*.sttd + manifest.json.

Implementations

impl PackWriter

pub fn create<P: AsRef<Path>>( out_dir: P, ordering: BlobOrdering, pack_target_bytes: u64, ) -> Result<Self>

Create a packed-format writer targeting out_dir.

out_dir (and its index/ + packs/ subdirs) are created on finalize. ordering controls the on-disk blob byte order (BlobOrdering::Auto resolves per-dataset at finalize); pack_target_bytes is the soft per-pack size cap — a single blob larger than the target gets its own pack rather than being split.

pub fn with_paging(self, page_entries: Option<usize>) -> Self

Opt into a paged directory: the .sttd becomes a root page + leaf pages of ≤ page_entries entries each, so a cold reader fetches only the leaves its viewport/time-window touches (Wave 2). None (the default) emits the single whole-load v5 directory — byte-identical output to a pre-paging build. Some(0) is clamped to 1.

pub fn with_zstd_level(self, level: i32) -> Self

Set the zstd compression level for tile blobs and the directory.

The packed format is write-once / serve-many, so the higher build CPU of a level like 19 is paid once while the smaller bytes are paid on every fetch (measured −10..19% vs the level-3 default; decode is unaffected). Clamped to zstd’s valid 1..=22 range. The default (compression::ZSTD_LEVEL) reproduces byte-identical pre-existing builds.

pub fn add_tile_full( &mut self, id: &TileId, time_start: i64, time_end: i64, cover_t_min: Option<i64>, feature_count: u32, temporal_bucket_ms: Option<u64>, payload: &[u8], ) -> Result<()>

Add a tile carrying the full directory metadata. Same shape as ArchiveWriter::add_tile_full: cover_t_min is the tight lower covering bound (None to omit), temporal_bucket_ms tags the directory entry with the temporal bucket size the tile represents. The payload is the uncompressed tile frame.

pub fn tile_count(&self) -> usize

Number of tiles buffered so far.

pub fn finalize(self, metadata: &Metadata) -> Result<Manifest>

Finalise: order + dedup + per-blob zstd, cut packs, write packs/*.sttp + index/*.sttd + manifest.json into out_dir.

Mirrors ArchiveWriter::finalize_buffered: the same time-bucket calc, BlobOrdering::Auto → BlobOrdering::choose resolution, space-time sort key, per-blob compress_zstd_with_dict(_, None) (no shared dict), and blake3 byte-identical dedup. THEN the ordered, deduped blob stream is cut into packs.