Create a logical replication slot. Returns slot info including the consistent point LSN.

On timeout, the connection is retired (csClosed) unless the wire had settled (asyncdispatch always retires: the timed-out op stays on the socket).

Drop a replication slot.

On timeout, the connection is retired (csClosed) unless the wire had settled (asyncdispatch always retires: the timed-out op stays on the socket).

Execute IDENTIFY_SYSTEM and return system identification info.

On timeout, the connection is retired (csClosed) unless the wire had settled (asyncdispatch always retires: the timed-out op stays on the socket).

Read information about an existing physical replication slot.

Only physical slots are supported: the server rejects a logical slot with PgQueryError ("cannot use READ_REPLICATION_SLOT with logical replication slot") and reports a nonexistent slot as PgConnectionError. consistentPoint carries restart_lsn (InvalidLsn when the slot never reserved WAL) and restartTli its timeline (0 when NULL).

On timeout, the connection is retired (csClosed) unless the wire had settled (asyncdispatch always retires: the timed-out op stays on the socket).

End LSN of the WAL data actually contained in this message (startLsn + len(data)). On a physical stream, use this when acknowledging received data via sendStandbyStatus; do not use walEnd, which may point past data this message does not carry.

Physical replication only: logical data is plugin output, not WAL bytes, so this may point past commits not yet sent. Confirm logical progress with CommitMessage.endLsn or PrimaryKeepalive.walEnd.

Send Standby Status Update. InvalidLsn defaults up to receiveLsn. Raises PgStateError unless the connection is csReplicating, or PgConnectionError when the connection was lost. After stopReplication the update still goes out, ahead of the stop's final status, while that is queued; once it is encoded the update is silently dropped, as the walsender reads nothing after the client's CopyDone. Report before stopping to be sure. Cancelling only stops the wait: the update is still written. A failed write closes the connection.

Values are sent verbatim, unlike confirmFlushed. On a logical stream pass CommitMessage.endLsn or PrimaryKeepalive.walEnd, never receivedEndLsn: a flush past an unsent commit makes the server skip it. The auto-reply, periodic status and stopReplication never report less than the last update sent here: they send the confirmFlushed position or these, whichever is higher.

Physical replication streaming. Callback per message, raw WAL in XLogData. Raises PgStateError (closed by close(), or busy) / PgConnectionError (lost) unless csReady. Error handling matches startReplication: a callback exception or any other mid-stream failure poisons the connection (marked closed) and propagates, so reconnect and resume from the last LSN tracked. A ReadyForQuery without CopyDone retires the connection and raises PgUnavailableError too, with no cause named: a physical walsender does reset its streaming flags, so no ordinary stream ends that way.

slotName = "" streams without a slot. Non-zero timeline is sent as TIMELINE n (negative raises ValueError). statusInterval behaves as on startReplication.

On a timeline switch the server may send a result set describing the next timeline between CopyDone and ReadyForQuery; this proc drains and discards it — re-issue IDENTIFY_SYSTEM if you need that information.

Synchronous standbys: the flush LSN governs how much WAL the primary may recycle, so a standby in synchronous_standby_names that relies on the auto-reply must call confirmFlushed (or reply manually) or the primary's COMMITs block waiting on a flush position that never advances.

Begin logical replication. Callback invoked per message. Use confirmFlushed for flush tracking; or set autoKeepaliveReply=false and use sendStandbyStatus manually.

autoConfirm (pgoutput only) confirms progress for you: a transaction's CommitMessage.endLsn once the callback has returned for its Commit, and a keepalive's walEnd outside a transaction (reported right away), so the slot also advances while pgoutput skips unpublished transactions. The callback returning therefore means "processed durably"; a callback raising on a transaction's messages confirms nothing of it. A keepalive carries no data, so its position is confirmed before its callback runs.

Nothing is confirmed once stopReplication's final status is encoded. That waits for a running callback to return, so a stop from a Commit's own callback still reports that transaction; messages after it are not confirmed.

