@tungthedev/streams-server 0.2.0

package/src/store/segment_manifest_store.ts

@@ -0,0 +1,129 @@
+import type { MaybePromise } from "./capabilities";
+import type { StreamReadRow } from "./segment_read_store";
+import type { WalReadRow } from "./wal_store";
+import type {
+  IndexRunRow,
+  IndexStateRow,
+  LexiconIndexRunRow,
+  LexiconIndexStateRow,
+  SearchCompanionPlanRow,
+  SearchSegmentCompanionRow,
+  SecondaryIndexRunRow,
+  SecondaryIndexStateRow,
+  SegmentMetaRow,
+  SegmentRow,
+} from "./rows";
+export type {
+  IndexRunRow,
+  IndexStateRow,
+  LexiconIndexRunRow,
+  LexiconIndexStateRow,
+  SearchCompanionPlanRow,
+  SearchSegmentCompanionRow,
+  SecondaryIndexRunRow,
+  SecondaryIndexStateRow,
+  SegmentMetaRow,
+  SegmentRow,
+} from "./rows";
+
+export type SegmentCandidateRow = {
+  stream: string;
+  pending_bytes: bigint;
+  pending_rows: bigint;
+  last_segment_cut_ms: bigint;
+  sealed_through: bigint;
+  next_offset: bigint;
+  epoch: number;
+};
+
+export type SegmentClaim = {
+  token: string;
+};
+
+export type SealedSegmentCommit = {
+  segmentId: string;
+  stream: string;
+  segmentIndex: number;
+  startOffset: bigint;
+  endOffset: bigint;
+  blockCount: number;
+  lastAppendMs: bigint;
+  payloadBytes: bigint;
+  sizeBytes: number;
+  localPath: string;
+  rowsSealed: bigint;
+  claimToken?: string;
+};
+
+export type ManifestRow = {
+  stream: string;
+  generation: number;
+  uploaded_generation: number;
+  last_uploaded_at_ms: bigint | null;
+  last_uploaded_etag: string | null;
+  last_uploaded_size_bytes: bigint | null;
+};
+
+export type StreamProfileRow = {
+  stream: string;
+  profile_json: string;
+  updated_at_ms: bigint;
+};
+
+export type ManifestPublicationSnapshot = {
+  publicationToken?: string;
+  streamRow: StreamReadRow;
+  prevUploadedSegmentCount: number;
+  uploadedPrefixCount: number;
+  uploadedThrough: bigint;
+  publishedLogicalSizeBytes: bigint;
+  generation: number;
+  segmentMeta: SegmentMetaRow;
+  profileJson: Record<string, any> | null;
+  indexState: IndexStateRow | null;
+  indexRuns: IndexRunRow[];
+  retiredRuns: IndexRunRow[];
+  secondaryIndexStates: SecondaryIndexStateRow[];
+  secondaryIndexRuns: SecondaryIndexRunRow[];
+  retiredSecondaryIndexRuns: SecondaryIndexRunRow[];
+  lexiconIndexStates: LexiconIndexStateRow[];
+  lexiconIndexRuns: LexiconIndexRunRow[];
+  retiredLexiconIndexRuns: LexiconIndexRunRow[];
+  searchCompanionPlan: SearchCompanionPlanRow | null;
+  searchSegmentCompanions: SearchSegmentCompanionRow[];
+};
+
+export type ManifestPublicationOptions = {
+  wait?: boolean;
+};
+
+export interface SegmentStore {
+  getSegmentStreamState(stream: string): MaybePromise<StreamReadRow | null>;
+  isDeleted(row: StreamReadRow): boolean;
+  readWalRange(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array): AsyncIterable<WalReadRow>;
+  candidates(minPendingBytes: bigint, minPendingRows: bigint, maxIntervalMs: bigint, limit: number): MaybePromise<SegmentCandidateRow[]>;
+  recentSegmentCompressionRatio(stream: string, limit?: number): MaybePromise<number | null>;
+  tryClaimSegment(stream: string): MaybePromise<SegmentClaim | null>;
+  setSegmentInProgress(stream: string, inProgress: number, claim?: SegmentClaim): MaybePromise<void>;
+  nextSegmentIndexForStream(stream: string): MaybePromise<number>;
+  commitSealedSegment(row: SealedSegmentCommit): MaybePromise<void>;
+}
+
+export interface ManifestStore {
+  nowMs(): bigint;
+  countPendingSegments(): MaybePromise<number>;
+  pendingUploadHeads(limit: number): MaybePromise<SegmentRow[]>;
+  markSegmentUploaded(segmentId: string, etag: string, uploadedAtMs: bigint): MaybePromise<void>;
+  loadManifestPublicationSnapshot(stream: string, opts?: ManifestPublicationOptions): MaybePromise<ManifestPublicationSnapshot | null>;
+  commitManifest(
+    stream: string,
+    generation: number,
+    etag: string,
+    uploadedAtMs: bigint,
+    uploadedThrough: bigint,
+    sizeBytes: number,
+    publicationToken?: string
+  ): MaybePromise<void>;
+  releaseManifestPublication?(publicationToken: string): MaybePromise<void>;
+  getSegmentForManifestCleanup(stream: string, segmentIndex: number): MaybePromise<SegmentRow | null>;
+}

