@volter/world-core 3.0.38 → 3.0.40

package/src/openai-wire.ts

@@ -14,7 +14,7 @@ const obj = (v: unknown): Row => (v && typeof v === 'object' && !Array.isArray(v
 const arr = (v: unknown): Row[] => (Array.isArray(v) ? v as Row[] : []);
 
 /** A turn: the text, or tool calls, the reasoning when there is some, and why it finished. */
-export type WireTurn = { text?: string | null; toolCalls?: Array<{ name: string; arguments: Row }>; reasoning?: string | null; finishReason?: string };
+export type WireTurn = { text?: string | null; toolCalls?: Array<{ name: string; arguments: Row }>; reasoning?: string | null; reasoningDetails?: Row[]; finishReason?: string };
 
 /** Tokens, estimated at about four characters a token: a twin's count, not a tokenizer's. */
 export const estimateTokens = (text: string): number => Math.max(1, Math.ceil(text.length / 4));
@@ -91,7 +91,7 @@ function chatParts(s: ChatShape): { text: string | null; finish: string; calls:
 export function chatCompletion(s: ChatShape): Row {
   const p = chatParts(s);
   const field = s.reasoningField ?? 'reasoning';
-  const message = { role: 'assistant', content: p.text, refusal: null, ...(p.reasoning ? { [field]: p.reasoning } : {}), ...(p.calls.length ? { tool_calls: p.calls } : {}) };
+  const message = { role: 'assistant', content: p.text, refusal: null, ...(p.reasoning ? { [field]: p.reasoning } : {}), ...(s.turn.reasoningDetails ? { reasoning_details: s.turn.reasoningDetails } : {}), ...(p.calls.length ? { tool_calls: p.calls } : {}) };
   return {
     id: s.id, ...(s.extra ?? {}), model: s.model, object: 'chat.completion', created: s.created,
     choices: [{ index: 0, message, logprobs: null, finish_reason: p.finish, ...(s.nativeFinish ? { native_finish_reason: p.finish } : {}) }], usage: p.usage,
@@ -101,21 +101,22 @@ export function chatCompletion(s: ChatShape): Row {
 /** A chat completion streamed: its chunks (`object: chat.completion.chunk`) as Server-Sent Events, the text in two
  *  deltas, the last chunk carrying the finish reason and the usage, then `data: [DONE]`. `comment` is a keep-alive a
  *  vendor sends first (OpenRouter's `: OPENROUTER PROCESSING`). */
-export function chatCompletionSSE(s: ChatShape & { comment?: string }): string {
+export function chatCompletionSSE(s: ChatShape & { comment?: string; separateUsageChunk?: boolean }): string {
   const p = chatParts(s);
   const field = s.reasoningField ?? 'reasoning';
-  const chunk = (delta: Row, last: boolean): string => `data: ${JSON.stringify({
+  const chunk = (delta: Row, last: boolean, usage = last): string => `data: ${JSON.stringify({
     id: s.id, ...((last ? s.extra : s.interimExtra ?? s.extra) ?? {}), model: s.model, object: 'chat.completion.chunk', created: s.created,
     choices: [{ index: 0, delta, logprobs: null, finish_reason: last ? p.finish : null, ...(s.nativeFinish ? { native_finish_reason: last ? p.finish : null } : {}) }],
-    ...(last ? { usage: p.usage } : {}),
+    ...(usage ? { usage: p.usage } : {}),
   })}\n\n`;
   const half = p.text ? Math.ceil(p.text.length / 2) : 0;
   return [
     ...(s.comment ? [`: ${s.comment}\n\n`] : []),
-    ...(p.reasoning ? [chunk({ role: 'assistant', content: '', [field]: p.reasoning }, false)] : []),
+    ...(p.reasoning || s.turn.reasoningDetails ? [chunk({ role: 'assistant', content: '', ...(p.reasoning ? { [field]: p.reasoning } : {}), ...(s.turn.reasoningDetails ? { reasoning_details: s.turn.reasoningDetails } : {}) }, false)] : []),
     ...(p.text ? [chunk({ role: 'assistant', content: p.text.slice(0, half) }, false), ...(p.text.length > half ? [chunk({ content: p.text.slice(half) }, false)] : [])] : []),
     ...(p.calls.length ? [chunk({ role: 'assistant', content: null, tool_calls: p.calls.map((c, i) => ({ index: i, ...c })) }, false)] : []),
-    chunk({}, true),
+    chunk(s.separateUsageChunk ? { role: 'assistant', content: '' } : {}, true, !s.separateUsageChunk),
+    ...(s.separateUsageChunk ? [chunk({ role: 'assistant', content: '' }, true, true)] : []),
     'data: [DONE]\n\n',
   ].join('');
 }
@@ -229,12 +230,15 @@ export type ResponsesShape = {
   /** ids for the output items: the message, the reasoning, each function call and its call id */
   itemId: (kind: 'msg' | 'rs' | 'fc' | 'call', i: number) => string;
   extra?: Row;
+  /** Vendor defaults; explicit request values win, including nullable gateway defaults. */
+  defaults?: Row;
 };
 
 /** A Responses object (`object: response`, `status: completed`): its output items (the reasoning when there is some,
  *  the message with its output text, or function calls) and its usage. */
 export function responsesAnswer(s: ResponsesShape): Row {
   const b = s.body;
+  const defaultOf = (field: string, fallback: unknown): unknown => s.defaults && Object.hasOwn(s.defaults, field) ? s.defaults[field] : fallback;
   let text = s.turn.text ?? null;
   const max = typeof b.max_output_tokens === 'number' ? b.max_output_tokens : undefined;
   let incomplete: Row | null = null;
@@ -251,10 +255,10 @@ export function responsesAnswer(s: ResponsesShape): Row {
     id: s.id, object: 'response', created_at: s.createdAt, status: incomplete ? 'incomplete' : 'completed', ...(s.extra ?? {}),
     error: null, incomplete_details: incomplete, instructions: b.instructions ?? null, max_output_tokens: max ?? null, model: s.model, output,
     parallel_tool_calls: b.parallel_tool_calls ?? true, previous_response_id: b.previous_response_id ?? null,
-    reasoning: { effort: obj(b.reasoning).effort ?? null, summary: obj(b.reasoning).summary ?? null }, store: b.store ?? true,
-    temperature: b.temperature ?? 1, text: b.text ?? { format: { type: 'text' } }, tool_choice: b.tool_choice ?? 'auto', tools: b.tools ?? [], top_p: b.top_p ?? 1,
+    reasoning: { effort: obj(b.reasoning).effort ?? null, summary: obj(b.reasoning).summary ?? null }, store: b.store ?? defaultOf('store', true),
+    temperature: b.temperature ?? defaultOf('temperature', 1), text: b.text ?? { format: { type: 'text' } }, tool_choice: b.tool_choice ?? 'auto', tools: b.tools ?? [], top_p: b.top_p ?? defaultOf('top_p', 1),
     usage: { input_tokens: input, input_tokens_details: { cached_tokens: 0 }, output_tokens: out + reasoningTokens, output_tokens_details: { reasoning_tokens: reasoningTokens }, total_tokens: input + out + reasoningTokens },
-    metadata: b.metadata ?? {},
+    metadata: b.metadata ?? defaultOf('metadata', {}),
   };
 }
 
@@ -278,7 +282,14 @@ export function responsesSSE(s: ResponsesShape): string {
       events.push({ type: 'response.function_call_arguments.delta', item_id: item.id, output_index: i, delta: item.arguments });
       events.push({ type: 'response.function_call_arguments.done', item_id: item.id, output_index: i, arguments: item.arguments });
     } else {
-      events.push({ type: 'response.output_item.added', output_index: i, item });
+      // announced empty, as a message item is: an SDK's accumulator appends each summary part the events below add
+      events.push({ type: 'response.output_item.added', output_index: i, item: { ...item, summary: [], status: 'in_progress' } });
+      for (const [n, summary] of arr(item.summary).entries()) {
+        events.push({ type: 'response.reasoning_summary_part.added', item_id: item.id, output_index: i, summary_index: n, part: { type: 'summary_text', text: '' } });
+        events.push({ type: 'response.reasoning_summary_text.delta', item_id: item.id, output_index: i, summary_index: n, delta: summary.text });
+        events.push({ type: 'response.reasoning_summary_text.done', item_id: item.id, output_index: i, summary_index: n, text: summary.text });
+        events.push({ type: 'response.reasoning_summary_part.done', item_id: item.id, output_index: i, summary_index: n, part: summary });
+      }
     }
     events.push({ type: 'response.output_item.done', output_index: i, item });
   }
@@ -298,18 +309,19 @@ export const forbidsTools = (choice: unknown): boolean => choice === 'none' || o
 
 /** The turn a scenario's decision scripts (`respond`: text, toolCalls, reasoning, finishReason), or undefined. */
 export function scenarioTurn(decision: ScenarioDecision | undefined): WireTurn | undefined {
-  if (!decision || decision.kind !== 'handler') return undefined;
+  if (!decision || decision.kind !== 'handler' || decision.fault?.kind === 'generation') return undefined;
   const r = obj(decision.respond);
   return {
     ...(typeof r.text === 'string' ? { text: r.text } : {}),
     ...(r.toolCalls !== undefined ? { toolCalls: (Array.isArray(r.toolCalls) ? r.toolCalls : [r.toolCalls]) as WireTurn['toolCalls'] } : {}),
     ...(typeof r.reasoning === 'string' ? { reasoning: r.reasoning } : {}),
+    ...(Array.isArray(r.reasoningDetails) ? { reasoningDetails: r.reasoningDetails as Row[] } : {}),
     ...(typeof r.finishReason === 'string' ? { finishReason: r.finishReason } : {}),
   };
 }
 
 const nonEmpty = (v: unknown): v is string => typeof v === 'string' && v.length > 0;
-const RESPOND_KEYS = new Set(['text', 'toolCalls', 'reasoning', 'finishReason']);
+const RESPOND_KEYS = new Set(['text', 'toolCalls', 'reasoning', 'reasoningDetails', 'finishReason']);
 
 /** A request as the scenario reads it: its model, its text, its last user text, the tools it offers and the tool
  *  results it ends with, from a chat completion's messages or a Responses input. */
@@ -347,10 +359,11 @@ export function scenario(vendor: string, operations: string[], faultBody: (statu
       return null;
     },
     validateRespond: (respond) => {
-      if (typeof respond !== 'object' || respond === null || Array.isArray(respond)) return 'respond is an object { text?, toolCalls?, reasoning?, finishReason? }';
+      if (typeof respond !== 'object' || respond === null || Array.isArray(respond)) return 'respond is an object { text?, toolCalls?, reasoning?, reasoningDetails?, finishReason? }';
       const r = respond as Row;
       for (const k of Object.keys(r)) if (!RESPOND_KEYS.has(k)) return `respond: unknown key "${k}" (valid: ${[...RESPOND_KEYS].join(', ')})`;
       if (r.text !== undefined && typeof r.text !== 'string') return 'respond.text is a string';
+      if (r.reasoningDetails !== undefined && (!Array.isArray(r.reasoningDetails) || r.reasoningDetails.some((d) => !d || typeof d !== 'object' || Array.isArray(d)))) return 'respond.reasoningDetails is an array of JSON objects';
       if (r.reasoning !== undefined && typeof r.reasoning !== 'string') return 'respond.reasoning is a string';
       for (const c of r.toolCalls === undefined ? [] : Array.isArray(r.toolCalls) ? r.toolCalls : [r.toolCalls]) {
         const u = c as Row;
@@ -369,3 +382,21 @@ export function scenario(vendor: string, operations: string[], faultBody: (statu
   };
   return { adapter, operations, request };
 }
+
+/** An admitted generation that fails: partial JSON or actual Chat Completions error frames.
+ * The pack supplies its error envelope/type; the shared wire owns the SDK framing. */
+export function chatCompletionFailure(s: { id: string; model: string; created: number; error: Row; text?: string; extra?: Row }, stream: boolean): Row | string {
+  const common = { id: s.id, model: s.model, created: s.created, ...s.extra };
+  if (!stream) return { ...common, object: 'chat.completion', choices: [{ index: 0, message: { role: 'assistant', content: s.text ?? '' }, finish_reason: 'error', error: s.error }] };
+  const frames: Row[] = [];
+  if (s.text) frames.push({ ...common, object: 'chat.completion.chunk', choices: [{ index: 0, delta: { role: 'assistant', content: s.text }, finish_reason: null }] });
+  frames.push({ ...common, object: 'chat.completion.chunk', choices: [{ index: 0, delta: { content: '' }, finish_reason: 'error' }], error: s.error });
+  return frames.map((f) => `data: ${JSON.stringify(f)}\n\n`).join('') + 'data: [DONE]\n\n';
+}
+
+/** Responses generation failures keep the response's canonical fields and native error code. */
+export function responsesFailure(response: Row, stream: boolean, event = 'response.failed'): Row | string {
+  if (!stream) return response;
+  const data = event === 'response.failed' ? { type: event, response } : { type: event, error: response.error };
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}

package/src/pack-fetch.ts

@@ -1,3 +1,5 @@
+import { parseExactJson } from './exact-json.ts';
+import { readHostPort } from './host-port.ts';
 // A Protocol 3 pack's whole HTTP surface, served by the kernel from the pack's declarations (docs/contributing/
 // architecture.md, "The pack contract: the kernel's root"): the discovery door (`GET /twin`, the manifest's
 // `discovery`), the vendor's own moves as time passes (`semantics/clock.ts`), the World's doors (the manifest's `doors`,
@@ -10,7 +12,7 @@ import { placedCookies, TWIN_PREFIX_HEADER } from './twin-fetch.ts';
 import { PREFIX_PARAMS_HEADER } from './derived.ts';
 import { withHeaders } from './with-headers.ts';
 import { authRefusal, bindSemantics, contextFor, LANE_HEADER, SCENARIO_DECISION_HEADER, coreFor, crossCutting, derivedRequestScopes, vendorError, type CoreScope, type DerivedManifest, type ErrorSpec, type Handler, type HandlerContext, type LanesDecl, type VendorManifest } from './derived-core.ts';
-import { compileSurface, createDerivedFetch, matchOperation, type DerivedFetch, type DerivedOperation, type DerivedOwner, type DerivedSurface, type Workspace, type BoardFrame } from './derived.ts';
+import { compileSurface, createDerivedFetch, matchOperation, pathParams, type DerivedFetch, type DerivedOperation, type DerivedOwner, type DerivedSurface, type Workspace, type BoardFrame } from './derived.ts';
 import { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER, runAsVendorMove } from './request-scope.ts';
 import { parseScenarioDocument, ScenarioEngine, ScenarioError, statefulTwinManifest, twinManifest, type PackScenarioAdapter } from './scenario.ts';
 import { getActiveWorldStore } from './world-store.ts';
@@ -25,10 +27,13 @@ import { hostRules } from '../host-routing.cjs';
 /** A descriptor's host rules, as data. */
 type PackDescriptorHosts = ReadonlyArray<HostRule> | undefined;
 import { socketUpgrade, type SocketEngine } from './sockets.ts';
-import { MACHINE_POOL, POOL_KINDS } from './machines.ts';
+import type { WebSocketUpgrade, WebSocketPeer } from './serve-http.ts';
+import { MACHINE_POOL, POOL_KINDS, resetFakePool } from './machines.ts';
 import { applyTwinWrite } from './serve.ts';
 import { graphqlEndpoint, type GraphqlPart } from './graphql-wire.ts';
-import { brotliDecompressSync, gunzipSync, gzipSync, inflateSync, zstdDecompressSync } from 'node:zlib';
+import { gzipSync } from 'node:zlib';
+import { decompress } from './bytes.ts';
+import { decodedBodyLimit, oversizedBody, RequestBodyTooLargeError } from './request-body.ts';
 
 /** What a pack declares and writes, and nothing it assembles itself. */
 export type PackParts = {
@@ -80,6 +85,7 @@ export type LanePart = {
     serves?: (method: string, path: string) => boolean; boards?: boolean; draws?: (url: string) => boolean;
     /** the hosts the lane's built content screens name: its vendor's router sends `<base>/@<host>/` there */
     contentHosts?: ReadonlyArray<string>;
+    upgrade?: WebSocketUpgrade;
   };
   manifest: { doors?: ReadonlyArray<{ method: string; path: string }> };
 };
@@ -112,6 +118,8 @@ function pathMatcher(pattern: string, prefix: boolean): (path: string) => Match
 }
 /** A declared host (`dash.cloudflare.com`, `<domain>.daily.co`) as a matcher of a request's host. */
 function hostMatcher(pattern: string): (host: string) => Match | undefined {
+  const whole = /^(?:\{([^}]+)\}|<([^>]+)>)$/.exec(pattern);
+  if (whole) return (host) => host ? { params: { [whole[1] ?? whole[2]!]: host } } : undefined;
   const names: string[] = [];
   const re = new RegExp(`^${pattern.split('.').map((label) => {
     const m = /^(?:\{([^}]+)\}|<([^>]+)>)$/.exec(label);
@@ -125,7 +133,7 @@ function hostMatcher(pattern: string): (host: string) => Match | undefined {
   };
 }
 /** The host a request is for: the vendor host the World's injector names, else its own. */
-const hostOf = (request: Request): string => (request.headers.get('x-volter-twin-original-host') ?? request.headers.get('host') ?? new URL(request.url).host).split(':')[0]!.toLowerCase();
+const hostOf = (request: Request): string => readHostPort(request.headers.get('x-volter-twin-original-host') ?? request.headers.get('host') ?? new URL(request.url).host)?.host ?? '';
 
 /** The answer for a path no operation, door or screen serves, and for an operation nothing models: the manifest's
  *  `gap`, its `{method}` and `{path}` filled, else the manifest's not-found refusal. */
@@ -137,25 +145,29 @@ function gapAnswer(m: DerivedManifest, request: Request, otherMethod = false): R
 }
 
 const METHODS = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE'];
-const DECODE = { gzip: gunzipSync, zstd: zstdDecompressSync, deflate: inflateSync, br: brotliDecompressSync } as const;
+type ContentCoding = 'gzip' | 'zstd' | 'deflate' | 'br';
 
 /** A request with its body decoded as its Content-Encoding says, when the manifest's `encodings` reads that coding;
  *  undefined when the bytes are not what the header names. */
-async function decoded(m: DerivedManifest, request: Request): Promise<Request | undefined> {
+async function decoded(m: DerivedManifest, request: Request): Promise<Request | Response | undefined> {
+  const codings = (request.headers.get('content-encoding') ?? '').split(',').map(c => c.trim().toLowerCase()).filter(Boolean);
+  if (codings.length > 1) return new Response('Unsupported Content-Encoding', { status: 415 });
   if (request.method === 'GET' || request.method === 'HEAD' || request.body === null) return request;
   // the body read once, here, and every part of the pack given a request made again from its bytes: a served request's
   // body read through a clone and then read again (an `around` that checks a body before its handler does) tees a stream
   // whose second branch a Bun server never finishes, and the request hung
   const raw = new Uint8Array(await request.arrayBuffer());
-  const coding = (request.headers.get('content-encoding') ?? '').trim().toLowerCase() as keyof typeof DECODE;
+  const coding = (codings[0] ?? '') as ContentCoding;
   if (!m.encodings?.request?.includes(coding)) return new Request(request.url, { method: request.method, headers: request.headers, body: raw });
   let body: Uint8Array;
-  try { body = DECODE[coding](raw); } catch { return undefined; }
+  try { body = await decompress(raw, coding, decodedBodyLimit(m.descriptor?.maxRequestBodySize)); }
+  catch (error) { return error instanceof RequestBodyTooLargeError ? oversizedBody() : undefined; }
   const headers = new Headers(request.headers);
   headers.delete('content-encoding');
   headers.delete('content-length');
-  // a copy over an ArrayBuffer of its own: zlib's result may view a shared buffer, which a request body does not take
-  return new Request(request.url, { method: request.method, headers, body: new Uint8Array(body) });
+  // A finite single-chunk stream holds the decoder's buffer; BufferSource extraction would copy the entire body.
+  const buffered = new ReadableStream<Uint8Array>({ start(controller) { controller.enqueue(body); controller.close(); } });
+  return new Request(request.url, { method: request.method, headers, body: buffered, duplex: 'half' } as RequestInit);
 }
 
 /** An answer in the coding the request accepts, when the manifest's `encodings` answers in it. */
@@ -171,6 +183,9 @@ async function encoded(m: DerivedManifest, request: Request, res: Response): Pro
 }
 
 /** A pack's HTTP surface, as the kernel serves it from the pack's parts. */
+/** A door's path as it is served and listed: under `/_twin/`, whether the manifest writes the prefix or not. */
+const doorPath = (path: string): string => (path.startsWith('/_twin/') ? path : `/_twin${path.startsWith('/') ? '' : '/'}${path}`);
+
 export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}): DerivedFetch {
   const m = parts.manifest;
   const scope: CoreScope = {
@@ -195,7 +210,7 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
       if (parts.gap) {
         const url = new URL(request.url);
         const matched = operation ? matchOperation(routes, request.method, url.pathname, url.searchParams, request.headers) : undefined;
-        return parts.gap(await contextFor(m, { request, operation: operation ?? ({ id: 'unmatched', method: request.method, path: url.pathname, class: request.method === 'GET' ? 'retrieve' : 'action' } as DerivedOperation), params: matched?.params ?? {} }, scope));
+        return parts.gap(await contextFor(m, { request, operation: operation ?? ({ id: 'unmatched', method: request.method, path: url.pathname, class: request.method === 'GET' ? 'retrieve' : 'action' } as DerivedOperation), params: matched?.params ?? pathParams(routes, url.pathname) }, scope));
       }
       const url = new URL(request.url);
       const other = !matchOperation(routes, request.method, url.pathname, url.searchParams, request.headers)
@@ -224,7 +239,7 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
     const raw = getActiveWorldStore().read(options.scenarioPath);
     if (raw === null) throw new ScenarioError(`${m.vendor} scenario: no file at ${options.scenarioPath}`);
     if (!engine || raw !== engineRaw) {
-      engine = new ScenarioEngine(parts.scenario.adapter, parseScenarioDocument(JSON.parse(raw), parts.scenario.adapter));
+      engine = new ScenarioEngine(parts.scenario.adapter, parseScenarioDocument(parseExactJson(raw), parts.scenario.adapter));
       engineRaw = raw;
     }
     return engine;
@@ -232,11 +247,13 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
   /** The API, a turn the scenario decides handed its decision (ctx.scenario), or answered as the fault it names. */
   const decided = async (arrived: Request): Promise<Response> => {
     if (!parts.scenario) return api(arrived);
-    // the body is read once and the request made again from its bytes: a served request's body cloned (for the turn's
-    // context) and then forwarded tees a stream whose second branch a Bun server never finishes, and every turn hung
-    // (measured on merge served with --scenario: no answer in 8 s, matched or not; t_c0279b69)
+    // the body is read once and the request made again from its bytes, so the turn's context and the API each read their
+    // own. Merge served with --scenario once answered no turn in 8 s (t_c0279b69), and this change came with the cure;
+    // putting the earlier read back (the served request cloned for the context, then forwarded) does not reproduce the
+    // hang on its own (2026-10-01: merge's CLI with --scenario, and its life walked over HTTP: every turn answered), so
+    // what hung is UNEXPLAINED, and this is no proof of its cause
     const bytes = arrived.method === 'GET' || arrived.method === 'HEAD' ? undefined : await arrived.arrayBuffer();
-    const request = new Request(arrived.url, { method: arrived.method, headers: arrived.headers, ...(bytes ? { body: bytes } : {}) });
+    const request = new Request(arrived.url, { method: arrived.method, headers: arrived.headers, signal: arrived.signal, ...(bytes ? { body: bytes } : {}) });
     const url = new URL(request.url);
     const matched = matchOperation(routes, request.method, url.pathname, url.searchParams, request.headers);
     if (!matched || !parts.scenario.operations.includes(matched.operation.id)) return api(request);
@@ -262,7 +279,7 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
   const doors = (m.doors ?? []).map((d) => {
     const answer = parts.doors?.[d.id];
     if (!answer) throw new Error(`${m.vendor}: the manifest declares the door ${d.id}, and semantics/doors.ts exports no ${d.id}`);
-    return { decl: d, path: pathMatcher(d.path.startsWith('/_twin/') ? d.path : `/_twin${d.path.startsWith('/') ? '' : '/'}${d.path}`, false), answer };
+    return { decl: d, path: pathMatcher(doorPath(d.path), false), answer };
   });
   const screens = (m.screens ?? []).filter((s) => s.status === 'done' && parts.screens?.[s.id]).map((s) => {
     const hosts = [s.host, ...(s.hosts ?? [])].map(hostMatcher);
@@ -287,22 +304,49 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
   // a context the kernel opens for what no surface operation names: a door, a screen, the clock, the board
   const open = (request: Request, id: string, method: string, path: string, params: Record<string, string>): Promise<HandlerContext> =>
     contextFor(m, { request, operation: { id, method, path, class: method === 'GET' ? 'retrieve' : 'action' } as DerivedOperation, params }, scope);
+  const advanceClock = async (request: Request): Promise<void> => {
+    if (parts.clock) await runAsVendorMove(async () => parts.clock!(await open(new Request(request.url, m.tenant ? { headers: request.headers } : {}), 'clock', 'POST', '/_twin/clock', {})));
+  };
   const refusedReadOnly = (): Response => vendorError(m, m.readOnly);
 
   const prefix = m.pathPrefix ? new RegExp(`^(?:${m.pathPrefix})(?=/)`) : undefined;
+  const base = surface.basePath ?? '';
+  const baseAlias = m.basePathAlias && base ? new RegExp(`^(?:${m.basePathAlias})(?=/)`) : undefined;
   const hostPath = m.pathFromHost ? new RegExp(m.pathFromHost, 'i') : undefined;
   const hostParams = m.hostParams ? new RegExp(m.hostParams, 'i') : undefined;
-  /** The request as its vendor routes it: duplicate slashes collapsed, the manifest's path prefix taken off, a host's
+  // each operation's spanning parameters, keyed by the operation and the parameter as the route compiles them (a whole
+  // segment's label whose name the surface or the manifest declares spanning), so one operation's spanning name never
+  // keeps another's slashes, nor a label that only part of a segment holds
+  const spanningNames = new Set(surface.spanning ?? []);
+  const spanningOf = new Set(surface.operations.flatMap((op) => ((op.basePath ?? base) + op.path).split('/').flatMap((seg) => {
+    const label = /^\{([^}]+)\}$/.exec(seg)?.[1];
+    return label !== undefined && spanningNames.has(label) ? [`${op.id}\u0000${label}`] : [];
+  })));
+  /** A path as the vendor routes it: the manifest's path prefix taken off, the spec's base in an alias's place, a host's
    *  path label (pathFromHost) put in front. */
+  const rewritten = (pathname: string, host: string): string => {
+    let path = pathname;
+    if (prefix) path = path.replace(prefix, '') || '/';
+    // a base the vendor serves as its own: the spec's base in its place (a path already under the spec's base stays)
+    if (baseAlias && !(path === base || path.startsWith(`${base}/`))) path = path.replace(baseAlias, base);
+    const label = hostPath?.exec(host)?.[1];
+    if (label) path = `/${label}${path === '/' ? '' : path}`;
+    return path;
+  };
+  /** The request as its vendor routes it: duplicate slashes collapsed, unless the rewritten path matches an operation
+   *  through one of that operation's spanning parameters (the surface's and the manifest's), whose value keeps its
+   *  slashes; then rewritten. */
   const routed = (request: Request): Request => {
     const url = new URL(request.url);
-    let path = url.pathname.replace(/\/{2,}/g, '/');
+    const host = hostOf(request);
+    const kept = rewritten(url.pathname, host);
+    const matched = matchOperation(routes, request.method, kept);
+    const spanning = matched !== undefined && Object.keys(matched.params).some((name) => spanningOf.has(`${matched.operation.id}\u0000${name}`));
+    const source = spanning ? url.pathname : url.pathname.replace(/\/{2,}/g, '/');
     // a prefix's named groups (Jira's `/ex/jira/(?<cloudId>[^/]+)`) and the host's (E2B's envd at
     // `49983-(?<sandboxID>…).e2b.app`) join the operation's parameters
-    const groups = { ...(prefix?.exec(path)?.groups ?? {}), ...(hostParams?.exec(hostOf(request))?.groups ?? {}) };
-    if (prefix) path = path.replace(prefix, '') || '/';
-    const label = hostPath?.exec(hostOf(request))?.[1];
-    if (label) path = `/${label}${path === '/' ? '' : path}`;
+    const groups = { ...(prefix?.exec(source)?.groups ?? {}), ...(hostParams?.exec(host)?.groups ?? {}), ...Object.fromEntries(Object.entries(m.headerParams ?? {}).flatMap(([param, header]) => { const value = request.headers.get(header); return value === null ? [] : [[param, value]]; })) };
+    const path = spanning ? kept : rewritten(source, host);
     if (path === url.pathname && !Object.keys(groups).length) return request;
     // the path the client sent, which a signature over the request (SigV4's canonical URI) covers
     const headers = new Headers(request.headers);
@@ -314,6 +358,8 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
   };
   const rootServes = (method: string, path: string): boolean => Boolean(matchOperation(routes, method, path));
   const lane = m.lanes ? laneRouter(m.vendor, m.lanes, parts.lanes ?? {}, rootServes) : undefined;
+  // Inspect lane-owned World doors directly, without routing them back through the vendor gateway.
+  const laneDoor = (request: Request, path: string): Promise<Record<string, unknown>> => laneDoors(parts.lanes ?? {}, request, path);
   // at a World's place, a page's asset or upload on another of the pack's content hosts is `<base>/@<host>/<path>`
   // (architecture, "A page at a World's place"): answered by the built content screen that names that host exactly,
   // routed from it, and by nothing else; a request naming no such host is general routing's
@@ -358,7 +404,7 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
   };
   /** A request as the kernel reads it: the headers only the kernel names taken off, its body decoded (undefined when it
    *  does not decode as its Content-Encoding says). */
-  const prepared = async (arrived: Request): Promise<Request | undefined> => {
+  const prepared = async (arrived: Request): Promise<Request | Response | undefined> => {
     if (arrived.headers.has(SCENARIO_DECISION_HEADER) || arrived.headers.has(PREFIX_PARAMS_HEADER)) {
       const headers = new Headers(arrived.headers);
       headers.delete(SCENARIO_DECISION_HEADER);
@@ -374,7 +420,7 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
     const address = arrived.headers.has(TWIN_PREFIX_HEADER) ? contentAddressOf(new URL(arrived.url).pathname) : undefined;
     if (!address || !contentHosts.includes(address.host)) return undefined;
     const readable = await prepared(arrived);
-    return readable ? atContentHost(readable) : undecodable(arrived);
+    return readable instanceof Response ? readable : readable ? atContentHost(readable) : undecodable(arrived);
   };
   const fetch = async (arrived: Request): Promise<Response> => {
     // the discovery door is the pack's own, whichever lane would take its path
@@ -393,9 +439,12 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
     // one a lane's names, the lane router sends it to that lane's own fetch, wrapped as any request to it is
     const own = await answerContent(arrived);
     if (own) return own;
-    const toLane = discovery ? undefined : lane?.(arrived);
+    // Root World doors belong to the pack at every routed host, including a lane's host.
+    const rootDoor = doors.some((d) => d.decl.method.toUpperCase() === arrived.method && d.path(asked));
+    const toLane = discovery || rootDoor ? undefined : lane?.(arrived);
     if (toLane) return toLane(arrived);
     const readable = await prepared(arrived);
+    if (readable instanceof Response) return readable;
     if (!readable) return undecodable(arrived);
     const incoming = routed(readable);
     // a twin started read-only marks every request so, so every context it opens knows (isReadOnlyRequest)
@@ -405,31 +454,41 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
     const readOnly = (options.readOnly ?? false) || isReadOnlyRequest(request);
     if (request.method === 'GET' && path === '/twin' && m.discovery) {
       const d = m.discovery;
+      const discoveryDoors = [...(m.doors ?? []), ...(m.machines ? [{ id: 'machine-pool', method: 'POST', path: '/_twin/machine-pool', note: 'Enroll the World execution pool: { kind: light | docker | none | fake, images?: { image: { context, command?, runtime? } } }.' }] : [])];
       // the workspaces a person can be shown (Viewing a World): each built workspace screen's id and path
-      const shown = workspaces().length ? { screens: workspaces() } : {};
+      const laneDiscovery = await laneDoor(request, '/twin');
+      const shown = { ...(workspaces().length ? { screens: workspaces() } : {}), ...(Object.keys(laneDiscovery).length ? { lanes: laneDiscovery } : {}) };
+      const identity = d.identity ?? (m.auth?.held ? 'Authenticate as the vendor does, using a credential issued in this World; unknown credentials are refused.' : undefined);
       // a model vendor's: its state, and what its scenario scripts, with the scenario's live counts
       if (parts.scenario && d.behavior) {
-        return Response.json({ ...shown, ...twinManifest({
+        const body = twinManifest({
           vendor: m.vendor, twinOf: d.twinOf,
-          stateSentence: `Stateful: it stores ${d.stores}. Create state through the vendor's OWN API with the real SDK or plain fetch pointed here.`,
+          stateSentence: `Stateful: it stores ${d.stores}. Create state through the vendor's OWN API with the real SDK or plain fetch pointed here${discoveryDoors.length ? "; what the vendor does on its own pages (not its API) is a door of the World, listed under doors" : ''}.`,
           behaviorSentence: d.behavior, exampleHandler: d.exampleHandler ?? null, ...(engineOf() ? { engine: engineOf() as never } : {}),
-        }) });
+        });
+        const declared = Object.fromEntries(discoveryDoors.map((door) => [`${door.method} ${doorPath(door.path)}`, door.note ?? 'a door of the World']));
+        return Response.json({ ...shown, ...body, program: { ...(body.program as Record<string, unknown>), ...(identity ? { identity } : {}) }, doors: { ...(body.doors as Record<string, string>), ...declared } });
       }
-      return Response.json({ ...statefulTwinManifest({ vendor: m.vendor, twinOf: d.twinOf, stores: d.stores, ...(d.identity ? { identity: d.identity } : {}), ...(d.notes ? { notes: d.notes } : {}) }), ...shown });
+      return Response.json({ ...statefulTwinManifest({ vendor: m.vendor, twinOf: d.twinOf, stores: d.stores, ...(identity ? { identity } : {}), ...(d.behavior ? { behavior: d.behavior } : {}), ...(d.notes ? { notes: d.notes } : {}), ...(discoveryDoors.length ? { doors: discoveryDoors.map((door) => ({ ...door, path: doorPath(door.path) })) } : {}) }), ...shown });
     }
     // the scenario's handlers with their match counts, and the recent misses
-    if (request.method === 'GET' && path === '/twin/scenario' && parts.scenario) return Response.json(engineOf()?.status() ?? { vendor: m.vendor, handlers: [], misses: 0, recentMisses: [] });
+    if (request.method === 'GET' && path === '/twin/scenario') {
+      const lanes = await laneDoor(request, '/twin/scenario');
+      if (parts.scenario || Object.keys(lanes).length) return Response.json({ ...(engineOf()?.status() ?? { vendor: m.vendor, handlers: [], misses: 0, recentMisses: [] }), ...(Object.keys(lanes).length ? { lanes } : {}) });
+    }
     // the vendor's own moves, not the caller's: its context carries none of the request's headers (a Stripe-Account
     // header would make a payout time makes the caller's), but a tenant's, when the vendor keeps tenants apart
-    if (parts.clock) await runAsVendorMove(async () => parts.clock!(await open(new Request(request.url, m.tenant ? { headers: request.headers } : {}), 'clock', 'POST', '/_twin/clock', {})));
+    await advanceClock(request);
     if (path.startsWith('/_twin/')) {
       // the World's machine pool, enrolled by the kernel for a vendor that runs images (machines.ts)
       if (m.machines && path === '/_twin/machine-pool' && request.method === 'POST') {
         if (readOnly) return refusedReadOnly();
-        let kind: unknown;
-        try { kind = (JSON.parse(await request.clone().text()) as { kind?: unknown }).kind; } catch { kind = undefined; }
+        let enrollment: Record<string, unknown> = {};
+        try { enrollment = parseExactJson(await request.clone().text()); } catch {}
+        const kind = enrollment.kind;
         if (!POOL_KINDS.includes(kind as never)) return Response.json({ message: `kind must be one of ${POOL_KINDS.join(', ')}` }, { status: 400 });
-        await applyTwinWrite(m.service, { operation: 'machine_pool.enroll', subjectType: MACHINE_POOL, subjectId: 'pool', fields: { kind }, occurredAt: (await open(request, 'machine-pool', 'POST', '/_twin/machine-pool', {})).occurredAt, actor: { kind: 'system' } }, options.root);
+        await applyTwinWrite(m.service, { operation: 'machine_pool.enroll', subjectType: MACHINE_POOL, subjectId: 'pool', fields: { kind, ...(kind === 'fake' && Array.isArray(enrollment.httpReplies) ? { httpReplies: enrollment.httpReplies } : {}), ...(kind === 'light' ? { images: enrollment.images ?? {} } : {}) }, occurredAt: (await open(request, 'machine-pool', 'POST', '/_twin/machine-pool', {})).occurredAt, actor: { kind: 'system' } }, options.root);
+        if (kind === 'fake') resetFakePool(m.service, options.root);
         return Response.json({ kind }, { status: 201 });
       }
       for (const d of doors) {
@@ -471,11 +530,27 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
       if (readOnly && request.method !== 'GET' && request.method !== 'HEAD') return refusedReadOnly();
       return byPath.s.answer(await open(request, byPath.s.decl.id, request.method, byPath.s.decl.path, { ...(byPath.onHost?.params ?? {}), ...byPath.hit!.params }));
     }
+    for (const route of m.machineRoutes ?? []) {
+      const host = request.headers.get('x-volter-twin-original-host') ?? new URL(request.url).hostname;
+      const match = new RegExp(route.host).exec(host);
+      if (!match) continue;
+      const ctx = await open(request, 'machine.traffic', request.method, url.pathname, match.groups ?? {});
+      const field = (row: Record<string, unknown>, path: string): unknown => path.split('.').reduce<unknown>((value, key) => value && typeof value === 'object' ? (value as Record<string, unknown>)[key] : undefined, row);
+      const fill = (value: string, row: Record<string, unknown> = {}): string => value.replace(/\{([^}]+)\}/g, (_, key: string) => String(match.groups?.[key] ?? field(row, key) ?? ''));
+      const row = ctx.rowsRaw(route.resource).find(row => Object.entries(route.where).every(([key, value]) => String(field(row, key)) === fill(value)));
+      if (!row) return new Response('Guest is unavailable', { status: 503 });
+      try { return await ctx.machines.request(String(field(row, route.name)), Number(typeof route.port === 'string' ? fill(route.port, row) : route.port), request); }
+      catch { return new Response('Guest is unavailable', { status: 503 }); }
+    }
     if (!parts.around) return encoded(m, request, await decided(request));
-    const matched = matchOperation(routes, request.method, url.pathname, url.searchParams, request.headers);
-    const operation = matched?.operation ?? ({ id: 'unmatched', method: request.method, path: url.pathname, class: request.method === 'GET' ? 'retrieve' : 'action' } as DerivedOperation);
-    const ctx = await contextFor(m, { request: request.clone(), operation, params: matched?.params ?? {} }, scope);
-    return encoded(m, request, await parts.around(ctx, (rewritten) => decided(rewritten ?? request)));
+    // The front reads a context before forwarding (possibly with new headers). Materialize a transport body before
+    // those independent reads, rather than chaining tees of the incoming stream through the front and the scenario.
+    const bytes = request.method === 'GET' || request.method === 'HEAD' ? undefined : await request.arrayBuffer();
+    const buffered = new Request(request.url, { method: request.method, headers: request.headers, signal: request.signal, ...(bytes ? { body: bytes } : {}) });
+    const matched = matchOperation(routes, buffered.method, url.pathname, url.searchParams, buffered.headers);
+    const operation = matched?.operation ?? ({ id: 'unmatched', method: buffered.method, path: url.pathname, class: buffered.method === 'GET' ? 'retrieve' : 'action' } as DerivedOperation);
+    const ctx = await contextFor(m, { request: buffered.clone(), operation, params: matched?.params ?? pathParams(routes, url.pathname) }, scope);
+    return encoded(m, buffered, await parts.around(ctx, (rewritten) => decided(rewritten ?? buffered)));
   };
   // the request's id is the correlation of every entry it appends (runtime contract D3), minted here, always: it is the
   // group a perform sends as one call (the real-system adapters, "Perform"). Under `auto` the group is performed once
@@ -513,13 +588,21 @@ export function createPackFetch(parts: PackParts, options: PackFetchOptions = {}
   // the vendor's sockets: a request to a declared socket's path opens a session of its engine, over a context of the
   // request that opened it (operation `socket:<id>`)
   for (const d of m.sockets ?? []) if (!parts.sockets?.[d.id]) throw new Error(`${m.vendor}: the manifest declares the socket ${d.id}, and semantics/sockets.ts exports no ${d.id}`);
-  const upgrade = m.sockets?.length ? socketUpgrade(m.service, options.root, m.sockets, parts.sockets!,
+  const ownUpgrade = m.sockets?.length ? socketUpgrade(m.service, options.root, m.sockets, parts.sockets!,
     (request, d) => open(request, `socket:${d.id}`, 'GET', d.path, {}), hostOf, (request) => new URL(routed(request).url).pathname,
     // a turn a session speaks (a voice agent's reply) is the World's scenario's, as a turn over HTTP is
     async (asked) => engineOf()?.serve(asked)) : undefined;
-  // what serves each operation: the pack's own, and each lane's
-  const owners = (): Record<string, DerivedOwner> => ({ ...api.owners(), ...lanesOwners(parts.lanes ?? {}) });
-  return derivedRequestScopes(m, Object.assign(served, { owners, serves, workspaces, boards: Boolean(parts.board), draws: drawsUrl, contentHosts, ...(upgrade ? { upgrade } : {}) }));
+  const upgrade = laneUpgrades(parts.lanes ?? {}, ownUpgrade);
+  // what serves each operation: the pack's own, and each lane's, each unit's under its own name
+  const ownersByUnit = (): Record<string, Record<string, DerivedOwner>> => ({
+    '': {
+      ...((surface.format === 'command-reply' || surface.format === 'command-table' && m.descriptor?.transport === 'raw-tcp') ? Object.fromEntries((surface.commands ?? []).map((c) => [c.id, parts.around && !m.unmodeled?.includes(c.id) ? 'handler' : 'gap'])) : api.owners()),
+      ...Object.fromEntries((parts.graphql?.operations ?? []).map((op) => [op.id, `${op.kind === 'query' ? 'Query' : 'Mutation'}.${op.field}` in (parts.graphql?.resolvers ?? {}) ? 'handler' : 'gap'] as const)),
+    },
+    ...lanesOwners(parts.lanes ?? {}),
+  });
+  const owners = (): Record<string, DerivedOwner> => flatOwners(ownersByUnit());
+  return derivedRequestScopes(m, Object.assign(served, { owners, ownersByUnit, serves, advanceClock, workspaces, boards: Boolean(parts.board), maxRequestBodySize: m.descriptor?.maxRequestBodySize, draws: drawsUrl, contentHosts, ...(upgrade ? { upgrade } : {}) }), options.readOnly);
 }
 
 /** The vendor's gateway over its lanes: the lane a request goes to (a door to the lane that declares it, then the first
@@ -574,17 +657,52 @@ function laneRouter(vendor: string, decl: LanesDecl, lanes: Record<string, LaneP
 
 /** A vendor whose every API is a lane (Cloudflare's API v4 and R2, AWS's services), served from its manifest: the
  *  discovery door, then its lanes as its gateway sends them; a request no lane takes is the vendor's not-found. */
-/** What serves each of a vendor's lanes' operations (a handler, the core, or the gap), as one map. */
-const lanesOwners = (lanes: Record<string, LanePart>): Record<string, DerivedOwner> =>
-  Object.assign({}, ...Object.values(lanes).map((l) => (l.fetch as { owners?: () => Record<string, DerivedOwner> }).owners?.() ?? {}));
+/** Each lane's answer at one of its World doors (`/twin`, `/twin/scenario`), by lane, read from the lane directly rather
+ *  than routed back through the vendor's front: a vendor's discovery holds its lanes' (their doors, their scripts). */
+async function laneDoors(lanes: Record<string, LanePart>, request: Request, path: string): Promise<Record<string, unknown>> {
+  const entries = await Promise.all(Object.entries(lanes).map(async ([name, part]) => {
+    const url = new URL(request.url); url.pathname = path; url.search = '';
+    const answer = await part.fetch(new Request(url, { headers: request.headers, signal: request.signal }));
+    return answer.ok ? [name, await answer.json()] as const : undefined;
+  }));
+  return Object.fromEntries(entries.filter((entry): entry is readonly [string, unknown] => entry !== undefined));
+}
+
+/** What serves each of a vendor's lanes' operations (a handler, the core, or the gap), by lane: a lane's operation is the
+ *  lane's own, so an id it shares with its root or another lane (Clerk's Backend and Frontend APIs both name
+ *  `ListOrganizationMemberships`) keeps the lane's own owner, and a lane's gap stays a gap whoever else serves the id. */
+const lanesOwners = (lanes: Record<string, LanePart>): Record<string, Record<string, DerivedOwner>> =>
+  Object.fromEntries(Object.entries(lanes).map(([name, l]) => [name, (l.fetch as { owners?: () => Record<string, DerivedOwner> }).owners?.() ?? {}]));
+
+/** A vendor's owners as one map, for its breadth: its own API's operations by id, a lane's as `<lane>:<id>`. */
+const flatOwners = (byUnit: Record<string, Record<string, DerivedOwner>>): Record<string, DerivedOwner> =>
+  Object.fromEntries(Object.entries(byUnit).flatMap(([unit, map]) => Object.entries(map).map(([id, owner]) => [unit ? `${unit}:${id}` : id, owner] as const)));
 
 /** The workspaces a vendor's lanes draw, as one list. */
 const lanesWorkspaces = (lanes: Record<string, LanePart>): Workspace[] =>
   Object.values(lanes).flatMap((l) => (l.fetch as { workspaces?: () => Workspace[] }).workspaces?.() ?? []);
 
-export function createVendorFetch(manifest: VendorManifest, lanes: Record<string, LanePart>): ((request: Request) => Promise<Response>) & { owners: () => Record<string, DerivedOwner>; workspaces: () => Workspace[] } {
+/** Keep each upgraded peer on the vendor or lane engine that accepted its opening request. */
+function laneUpgrades(lanes: Record<string, LanePart>, own?: WebSocketUpgrade): WebSocketUpgrade | undefined {
+  const choices = [own, ...Object.values(lanes).map(lane => lane.fetch.upgrade)].filter((choice): choice is WebSocketUpgrade => choice !== undefined);
+  if (choices.length === 0) return undefined;
+  if (choices.length === 1) return choices[0];
+  const held = new WeakMap<WebSocketPeer, WebSocketUpgrade>();
+  const select = (request: Request): WebSocketUpgrade | undefined => choices.find(choice => choice.accepts(request));
+  return {
+    accepts: request => select(request) !== undefined,
+    protocol: request => select(request)?.protocol?.(request),
+    open(peer, request) { const selected = select(request); if (selected) { held.set(peer, selected); selected.open(peer, request); } },
+    message(peer, data) { return held.get(peer)?.message(peer, data); },
+    close(peer) { const selected = held.get(peer); held.delete(peer); selected?.close(peer); },
+  };
+}
+
+export function createVendorFetch(manifest: VendorManifest, lanes: Record<string, LanePart>): DerivedFetch {
+  const upgrade = laneUpgrades(lanes);
   const lane = laneRouter(manifest.vendor, manifest.lanes, lanes);
   return Object.assign(async (request: Request): Promise<Response> => {
+    for (const part of Object.values(lanes)) await (part.fetch as typeof part.fetch & { advanceClock?: (request: Request) => Promise<void> }).advanceClock?.(request);
     const path = new URL(request.url).pathname.replace(/\/+$/, '') || '/';
     // the vendor's board is the frames of the lanes that lay one out, each drawn when any lane's screen takes its url
     if (request.method === 'GET' && path === '/twin/board') {
@@ -602,9 +720,14 @@ export function createVendorFetch(manifest: VendorManifest, lanes: Record<string
     if (request.method === 'GET' && path === '/twin' && manifest.discovery) {
       // the vendor's screens are its lanes' (a dashboard drawn by one lane is the vendor's)
       const screens = lanesWorkspaces(lanes);
-      return Response.json({ ...statefulTwinManifest({ vendor: manifest.vendor, ...manifest.discovery }), ...(screens.length ? { screens } : {}) });
+      const laneDiscovery = await laneDoors(lanes, request, '/twin');
+      return Response.json({ ...statefulTwinManifest({ vendor: manifest.vendor, ...manifest.discovery }), ...(screens.length ? { screens } : {}), ...(Object.keys(laneDiscovery).length ? { lanes: laneDiscovery } : {}) });
+    }
+    if (request.method === 'GET' && path === '/twin/scenario') {
+      const laneScenarios = await laneDoors(lanes, request, '/twin/scenario');
+      if (Object.keys(laneScenarios).length) return Response.json({ vendor: manifest.vendor, lanes: laneScenarios });
     }
     const to = lane(request);
     return to ? to(request) : Response.json({ error: `${manifest.vendor}: no lane serves ${request.method} ${path}` }, { status: 404 });
-  }, { owners: () => lanesOwners(lanes), workspaces: () => lanesWorkspaces(lanes) });
+  }, { maxRequestBodySize: manifest.descriptor?.maxRequestBodySize, owners: () => flatOwners(lanesOwners(lanes)), ownersByUnit: () => lanesOwners(lanes), workspaces: () => lanesWorkspaces(lanes), ...(upgrade ? { upgrade } : {}) });
 }