@theoremjs/web 0.3.4-next.679.gcdf1a3a → 0.3.4-next.693.g4ab1526

package/README.md

@@ -199,6 +199,7 @@ await chat.submit();
 - `getState()` returns a `ChatState`. It is a new object after each change, and the same object between changes. So you can compare it by reference, as React's `useSyncExternalStore` does.
 - `subscribe(listener)` calls the listener once for each group of changes, after the code that made them has run. It returns the function that unsubscribes. Until the first subscribe or send, the chat asks nothing of the host. Then it reads a resumed conversation that came without its `conversationView`, and answers a restored page gate as unanswered.
 - `update(options)` gives the controller your latest options, such as a new `context`, `slots`, or `pageTools`. Each turn reads the options as they are when it is sent. `conversation`, `conversationView`, `initialText`, `initialFiles`, `initialVoice`, and `initialPending` are read only when the controller is created.
+- A live call takes `stated` in its options, and `setStated(stated)` changes it during the call. As with `setSlots`, the call is taken up again with the prompt lines the new value chooses.
 - Each method is bound to the controller. Pass it as a callback as it is.
 
 `state.phase` is `'idle'`, `'streaming'`, or `'gated'`. The methods for the composer depend on it:
@@ -261,6 +262,7 @@ const transport = withPageToolDispatch(
 | `prepare` | Your app's own turn, from the one the handler builds (`TurnWiring.prepare` from `@theoremjs/agents`). Set what your app sets per turn, such as `system`, `credentials`, `onStage` and `onAgentCall`; read your app data as `turn.host`. The handler keeps its profile, its tool execution and its abort. Your `onStage` runs before the handler's steering, and your `credentials` are read before the session's. A call held at a gate runs on, once answered, with the `host`, `onStage` and `credentials` you give for that call's turn. |
 | `onStage` | The server's own stage handler, on every call the handler runs, a host profile's included: after your app's (`prepare`), before steering. For a rule the server adds to whatever the app says, such as a question before each tool that writes. |
 | `pageToolBroker` | Delivers results to active page dispatches. Default: bounded process memory. |
+| `pageStatesTurn` | Let the page say which prompt lines a turn gets, through `stated` on a turn or a live call. Set it only for a page you trust as yourself, such as a builder's own tool. Without it, a request with `stated` is refused. |
 | `conversationStore` | Where the conversation is kept. Required, except for a stateless profile, which must not have one. See [Keep the conversation](#keep-the-conversation). |
 | `sessionStore`, `steerInbox` | Where open gates are kept, and where steers and stops reach a running turn. Default: process memory, which reaches only turns this process runs. On more than one instance, give a shared `SteerInbox`. |
 | `credentialStore` | Where tool credentials are kept, by session. Default: process memory. |

package/client/chat.d.ts

@@ -2,7 +2,7 @@ import { type AttachmentValidationIssue, type ComposerMenuAction, type ComposerP
 import { type ClientFailure } from './failure.ts';
 import { type PageTools } from './live/live-page-tool.ts';
 import type { AnsweringGate, ToolDecisionAction } from './tool-resume.ts';
-import { type ConversationView, type TheoremTransport, type TurnEventSink } from './transport.ts';
+import { type ConversationView, type StatedTurn, type TheoremTransport, type TurnEventSink } from './transport.ts';
 export type ChatOptions = {
     transport: TheoremTransport;
     /** The profile's composer interface, as `transport.describe()` returns it. `null` while it loads. */
@@ -42,6 +42,8 @@ export type ChatOptions = {
      * `pickSlot`), starting at its first allowed value.
      */
     slots?: Record<string, string>;
+    /** Which prompt lines each turn gets, for a host that lets its page choose (`pageStatesTurn`). */
+    stated?: StatedTurn;
     /** Told each time the visitor picks a slot, with every slot's value. */
     onSlotsChange?: (slots: Record<string, string>) => void;
     /** What the page wants the agent to know: any JSON. The latest value goes with every turn. */

package/client/chat.js

@@ -653,12 +653,13 @@ class Chat {
         };
     }
     #withValues(request) {
-        const { iface, slots: fixed, context } = this.#options;
+        const { iface, slots: fixed, context, stated } = this.#options;
         const slots = slotsOf(iface, fixed, this.#picked).values;
-        if (slots === undefined && context === undefined)
+        if (slots === undefined && context === undefined && stated === undefined)
             return request;
         return {
             ...request,
+            ...(stated === undefined ? {} : { stated }),
             input: {
                 ...request.input,
                 ...(slots === undefined ? {} : { slots }),

package/client/index.d.ts

@@ -33,5 +33,5 @@ export { hasLead, layoutResult, type ResultChart, type ResultFigure, type Result
 export type { AnsweringGate, ToolDecisionAction, ToolGateResolution, } from './tool-resume.ts';
 export { continueGatedToolInvocation, type PersonGateResolution } from './tool-resume.ts';
 export { createTraceFeed, recordedFeed, type TraceFeed } from './trace-feed.ts';
-export { CHAT_LINES, type ChatLine, type ChatLineSink, type ClientTurnEvent, type ConversationLine, type ConversationView, createHttpTransport, fetchConversation, fetchRewound, fetchStarted, type HostErrorBody, type HttpOptions, type HttpTransportOptions, hostError, isTheoremStreamError, type MalformedEvent, postJson, postNdjson, readNdjsonStream, type TheoremConversationRequest, type TheoremInvokeRequest, type TheoremReplay, type TheoremRewindRequest, type TheoremRewound, type TheoremStartRequest, type TheoremSteerRequest, type TheoremStopRequest, TheoremStreamError, type TheoremTransport, type TheoremTurnInput, type TheoremTurnRequest, type TurnEventSink, type UnsupportedEvent, type WireLines, } from './transport.ts';
+export { CHAT_LINES, type ChatLine, type ChatLineSink, type ClientTurnEvent, type ConversationLine, type ConversationView, createHttpTransport, fetchConversation, fetchRewound, fetchStarted, type HostErrorBody, type HttpOptions, type HttpTransportOptions, hostError, isTheoremStreamError, type MalformedEvent, postJson, postNdjson, readNdjsonStream, type StatedTurn, type TheoremConversationRequest, type TheoremInvokeRequest, type TheoremReplay, type TheoremRewindRequest, type TheoremRewound, type TheoremStartRequest, type TheoremSteerRequest, type TheoremStopRequest, TheoremStreamError, type TheoremTransport, type TheoremTurnInput, type TheoremTurnRequest, type TurnEventSink, type UnsupportedEvent, type WireLines, } from './transport.ts';
 export { buildInvokeRequest, buildTurnRequest, foldAssistantTurn, issuedOperationId, type RunScope, type WalkAway, } from './turn-client.ts';

package/client/live/live-page-tool.d.ts

@@ -1,3 +1,4 @@
+import type { StatedTurn } from '../transport.ts';
 /** The page's result for a call: the tool's output schema checks it, then the model reads it. */
 export type PageToolAnswer = {
     output: unknown;
@@ -16,6 +17,8 @@ export type PageTools = Record<string, PageTool>;
 export type LiveCallOptions = {
     /** The value chosen for each of the profile's `inputs.slots`, read as the call starts. */
     slots?: Record<string, string>;
+    /** Which prompt lines the call gets, for a host that lets its page choose (`pageStatesTurn`). */
+    stated?: StatedTurn;
     /**
      * What the page tells the agent: any JSON. It goes with the call's opening, and
      * again whenever it changes, as background the agent reads without replying.

package/client/live-client.d.ts

@@ -15,7 +15,7 @@ import { type SessionEventOf, type TraceRecord } from '@theoremjs/agents';
 import type { PageTools } from './live/live-page-tool.ts';
 import type { LiveConnectPhase, LiveSessionStatus } from './live/live-state.ts';
 import type { LiveGateReply, LiveToolGatePrompt } from './live/live-tool.ts';
-import { type ClientTurnEvent } from './transport.ts';
+import { type ClientTurnEvent, type StatedTurn } from './transport.ts';
 export type { LiveConnection, LiveSocket } from './live-messages.ts';
 import type { LiveSocket } from './live-messages.ts';
 export interface LiveClientOptions {
@@ -24,6 +24,8 @@ export interface LiveClientOptions {
     openMessage?: Record<string, unknown>;
     /** The value chosen for each of the profile's `inputs.slots`, fixed for the call. */
     slots?: Record<string, string>;
+    /** Which prompt lines the call gets, for a host that lets its page choose (`pageStatesTurn`). */
+    stated?: StatedTurn;
     /** What the page tells the agent as the call opens; `setContext` replaces it during the call. */
     context?: unknown;
     relayUrl?: string;
@@ -181,6 +183,9 @@ export declare class LiveSessionClient {
      * handle; with none, the next call has them.
      */
     setSlots(slots: Record<string, string> | undefined): void;
+    /** The call's prompt lines, as `setSlots` takes its slots. */
+    setStated(stated: StatedTurn | undefined): void;
+    private takeUpAgain;
     /**
      * Replace the page's context package. In a call it reaches the agent as
      * background, with no reply; before one, it goes with the call's opening.

package/client/live-client.js

@@ -228,11 +228,12 @@ export class LiveSessionClient {
     }
     /** The first message: the call's values, and the handle and time away when it takes a dropped call up again. */
     openMessage() {
-        const { slots, openMessage: host } = this.options;
+        const { slots, stated, openMessage: host } = this.options;
         return {
             type: 'open',
             ...(this.history.length ? { history: structuredClone(this.history) } : {}),
             ...(slots ? { slots } : {}),
+            ...(stated ? { stated } : {}),
             ...(this.context === undefined ? {} : { context: this.context }),
             ...(this.providerState
                 ? {
@@ -771,6 +772,16 @@ export class LiveSessionClient {
         if (JSON.stringify(slots) === JSON.stringify(this.options.slots))
             return;
         this.options = { ...this.options, slots };
+        this.takeUpAgain();
+    }
+    /** The call's prompt lines, as `setSlots` takes its slots. */
+    setStated(stated) {
+        if (JSON.stringify(stated) === JSON.stringify(this.options.stated))
+            return;
+        this.options = { ...this.options, stated };
+        this.takeUpAgain();
+    }
+    takeUpAgain() {
         if (this.providerState && !this.opening && this.ws?.readyState === WebSocket.OPEN) {
             this.handleDrop();
         }

package/client/live-messages.d.ts

@@ -7,7 +7,7 @@ import { type ProviderCheckpoint } from '@theoremjs/agents';
  * @module
  */
 import { type GateDecision, type ToolGate, type TraceRecord, type TurnEvent, type TurnHistoryMessage, z } from '@theoremjs/agents';
-import { type HostErrorBody } from './transport.ts';
+import { type HostErrorBody, type StatedTurn } from './transport.ts';
 import { type MalformedEvent, type UnsupportedEvent } from './wire-line.ts';
 /**
  * The live client's first message, before the relay opens the session: the
@@ -20,6 +20,8 @@ export type LiveOpenMessage = {
     slots?: Record<string, string>;
     /** What the page tells the agent as the call opens: the client's context package. */
     context?: unknown;
+    /** Which prompt lines the call gets, for a host that lets its page choose (`pageStatesTurn`). */
+    stated?: StatedTurn;
     /** A call that dropped, taken up again: the provider's handle, and how long the caller was away. */
     resume?: {
         providerState: ProviderCheckpoint;

package/client/live-messages.js

@@ -7,13 +7,14 @@ import { providerCheckpointSchema } from '@theoremjs/agents';
  * @module
  */
 import { GATE_DECISIONS, TURN_EVENT_SCHEMAS, toolGateSchema, traceRecordSchema, turnHistoryMessageSchema, z, } from '@theoremjs/agents';
-import { hostErrorBodySchema } from "./transport.js";
+import { hostErrorBodySchema, statedTurnSchema, } from "./transport.js";
 import { readWireLine, readWireValue, } from "./wire-line.js";
 const liveOpenMessage = z.object({
     type: z.literal('open'),
     history: z.array(turnHistoryMessageSchema).optional(),
     slots: z.record(z.string(), z.string()).optional(),
     context: z.unknown().optional(),
+    stated: statedTurnSchema.optional(),
     resume: z
         .object({ providerState: providerCheckpointSchema, awayMs: z.number().nonnegative() })
         .optional(),

package/client/transport.d.ts

@@ -49,6 +49,13 @@ export type TheoremReplay = {
 };
 /** For a host that reads the studio's client-held state. */
 export declare const theoremReplaySchema: z.ZodType<TheoremReplay>;
+/** Which prompt lines a turn gets: the path it says it came by, and its `identity.conditions`. */
+export type StatedTurn = {
+    path?: string;
+    conditions?: Record<string, string>;
+};
+/** A stated turn off the wire. */
+export declare const statedTurnSchema: z.ZodType<StatedTurn>;
 /**
  * One message. The host resolves the profile and owns the conversation: the
  * client sends only the message and the ref of the conversation it continues.
@@ -63,6 +70,8 @@ export type TheoremTurnRequest = {
     conversation?: string;
     model?: string;
     effort?: string;
+    /** For a host that lets its page choose (`pageStatesTurn`); any other host refuses it. */
+    stated?: StatedTurn;
     /** Client-generated id so mid-turn steers can find this turn's inbox. */
     turnId?: string;
     /** invariant: Both issued IDs identify each paused action that this message abandons. */

package/client/transport.js

@@ -39,11 +39,19 @@ true;
 export const theoremReplaySchema = theoremReplay;
 /** An id the client made: trimmed, never blank. */
 const clientId = z.string().trim().min(1);
+const statedTurn = z.object({
+    path: z.string().optional(),
+    conditions: z.record(z.string(), z.string()).optional(),
+});
+true;
+/** A stated turn off the wire. */
+export const statedTurnSchema = statedTurn;
 const theoremTurnRequest = z.object({
     input: theoremTurnInput,
     conversation: z.string().min(1).optional(),
     model: z.string().optional(),
     effort: z.string().optional(),
+    stated: statedTurn.optional(),
     turnId: clientId.optional(),
     abandon: z.array(gateReferenceSchema).min(1).optional(),
     replay: theoremReplay.pick({ sessionPermissions: true }).optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theoremjs/web",
-  "version": "0.3.4-next.679.gcdf1a3a",
+  "version": "0.3.4-next.693.g4ab1526",
   "description": "Theorem on the web platform, with no UI framework: Web-standard server handlers that serve a profile, and the browser client that talks to them.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,6 @@
   },
   "peerDependencies": {
     "zod": "^4.6.5",
-    "@theoremjs/agents": "^0.3.4-next.679.gcdf1a3a"
+    "@theoremjs/agents": "^0.3.4-next.693.g4ab1526"
   }
 }

package/server/conversation-store.d.ts

@@ -11,6 +11,7 @@
  */
 import { type ProviderCheckpoint, TheoremError, type TurnEvent, type TurnHistoryMessage, z } from '@theoremjs/agents';
 import type { TranscriptBlock } from '@theoremjs/agents/interface';
+import { type StatedTurn } from '../client/transport.ts';
 import { type MemorySessionStoreOptions } from './session-store.ts';
 /** A reply paused on gates: its events so far, and the history it was given. */
 export type PausedReply = {
@@ -23,9 +24,10 @@ export type PausedReply = {
     workedMs: number;
     /** When the reply last paused (epoch ms). */
     endedAt: number;
-    /** The model and effort the reply ran with, for the run that goes on after its gates. */
+    /** The model, effort, and stated turn the reply ran with, for the run that goes on after its gates. */
     model?: string;
     effort?: string;
+    stated?: StatedTurn;
 };
 /** One conversation as the host stores it. */
 export type StoredConversation = {

package/server/conversation-store.js

@@ -12,6 +12,7 @@
 import { labelText, providerCheckpointSchema, TheoremError, turnEventSchema, turnHistoryMessageSchema, z, } from '@theoremjs/agents';
 import { openSecret, sealSecret } from '@theoremjs/agents/kernel';
 import { transcriptBlockSchema } from "../client/transcript-schema.js";
+import { statedTurnSchema } from "../client/transport.js";
 import { memoryStoreLimits } from "./session-store.js";
 const pausedReply = z.object({
     events: z.array(turnEventSchema),
@@ -21,6 +22,7 @@ const pausedReply = z.object({
     endedAt: z.number(),
     model: z.string().optional(),
     effort: z.string().optional(),
+    stated: statedTurnSchema.optional(),
 });
 true;
 const storedConversation = z.object({

package/server/conversation.d.ts

@@ -17,7 +17,7 @@
 import { type GateReference, type LabelOverrides, type Profile, type ProviderCheckpoint, TheoremError, type TurnEvent, type TurnHistoryMessage, type TurnInput } from '@theoremjs/agents';
 import { type ClientTurnOptions } from '@theoremjs/agents/host';
 import { type ComposerProfileInterface, streamThoughtsEnabled, type TranscriptBlock, type UserTurnDraft, type UserTurnHistoryMedia } from '@theoremjs/agents/interface';
-import type { ConversationLine, ConversationView, TheoremTurnInput } from '../client/transport.ts';
+import type { ConversationLine, ConversationView, StatedTurn, TheoremTurnInput } from '../client/transport.ts';
 import { type StoredConversation, type TheoremConversationStore } from './conversation-store.ts';
 /** One walked-away call: its id, and the run that settles it (`invokeTool` with the abandoned resume). */
 export type WalkedAwayCall = {
@@ -119,6 +119,7 @@ export type ReplyTurn = {
     providerState?: ProviderCheckpoint;
     model?: string;
     effort?: string;
+    stated?: StatedTurn;
 };
 /** What a reply's model run takes from the host. */
 export type ReplyRunner = {
@@ -131,6 +132,7 @@ export type ReplyRunner = {
     compact(history: TurnHistoryMessage[], tokens: number, model: string | undefined): Promise<TurnHistoryMessage[] | undefined>;
     model?: string;
     effort?: string;
+    stated?: StatedTurn;
     signal: AbortSignal;
 };
 /** A line of a reply's stream: an event, or the ref of what the store wrote. */

package/server/conversation.js

@@ -192,6 +192,7 @@ function pausedOn(conversation, reply, runner) {
         endedAt: Date.now(),
         ...(runner.model ? { model: runner.model } : {}),
         ...(runner.effort ? { effort: runner.effort } : {}),
+        ...(runner.stated ? { stated: runner.stated } : {}),
     };
     return { ...conversation, ...metered(conversation, reply.events), paused };
 }
@@ -234,6 +235,7 @@ async function* runReply(host, opened, reply, runner, input, withMessage) {
             providerState: conversation.providerState,
             model: runner.model,
             effort: runner.effort,
+            ...(runner.stated ? { stated: runner.stated } : {}),
         });
         for await (const event of events) {
             reply.events.push(event);
@@ -485,7 +487,12 @@ export async function* answerReply(args) {
             yield error;
         return;
     }
-    yield* runReply(host, { ...opened, conversation: waiting }, reply, { ...runner, model: runner.model ?? paused.model, effort: runner.effort ?? paused.effort }, {
+    yield* runReply(host, { ...opened, conversation: waiting }, reply, {
+        ...runner,
+        model: runner.model ?? paused.model,
+        effort: runner.effort ?? paused.effort,
+        ...(paused.stated ? { stated: paused.stated } : {}),
+    }, {
         history: replyHistory(reply),
         ...(waiting.inputTokens === undefined ? {} : { inputTokens: waiting.inputTokens }),
         ...(waiting.historyTokens === undefined ? {} : { historyTokens: waiting.historyTokens }),

package/server/handler.d.ts

@@ -73,6 +73,11 @@ export type TheoremHandlerOptions = {
      * answered, with the `host`, `onStage` and `credentials` it gives for that call's turn.
      */
     prepare?: TurnWiring['prepare'];
+    /**
+     * Let the page say which prompt lines a turn gets (`stated`), for a page the host trusts as it
+     * trusts itself: the studio's. Unset refuses them, so a public page never chooses its own lines.
+     */
+    pageStatesTurn?: boolean;
     /**
      * The server's own stage handler, on every call this handler runs, a host's included: after
      * the application's, before steering. For a rule the server adds to whatever the application

package/server/handler.js

@@ -418,6 +418,7 @@ async function* chatTurn(ctx, request, session, turn, key, stop) {
             host,
             ...(turn.model ? { model: turn.model } : {}),
             ...(turn.effort ? { effort: turn.effort } : {}),
+            ...turn.stated,
         }, {
             credentials: sessionCredentials(ctx, session.id),
             ...(onStage ? { onStage } : {}),
@@ -454,6 +455,7 @@ function chatRunner(ctx, request, session, generation) {
         },
         ...(generation.model ? { model: generation.model } : {}),
         ...(generation.effort ? { effort: generation.effort } : {}),
+        ...(generation.stated ? { stated: generation.stated } : {}),
         signal,
     };
 }
@@ -472,6 +474,9 @@ function conversationHost(ctx, session) {
 /** The person's message: a new reply, run against the conversation the host keeps. */
 async function turn(ctx, chat, request, session) {
     const body = await readBody(request, theoremTurnRequestSchema, ctx.options.maxRequestBytes);
+    if (body.stated && !ctx.options.pageStatesTurn) {
+        throw new TheoremError('request', labelText('error.request'));
+    }
     const message = postedMessage(chatInterface(chat), body.input, await ctx.options.context?.(request));
     const runner = chatRunner(ctx, request, session, body);
     const host = conversationHost(ctx, session);
@@ -481,7 +486,12 @@ async function turn(ctx, chat, request, session) {
         // labels-exempt: internal diagnostic; the user reads error.request
         if (body.abandon)
             throw statelessRefusal('walk away from');
-        return eventStream(ctx, request, () => runner.run({ input: message.input, model: body.model, effort: body.effort }));
+        return eventStream(ctx, request, () => runner.run({
+            input: message.input,
+            model: body.model,
+            effort: body.effort,
+            ...(body.stated ? { stated: body.stated } : {}),
+        }));
     }
     const opened = await openConversation(host, body.conversation, {
         kind: 'message',

package/server/mod.d.ts

@@ -7,7 +7,7 @@
  */
 export { theoremHostCallRequestSchema } from '../client/host-transport.ts';
 export type { LiveClientMessage, LiveOpenMessage } from '../client/live-messages.ts';
-export { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremReplaySchema, theoremRewindRequestSchema, theoremStartRequestSchema, theoremSteerRequestSchema, theoremStopRequestSchema, theoremTurnRequestSchema, } from '../client/transport.ts';
+export { type StatedTurn, theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremReplaySchema, theoremRewindRequestSchema, theoremStartRequestSchema, theoremSteerRequestSchema, theoremStopRequestSchema, theoremTurnRequestSchema, } from '../client/transport.ts';
 export { answerReply, type ConversationHost, type ConversationUse, conversationView, type IssuedWalkAway, messageReply, type OpenedConversation, openConversation, type PostedMessage, postedMessage, type ReplyLine, type ReplyRunner, type ReplyTurn, readerConversationHost, rewindConversation, startConversation, statelessRefusal, type WalkedAwayCall, waitingCalls, } from './conversation.ts';
 export { type ConversationSnapshot, type ConversationWriteResult, createMemoryConversationStore, createSealedConversationStore, emptyConversation, type PausedReply, type SealedConversationStoreOptions, type StoredConversation, storedConversationSchema, type TheoremConversationStore, unknownConversation, } from './conversation-store.ts';
 export { createMemoryCredentialStore, type TheoremCredentialStore, type TheoremCredentials, } from './credential-store.ts';

package/server/session-boundary.d.ts

@@ -8,11 +8,13 @@ export interface SessionBoundaryOptions {
     sessionStore: TheoremSessionStore;
     gateTtlMs?: number;
     operationRetentionMs?: number;
+    /** As `TheoremHandlerOptions.pageStatesTurn`: refuses a live call's `stated` unless set. */
+    pageStatesTurn?: boolean;
     pageToolBroker?: PageToolBroker;
     /** How long the page has to answer a tool call it runs, in milliseconds. Unset, it waits. */
     pageToolTimeoutMs?: number;
 }
-export type PreparedLiveOpen = Pick<SessionRequest, 'history' | 'slots' | 'context' | 'providerState' | 'awayMs'>;
+export type PreparedLiveOpen = Pick<SessionRequest, 'history' | 'slots' | 'context' | 'providerState' | 'awayMs' | 'path' | 'conditions'>;
 export interface TheoremSessionBoundary {
     sessionId: string;
     setCookie?: string;

package/server/session-boundary.js

@@ -31,6 +31,9 @@ export async function createTheoremSessionBoundary(options) {
         toolExecution: sessionToolCoordinator(store, id),
         async prepareLiveOpen(raw, server) {
             const open = checkRequest(liveOpenMessageSchema, raw, 'live open');
+            if (open.stated && !options.pageStatesTurn) {
+                throw new TheoremError('request', labelText('error.request'));
+            }
             const prepared = liveSessionOpen(open, server);
             const state = await store.read(id);
             const providerState = await requireOwnedCheckpoint(state.providerCheckpoints, prepared.providerState, state.operations);

package/server/turn-input.d.ts

@@ -7,4 +7,4 @@ export declare function kernelTurnInput(input: TheoremTurnInput, server?: unknow
  * What a live call's first message asks of the session, as `runSession` takes
  * it: the page's context is the client's, and `server` is the host's own.
  */
-export declare function liveSessionOpen(open: LiveOpenMessage, server?: unknown): Pick<SessionRequest, 'slots' | 'context' | 'providerState' | 'awayMs' | 'history'>;
+export declare function liveSessionOpen(open: LiveOpenMessage, server?: unknown): Pick<SessionRequest, 'slots' | 'context' | 'providerState' | 'awayMs' | 'history' | 'path' | 'conditions'>;

package/server/turn-input.js

@@ -22,6 +22,7 @@ export function liveSessionOpen(open, server) {
         ...(open.history ? { history: open.history } : {}),
         ...(open.slots ? { slots: open.slots } : {}),
         ...(context ? { context } : {}),
+        ...open.stated,
         ...(open.resume
             ? { providerState: open.resume.providerState, awayMs: open.resume.awayMs }
             : {}),