package/src/store/segment_read_store.ts

@@ -0,0 +1,22 @@
+import type { SearchCompanionPlanRow, SearchSegmentCompanionRow, SegmentRow, StreamRow } from "./rows";
+
+export type StreamReadRow = StreamRow;
+export type SegmentReadRow = SegmentRow;
+export type SearchCompanionPlanReadRow = SearchCompanionPlanRow;
+export type SearchSegmentCompanionReadRow = SearchSegmentCompanionRow;
+
+export interface StreamReadStore {
+  nowMsForRead(): Promise<bigint>;
+  getStreamForRead(stream: string): Promise<StreamReadRow | null>;
+  isDeleted(row: StreamReadRow): boolean;
+}
+
+export interface SegmentReadStore {
+  listSegmentsForRead(stream: string): Promise<SegmentReadRow[]>;
+  getSegmentByIndexForRead(stream: string, segmentIndex: number): Promise<SegmentReadRow | null>;
+  findSegmentForOffsetForRead(stream: string, offset: bigint): Promise<SegmentReadRow | null>;
+  countSegmentsForRead(stream: string): Promise<number>;
+  getSearchCompanionPlanForRead(stream: string): Promise<SearchCompanionPlanReadRow | null>;
+  listSearchSegmentCompanionsForRead(stream: string): Promise<SearchSegmentCompanionReadRow[]>;
+  getSearchSegmentCompanionForRead(stream: string, segmentIndex: number): Promise<SearchSegmentCompanionReadRow | null>;
+}

package/src/store/stats_accounting_store.ts

