@ultimat3/realtime 1.2.0 → 2.0.0

package/src/nats-protocol.ts

@@ -1,222 +0,0 @@
-// Single responsibility: the NATS client protocol codec — pure encode/decode of the text
-// protocol nats-server speaks on port 4222. No sockets, no timers, no randomness: chunks of
-// bytes in, whole operations out, so the socket layer can be tested with no network at all.
-
-import { TransportProtocolError } from './errors';
-
-const decoder = new TextDecoder();
-const CR = 0x0d;
-const LF = 0x0a;
-
-/** A single declared payload is bounded so a corrupt byte count cannot allocate the machine. */
-const MAX_PAYLOAD_BYTES = 64 * 1024 * 1024;
-
-const protocolError = (stage: 'read' | 'headers', detail: string): TransportProtocolError =>
-  new TransportProtocolError({ transport: 'nats', stage, detail });
-const missingArg = (label: string): never => {
-  throw protocolError('read', `missing ${label}`);
-};
-
-export interface NatsServerInfo {
-  readonly serverId: string;
-  readonly version: string;
-  readonly maxPayload: number;
-  readonly tlsRequired: boolean;
-  readonly tlsAvailable: boolean;
-  readonly authRequired: boolean;
-  readonly headers: boolean;
-  readonly nonce: string | undefined;
-}
-export type NatsHeaders = ReadonlyMap<string, string>;
-export interface NatsMessage {
-  readonly subject: string;
-  readonly sid: string;
-  readonly replyTo: string | undefined;
-  readonly payload: Uint8Array;
-  readonly headers: NatsHeaders;
-  /** From `NATS/1.0 <code> <description>`; `undefined` on a plain MSG or a status-less header. */
-  readonly status: number | undefined;
-  readonly description: string | undefined;
-}
-export type NatsOperation =
-  | { readonly kind: 'info'; readonly info: NatsServerInfo }
-  | { readonly kind: 'msg'; readonly message: NatsMessage }
-  | { readonly kind: 'ping' }
-  | { readonly kind: 'pong' }
-  | { readonly kind: 'ok' }
-  | { readonly kind: 'err'; readonly detail: string };
-
-const EMPTY_HEADERS: NatsHeaders = new Map<string, string>();
-const indexOfCrlf = (bytes: Uint8Array, from: number): number => {
-  for (let i = from; i < bytes.length - 1; i += 1) {
-    if (bytes[i] === CR && bytes[i + 1] === LF) return i;
-  }
-  return -1;
-};
-export const concatBytes = (...parts: readonly Uint8Array[]): Uint8Array => {
-  const total = parts.reduce((sum, part) => sum + part.length, 0);
-  const joined = new Uint8Array(total);
-  let at = 0;
-  for (const part of parts) {
-    joined.set(part, at);
-    at += part.length;
-  }
-  return joined;
-};
-const splitArgs = (text: string): string[] =>
-  text.split(/[ \t]+/).filter((part) => part.length > 0);
-const parseByteCount = (text: string | undefined): number => {
-  if (text === undefined || !/^\d+$/.test(text)) {
-    throw protocolError('read', `expected a byte count, got "${text ?? ''}"`);
-  }
-  return Number(text);
-};
-
-const parseInfo = (json: string): NatsServerInfo => {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(json);
-  } catch {
-    throw protocolError('read', `INFO json did not parse: "${json}"`);
-  }
-  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-    throw protocolError('read', `INFO json was not an object: "${json}"`);
-  }
-  const info = parsed as Record<string, unknown>;
-  return {
-    serverId: typeof info['server_id'] === 'string' ? info['server_id'] : '',
-    version: typeof info['version'] === 'string' ? info['version'] : '',
-    maxPayload: typeof info['max_payload'] === 'number' ? info['max_payload'] : 1_048_576,
-    tlsRequired: info['tls_required'] === true,
-    tlsAvailable: info['tls_available'] === true,
-    authRequired: info['auth_required'] === true,
-    headers: info['headers'] === true,
-    nonce: typeof info['nonce'] === 'string' ? info['nonce'] : undefined,
-  };
-};
-
-/** Parses an HMSG/HPUB header block: `NATS/1.0[ <code> <description>]\r\nKey: Value\r\n...\r\n\r\n`. */
-export function parseHeaders(bytes: Uint8Array): {
-  readonly headers: ReadonlyMap<string, string>;
-  readonly status: number | undefined;
-  readonly description: string | undefined;
-} {
-  const lines = decoder.decode(bytes).split('\r\n');
-  const first = lines[0] ?? '';
-  if (!first.startsWith('NATS/1.0')) {
-    throw protocolError('headers', `header block did not start with NATS/1.0: "${first}"`);
-  }
-  const statusPart = first.slice('NATS/1.0'.length).trim();
-  let status: number | undefined;
-  let description: string | undefined;
-  if (statusPart.length > 0) {
-    const spaceAt = statusPart.search(/\s/);
-    const code = spaceAt < 0 ? statusPart : statusPart.slice(0, spaceAt);
-    if (!/^\d{3}$/.test(code)) {
-      throw protocolError('headers', `status code was not 3 digits: "${code}"`);
-    }
-    status = Number(code);
-    description = spaceAt < 0 ? '' : statusPart.slice(spaceAt + 1).trim();
-  }
-  const headers = new Map<string, string>();
-  for (const line of lines.slice(1)) {
-    if (line.length === 0) continue;
-    const colonAt = line.indexOf(':');
-    if (colonAt < 0) continue;
-    headers.set(line.slice(0, colonAt).trim().toLowerCase(), line.slice(colonAt + 1).trim());
-  }
-  return { headers, status, description };
-}
-
-/** Chunks in, whole operations out. A TCP read boundary lands anywhere. */
-export class NatsProtocolParser {
-  #buffer: Uint8Array = new Uint8Array(0);
-
-  push(chunk: Uint8Array): void {
-    this.#buffer = this.#buffer.length === 0 ? chunk : concatBytes(this.#buffer, chunk);
-  }
-
-  /** Bytes read but not yet consumed — what a partial frame is holding. */
-  get buffered(): number {
-    return this.#buffer.length;
-  }
-
-  /** The next complete operation, or `undefined` when more bytes are needed. */
-  next(): NatsOperation | undefined {
-    const buffer = this.#buffer;
-    const lineEnd = indexOfCrlf(buffer, 0);
-    if (lineEnd < 0) return undefined;
-    const line = decoder.decode(buffer.subarray(0, lineEnd));
-    const spaceAt = line.search(/[ \t]/);
-    const verb = (spaceAt < 0 ? line : line.slice(0, spaceAt)).toUpperCase();
-    const rest = spaceAt < 0 ? '' : line.slice(spaceAt + 1).trim();
-    if (verb === 'MSG' || verb === 'HMSG') {
-      return this.#takeMessage(lineEnd, rest, verb === 'HMSG');
-    }
-    this.#buffer = buffer.subarray(lineEnd + 2);
-    switch (verb) {
-      case 'INFO':
-        return { kind: 'info', info: parseInfo(rest) };
-      case 'PING':
-        return { kind: 'ping' };
-      case 'PONG':
-        return { kind: 'pong' };
-      case '+OK':
-        return { kind: 'ok' };
-      case '-ERR': {
-        const trimmed = rest.trim();
-        const quoted = trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'");
-        return { kind: 'err', detail: quoted ? trimmed.slice(1, -1) : trimmed };
-      }
-      default:
-        throw protocolError('read', `unknown verb "${verb}"`);
-    }
-  }
-
-  #takeMessage(lineEnd: number, rest: string, headered: boolean): NatsOperation | undefined {
-    const buffer = this.#buffer;
-    const args = splitArgs(rest);
-    const minArgs = headered ? 4 : 3;
-    const maxArgs = headered ? 5 : 4;
-    if (args.length !== minArgs && args.length !== maxArgs) {
-      const verb = headered ? 'HMSG' : 'MSG';
-      throw protocolError('read', `${verb} wants ${minArgs} or ${maxArgs} args, got "${rest}"`);
-    }
-    const hasReply = args.length === maxArgs;
-    const subject = args[0] ?? missingArg('subject');
-    const sid = args[1] ?? missingArg('sid');
-    const replyTo = hasReply ? (args[2] ?? missingArg('reply-to')) : undefined;
-    const headerBytes = headered ? parseByteCount(args[hasReply ? 3 : 2]) : 0;
-    const totalBytes = parseByteCount(args[args.length - 1]);
-    if (headered && totalBytes < headerBytes) {
-      throw protocolError('read', `HMSG total ${totalBytes} is smaller than header ${headerBytes}`);
-    }
-    if (totalBytes > MAX_PAYLOAD_BYTES) {
-      throw protocolError('read', `payload of ${totalBytes} bytes exceeds ${MAX_PAYLOAD_BYTES}`);
-    }
-    const payloadStart = lineEnd + 2;
-    const headerEnd = payloadStart + headerBytes;
-    const payloadEnd = payloadStart + totalBytes;
-    const end = payloadEnd + 2;
-    if (buffer.length < end) return undefined;
-    if (buffer[payloadEnd] !== CR || buffer[payloadEnd + 1] !== LF) {
-      throw protocolError('read', `payload was not followed by CRLF at offset ${payloadEnd}`);
-    }
-    const { headers, status, description } = headered
-      ? parseHeaders(buffer.subarray(payloadStart, headerEnd))
-      : { headers: EMPTY_HEADERS, status: undefined, description: undefined };
-    this.#buffer = buffer.subarray(end);
-    return {
-      kind: 'msg',
-      message: {
-        subject,
-        sid,
-        replyTo,
-        payload: buffer.subarray(headerEnd, payloadEnd),
-        headers,
-        status,
-        description,
-      },
-    };
-  }
-}

