SessionEndpoint

Where one picture of a session's transcript is fetched from.

The call and the part stay parameters: they name a place inside the session's conversation rather than a resource of their own.

Where a session is followed as it is written.

Where a running turn of a session is stopped.

Where a session's transcript is fetched from, already rendered as markup.

Where what a person typed is sent to a session.

Reads a session id out of a URL query string, refusing a question that names no session or names one this contract will not carry.

The contract's own addresses name the session in the path, so this is for a host writing its own pages around a transcript — the viewer's ?session=<id> — which is where a reader's own typing still arrives.

The request a reader makes for one session's transcript.

The segment, under a session's address, where a host answers for the bytes of one picture a call came back with.

A picture is not carried on the transcript wire, so a page holds a reference to where it sits — the session, the call it answered, and which part of that answer it is — and asks for it here. The host reads it out of the session it already read the transcript from.

The query parameter naming the call whose answer holds the picture.

The segment, under a session's address, where a host answers for as long as a session is being written.

A page that follows a session is not sent the conversation again on every entry: it is told how much of what it holds is still right, and given the markup for the rest — a TranscriptTail, one per stretch the agent writes. The first thing a follower is told keeps nothing, so a page that has just connected, and a page that has just reconnected after a break, are told the same thing and need no memory of what went before.

The segment, under a session's address, where a running turn is stopped.

Stopping is not reading and not saying: it reaches the agent over the vendor's own control channel and really stops the work, where abandoning the transcript would only stop us watching it.

The segment, under a session's address, where a host answers with a session's transcript already rendered as the cc-* markup.

A transcript's rows have one producer, on the JVM; this is where a page reaches it. The element fetches this address and inserts what comes back as-is, so it never draws a row from data itself.

The query parameter naming which part of that answer the picture is.

The address a host answers about sessions on.

A session is the resource: what is read, what is rendered, what is followed, and what a picture is fetched out of all hang under the one session they belong to, named in the address rather than asked for beside it.

Reading the transcript is the session's own address and carries no segment after it — the transcript is what a session is, so there is no history to ask for. Everything else is a segment under that address, and each is named below. A request for a segment this contract does not define reaches whatever the host does with an address it does not know, which on a host that also serves pages is its catch-all: the answer then says nothing about this contract, and a mounting that works reads exactly like one that does not.

The segment, under a session's address, where what a person typed is sent to the agent.

Sending is not reading: the transcript says what has been said, and this is where the next thing to say arrives. What comes back of it comes back on the transcript, like everything else the session writes.

What the session is called where an address names it.

What sessions are called in an address.

Which version of this contract an address belongs to.

It opens every address, so a host can serve a later shape beside this one and a page built against either goes on being answered. The contract says what it is rather than leaving a consumer to discover it from a shape that changed under them.