@@ -0,0 +1,83 @@
+import type { MaybePromise } from "./capabilities";
+
+export interface StorageStatsStore {
+  countStreams(): MaybePromise<number>;
+  getWalDbSizeBytes(): MaybePromise<number>;
+  getMetaDbSizeBytes(): MaybePromise<number>;
+}
+
+export type ObjectStoreRequestSummary = {
+  puts: bigint;
+  reads: bigint;
+  gets: bigint;
+  heads: bigint;
+  lists: bigint;
+  deletes: bigint;
+  by_artifact: Array<{
+    artifact: string;
+    puts: bigint;
+    gets: bigint;
+    heads: bigint;
+    lists: bigint;
+    deletes: bigint;
+    reads: bigint;
+  }>;
+};
+
+export type ObjectStoreRequestCountRow = {
+  artifact: string;
+  op: string;
+  count: bigint;
+};
+
+export function summarizeObjectStoreRequestCounts(rows: ObjectStoreRequestCountRow[]): ObjectStoreRequestSummary {
+  const byArtifact = new Map<string, { puts: bigint; gets: bigint; heads: bigint; lists: bigint; deletes: bigint; reads: bigint }>();
+  let puts = 0n;
+  let gets = 0n;
+  let heads = 0n;
+  let lists = 0n;
+  let deletes = 0n;
+  for (const row of rows) {
+    const artifact = String(row.artifact);
+    const op = String(row.op);
+    const count = row.count;
+    const entry = byArtifact.get(artifact) ?? { puts: 0n, gets: 0n, heads: 0n, lists: 0n, deletes: 0n, reads: 0n };
+    if (op === "put") {
+      entry.puts += count;
+      puts += count;
+    } else if (op === "get") {
+      entry.gets += count;
+      entry.reads += count;
+      gets += count;
+    } else if (op === "head") {
+      entry.heads += count;
+      entry.reads += count;
+      heads += count;
+    } else if (op === "list") {
+      entry.lists += count;
+      entry.reads += count;
+      lists += count;
+    } else if (op === "delete") {
+      entry.deletes += count;
+      deletes += count;
+    }
+    byArtifact.set(artifact, entry);
+  }
+  return {
+    puts,
+    reads: gets + heads + lists,
+    gets,
+    heads,
+    lists,
+    deletes,
+    by_artifact: Array.from(byArtifact.entries()).map(([artifact, entry]) => ({ artifact, ...entry })),
+  };
+}
+
+export interface ObjectStoreAccountingRecorder {
+  recordObjectStoreRequestByHash(streamHash: string, artifact: string, op: string, bytes?: number, count?: number): MaybePromise<void>;
+}
+
+export interface ObjectStoreAccountingStore extends ObjectStoreAccountingRecorder {
+  getObjectStoreRequestSummaryByHash(streamHash: string): MaybePromise<ObjectStoreRequestSummary>;
+}

package/src/store/touch_store.ts

@@ -0,0 +1,98 @@
+import type { StreamRow } from "./rows";
+import type { MaybePromise } from "./capabilities";
+import type { WalReadRow } from "./wal_store";
+
+export type StreamTouchStateRow = {
+  stream: string;
+  processed_through: bigint;
+  updated_at_ms: bigint;
+};
+
+export type LiveTemplateStoreRow = {
+  stream: string;
+  template_id: string;
+  entity: string;
+  fields_json: string;
+  encodings_json: string;
+  state: string;
+  created_at_ms: bigint;
+  last_seen_at_ms: bigint;
+  inactivity_ttl_ms: bigint;
+  active_from_source_offset: bigint;
+  retired_at_ms: bigint | null;
+  retired_reason: string | null;
+};
+
+export type LiveTemplateIdentityRow = {
+  template_id: string;
+  entity: string;
+  fields_json: string;
+  encodings_json?: string;
+  last_seen_at_ms: bigint;
+  inactivity_ttl_ms?: bigint;
+};
+
+export type LiveTemplateLastSeenUpdate = {
+  stream: string;
+  templateId: string;
+  lastSeenAtMs: number;
+};
+
+export type LiveTemplateActivationInput = {
+  templateId: string;
+  entity: string;
+  fieldsJson: string;
+  encodingsJson: string;
+  nowMs: number;
+  inactivityTtlMs: number;
+  activeFromSourceOffset: bigint;
+};
+
+export type LiveTemplateActivationResult = {
+  activated: string[];
+  invalid: string[];
+  rateLimited: string[];
+  activationTokensUsed: number;
+  evicted: Array<{ templateId: string; reason: "cap_exceeded"; cap: number }>;
+};
+
+export interface ProfileTouchControlStore {
+  ensureStreamTouchState(stream: string): MaybePromise<void>;
+  deleteStreamTouchState(stream: string): MaybePromise<void>;
+}
+
+export interface TouchRouteStore {
+  countActiveLiveTemplates(stream: string): MaybePromise<number>;
+  getStreamTouchState(stream: string): MaybePromise<StreamTouchStateRow | null>;
+}
+
+export interface LiveTemplateStore {
+  activateLiveTemplates(args: {
+    stream: string;
+    templates: LiveTemplateActivationInput[];
+    maxActiveTemplatesPerStream: number;
+    maxActiveTemplatesPerEntity: number;
+    maxActivationTokens: number;
+  }): MaybePromise<LiveTemplateActivationResult>;
+  countActiveLiveTemplates(stream: string): MaybePromise<number>;
+  listActiveLiveTemplates(stream: string): MaybePromise<LiveTemplateStoreRow[]>;
+  updateLiveTemplateLastSeenBatch(updates: LiveTemplateLastSeenUpdate[]): MaybePromise<void>;
+  listExpiredLiveTemplates(stream: string, nowMs: number, limit: number): MaybePromise<LiveTemplateIdentityRow[]>;
+  retireLiveTemplatesForInactivity(stream: string, templateIds: string[], nowMs: number): MaybePromise<void>;
+  listActiveLiveTemplateEntitiesByIds(stream: string, templateIds: string[]): MaybePromise<string[]>;
+}
+
+export interface TouchProcessorStore extends ProfileTouchControlStore, TouchRouteStore, LiveTemplateStore {
+  nowMs(): bigint;
+  getStream(stream: string): MaybePromise<StreamRow | null>;
+  ensureStream(stream: string, opts?: { contentType?: string; streamFlags?: number }): MaybePromise<StreamRow>;
+  addStreamFlags(stream: string, flags: number): MaybePromise<void>;
+  isDeleted(row: StreamRow): boolean;
+  readWalRange(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array): AsyncIterable<WalReadRow>;
+  listStreamTouchStates(): MaybePromise<StreamTouchStateRow[]>;
+  listStreamsByProfile(kind: string): MaybePromise<string[]>;
+  updateStreamTouchStateThrough(stream: string, processedThrough: bigint): MaybePromise<void>;
+  deleteWalThrough(stream: string, uploadedThrough: bigint): MaybePromise<{ deletedRows: number; deletedBytes: number }>;
+  getWalOldestOffset(stream: string): MaybePromise<bigint | null>;
+  trimWalByAge(stream: string, maxAgeMs: number): MaybePromise<{ trimmedRows: number; trimmedBytes: number; keptFromOffset: bigint | null }>;
+}