package/src/nats-socket.ts

@@ -1,236 +0,0 @@
-// Single responsibility: the one production `NatsStream`, over `Bun.connect` — plus the URL
-// parsing. NATS sends its INFO line in cleartext before any TLS decision, so the upgrade is a
-// method the caller invokes after reading it, never a handshake negotiated here at connect time.
-
-import { TransportUnavailableError } from './errors';
-import type { BunConnect, SocketHandlers, SocketLike } from './pg-socket';
-
-export interface NatsTarget {
-  readonly host: string;
-  readonly port: number; // default 4222
-  /** `tls://` demands TLS; `nats://` still upgrades when the server's INFO says it is required. */
-  readonly tls: boolean;
-  readonly user: string | undefined;
-  readonly pass: string | undefined;
-  /** `nats://token@host` — NATS' single-credential form, mutually exclusive with user/pass. */
-  readonly token: string | undefined;
-}
-
-const DEFAULT_PORT = 4222;
-
-/** `nats://user:pass@host:4222`. The one place a bus URL is read. */
-export function parseNatsUrl(url: string): NatsTarget {
-  let parsed: URL;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new TransportUnavailableError({
-      transport: 'nats',
-      reason: `"${url}" is not a connection URL`,
-    });
-  }
-  if (parsed.protocol !== 'nats:' && parsed.protocol !== 'tls:') {
-    throw new TransportUnavailableError({
-      transport: 'nats',
-      reason: `the connection URL uses "${parsed.protocol}" rather than nats: or tls:`,
-    });
-  }
-  if (parsed.hostname === '') {
-    throw new TransportUnavailableError({
-      transport: 'nats',
-      reason: `"${url}" has no host`,
-    });
-  }
-  const hasUser = parsed.username !== '';
-  const hasPass = parsed.password !== '';
-  // A password with no user matches neither credential form, and dropping it silently connects
-  // anonymously — the failure then surfaces as the server's own 'Authorization Violation', which
-  // names nothing about the URL. The URL itself is never echoed back: it holds the secret.
-  if (!hasUser && hasPass) {
-    throw new TransportUnavailableError({
-      transport: 'nats',
-      reason: `the connection URL for ${parsed.hostname} carries a password with no user`,
-      fix: 'set the URL to nats://<user>:<pass>@host:4222, or the bare-token form nats://<token>@host:4222',
-    });
-  }
-  const user = hasUser ? decodeURIComponent(parsed.username) : undefined;
-  const pass = hasPass ? decodeURIComponent(parsed.password) : undefined;
-  return {
-    host: parsed.hostname,
-    port: parsed.port === '' ? DEFAULT_PORT : Number.parseInt(parsed.port, 10),
-    tls: parsed.protocol === 'tls:',
-    // A username with no password is NATS' bare-token form; a password makes it user/pass instead.
-    user: hasUser && hasPass ? user : undefined,
-    pass: hasUser && hasPass ? pass : undefined,
-    token: hasUser && !hasPass ? user : undefined,
-  };
-}
-
-/** The byte pipe a NATS connection runs over. Mirrors `PgStream`, plus the late TLS upgrade. */
-export interface NatsStream {
-  /** The next chunk the server sent, or `undefined` once it closed the connection. */
-  read(): Promise<Uint8Array | undefined>;
-  write(bytes: Uint8Array): Promise<void>;
-  /** In-band TLS. Must be called before any byte other than the server's INFO is exchanged. */
-  upgradeTls(): void;
-  close(): void;
-}
-
-interface Waiter {
-  readonly resolve: (chunk: Uint8Array | undefined) => void;
-  readonly reject: (error: Error) => void;
-}
-
-/** Chunks the socket pushed, handed out one `read()` at a time — EOF and socket errors included. */
-class ChunkQueue {
-  readonly #chunks: Uint8Array[] = [];
-  #waiting: Waiter | undefined;
-  #ended = false;
-  #failure: Error | undefined;
-
-  push(chunk: Uint8Array): void {
-    const waiter = this.#take();
-    if (waiter === undefined) {
-      this.#chunks.push(chunk);
-      return;
-    }
-    waiter.resolve(chunk);
-  }
-
-  /** EOF. A reader parked on `read()` is released rather than left hanging forever. */
-  end(): void {
-    this.#ended = true;
-    this.#take()?.resolve(undefined);
-  }
-
-  fail(error: Error): void {
-    this.#failure = error;
-    this.#ended = true;
-    this.#take()?.reject(error);
-  }
-
-  read(): Promise<Uint8Array | undefined> {
-    const next = this.#chunks.shift();
-    if (next !== undefined) return Promise.resolve(next);
-    if (this.#failure !== undefined) return Promise.reject(this.#failure);
-    if (this.#ended) return Promise.resolve(undefined);
-    if (this.#waiting !== undefined) {
-      // One reader drives this queue — the handshake, then the session's single read loop.
-      // Overwriting the parked waiter would strand it: nothing left would ever settle its promise,
-      // so the caller hangs with no error and no deadline. Refusing the second reader names it.
-      return Promise.reject(
-        new TransportUnavailableError({
-          transport: 'nats',
-          reason: 'a second read() started while one was already parked on this stream',
-          fix: 'read a NatsStream from one place only: one stream feeds exactly one read loop',
-        }),
-      );
-    }
-    return new Promise((resolve, reject) => {
-      this.#waiting = { resolve, reject };
-    });
-  }
-
-  #take(): Waiter | undefined {
-    const waiter = this.#waiting;
-    this.#waiting = undefined;
-    return waiter;
-  }
-}
-
-export const bunNatsStream = (target: NatsTarget): Promise<NatsStream> =>
-  natsStreamOver(Bun as unknown as BunConnect, target);
-
-/** `bunNatsStream` with the runtime handed in, so the whole path runs in a test with no network. */
-export async function natsStreamOver(runtime: BunConnect, target: NatsTarget): Promise<NatsStream> {
-  const queue = new ChunkQueue();
-  let draining: (() => void) | undefined;
-  let upgraded = false;
-
-  /**
-   * A write parked for `drain` can never get one from a socket that is gone, so it is released
-   * here; it then fails on the next `write` rather than burning a whole deadline first. The read
-   * side ends cleanly because an EOF that matters is already an error one layer up.
-   */
-  const died = (): void => {
-    const resume = draining;
-    draining = undefined;
-    resume?.();
-    queue.end();
-  };
-
-  const handlers: SocketHandlers = {
-    // Copied before it is queued or handed on: Bun owns that buffer and gives no guarantee its
-    // contents survive the handler returning, while a queued chunk is read a whole tick later.
-    data: (_socket, data) => queue.push(data.slice()),
-    close: died,
-    end: died,
-    drain: () => {
-      const resume = draining;
-      draining = undefined;
-      resume?.();
-    },
-    error: (_socket, error) =>
-      queue.fail(
-        new TransportUnavailableError({
-          transport: 'nats',
-          reason: `${target.host}:${target.port} — ${error.message}`,
-        }),
-      ),
-  };
-
-  let socket: SocketLike = await runtime.connect({
-    hostname: target.host,
-    port: target.port,
-    socket: handlers,
-  });
-
-  const write = async (bytes: Uint8Array): Promise<void> => {
-    let rest = bytes;
-    while (rest.length > 0) {
-      const written = socket.write(rest);
-      if (written >= rest.length) return;
-      // A negative count is a refusal, not backpressure: no `drain` follows a dead socket, so
-      // waiting for one would park this write forever.
-      if (written < 0) {
-        throw new TransportUnavailableError({
-          transport: 'nats',
-          reason: `the socket refused a ${rest.length}-byte write to ${target.host}:${target.port}`,
-        });
-      }
-      if (written > 0) rest = rest.subarray(written);
-      await new Promise<void>((resolve) => {
-        draining = resolve;
-      });
-    }
-  };
-
-  return {
-    read: () => queue.read(),
-    write,
-    upgradeTls: () => {
-      // Marked before the attempt, not after: a failed upgrade still leaves the raw socket in an
-      // indeterminate TLS-negotiation state, so a retry is refused rather than risking a second
-      // ClientHello on top of the first.
-      if (upgraded) {
-        throw new TransportUnavailableError({
-          transport: 'nats',
-          reason: `upgradeTls() was already called for ${target.host}:${target.port}`,
-        });
-      }
-      upgraded = true;
-      // Bun hands back `[raw, tls]`; every later read and write goes through the second one, and
-      // the handlers are re-registered because the upgraded socket is a different object.
-      const next = socket.upgradeTLS({ tls: { serverName: target.host }, socket: handlers })[1];
-      if (next === undefined) {
-        throw new TransportUnavailableError({
-          transport: 'nats',
-          reason: `the runtime returned no TLS socket for the upgrade to ${target.host}:${target.port}`,
-          fix: 'bun upgrade   # in-band TLS needs bun >= 1.3',
-        });
-      }
-      socket = next;
-    },
-    close: () => socket.end(),
-  };
-}

package/src/pg-connection-fixture.ts

@@ -1,215 +0,0 @@
-// Single responsibility: the one scripted Postgres server this package's `PgConnection` tests run
-// against — a fake `PgStream` plus a builder per backend message. Two test files need it, and two
-// private copies would be two chances to script a frame the real server never sends.
-// Not part of the public API — `index.ts` deliberately does not re-export it.
-
-import { ByteReader, ByteWriter } from './pg-bytes';
-import { PgConnection, type PgConnectionOptions } from './pg-connection';
-import { frame, type PgStream } from './pg-wire';
-
-export const encoder = new TextEncoder();
-export const decoder = new TextDecoder();
-
-/**
- * A scriptable fake `PgStream`. `push()` queues chunks for `read()`; once the queue is empty and
- * the stream has not `end()`-ed, `read()` parks until the next `push()`/`end()` — the shape a test
- * needs to script a real request/response handshake. `write()` records every byte the client sent.
- */
-export class FakeStream implements PgStream {
-  readonly writes: Uint8Array[] = [];
-  readonly #queue: Uint8Array[] = [];
-  #ended = false;
-  #parked: ((chunk: Uint8Array | undefined) => void) | undefined;
-  #closed = false;
-  #nextWriteError: Error | undefined;
-  #closeError: Error | undefined;
-
-  push(...chunks: readonly Uint8Array[]): void {
-    for (const chunk of chunks) {
-      const parked = this.#parked;
-      if (parked !== undefined) {
-        this.#parked = undefined;
-        parked(chunk);
-      } else {
-        this.#queue.push(chunk);
-      }
-    }
-  }
-
-  /** Clean EOF: releases a parked `read()` with `undefined`, and every one after it. */
-  end(): void {
-    this.#ended = true;
-    const parked = this.#parked;
-    if (parked !== undefined) {
-      this.#parked = undefined;
-      parked(undefined);
-    }
-  }
-
-  throwOnNextWrite(error: Error): void {
-    this.#nextWriteError = error;
-  }
-
-  /** A socket whose `close()` throws — the failure that must not replace the one being reported. */
-  throwOnClose(error: Error): void {
-    this.#closeError = error;
-  }
-
-  get closed(): boolean {
-    return this.#closed;
-  }
-
-  read(): Promise<Uint8Array | undefined> {
-    const next = this.#queue.shift();
-    if (next !== undefined) return Promise.resolve(next);
-    if (this.#ended) return Promise.resolve(undefined);
-    return new Promise((resolve) => {
-      this.#parked = resolve;
-    });
-  }
-
-  write(bytes: Uint8Array): Promise<void> {
-    this.writes.push(bytes);
-    const error = this.#nextWriteError;
-    if (error !== undefined) {
-      this.#nextWriteError = undefined;
-      return Promise.reject(error);
-    }
-    return Promise.resolve();
-  }
-
-  close(): void {
-    this.#closed = true;
-    if (this.#closeError !== undefined) throw this.#closeError;
-  }
-}
-
-// --- Backend message builders: one per row of the wire table, `frame()` owns tag + length -------
-
-export const AUTH_OK = 0;
-export const AUTH_CLEARTEXT = 3;
-export const AUTH_MD5 = 5;
-export const AUTH_SASL = 10;
-export const AUTH_SASL_CONTINUE = 11;
-export const AUTH_SASL_FINAL = 12;
-export const AUTH_GSSAPI = 7;
-
-export const authMethod = (method: number, extra: Uint8Array = new Uint8Array(0)): Uint8Array =>
-  frame('R', new ByteWriter().int32(method).raw(extra).finish());
-export const authOk = (): Uint8Array => authMethod(AUTH_OK);
-export const authCleartext = (): Uint8Array => authMethod(AUTH_CLEARTEXT);
-export const authMd5 = (salt: Uint8Array): Uint8Array => authMethod(AUTH_MD5, salt);
-export const authGssapi = (): Uint8Array => authMethod(AUTH_GSSAPI);
-export const authSaslContinue = (payload: Uint8Array): Uint8Array =>
-  authMethod(AUTH_SASL_CONTINUE, payload);
-export const authSaslFinal = (payload: Uint8Array): Uint8Array =>
-  authMethod(AUTH_SASL_FINAL, payload);
-export const authSasl = (...mechanisms: readonly string[]): Uint8Array => {
-  const writer = new ByteWriter().int32(AUTH_SASL);
-  for (const mechanism of mechanisms) writer.cstring(mechanism);
-  return frame('R', writer.uint8(0).finish());
-};
-
-export const parameterStatus = (name: string, value: string): Uint8Array =>
-  frame('S', new ByteWriter().cstring(name).cstring(value).finish());
-
-export const backendKeyData = (pid: number, secret: number): Uint8Array =>
-  frame('K', new ByteWriter().int32(pid).int32(secret).finish());
-
-export const READY_IDLE = 'I'.charCodeAt(0);
-export const readyForQuery = (): Uint8Array =>
-  frame('Z', new ByteWriter().uint8(READY_IDLE).finish());
-
-export const rowDescriptionStub = (): Uint8Array => frame('T', new Uint8Array(0));
-
-export const dataRow = (...values: readonly (string | null)[]): Uint8Array => {
-  const writer = new ByteWriter().int16(values.length);
-  for (const value of values) {
-    if (value === null) {
-      writer.int32(-1);
-    } else {
-      const bytes = encoder.encode(value);
-      writer.int32(bytes.length).raw(bytes);
-    }
-  }
-  return frame('D', writer.finish());
-};
-
-export const commandComplete = (tag: string): Uint8Array =>
-  frame('C', new ByteWriter().cstring(tag).finish());
-
-export const fieldedMessage = (
-  tag: 'E' | 'N',
-  fields: Readonly<Record<string, string>>,
-): Uint8Array => {
-  const writer = new ByteWriter();
-  for (const [code, value] of Object.entries(fields)) {
-    writer.uint8(code.charCodeAt(0)).cstring(value);
-  }
-  return frame(tag, writer.uint8(0).finish());
-};
-export const errorResponse = (fields: Readonly<Record<string, string>>): Uint8Array =>
-  fieldedMessage('E', fields);
-export const noticeResponse = (fields: Readonly<Record<string, string>>): Uint8Array =>
-  fieldedMessage('N', fields);
-
-export const copyBothResponse = (): Uint8Array =>
-  frame('W', new ByteWriter().uint8(0).int16(0).finish());
-export const copyData = (payload: Uint8Array): Uint8Array => frame('d', payload);
-export const copyDoneFrame = (): Uint8Array => frame('c', new Uint8Array(0));
-
-/** One frontend `tag` + Int32 length + body frame — the shape `frame()` builds. */
-export const decodeFrame = (bytes: Uint8Array): { tag: string; body: Uint8Array } => {
-  const reader = new ByteReader(bytes);
-  const tag = reader.tag();
-  const length = reader.int32();
-  return { tag, body: reader.take(length - 4) };
-};
-
-/** The tagless startup packet: Int32 length, Int32 version, then key/value cstrings to `\0`. */
-export const decodeStartup = (
-  bytes: Uint8Array,
-): { version: number; params: Record<string, string> } => {
-  const reader = new ByteReader(bytes);
-  reader.int32(); // total length — implied by `bytes.length`, not needed to check the shape
-  const version = reader.int32();
-  const params: Record<string, string> = {};
-  for (;;) {
-    const key = reader.cstring();
-    if (key === '') break;
-    params[key] = reader.cstring();
-  }
-  return { version, params };
-};
-
-export const toBase64 = (bytes: Uint8Array): string => btoa(String.fromCharCode(...bytes));
-
-// --- Fixtures --------------------------------------------------------------------------------
-
-export const opts = (
-  stream: PgStream,
-  extra?: Partial<PgConnectionOptions>,
-): PgConnectionOptions => ({
-  stream,
-  user: 'repluser',
-  database: 'app',
-  ...extra,
-});
-
-/** A connection past the handshake, via the cheapest auth method — trust. */
-export async function openTrusted(
-  stream: FakeStream,
-  extra?: Partial<PgConnectionOptions>,
-): Promise<PgConnection> {
-  stream.push(authOk(), readyForQuery());
-  return PgConnection.open(opts(stream, extra));
-}
-
-export const START_REPLICATION_SQL = 'START_REPLICATION SLOT s LOGICAL 0/0';
-
-export async function openInCopyBoth(stream: FakeStream): Promise<PgConnection> {
-  const connection = await openTrusted(stream);
-  stream.push(copyBothResponse());
-  await connection.startCopyBoth(START_REPLICATION_SQL);
-  return connection;
-}