To resume after an error, reconnect and pass InvalidLsn: the server restarts from the slot's confirmed_flush_lsn, re-sending anything not yet reported. With autoConfirm, the slot's confirmed_flush_lsn is looked up first and the stream starts from it or startLsn, whichever is later (the server would not start earlier either), so keepalives seen while the server re-reads WAL from restart_lsn never report a position below it. Without it, no lookup is made and startLsn is sent as given. A Commit's position is confirmed at once but reaches the server with the next status: a keepalive's, statusInterval's or the stop's. Set statusInterval on a stream that may stay busy for long, as its walsender sends no idle keepalive meanwhile.

A connection can stream logical replication only once: its walsender does not reset the streaming flags, so the next START_REPLICATION ... LOGICAL on it ends at once (BUG #18754). The library retires the connection (csClosed) and raises PgUnavailableError — accepted by isTransientError — so reconnect and resume with InvalidLsn.

With autoConfirm, requires publication_names in options and autoKeepaliveReply (ValueError otherwise). Without it, omitting publication_names is left to the server, which rejects a logical stream without one (pgoutput); the option checks above still apply.

Returns on server CopyDone or connection close, or raises PgUnavailableError as above. To stop from the client side, call stopReplication from the callback (or a concurrent task).

Errors poison connection. Track LSN for resume. A failing auto-reply propagates too, and the callback is not invoked for that keepalive. Option values are passed unquoted and single-quoted when building the command (keys stay identifier-validated). An empty value means a flag-only option (binary rather than binary ''). Raises PgStateError (closed by close(), or busy) / PgConnectionError (lost) unless csReady, and ValueError for a proto_version other than 1 in options (the value must be the unquoted string "1", an empty one included): the bundled pgoutput decoder supports v1 only. Any value already wrapped in quotes raises ValueError too, so the verbatim-options spelling cannot silently name a publication 'my_pub' or send a thrice-quoted binary flag the plugin rejects mid-stream. publication_names alone may be wrapped in double quotes: it is an identifier list, where "MyPub" keeps the case (unquoted, MyPub means mypub). An empty publication_names and a value containing a NUL byte are rejected the same way. publication_names without an explicit proto_version adds proto_version '1' to the generated command, so a server-side default bump cannot outrun that decoder.

statusInterval (ZeroDuration = off) sends a proactive Standby Status Update at least that often — receive = highest received, flush/apply = confirmFlushed (never below a position the caller itself reported via sendStandbyStatus) — so the slot advances on a server that never requests a reply (wal_sender_timeout = 0). Honoured only with autoKeepaliveReply; under asyncdispatch it fires only while messages are flowing, so a fully idle stream sends nothing until the next message.

Synchronous standbys: the auto-reply reports receive and flush/apply separately, so a consumer in synchronous_standby_names that never calls confirmFlushed keeps wal_sender_timeout reset via the receive field yet never advances flush — the primary's COMMITs then block indefinitely.

Terminate replication. Flushes confirmed position before CopyDone, never below the caller's last reported status (sendStandbyStatus). Raises PgStateError unless the connection is csReplicating, or PgConnectionError when the connection was lost. The final status and CopyDone are queued behind every earlier replication write; a call made once they are queued waits for that same CopyDone. Cancelling only stops the wait: the stop still goes out. A failed write closes the connection.

While the stream's callback runs, the final status waits for it to return, so a position it confirms after this call (autoConfirm's Commit included) is still reported. A call made meanwhile, from the callback or elsewhere, returns once the stop is queued; startReplication reports a failed write. To stop from another task, await startReplication rather than calling close() right after, or the stop may never go out.

Create a ReplicationCallback that works with both asyncdispatch and chronos. Inside body, the current message is available as msg: ReplicationMessage.

Kept module-local: routing this through a shared template with an untyped/typedesc param for the parameter type trips asyncdispatch's {.async.} macro ("cannot use symbol of kind 'func' as a 'param'").