package/src/store/wal_store.ts

@@ -0,0 +1,21 @@
+import type { StoreAppendBatch, StoreAppendTask } from "./append";
+
+export type WalReadRow = {
+  offset: bigint;
+  tsMs: bigint;
+  routingKey: Uint8Array | null;
+  contentType: string | null;
+  payload: Uint8Array;
+};
+
+export interface WalAppendStore {
+  appendBatch(tasks: StoreAppendTask[]): Promise<StoreAppendBatch>;
+}
+
+export interface WalReadStore {
+  readWalRange(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array): AsyncIterable<WalReadRow>;
+  readWalRangeDesc(stream: string, startOffset: bigint, endOffset: bigint, routingKey?: Uint8Array): AsyncIterable<WalReadRow>;
+  getWalOldestTimestampMsForRead(stream: string): Promise<bigint | null>;
+}
+
+export interface WalStore extends WalAppendStore, WalReadStore {}

package/src/stream_size_reconciler.ts

@@ -0,0 +1,100 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { Result } from "better-result";
+import type { SqliteDurableStore, SegmentRow } from "./db/db";
+import type { ObjectStore } from "./objectstore/interface";
+import type { SegmentDiskCache } from "./segment/cache";
+import { loadSegmentBytesCached } from "./segment/cached_segment";
+import { iterateBlocksResult } from "./segment/format";
+import { dsError } from "./util/ds_error";
+import { yieldToEventLoop } from "./util/yield";
+
+export class StreamSizeReconciler {
+  private stopped = false;
+  private running: Promise<void> | null = null;
+
+  constructor(
+    private readonly db: SqliteDurableStore,
+    private readonly os: ObjectStore,
+    private readonly segmentCache?: SegmentDiskCache,
+    private readonly onMetadataChanged?: (stream: string) => void
+  ) {}
+
+  start(): void {
+    if (this.running) return;
+    this.running = this.run().finally(() => {
+      this.running = null;
+    });
+  }
+
+  stop(): void {
+    this.stopped = true;
+  }
+
+  private async run(): Promise<void> {
+    while (!this.stopped) {
+      const streams = this.db.listStreamsMissingLogicalSize(8);
+      if (streams.length === 0) return;
+      for (const stream of streams) {
+        if (this.stopped) return;
+        try {
+          await this.reconcileStream(stream);
+        } catch (e) {
+          const msg = String((e as any)?.message ?? e);
+          if (!this.stopped && !msg.includes("Statement has finalized")) {
+            // eslint-disable-next-line no-console
+            console.error("stream size reconcile failed", stream, e);
+          }
+        }
+      }
+    }
+  }
+
+  private async reconcileStream(stream: string): Promise<void> {
+    for (let attempt = 0; attempt < 3 && !this.stopped; attempt++) {
+      const before = this.db.getStream(stream);
+      if (!before || this.db.isDeleted(before) || before.next_offset <= 0n) return;
+      if (before.logical_size_bytes > 0n) return;
+
+      const segments = this.db.listSegmentsForStream(stream);
+      let total = 0n;
+      for (const segment of segments) {
+        if (this.stopped) return;
+        total += await this.sumSegmentPayloadBytes(segment);
+        await yieldToEventLoop();
+      }
+
+      const after = this.db.getStream(stream);
+      if (!after || this.db.isDeleted(after)) return;
+      if (after.logical_size_bytes > 0n) return;
+
+      if (segments.length !== this.db.countSegmentsForStream(stream)) continue;
+
+      const finalTotal = total + after.wal_bytes;
+      if (finalTotal > after.logical_size_bytes) {
+        this.db.setStreamLogicalSizeBytes(stream, finalTotal);
+        this.onMetadataChanged?.(stream);
+      }
+      return;
+    }
+  }
+
+  private async sumSegmentPayloadBytes(segment: SegmentRow): Promise<bigint> {
+    const bytes = await this.loadSegmentBytes(segment);
+    let total = 0n;
+    for (const blockRes of iterateBlocksResult(bytes)) {
+      if (Result.isError(blockRes)) throw dsError(blockRes.error.message);
+      for (const record of blockRes.value.decoded.records) {
+        total += BigInt(record.payload.byteLength);
+      }
+    }
+    return total;
+  }
+
+  private async loadSegmentBytes(segment: SegmentRow): Promise<Uint8Array> {
+    if (existsSync(segment.local_path)) {
+      return new Uint8Array(await readFile(segment.local_path));
+    }
+    return loadSegmentBytesCached(this.os, segment, this.segmentCache);
+  }
+}

