If `live` is true, convert mark_live at `pos` with `text` to a ins op for the editor; if false, convert mark_dead at `pos` with `text` to a del op for

Move cursor to the beginning of `iter`.

* Apply transform next, returning a transform handle. * You can then apply more transformations, draw, or retrieve the output. * @param tran

Check if a host has write permission Always returns true for ourselves.

Apply an EditInstruction to this mock document.

* The **`console.clear()`** static method clears the console if possible. * * [MDN Reference](https://developer.mozilla.org/docs/Web/API/con

Return the current global sequence number.

Generate undo or redo ops from the current undo tip. Although this function returns [FatOp]s, most of the field of the [FatOp] (seq, site_seq, etc) ar

Hash the binary DER file and return the hash in fingerprint format: each byte in uppercase hex, separated by colons. (ref:rcgen-cert-searlize)

Pull the named header out of `headers` as an owned String. Errors if the header is missing or its value isn’t valid UTF-8.

Insert a new `RemoteHandle` for `peer` in `map`, wrapping a `DropGuard` over the per-peer cancel token. If a live handle already exists, returns [`Web

Return `true` if this doc matches `path`. Owned docs match by PathId. Because, eg, editor could try to share a single file which actually is inside a

Send the currently opened files to the filewatch receptor.

Run the filewatch receptor. Returns when either channel closes. Normally this should never return; notifies `shutdown` on exit which the whole program

Run select! in a loop, once the loop exits, send `ConnectionBroke`. Async teardown of SCTP/DTLS/ICE happens in Drop handler, so cleanup runs always ru

Run the signaling server on `addr` (form: `"ip:port"`).

Send ICE candidate to peer.

Shift the editor position and range idx.

Spawn the receptor on a system thread and return the channel endpoints the test side keeps: a crossbeam `Sender` to feed WatchFiles, a tokio `Receiver

Spawn a tracked task that does *not* respond to cancellation.

Serialize to bytes for signing. Use a custom format (<timestamp>:<cert>) instead of json to keep it simple and predictable.

Truncate string for logging: show head…tail (N chars) if too long.

Create a child. Cancelling the parent cancels the child; cancelling the child doesn’t cancel the parent. The tracker is shared so child can’t close.

Get a remote doc by `EditorFileDesc`. Returns the remote doc id and a mutable reference to the doc if found.

Returns the name portion of a [`ServerId`], or `None` if there isn't one.

Move to the left by one, return the currently range. Caller must make sure this doesn’t overflow.

Move cursor to the position of `cursor`.

If `addr` has no URL scheme, prepend `wss://`. Existing schemes (`wss://`, `ws://`, `https://`, etc) are preserved.

Unix-epoch seconds. Timebase for the ping liveness counters so we can stuff them into an `AtomicU64`.

Return the op referenced by the `idxidx`th pointer in the undo queue.

Build two test WebChannels bound to a shared `TestFactory`, drain their dual receivers for the caller.

Helper: Send request and wait for response with custom timeout.

Save buffer content to file.

Send SDP to peer.

Return the site of the op.

Move the hub’s filewatch channels out of the setup and spawn a real `filewatch_receptor::run` on a system thread, wired to the hub’s `Server`. After t

Return the total length of global history + local history.

Get current unix epoch in seconds.

Apply an EditInstruction to the buffer without checking engine/buffer sync. Use `verify_buffer_engine_sync` after applying all instructions from a sin

Apply `op` to the document.

Broadcasts a message to all connected peers. Doesn't block.

Broadcast `info`, excluding the sender of it.

Check that the position of each cursor is correct. Only use this for debugging.

If `provided_id` doesn’t match `recorded_id`, return an error.

Spin up a host `Server`, mock editor, and create a real ssh connection to `yuan@localhost` running this same crate's envoy binary. Returns once the ho

Convert `ops` from an internal op to an editor op, but don’t apply `ops` to the internal doc.

Create a SignalingChannel, bind it for an endpoint, and wait for Bound. Returns the channel plus the receiver the server would normally read from.

Return the current global sequence number.

Return the total length of the editor document. Note that this function doesn't use any optimization and goes through every range front-to-back.

Helper: Wait for Connected notification and extract fields.

Write a length-prefixed serialized [`Message`] to `writer`. Format is `[8-byte big-endian length][serde_json payload]`.

Generate an undo op from the current undo tip. Return an empty vector if there's no more op to undo. Also return the current global seq as context. Wh

Get a remote doc by EditorFileDesc.

Return the internal document.

Return true if `msg_connection_id` does not match the peer's current `connection_id` (the message is from a different connect attempt and should be dr

If host_id is not us, delegate to remote, if it’s us, read files from disk. If dir is None, list top-level projects and docs, if dir non-nil, list fil

Install SIGINT/SIGTERM handlers and cancel `shutdown` when either signal arrives. Caller is responsible for owning the `CancelManager` and for spawnin

Starts sync threads carring messages between the editor and the collab peer, blocks on errors. Return when fatal error occurs.

Read file from disk and return the content as string. Return (content, file object, abs_path).

Get the global ops with sequence number larger than `seq`.

Build two WebChannels connected via a `tokio::io::duplex` and hand back each side’s `DualReceiver` for inbound assertions.