package/src/touch/canonical_change.ts

@@ -0,0 +1,7 @@
+export type CanonicalChange = {
+  entity: string;
+  key?: string;
+  op: "insert" | "update" | "delete";
+  before?: unknown;
+  after?: unknown;
+};

package/src/touch/live_keys.ts

@@ -0,0 +1,158 @@
+import { xxh3BigInt, xxh3Hex } from "../runtime/hash.ts";
+export type TemplateEncoding = "string" | "int64" | "bool" | "datetime" | "bytes";
+
+function utf8(s: string): Uint8Array {
+  return new TextEncoder().encode(s);
+}
+
+function encodeU64Be(v: bigint): Uint8Array {
+  const out = new Uint8Array(8);
+  let x = v;
+  for (let i = 7; i >= 0; i--) {
+    out[i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+  return out;
+}
+
+function xxh3Low32(bytes: Uint8Array): number {
+  const h = xxh3BigInt(bytes);
+  return Number(h & 0xffffffffn) >>> 0;
+}
+
+export function canonicalizeTemplateFields(fields: Array<{ name: string; encoding: TemplateEncoding }>): Array<{ name: string; encoding: TemplateEncoding }> {
+  const out = [...fields].map((f) => ({ name: f.name, encoding: f.encoding }));
+  out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  return out;
+}
+
+export function templateIdFor(entity: string, fieldNamesSorted: string[]): string {
+  const parts: Uint8Array[] = [utf8("tpl\0"), utf8(entity), utf8("\0")];
+  for (let i = 0; i < fieldNamesSorted.length; i++) {
+    if (i > 0) parts.push(utf8("\0"));
+    parts.push(utf8(fieldNamesSorted[i]));
+  }
+  return xxh3Hex(concat(parts));
+}
+
+export function tableKeyFor(entity: string): string {
+  return xxh3Hex(concat([utf8("tbl\0"), utf8(entity)]));
+}
+
+export function tableKeyIdFor(entity: string): number {
+  return xxh3Low32(concat([utf8("tbl\0"), utf8(entity)]));
+}
+
+export function templateKeyFor(templateIdHex16: string): string {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  return xxh3Hex(concat([utf8("tpl\0"), tplBytes]));
+}
+
+export function templateKeyIdFor(templateIdHex16: string): number {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  return xxh3Low32(concat([utf8("tpl\0"), tplBytes]));
+}
+
+export function membershipKeyFor(templateIdHex16: string, encodedArgs: string[]): string {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  const parts: Uint8Array[] = [utf8("mem\0"), tplBytes];
+  for (const a of encodedArgs) {
+    parts.push(utf8("\0"));
+    parts.push(utf8(a));
+  }
+  return xxh3Hex(concat(parts));
+}
+
+export function membershipKeyIdFor(templateIdHex16: string, encodedArgs: string[]): number {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  const parts: Uint8Array[] = [utf8("mem\0"), tplBytes];
+  for (const a of encodedArgs) {
+    parts.push(utf8("\0"));
+    parts.push(utf8(a));
+  }
+  return xxh3Low32(concat(parts));
+}
+
+export function projectedFieldKeyFor(templateIdHex16: string, fieldName: string, encodedArgs: string[]): string {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  const parts: Uint8Array[] = [utf8("fld\0"), tplBytes, utf8("\0"), utf8(fieldName)];
+  for (const a of encodedArgs) {
+    parts.push(utf8("\0"));
+    parts.push(utf8(a));
+  }
+  return xxh3Hex(concat(parts));
+}
+
+export function projectedFieldKeyIdFor(templateIdHex16: string, fieldName: string, encodedArgs: string[]): number {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  const parts: Uint8Array[] = [utf8("fld\0"), tplBytes, utf8("\0"), utf8(fieldName)];
+  for (const a of encodedArgs) {
+    parts.push(utf8("\0"));
+    parts.push(utf8(a));
+  }
+  return xxh3Low32(concat(parts));
+}
+
+export function watchKeyFor(templateIdHex16: string, encodedArgs: string[]): string {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  const parts: Uint8Array[] = [utf8("key\0"), tplBytes];
+  for (const a of encodedArgs) {
+    parts.push(utf8("\0"));
+    parts.push(utf8(a));
+  }
+  return xxh3Hex(concat(parts));
+}
+
+export function watchKeyIdFor(templateIdHex16: string, encodedArgs: string[]): number {
+  const tplBytes = encodeU64Be(BigInt(`0x${templateIdHex16}`));
+  const parts: Uint8Array[] = [utf8("key\0"), tplBytes];
+  for (const a of encodedArgs) {
+    parts.push(utf8("\0"));
+    parts.push(utf8(a));
+  }
+  return xxh3Low32(concat(parts));
+}
+
+export function encodeTemplateArg(value: unknown, encoding: TemplateEncoding): string | null {
+  if (value === null || value === undefined) return null;
+  switch (encoding) {
+    case "string": {
+      if (typeof value === "string") return value;
+      if (typeof value === "number" && Number.isFinite(value)) return String(value);
+      if (typeof value === "boolean") return value ? "true" : "false";
+      return null;
+    }
+    case "int64": {
+      if (typeof value === "bigint") return value.toString();
+      if (typeof value === "number" && Number.isFinite(value) && Number.isInteger(value)) return String(value);
+      if (typeof value === "string" && /^-?(0|[1-9][0-9]*)$/.test(value.trim())) return value.trim();
+      return null;
+    }
+    case "bool": {
+      if (typeof value !== "boolean") return null;
+      return value ? "1" : "0";
+    }
+    case "datetime": {
+      if (typeof value !== "string") return null;
+      const d = new Date(value);
+      if (!Number.isFinite(d.getTime())) return null;
+      return d.toISOString();
+    }
+    case "bytes": {
+      if (typeof value !== "string") return null;
+      return value;
+    }
+  }
+}
+
+function concat(parts: Uint8Array[]): Uint8Array {
+  let total = 0;
+  for (const p of parts) total += p.byteLength;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.byteLength;
+  }
+  return out;
+}