@neta-art/cohub 8.24.0 → 9.0.0

package/dist/chunks/http.js

@@ -1,894 +1,397 @@
-import { D as getRealtimeSpaceRoom, E as getRealtimeBoardRoom, n as HttpTransport, t as HttpError, y as isUuid } from "./transport.js";
+import { A as isUuid, f as getRealtimeBoardRoom, n as HttpTransport, p as getRealtimeSpaceRoom, t as HttpError } from "./transport.js";
 import { l as resolveExecutionToken, o as resolveApiBaseUrl } from "./environment.js";
 import { z } from "zod";
-//#region ../protocol/dist/board-constants.js
-const DEFAULT_BOARD_RENDER_LIMITS = {
-	particles: 2e4,
-	vertices: 5e5,
-	dynamicVertices: 15e4,
-	drawCalls: 400,
-	filterPasses: 24,
-	renderTexturePixels: 16777216,
-	textureBytes: 536870912,
-	bufferBytes: 268435456,
-	simulationSteps: 1e5
-};
-const BOARD_BUILTIN_CLIP_KINDS = [
-	"motion.path",
-	"draw.reveal",
-	"text.reveal",
-	"effects.particles",
-	"effects.trail",
-	"effects.impact",
-	"effects.flash",
-	"camera.focus",
-	"camera.shake"
-];
-const BOARD_BUILTIN_EFFECT_KINDS = [
-	"effects.pulse",
-	"effects.float",
-	"effects.deal"
-];
-const BOARD_ARROW_STROKE_SIZE = 2.5;
-const BOARD_CONNECTION_STROKE_SIZE = 2.5;
-function clipSchema(id) {
-	switch (id) {
-		case "motion.path": return { params: { points: {
-			coordinateSpace: "world-offset",
-			unit: "board"
-		} } };
-		case "effects.particles": return { params: { bounds: {
-			coordinateSpace: "world",
-			unit: "board"
-		} } };
-		case "camera.focus": return { params: {
-			focus: {
-				coordinateSpace: "world",
-				unit: "board"
-			},
-			padding: {
-				coordinateSpace: "screen",
-				unit: "css-px"
-			},
-			minZoom: { unit: "ratio" },
-			maxZoom: { unit: "ratio" }
-		} };
-		case "camera.shake": return { params: { amount: {
-			coordinateSpace: "screen-offset",
-			unit: "css-px"
-		} } };
-		default: return;
-	}
-}
-function effectSchema(id) {
-	switch (id) {
-		case "effects.deal": return { params: {
-			lift: { unit: "board" },
-			swing: { unit: "board" },
-			curve: { unit: "board" },
-			tilt: { unit: "degree" },
-			scale: { unit: "ratio" },
-			duration: { unit: "ms" },
-			landing: { unit: "ms" }
-		} };
-		default: return;
-	}
+//#region ../protocol/dist/model/metrics.js
+const count = z.number().finite().nonnegative();
+const usageSchema = z.object({
+	input: count.optional(),
+	output: count.optional(),
+	cacheRead: count.optional(),
+	cacheWrite: count.optional(),
+	totalTokens: count.optional(),
+	cost: z.object({
+		input: count.optional(),
+		output: count.optional(),
+		cacheRead: count.optional(),
+		cacheWrite: count.optional(),
+		total: count.optional()
+	}).nullable().optional()
+});
+/** One provider attempt, independent of whether its response becomes a chat message. */
+const requestMetricSchema = z.object({
+	id: z.string(),
+	provider: z.string(),
+	model: z.string(),
+	startedAt: count,
+	completedAt: count.optional(),
+	durationMs: count.optional(),
+	firstTokenMs: count.optional(),
+	outputDurationMs: count.optional(),
+	status: z.enum([
+		"running",
+		"completed",
+		"failed",
+		"interrupted"
+	]),
+	usage: usageSchema.nullable().optional(),
+	omitted: z.boolean().optional(),
+	imageToText: z.object({
+		calls: count,
+		durationMs: count,
+		usage: usageSchema.nullable(),
+		unknownUsageCalls: count
+	}).optional()
+});
+const toolMetricsSchema = z.object({
+	calls: count,
+	errors: count,
+	timedCalls: count,
+	activeMs: count.nullable()
+});
+z.object({
+	version: z.literal(1),
+	executionStartedAt: count.optional(),
+	requests: z.record(z.string(), requestMetricSchema).optional(),
+	retryWaitMs: count.optional(),
+	retryCount: count.optional(),
+	tools: toolMetricsSchema.optional(),
+	imageToText: z.object({
+		durationMs: count.nullable(),
+		timedCalls: count
+	}).optional()
+});
+function metricsRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-const BOARD_BUILTIN_CAPABILITIES = [...BOARD_BUILTIN_CLIP_KINDS.map((id) => {
-	const schema = clipSchema(id);
+const optionalCount = count.nullable();
+/** Additive facts only. Rates are computed from matching samples, never averaged averages. */
+const executionStatsSchema = z.object({
+	turns: count,
+	generations: count,
+	calls: optionalCount,
+	failedCalls: optionalCount,
+	unknownUsageCalls: count,
+	toolCalls: optionalCount,
+	toolErrors: optionalCount,
+	elapsedMs: optionalCount,
+	queueMs: optionalCount,
+	modelMs: optionalCount,
+	toolMs: optionalCount,
+	retryCount: optionalCount,
+	retryWaitMs: optionalCount,
+	ttftMs: count,
+	ttftSamples: count,
+	outputMs: count,
+	timedOutputTokens: count,
+	compactions: count,
+	compactionMs: optionalCount,
+	compactionUsage: usageSchema.nullable(),
+	imageToTextCalls: count,
+	imageToTextMs: optionalCount,
+	usage: usageSchema.nullable(),
+	modelCostUsd: optionalCount,
+	generationCostUsd: optionalCount,
+	/** Shared statistics never expose actual charges. */
+	chargedCostUsd: z.null().default(null),
+	partial: z.boolean()
+});
+const sessionStatsSchema = z.object({
+	version: z.literal(1),
+	updatedAt: z.string(),
+	revision: count,
+	own: executionStatsSchema,
+	inherited: executionStatsSchema,
+	auxiliaryUsage: usageSchema.nullable()
+});
+const normalizeExecutionStatsAliases = (value) => {
+	const record = metricsRecord(value);
+	const modelAlias = !Object.hasOwn(record, "modelCostUsd") && Object.hasOwn(record, "estimatedCostUsd");
+	const generationAlias = !Object.hasOwn(record, "generationCostUsd") && Object.hasOwn(record, "providerCostUsd");
+	if (!modelAlias && !generationAlias) return value;
 	return {
-		kind: "clip",
-		id,
-		version: 1,
-		renderers: ["webgpu", "webgl"],
-		...schema ? { schema } : {}
+		...record,
+		...modelAlias ? { modelCostUsd: record.estimatedCostUsd } : {},
+		...generationAlias ? { generationCostUsd: record.providerCostUsd } : {}
 	};
-}), ...BOARD_BUILTIN_EFFECT_KINDS.map((id) => {
-	const schema = effectSchema(id);
+};
+function sanitizeSessionStatsMeta(meta) {
+	const source = metricsRecord(meta);
+	if (!source.stats || typeof source.stats !== "object" || Array.isArray(source.stats)) return meta;
+	const stats = metricsRecord(source.stats);
+	const stripCharge = (value) => {
+		const record = metricsRecord(value);
+		return Object.hasOwn(record, "chargedCostUsd") && record.chargedCostUsd !== null ? {
+			...record,
+			chargedCostUsd: null
+		} : value;
+	};
+	const own = stripCharge(stats.own);
+	const inherited = stripCharge(stats.inherited);
+	if (own === stats.own && inherited === stats.inherited) return meta;
 	return {
-		kind: "effect",
-		id,
-		version: 1,
-		renderers: ["webgpu", "webgl"],
-		...schema ? { schema } : {}
+		...source,
+		stats: {
+			...stats,
+			own,
+			inherited
+		}
 	};
-})];
+}
+function readSessionStats(meta) {
+	const raw = metricsRecord(sanitizeSessionStatsMeta(meta)).stats;
+	const record = metricsRecord(raw);
+	const own = normalizeExecutionStatsAliases(record.own);
+	const inherited = normalizeExecutionStatsAliases(record.inherited);
+	const normalized = own === record.own && inherited === record.inherited ? raw : {
+		...record,
+		own,
+		inherited
+	};
+	const result = sessionStatsSchema.safeParse(normalized);
+	return result.success ? result.data : null;
+}
+//#endregion
+//#region ../protocol/dist/display/index.js
 /**
-* Where a connection meets its node.
-*
-* - `auto` — the side is chosen from the live geometry of both endpoints, so the
-*   connection stays sensible through any move or resize. This is the default and
-*   what almost every connection should use.
-* - `side` — the user pinned a side; `offset` (0..1) positions it along that edge.
-* - `fixed` — the user pinned an exact normalized point on the frame.
+* Displays: a machine's screens, shared with people over WebRTC and with
+* agents as stills and input. Mirrored in Go by `apps/sandbox/display` and
+* `apps/sandbox/rtc`, and in Kotlin by the Android display provider; the
+* vocabulary and limits below are generated into both
+* (`pnpm --filter @cohub/protocol generate:display`).
 *
-* `auto` is a *declaration of intent*, not a computed value: the resolved side is
-* never written back, so the connection keeps adapting instead of freezing the
-* first layout it happened to have.
+* Coordinates are normalized to the display (0..1, origin top-left), so
+* viewers and agents never need its pixel size to act on it.
 */
-const BoardConnectionAnchorSchema = z.union([
-	z.object({ kind: z.literal("auto") }),
-	z.object({
-		kind: z.literal("side"),
-		side: z.enum([
-			"top",
-			"right",
-			"bottom",
-			"left"
-		]),
-		offset: z.number().finite().min(0).max(1).default(.5)
-	}),
-	z.object({
-		kind: z.literal("fixed"),
-		nx: z.number().finite().min(0).max(1),
-		ny: z.number().finite().min(0).max(1)
-	})
-]);
-const BoardConnectionEndpointSchema = z.object({
-	itemId: z.string().min(1).max(160),
-	/** Optional semantic port. Older connections omit it and remain valid. */
-	portId: z.string().min(1).max(120).optional(),
-	anchor: BoardConnectionAnchorSchema.default({ kind: "auto" })
+const unit = z.number().min(0).max(1);
+const displayIdSchema = z.string().regex(/^[A-Za-z0-9._-]{1,64}$/);
+const DISPLAY_DIMENSION_MAX = 16384;
+const DISPLAY_SYSTEM_ACTIONS = [
+	"back",
+	"home",
+	"recents",
+	"notifications",
+	"quickSettings",
+	"lock"
+];
+const DISPLAY_PERMISSIONS = ["screenRecording", "accessibility"];
+const DISPLAY_POINTER_ACTIONS = [
+	"down",
+	"move",
+	"up",
+	"cancel"
+];
+const DISPLAY_KEY_ACTIONS = [
+	"down",
+	"up",
+	"press"
+];
+const DISPLAY_BUTTONS = [
+	"primary",
+	"secondary",
+	"middle"
+];
+/** A list of known names; names a newer machine adds are dropped, so older clients keep working. */
+const knownNames = (names, max) => z.array(z.string().max(32)).max(max).transform((values) => values.filter((value) => names.includes(value)));
+const displayViewerSchema = z.object({
+	userId: z.string().min(1).max(64),
+	control: z.boolean().optional()
 });
-/**
-* Which ends carry an arrowhead.
-*
-* This is the *semantic* direction, not a style flag: `forward` means the
-* relation reads source → target, `backward` means target → source, and `none`
-* means the relation is symmetric. Renderers derive arrowheads from it, so the
-* drawing can never disagree with the meaning.
-*/
-const BOARD_CONNECTION_DIRECTIONS = [
-	"none",
-	"forward",
-	"backward",
-	"both"
+const displayInfoSchema = z.object({
+	id: displayIdSchema,
+	name: z.string().max(200),
+	width: z.number().int().min(0).max(DISPLAY_DIMENSION_MAX),
+	height: z.number().int().min(0).max(DISPLAY_DIMENSION_MAX),
+	stream: z.boolean(),
+	capture: z.boolean(),
+	input: z.boolean(),
+	system: knownNames(DISPLAY_SYSTEM_ACTIONS, 16).optional(),
+	desktop: z.boolean().optional(),
+	tree: z.boolean().optional(),
+	needs: knownNames(DISPLAY_PERMISSIONS, 8).optional(),
+	viewers: z.array(displayViewerSchema).max(16).optional()
+});
+z.object({ displays: z.array(displayInfoSchema).max(16) });
+z.object({ size: z.string().regex(/^\d{3,4}x\d{3,4}$/).optional() });
+const DISPLAY_ELEMENT_ROLES = [
+	"window",
+	"dialog",
+	"group",
+	"list",
+	"listItem",
+	"text",
+	"heading",
+	"image",
+	"button",
+	"link",
+	"textField",
+	"checkbox",
+	"radio",
+	"switch",
+	"slider",
+	"tab",
+	"menu",
+	"menuItem",
+	"web",
+	"other"
 ];
-/** How the line travels between its two resolved endpoints. */
-const BOARD_CONNECTION_ROUTINGS = [
-	"straight",
-	"curve",
-	"orthogonal"
+const DISPLAY_ELEMENT_STATES = [
+	"focused",
+	"selected",
+	"checked",
+	"disabled",
+	"editable",
+	"password",
+	"scrollable",
+	"expanded"
 ];
-const BOARD_CONNECTION_LINES = ["solid", "dashed"];
-/**
-* Relation kind — a free-form slug, not an enum.
-*
-* Boards are used for domains we do not control, so a closed vocabulary would
-* force unrelated meanings into the wrong bucket. The format is constrained
-* (lowercase, dash/dot separated) so relations stay comparable and queryable
-* across clients instead of accumulating near-duplicate spellings.
-*/
-const BoardRelationSchema = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/, "relation must be a lowercase slug").default("related");
-/**
-* Waypoints a user dragged the line through, in world space.
-*
-* Stored because they are *input*, not output: the resolved path is recomputed
-* from them on every read, but the intent behind a hand-routed line cannot be
-* recovered once discarded.
-*/
-const BoardConnectionWaypointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite()
+const DISPLAY_ELEMENT_ACTIONS = [
+	"click",
+	"longPress",
+	"focus",
+	"setText",
+	"scrollForward",
+	"scrollBackward"
+];
+const DISPLAY_ELEMENT_REF_PATTERN = /^e\d{1,9}\.\d{1,5}$/;
+const DISPLAY_TREE_MAX_ELEMENTS = 1e3;
+const displayElementSchema = z.object({
+	ref: z.string().regex(DISPLAY_ELEMENT_REF_PATTERN),
+	depth: z.number().int().min(0).max(64),
+	role: z.string().max(32).transform((role) => DISPLAY_ELEMENT_ROLES.includes(role) ? role : "other"),
+	name: z.string().max(500).optional(),
+	/** The current text of a field; never reported for passwords. */
+	value: z.string().max(500).optional(),
+	bounds: z.tuple([
+		unit,
+		unit,
+		unit,
+		unit
+	]),
+	states: knownNames(DISPLAY_ELEMENT_STATES, 16).optional(),
+	actions: knownNames(DISPLAY_ELEMENT_ACTIONS, 16).optional()
 });
-const BoardConnectionRoutingSchema = z.object({
-	kind: z.enum(BOARD_CONNECTION_ROUTINGS).default("curve"),
-	/** Curve bow as a fraction of endpoint distance (-0.85..0.85). */
-	bend: z.number().finite().min(-.85).max(.85).default(0),
-	waypoints: z.array(BoardConnectionWaypointSchema).max(64).default([])
+z.object({
+	maxElements: z.number().int().min(1).max(DISPLAY_TREE_MAX_ELEMENTS).optional(),
+	actionable: z.boolean().optional()
 });
-const BoardConnectionStyleSchema = z.object({
-	/** Palette color id, resolved to a theme token at render time. */
-	color: z.string().min(1).max(40).default("brand"),
-	size: z.number().finite().positive().default(BOARD_CONNECTION_STROKE_SIZE),
-	line: z.enum(BOARD_CONNECTION_LINES).default("solid")
+z.object({
+	width: z.number().int().min(0).max(DISPLAY_DIMENSION_MAX),
+	height: z.number().int().min(0).max(DISPLAY_DIMENSION_MAX),
+	elements: z.array(displayElementSchema).max(DISPLAY_TREE_MAX_ELEMENTS),
+	truncated: z.boolean().optional()
 });
-const DEFAULT_BOARD_CONNECTION_ROUTING = {
-	kind: "curve",
-	bend: 0,
-	waypoints: []
-};
-const DEFAULT_BOARD_CONNECTION_STYLE = {
-	color: "brand",
-	size: BOARD_CONNECTION_STROKE_SIZE,
-	line: "solid"
-};
-const BoardConnectionSchema = z.object({
-	id: z.string().min(1).max(160),
-	source: BoardConnectionEndpointSchema,
-	target: BoardConnectionEndpointSchema,
-	relation: BoardRelationSchema,
-	direction: z.enum(BOARD_CONNECTION_DIRECTIONS).default("forward"),
-	label: z.string().max(280).default(""),
-	routing: BoardConnectionRoutingSchema.default(DEFAULT_BOARD_CONNECTION_ROUTING),
-	style: BoardConnectionStyleSchema.default(DEFAULT_BOARD_CONNECTION_STYLE),
-	metadata: z.record(z.string(), z.unknown()).default({})
-}).strict();
-/**
-* A patch to an existing connection.
-*
-* `id` is excluded: a connection's identity never changes, and re-pointing both
-* endpoints is an edit of the same relation, not a new one.
-*/
-const BoardConnectionPatchSchema = BoardConnectionSchema.omit({ id: true }).partial();
-//#endregion
-//#region ../protocol/dist/board-composition.js
-const idSchema$2 = z.string().min(1).max(160);
-const finiteSchema$1 = z.number().finite();
-const jsonObjectSchema$2 = z.record(z.string(), z.unknown());
-const BoardEasingSchema = z.enum([
-	"linear",
-	"ease-in-quad",
-	"ease-out-quad",
-	"ease-in-out-quad",
-	"ease-in-cubic",
-	"ease-out-cubic",
-	"ease-in-out-cubic",
-	"ease-out-quart",
-	"ease-out-expo"
-]);
-const BoardAnimationTargetSchema = z.discriminatedUnion("type", [
+const DISPLAY_INPUT_MAX_TEXT = 4096;
+const DISPLAY_INPUT_MAX_SCHEDULE_MS = 6e4;
+const delta = z.number().min(-10).max(10);
+const at = z.number().int().min(0).max(DISPLAY_INPUT_MAX_SCHEDULE_MS).optional();
+const displayInputEventSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("pointer"),
+		action: z.enum(DISPLAY_POINTER_ACTIONS),
+		x: unit,
+		y: unit,
+		button: z.enum(DISPLAY_BUTTONS).optional(),
+		t: at
+	}),
+	z.object({
+		type: z.literal("scroll"),
+		x: unit,
+		y: unit,
+		dx: delta.optional(),
+		dy: delta.optional(),
+		t: at
+	}),
+	z.object({
+		type: z.literal("key"),
+		action: z.enum(DISPLAY_KEY_ACTIONS),
+		key: z.string().min(1).max(64),
+		t: at
+	}),
+	z.object({
+		type: z.literal("text"),
+		text: z.string().min(1).max(DISPLAY_INPUT_MAX_TEXT),
+		t: at
+	}),
 	z.object({
-		type: z.literal("item"),
-		itemId: idSchema$2
-	}).strict(),
+		type: z.literal("system"),
+		action: z.enum(DISPLAY_SYSTEM_ACTIONS),
+		t: at
+	}),
 	z.object({
-		type: z.literal("effect"),
-		effectId: idSchema$2
-	}).strict(),
-	z.object({ type: z.literal("camera") }).strict(),
-	z.object({ type: z.literal("board") }).strict()
+		type: z.literal("element"),
+		ref: z.string().regex(DISPLAY_ELEMENT_REF_PATTERN),
+		action: z.enum(DISPLAY_ELEMENT_ACTIONS),
+		text: z.string().max(DISPLAY_INPUT_MAX_TEXT).optional(),
+		t: at
+	})
 ]);
-const vector2Schema = z.object({
-	x: finiteSchema$1,
-	y: finiteSchema$1
-}).strict();
-const scaleSchema = z.union([finiteSchema$1.nonnegative(), z.object({
-	x: finiteSchema$1.nonnegative(),
-	y: finiteSchema$1.nonnegative()
-}).strict()]);
-const BOARD_ANIMATION_CHANNELS = {
-	"transform.translation": {
-		targets: ["item"],
-		value: vector2Schema,
-		interpolations: ["linear", "step"],
-		coordinateSpace: "world-offset",
-		unit: "board"
-	},
-	"transform.rotation": {
-		targets: ["item"],
-		value: finiteSchema$1,
-		interpolations: ["linear", "step"],
-		unit: "radian"
-	},
-	"transform.scale": {
-		targets: ["item"],
-		value: scaleSchema,
-		interpolations: ["linear", "step"],
-		unit: "ratio"
-	},
-	"style.opacity": {
-		targets: ["item"],
-		value: finiteSchema$1.min(0).max(1),
-		interpolations: ["linear", "step"],
-		unit: "ratio"
-	}
-};
-const BoardTrackKeyframeSchema = z.object({
-	time: finiteSchema$1.nonnegative(),
-	value: z.unknown(),
-	easing: BoardEasingSchema.optional()
-}).strict();
-const BoardTrackSchema = z.object({
-	id: idSchema$2,
-	target: BoardAnimationTargetSchema,
-	channel: z.string().min(1).max(160),
-	channelVersion: z.number().int().positive().default(1),
-	interpolation: z.enum(["linear", "step"]).default("linear"),
-	fill: z.enum([
-		"none",
-		"backwards",
-		"forwards",
-		"both"
-	]).default("none"),
-	keyframes: z.array(BoardTrackKeyframeSchema).min(1).max(1e5),
-	metadata: jsonObjectSchema$2.default({})
-}).strict().superRefine((track, context) => {
-	let previous = -1;
-	for (const [index, keyframe] of track.keyframes.entries()) {
-		if (keyframe.time <= previous) context.addIssue({
-			code: "custom",
-			message: "keyframe times must be strictly increasing",
-			path: [
-				"keyframes",
-				index,
-				"time"
-			]
-		});
-		previous = keyframe.time;
-	}
-	const channel = BOARD_ANIMATION_CHANNELS[track.channel];
-	if (!channel) {
-		if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){2,}$/.test(track.channel)) context.addIssue({
-			code: "custom",
-			message: `unknown channel: ${track.channel}`,
-			path: ["channel"]
-		});
-		return;
-	}
-	if (!channel.targets.includes(track.target.type)) context.addIssue({
-		code: "custom",
-		message: `${track.channel} cannot target ${track.target.type}`,
-		path: ["target"]
-	});
-	if (!channel.interpolations.includes(track.interpolation)) context.addIssue({
-		code: "custom",
-		message: `${track.channel} does not support ${track.interpolation} interpolation`,
-		path: ["interpolation"]
-	});
-	for (const [index, keyframe] of track.keyframes.entries()) {
-		const parsed = channel.value.safeParse(keyframe.value);
-		if (!parsed.success) context.addIssue({
-			code: "custom",
-			message: parsed.error.issues[0]?.message ?? `invalid value for ${track.channel}`,
-			path: [
-				"keyframes",
-				index,
-				"value"
-			]
-		});
-	}
-});
-const extensionKindSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
-const BoardProceduralClipSchema = z.object({
-	id: idSchema$2,
-	kind: extensionKindSchema,
-	kindVersion: z.number().int().positive(),
-	target: BoardAnimationTargetSchema,
-	start: finiteSchema$1.nonnegative(),
-	duration: finiteSchema$1.positive(),
-	layer: z.enum([
-		"behind",
-		"content",
-		"front",
-		"screen"
-	]).default("content"),
-	fill: z.enum([
-		"none",
-		"backwards",
-		"forwards",
-		"both"
-	]).default("none"),
-	easing: BoardEasingSchema.default("linear"),
-	params: jsonObjectSchema$2.default({}),
-	assetRefs: z.array(z.object({
-		type: z.enum(["space-file", "extension"]),
-		ref: z.string().min(1).max(4096),
-		digest: z.string().min(16).max(160).optional()
-	}).strict()).default([]),
-	seed: idSchema$2,
-	metadata: jsonObjectSchema$2.default({})
-}).strict();
-const BoardTimelineMarkerSchema = z.object({
-	id: idSchema$2,
-	time: finiteSchema$1.nonnegative(),
-	duration: finiteSchema$1.nonnegative().optional(),
-	metadata: jsonObjectSchema$2.default({})
-}).strict();
-const BoardTimelineSchema = z.object({
-	duration: finiteSchema$1.nonnegative(),
-	tracks: z.array(BoardTrackSchema).max(5e4).default([]),
-	clips: z.array(BoardProceduralClipSchema).max(5e4).default([]),
-	markers: z.array(BoardTimelineMarkerSchema).max(1e4).default([])
-}).strict().superRefine((timeline, context) => {
-	const ids = /* @__PURE__ */ new Set();
-	const channels = /* @__PURE__ */ new Set();
-	for (const [index, track] of timeline.tracks.entries()) {
-		if (ids.has(track.id)) context.addIssue({
-			code: "custom",
-			message: `duplicate timeline id: ${track.id}`,
-			path: [
-				"tracks",
-				index,
-				"id"
-			]
-		});
-		ids.add(track.id);
-		const targetId = track.target.type === "item" ? track.target.itemId : track.target.type === "effect" ? track.target.effectId : track.target.type;
-		const key = `${track.target.type}:${targetId}:${track.channel}`;
-		if (channels.has(key)) context.addIssue({
+z.object({ events: z.array(displayInputEventSchema).min(1).max(512) }).superRefine(({ events }, ctx) => {
+	let last = 0;
+	events.forEach((event, index) => {
+		if (event.type === "scroll" && !event.dx && !event.dy) ctx.addIssue({
 			code: "custom",
-			message: `multiple tracks control ${key}`,
-			path: [
-				"tracks",
-				index,
-				"channel"
-			]
+			path: ["events", index],
+			message: "scroll needs dx or dy"
 		});
-		channels.add(key);
-		for (const [keyframeIndex, keyframe] of track.keyframes.entries()) if (keyframe.time > timeline.duration) context.addIssue({
+		if (event.type === "element" && event.action === "setText" !== (event.text !== void 0)) ctx.addIssue({
 			code: "custom",
-			message: "keyframe exceeds timeline duration",
 			path: [
-				"tracks",
+				"events",
 				index,
-				"keyframes",
-				keyframeIndex,
-				"time"
-			]
+				"text"
+			],
+			message: "text goes with setText only"
 		});
-	}
-	for (const [index, clip] of timeline.clips.entries()) {
-		if (ids.has(clip.id)) context.addIssue({
+		if (event.t === void 0) return;
+		if (event.t < last) ctx.addIssue({
 			code: "custom",
-			message: `duplicate timeline id: ${clip.id}`,
 			path: [
-				"clips",
+				"events",
 				index,
-				"id"
-			]
+				"t"
+			],
+			message: "t must ascend"
 		});
-		ids.add(clip.id);
-		if (clip.start + clip.duration > timeline.duration) context.addIssue({
-			code: "custom",
-			message: "clip exceeds timeline duration",
-			path: [
-				"clips",
-				index,
-				"duration"
-			]
-		});
-	}
-	for (const [index, marker] of timeline.markers.entries()) {
-		if (ids.has(marker.id)) context.addIssue({
-			code: "custom",
-			message: `duplicate timeline id: ${marker.id}`,
-			path: [
-				"markers",
-				index,
-				"id"
-			]
-		});
-		ids.add(marker.id);
-		if (marker.time + (marker.duration ?? 0) > timeline.duration) context.addIssue({
-			code: "custom",
-			message: "marker exceeds timeline duration",
-			path: ["markers", index]
-		});
-	}
-});
-const BoardCompositionPlaybackSchema = z.object({
-	loop: z.boolean().default(false),
-	endBehavior: z.enum(["hold", "reset"]).default("hold"),
-	reducedMotion: z.discriminatedUnion("mode", [
-		z.object({ mode: z.literal("base") }).strict(),
-		z.object({
-			mode: z.literal("time"),
-			time: finiteSchema$1.nonnegative()
-		}).strict(),
-		z.object({
-			mode: z.literal("marker"),
-			markerId: idSchema$2
-		}).strict()
-	]).default({ mode: "base" })
-}).strict();
-const compositionFields = {
-	id: idSchema$2,
-	name: z.string().min(1).max(255),
-	timeline: BoardTimelineSchema,
-	playback: BoardCompositionPlaybackSchema.default({
-		loop: false,
-		endBehavior: "hold",
-		reducedMotion: { mode: "base" }
-	}),
-	metadata: jsonObjectSchema$2.default({})
-};
-function validateCompositionFallback(composition, context) {
-	const fallback = composition.playback.reducedMotion;
-	if (fallback.mode === "time" && fallback.time > composition.timeline.duration) context.addIssue({
-		code: "custom",
-		message: "reduced-motion time exceeds timeline duration",
-		path: [
-			"playback",
-			"reducedMotion",
-			"time"
-		]
-	});
-	if (fallback.mode === "marker" && !composition.timeline.markers.some((marker) => marker.id === fallback.markerId)) context.addIssue({
-		code: "custom",
-		message: `marker does not exist: ${fallback.markerId}`,
-		path: [
-			"playback",
-			"reducedMotion",
-			"markerId"
-		]
+		last = event.t;
 	});
+});
+z.object({
+	format: z.enum(["jpeg", "png"]).optional(),
+	quality: z.number().int().min(1).max(100).optional(),
+	maxSize: z.number().int().min(1).max(DISPLAY_DIMENSION_MAX).optional()
+});
+z.object({
+	urls: z.union([z.string().min(1).max(512), z.array(z.string().min(1).max(512)).min(1).max(16)]),
+	username: z.string().max(512).optional(),
+	credential: z.string().max(512).optional()
+});
+z.object({
+	offer: z.string().min(1).max(65536),
+	control: z.boolean().optional()
+});
+const DISPLAY_CONTROL_CHANNEL = "control";
+const DISPLAY_INPUT_CHANNEL = "input";
+const DISPLAY_PING_INTERVAL_MS = 5e3;
+function normalizeDisplayPoint(x, y, width, height) {
+	const unit = (value, extent) => Math.min(1, Math.max(0, extent > 1 ? value / (extent - 1) : 0));
+	return {
+		x: unit(x, width),
+		y: unit(y, height)
+	};
 }
-const BoardCompositionInputSchema = z.object(compositionFields).strict().superRefine(validateCompositionFallback);
-const BoardCompositionSchema = z.object({
-	...compositionFields,
-	revision: z.number().int().nonnegative().default(0)
-}).strict().superRefine(validateCompositionFallback);
-/**
-* Accept inspect/get output as apply input while stripping server-owned
-* `revision`. Anything else that looks server-owned (or simply unknown) fails
-* with a pointer at the offending key, so a get → edit → apply round-trip that
-* accidentally carries runtime fields names the culprit instead of a bare
-* "Unrecognized key".
-*/
-function parseBoardCompositionInput(value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const { revision: _revision, ...input } = value;
-		const result = BoardCompositionInputSchema.safeParse(input);
-		if (!result.success) {
-			const issue = result.error.issues.find((item) => item.code === "unrecognized_keys");
-			if (issue) throw new Error(`unknown field in composition input: ${issue.message}. Server-owned fields such as revision are stripped automatically; remove other fields not part of the composition schema`);
-			throw result.error;
+function splitDisplayText(text, max = DISPLAY_INPUT_MAX_TEXT) {
+	const pieces = [];
+	let piece = "";
+	for (const char of text) {
+		if (piece.length + char.length > max) {
+			pieces.push(piece);
+			piece = "";
 		}
-		return result.data;
+		piece += char;
 	}
-	return BoardCompositionInputSchema.parse(value);
+	if (piece) pieces.push(piece);
+	return pieces;
 }
-const BOARD_ANIMATION_CHANNEL_CAPABILITIES = Object.entries(BOARD_ANIMATION_CHANNELS).map(([id, definition]) => ({
-	id,
-	version: 1,
-	targets: definition.targets,
-	interpolations: definition.interpolations,
-	..."coordinateSpace" in definition ? { coordinateSpace: definition.coordinateSpace } : {},
-	..."unit" in definition ? { unit: definition.unit } : {},
-	valueSchema: z.toJSONSchema(definition.value)
-}));
-//#endregion
-//#region ../protocol/dist/board-effect.js
-/**
-* Board effect schema, isolated so `board-authoring.ts` can reuse the exact
-* definition without a runtime cycle through `board.ts`. One definition, one
-* strictness level — semantic mutations and Board create must not drift apart.
-*/
-const idSchema$1 = z.string().min(1).max(160);
-const extensionIdSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
-const jsonObjectSchema$1 = z.record(z.string(), z.unknown());
-const BoardAssetRefSchema = z.object({
-	type: z.enum(["space-file", "extension"]),
-	ref: z.string().min(1).max(4096),
-	digest: z.string().min(16).max(160).optional()
-}).strict();
-const BoardEffectSchema = z.object({
-	id: idSchema$1,
-	boardId: z.string().uuid(),
-	target: z.discriminatedUnion("type", [z.object({
-		type: z.literal("item"),
-		itemId: idSchema$1
-	}).strict(), z.object({ type: z.literal("board") }).strict()]),
-	kind: extensionIdSchema,
-	kindVersion: z.number().int().positive().default(1),
-	enabled: z.boolean().default(true),
-	lifecycle: z.enum([
-		"persistent",
-		"when-visible",
-		"manual",
-		"on-enter"
-	]),
-	timeOrigin: z.enum([
-		"board",
-		"visible",
-		"activation"
-	]),
-	layer: z.enum([
-		"behind",
-		"front",
-		"screen"
-	]).default("front"),
-	seed: z.string().min(1).max(160),
-	params: jsonObjectSchema$1.default({}),
-	assetRefs: z.array(BoardAssetRefSchema).default([]),
-	metadata: jsonObjectSchema$1.default({}),
-	revision: z.number().int().nonnegative()
-}).strict();
-/** The client-authored effect form: no server-owned `boardId`/`revision`. */
-const BoardEffectInputSchema = BoardEffectSchema.omit({
-	boardId: true,
-	revision: true
-});
-/** Accept a read projection in a write command while stripping server fields. */
-function parseBoardEffectInput(value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const { boardId: _boardId, revision: _revision, ...input } = value;
-		return BoardEffectInputSchema.parse(input);
-	}
-	return BoardEffectInputSchema.parse(value);
-}
-//#endregion
-//#region ../protocol/dist/board-authoring.js
-const BOARD_AUTHORING_COLOR_IDS = [
-	"brand",
-	"neutral",
-	"black",
-	"white",
-	"blue",
-	"green",
-	"amber",
-	"violet",
-	"rose"
-];
-const BOARD_AUTHORING_GEO_KINDS = [
-	"rectangle",
-	"rounded",
-	"ellipse",
-	"diamond",
-	"triangle"
-];
-const idSchema = z.string().min(1).max(160);
-const jsonObjectSchema = z.record(z.string(), z.unknown());
-const finiteSchema = z.number().finite();
-const extensionTypeSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
-const BoardAuthoringPositionSchema = z.object({
-	x: finiteSchema,
-	y: finiteSchema
-}).strict();
-const BoardAuthoringSizeSchema = z.object({
-	width: finiteSchema.positive(),
-	height: finiteSchema.positive()
-}).strict();
-const BoardAuthoringPositionPatchSchema = z.object({
-	x: finiteSchema.optional(),
-	y: finiteSchema.optional()
-}).strict();
-const pointSchema = z.object({
-	x: finiteSchema,
-	y: finiteSchema,
-	p: finiteSchema.min(0).max(1).default(.5)
-}).strict();
-const worldPointSchema = z.object({
-	x: finiteSchema,
-	y: finiteSchema
-}).strict();
-const cropSchema = z.object({
-	x: finiteSchema.min(0).max(1),
-	y: finiteSchema.min(0).max(1),
-	w: finiteSchema.min(0).max(1),
-	h: finiteSchema.min(0).max(1)
-}).strict();
-const BoardItemStyleSchema = z.object({
-	color: z.enum(BOARD_AUTHORING_COLOR_IDS).optional(),
-	strokeWidth: finiteSchema.min(1).max(64).optional(),
-	fillOpacity: finiteSchema.min(0).max(1).optional()
-}).strict();
-const sourceSnapshotSchema = z.record(z.string(), z.unknown());
-function isSafeBoardSourcePath(value) {
-	return value.length > 0 && value.length <= 4096 && !value.startsWith("/") && !value.startsWith("\\") && !value.includes("\\") && value.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
-}
-const BoardItemSourceSchema = z.object({
-	kind: z.literal("space-file"),
-	path: z.string().refine(isSafeBoardSourcePath, "source path must be a safe relative Board file path"),
-	snapshot: sourceSnapshotSchema.optional()
-}).strict();
-const sizedBaseFields = {
-	id: idSchema,
-	position: BoardAuthoringPositionSchema.default({
-		x: 0,
-		y: 0
-	}),
-	rotation: finiteSchema.default(0),
-	parentId: idSchema.nullable().optional(),
-	locked: z.boolean().optional(),
-	metadata: jsonObjectSchema.optional(),
-	size: BoardAuthoringSizeSchema.optional()
-};
-const styledBaseFields = {
-	...sizedBaseFields,
-	style: BoardItemStyleSchema.optional()
-};
-const { position: _positionField, size: _sizeField, ...strokeBaseFields } = sizedBaseFields;
-const strokeStyledBaseFields = {
-	...strokeBaseFields,
-	rotation: z.literal(0).default(0),
-	style: BoardItemStyleSchema.optional()
-};
-const BoardTextAuthoringItemSchema = z.object({
-	...styledBaseFields,
-	type: z.literal("text"),
-	props: z.object({
-		text: z.string().default(""),
-		fontSize: finiteSchema.min(2).max(512).default(24)
-	}).strict()
-}).strict();
-const BoardGeoAuthoringItemSchema = z.object({
-	...styledBaseFields,
-	type: z.literal("geo"),
-	props: z.object({
-		shape: z.enum(BOARD_AUTHORING_GEO_KINDS).default("rectangle"),
-		text: z.string().default("")
-	}).strict()
-}).strict();
-const BoardDrawAuthoringItemSchema = z.object({
-	...strokeStyledBaseFields,
-	type: z.literal("draw"),
-	props: z.object({ points: z.array(pointSchema).min(1) }).strict()
-}).strict();
-const BoardArrowAuthoringItemSchema = z.object({
-	...strokeStyledBaseFields,
-	type: z.literal("arrow"),
-	props: z.object({
-		start: worldPointSchema,
-		end: worldPointSchema,
-		bend: finiteSchema.min(-.85).max(.85).default(0),
-		arrowStart: z.boolean().default(false),
-		arrowEnd: z.boolean().default(true),
-		label: z.string().default("")
-	}).strict()
-}).strict();
-const BoardFrameAuthoringItemSchema = z.object({
-	...styledBaseFields,
-	type: z.literal("frame"),
-	props: z.object({ label: z.string().default("Frame") }).strict()
-}).strict();
-const fileBackedFields = {
-	...sizedBaseFields,
-	style: z.object({}).strict().optional(),
-	source: BoardItemSourceSchema
-};
-const builtinItemSchemas = [
-	BoardTextAuthoringItemSchema,
-	BoardGeoAuthoringItemSchema,
-	BoardDrawAuthoringItemSchema,
-	BoardArrowAuthoringItemSchema,
-	BoardFrameAuthoringItemSchema,
-	z.object({
-		...fileBackedFields,
-		type: z.literal("image"),
-		props: z.object({ crop: cropSchema.optional() }).strict()
-	}).strict(),
-	z.object({
-		...fileBackedFields,
-		type: z.literal("video"),
-		props: z.object({}).strict()
-	}).strict(),
-	z.object({
-		...fileBackedFields,
-		type: z.literal("audio"),
-		props: z.object({}).strict()
-	}).strict(),
-	z.object({
-		...fileBackedFields,
-		type: z.literal("file"),
-		props: z.object({}).strict()
-	}).strict(),
-	z.object({
-		...sizedBaseFields,
-		type: z.literal("task"),
-		props: z.object({
-			taskRunId: z.string().min(1),
-			snapshot: z.record(z.string(), z.unknown())
-		}).strict(),
-		style: z.object({}).strict().optional()
-	}).strict()
-];
-const BoardBuiltinAuthoringItemSchema = z.discriminatedUnion("type", builtinItemSchemas);
-const BoardExtensionAuthoringItemSchema = z.object({
-	...sizedBaseFields,
-	type: extensionTypeSchema,
-	kindVersion: z.number().int().positive(),
-	props: jsonObjectSchema,
-	style: jsonObjectSchema.optional(),
-	source: z.object({
-		kind: z.string().min(1).max(80),
-		ref: z.string().min(1).max(4096),
-		snapshot: jsonObjectSchema.optional()
-	}).strict().optional()
-}).strict();
-const BoardAuthoringItemSchema = z.union([BoardBuiltinAuthoringItemSchema, BoardExtensionAuthoringItemSchema]);
-/** JSON Merge Patch semantics, constrained to the stable Item envelope. */
-const BoardItemPatchSchema = z.object({
-	position: BoardAuthoringPositionPatchSchema.optional(),
-	size: BoardAuthoringSizeSchema.nullable().optional(),
-	rotation: finiteSchema.optional(),
-	parentId: idSchema.nullable().optional(),
-	locked: z.boolean().nullable().optional(),
-	props: jsonObjectSchema.optional(),
-	style: jsonObjectSchema.nullable().optional(),
-	source: jsonObjectSchema.nullable().optional(),
-	metadata: jsonObjectSchema.nullable().optional()
-}).strict().refine((patch) => Object.keys(patch).length > 0, "item patch is empty");
-const BoardConnectionInputSchema = BoardConnectionSchema;
-const stripServerFields = (value) => {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-	const { boardId: _boardId, revision: _revision, ...input } = value;
-	return input;
-};
-const BoardEffectCommandInputSchema = z.preprocess(stripServerFields, BoardEffectInputSchema);
-const BoardCompositionCommandInputSchema = z.preprocess(stripServerFields, BoardCompositionInputSchema);
-const BoardSemanticCommandSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("board.patch"),
-		patch: z.object({
-			title: z.string().min(1).max(255).optional(),
-			metadata: jsonObjectSchema.nullable().optional(),
-			metadataPatch: jsonObjectSchema.optional()
-		}).strict().refine((patch) => Object.keys(patch).length > 0, "board patch is empty")
-	}).strict(),
-	z.object({
-		type: z.literal("item.create"),
-		item: BoardAuthoringItemSchema
-	}).strict(),
-	z.object({
-		type: z.literal("item.patch"),
-		itemId: idSchema,
-		patch: BoardItemPatchSchema
-	}).strict(),
-	z.object({
-		type: z.literal("item.replace"),
-		itemId: idSchema,
-		item: BoardAuthoringItemSchema
-	}).strict(),
-	z.object({
-		type: z.literal("item.delete"),
-		itemId: idSchema,
-		cascade: z.boolean().default(false)
-	}).strict(),
-	z.object({
-		type: z.literal("item.reorder"),
-		itemId: idSchema,
-		index: z.number().int().nonnegative()
-	}).strict(),
-	z.object({
-		type: z.literal("connection.create"),
-		connection: BoardConnectionInputSchema
-	}).strict(),
-	z.object({
-		type: z.literal("connection.patch"),
-		connectionId: idSchema,
-		patch: BoardConnectionPatchSchema
-	}).strict(),
-	z.object({
-		type: z.literal("connection.delete"),
-		connectionId: idSchema
-	}).strict(),
-	z.object({
-		type: z.literal("effect.apply"),
-		effect: BoardEffectCommandInputSchema
-	}).strict(),
-	z.object({
-		type: z.literal("effect.delete"),
-		effectId: idSchema
-	}).strict(),
-	z.object({
-		type: z.literal("composition.apply"),
-		composition: BoardCompositionCommandInputSchema
-	}).strict(),
-	z.object({
-		type: z.literal("composition.delete"),
-		compositionId: idSchema
-	}).strict()
-]);
-const BoardSemanticMutationSchema = z.object({
-	mutationId: idSchema,
-	baseVersion: z.number().int().nonnegative(),
-	clientId: idSchema.optional(),
-	undoGroupId: idSchema.optional(),
-	/** Validate (including server-side reference checks) without writing. */
-	dryRun: z.boolean().default(false),
-	commands: z.array(BoardSemanticCommandSchema).min(1).max(5e4)
-}).strict();
-z.object({
-	include: z.array(z.enum([
-		"items",
-		"connections",
-		"effects",
-		"compositions",
-		"playback"
-	])).optional(),
-	itemIds: z.array(idSchema).max(5e4).optional(),
-	connectionIds: z.array(idSchema).max(5e4).optional(),
-	effectIds: z.array(idSchema).max(5e4).optional(),
-	compositionIds: z.array(idSchema).max(5e4).optional(),
-	viewport: z.object({
-		x: finiteSchema,
-		y: finiteSchema,
-		width: finiteSchema.positive(),
-		height: finiteSchema.positive()
-	}).optional()
-}).strict();
 //#endregion
 //#region ../protocol/dist/space-hooks.js
 const SPACE_HOOK_WEBHOOK_SECRET_HEADER = "x-cohub-webhook-secret";
@@ -1472,14 +975,16 @@ var SearchApi = class {
 		for (const type of input.types ?? []) params.append("type", type);
 		if (input.spaceId) params.set("spaceId", input.spaceId);
 		if (input.labelRef) params.set("labelRef", input.labelRef);
-		if (input.groupTurns === false) params.set("groupTurns", "false");
 		return this.transport.request(`/api/search?${params.toString()}`, { fetch: customFetch });
 	}
 	/** Default (empty-query) command palette data: viewer-relative space signals. */
 	overview(input, customFetch) {
 		const params = new URLSearchParams();
 		if (input?.spaceLimit !== void 0) params.set("spaceLimit", String(input.spaceLimit));
-		if (input?.sessionLimit !== void 0) params.set("sessionLimit", String(input.sessionLimit));
+		for (const recent of input?.recentSpaces ?? []) {
+			params.append("recentSpaceId", recent.id);
+			params.append("recentSpaceAt", new Date(recent.timestamp).toISOString());
+		}
 		for (const spaceId of input?.recentSpaceIds ?? []) params.append("recentSpaceId", spaceId);
 		const query = params.toString();
 		return this.transport.request(`/api/palette/overview${query ? `?${query}` : ""}`, { fetch: customFetch });
@@ -1546,6 +1051,354 @@ function ensureRealtimeConnected(websocketClient) {
 	});
 }
 //#endregion
+//#region src/display-stats.ts
+const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+function perFrame(seconds, previousSeconds, frames, previousFrames) {
+	const count = frames - previousFrames;
+	return count > 0 ? Math.round((seconds - previousSeconds) * 1e3 / count) : null;
+}
+function readDisplayStats(report, previous, fallbackRttMs = null) {
+	const stats = {
+		path: null,
+		relayProtocol: null,
+		rttMs: fallbackRttMs,
+		fps: null,
+		bitrate: null,
+		width: null,
+		height: null,
+		jitterBufferMs: null,
+		decodeMs: null,
+		packetsLost: null,
+		freezes: null
+	};
+	let counters = null;
+	report.forEach((entry) => {
+		if (entry.type === "candidate-pair" && entry.nominated && entry.state === "succeeded") {
+			const local = report.get(String(entry.localCandidateId));
+			const remote = report.get(String(entry.remoteCandidateId));
+			stats.path = local?.candidateType === "relay" || remote?.candidateType === "relay" ? "relay" : "direct";
+			if (local?.candidateType === "relay" && typeof local.relayProtocol === "string") stats.relayProtocol = local.relayProtocol;
+			const rtt = num(entry.currentRoundTripTime);
+			if (rtt !== null) stats.rttMs = Math.round(rtt * 1e3);
+		}
+		if (entry.type === "inbound-rtp" && entry.kind === "video") {
+			stats.fps = num(entry.framesPerSecond);
+			stats.width = num(entry.frameWidth);
+			stats.height = num(entry.frameHeight);
+			stats.packetsLost = num(entry.packetsLost);
+			stats.freezes = num(entry.freezeCount);
+			counters = {
+				at: num(entry.timestamp) ?? 0,
+				bytes: num(entry.bytesReceived) ?? 0,
+				jitterBufferDelay: num(entry.jitterBufferDelay) ?? 0,
+				jitterBufferEmitted: num(entry.jitterBufferEmittedCount) ?? 0,
+				decodeTime: num(entry.totalDecodeTime) ?? 0,
+				decoded: num(entry.framesDecoded) ?? 0
+			};
+			if (previous && counters.at > previous.at) {
+				stats.bitrate = Math.round((counters.bytes - previous.bytes) * 8 * 1e3 / (counters.at - previous.at));
+				stats.jitterBufferMs = perFrame(counters.jitterBufferDelay, previous.jitterBufferDelay, counters.jitterBufferEmitted, previous.jitterBufferEmitted);
+				stats.decodeMs = perFrame(counters.decodeTime, previous.decodeTime, counters.decoded, previous.decoded);
+			}
+		}
+	});
+	return {
+		stats,
+		counters
+	};
+}
+//#endregion
+//#region src/display-session.ts
+const DEFAULT_GATHER_TIMEOUT_MS = 2e3;
+const DEFAULT_CONNECT_TIMEOUT_MS = 2e4;
+const INPUT_BACKLOG_BYTES = 65536;
+var DisplayConnection = class DisplayConnection {
+	api;
+	displayId;
+	control;
+	pc;
+	stream = new MediaStream();
+	currentState = "connecting";
+	currentDisplay = null;
+	reason = null;
+	sessionId = null;
+	listeners = /* @__PURE__ */ new Map();
+	controlChannel;
+	inputChannel;
+	pingTimer = null;
+	connectTimer = null;
+	pingId = 0;
+	lastPingAt = 0;
+	rtt = null;
+	counters = null;
+	isPaused = false;
+	constructor(api, displayId, control, pc) {
+		this.api = api;
+		this.displayId = displayId;
+		this.control = control;
+		this.pc = pc;
+		pc.addTransceiver("video", { direction: "recvonly" });
+		pc.ontrack = (event) => {
+			const receiver = event.receiver;
+			if ("jitterBufferTarget" in receiver) receiver.jitterBufferTarget = 0;
+			this.stream.addTrack(event.track);
+		};
+		pc.onconnectionstatechange = () => {
+			if (pc.connectionState === "connected") this.setState("connected");
+			else if (pc.connectionState === "failed") this.close("failed");
+		};
+		this.controlChannel = pc.createDataChannel(DISPLAY_CONTROL_CHANNEL);
+		this.controlChannel.onmessage = (event) => this.onControl(event.data);
+		this.controlChannel.onopen = () => {
+			if (this.isPaused) this.sendControl({ type: "pause" });
+			this.startPings();
+		};
+		this.controlChannel.onclose = () => this.close(this.reason ?? "closed");
+		this.inputChannel = control ? pc.createDataChannel(DISPLAY_INPUT_CHANNEL) : null;
+	}
+	static async open(api, displayId, options = {}) {
+		const { iceServers } = await api.iceServers({ signal: options.signal });
+		const pc = new RTCPeerConnection({
+			iceServers,
+			bundlePolicy: "max-bundle"
+		});
+		const connection = new DisplayConnection(api, displayId, options.control ?? true, pc);
+		try {
+			await pc.setLocalDescription(await pc.createOffer());
+			await gathered(pc, options.gatherTimeoutMs ?? DEFAULT_GATHER_TIMEOUT_MS, options.signal);
+			const offer = pc.localDescription?.sdp;
+			if (!offer) throw new Error("The browser produced no offer");
+			const session = await api.openSession(displayId, {
+				offer,
+				control: connection.control
+			}, { signal: options.signal });
+			connection.sessionId = session.sessionId;
+			await pc.setRemoteDescription({
+				type: "answer",
+				sdp: session.answer
+			});
+			connection.connectTimer = setTimeout(() => connection.close("connect_timeout"), options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
+			return connection;
+		} catch (error) {
+			connection.close("failed");
+			throw error;
+		}
+	}
+	get state() {
+		return this.currentState;
+	}
+	get display() {
+		return this.currentDisplay;
+	}
+	get closeReason() {
+		return this.currentState === "closed" ? this.reason : null;
+	}
+	on(event, listener) {
+		let set = this.listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(event, set);
+		}
+		set.add(listener);
+		return () => set.delete(listener);
+	}
+	emit(event, value) {
+		for (const listener of this.listeners.get(event) ?? []) listener(value);
+	}
+	setState(state) {
+		if (this.currentState === state || this.currentState === "closed") return;
+		this.currentState = state;
+		if (state === "connected" && this.connectTimer) {
+			clearTimeout(this.connectTimer);
+			this.connectTimer = null;
+		}
+		this.emit("state", state);
+	}
+	sendInput(events) {
+		const channel = this.inputChannel;
+		if (channel?.readyState !== "open" || events.length === 0) return false;
+		if (channel.bufferedAmount > INPUT_BACKLOG_BYTES && events.every((event) => event.type === "pointer" && event.action === "move")) return false;
+		channel.send(JSON.stringify({ events }));
+		return true;
+	}
+	requestKeyframe() {
+		this.sendControl({ type: "keyframe" });
+	}
+	get paused() {
+		return this.isPaused;
+	}
+	pause() {
+		if (this.isPaused) return;
+		this.isPaused = true;
+		this.sendControl({ type: "pause" });
+	}
+	resume() {
+		if (!this.isPaused) return;
+		this.isPaused = false;
+		this.counters = null;
+		this.sendControl({ type: "resume" });
+	}
+	async stats() {
+		const { stats, counters } = readDisplayStats(await this.pc.getStats(), this.counters, this.rtt);
+		this.counters = counters;
+		return stats;
+	}
+	close(reason = "closed") {
+		if (this.currentState === "closed") return;
+		this.reason = reason;
+		if (this.pingTimer) clearInterval(this.pingTimer);
+		if (this.connectTimer) clearTimeout(this.connectTimer);
+		if (this.sessionId) this.api.closeSession(this.displayId, this.sessionId).catch(() => void 0);
+		this.sessionId = null;
+		for (const track of this.stream.getTracks()) track.stop();
+		this.pc.close();
+		this.currentState = "closed";
+		this.emit("state", "closed");
+	}
+	startPings() {
+		const ping = () => {
+			this.pingId += 1;
+			this.lastPingAt = performance.now();
+			this.sendControl({
+				type: "ping",
+				id: this.pingId
+			});
+		};
+		ping();
+		this.pingTimer = setInterval(ping, DISPLAY_PING_INTERVAL_MS);
+	}
+	sendControl(message) {
+		if (this.controlChannel.readyState === "open") this.controlChannel.send(JSON.stringify(message));
+	}
+	onControl(data) {
+		if (typeof data !== "string") return;
+		let message;
+		try {
+			message = JSON.parse(data);
+		} catch {
+			return;
+		}
+		switch (message.type) {
+			case "ready":
+			case "display":
+				this.currentDisplay = message.display;
+				this.emit("display", message.display);
+				break;
+			case "pong":
+				if (message.id === this.pingId) this.rtt = Math.round(performance.now() - this.lastPingAt);
+				break;
+			case "error":
+				this.emit("error", {
+					code: message.code,
+					message: message.message
+				});
+				break;
+			case "closed":
+				this.sessionId = null;
+				this.close(message.reason);
+		}
+	}
+};
+function gathered(pc, timeoutMs, signal) {
+	if (pc.iceGatheringState === "complete") return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const done = () => {
+			clearTimeout(timer);
+			pc.removeEventListener("icegatheringstatechange", check);
+			signal?.removeEventListener("abort", abort);
+			resolve();
+		};
+		const check = () => {
+			if (pc.iceGatheringState === "complete") done();
+		};
+		const abort = () => {
+			clearTimeout(timer);
+			pc.removeEventListener("icegatheringstatechange", check);
+			reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+		};
+		const timer = setTimeout(done, timeoutMs);
+		pc.addEventListener("icegatheringstatechange", check);
+		signal?.addEventListener("abort", abort, { once: true });
+	});
+}
+function connectDisplay(api, displayId, options) {
+	return DisplayConnection.open(api, displayId, options);
+}
+//#endregion
+//#region src/apis/displays.ts
+const ICE_REFRESH_MARGIN_MS = 3e5;
+var SpaceDisplaysApi = class {
+	transport;
+	spaceId;
+	ice = null;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	path(displayId, suffix = "") {
+		return `/api/spaces/${this.spaceId}/displays/${encodeURIComponent(displayId)}${suffix}`;
+	}
+	list(options = {}) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/displays`, { signal: options.signal });
+	}
+	startVirtual(params = {}) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/displays/virtual`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(params)
+		});
+	}
+	stopVirtual() {
+		return this.transport.request(`/api/spaces/${this.spaceId}/displays/virtual`, { method: "DELETE" });
+	}
+	tree(displayId, params = {}, options = {}) {
+		const query = new URLSearchParams();
+		if (params.maxElements) query.set("maxElements", String(params.maxElements));
+		if (params.actionable) query.set("actionable", "true");
+		const search = query.size ? `?${query}` : "";
+		return this.transport.request(this.path(displayId, `/tree${search}`), { signal: options.signal });
+	}
+	capture(displayId, params = {}, options = {}) {
+		const query = new URLSearchParams();
+		if (params.format) query.set("format", params.format);
+		if (params.quality) query.set("quality", String(params.quality));
+		if (params.maxSize) query.set("maxSize", String(params.maxSize));
+		const search = query.size ? `?${query}` : "";
+		return this.transport.request(this.path(displayId, `/capture${search}`), { signal: options.signal });
+	}
+	input(displayId, events, options = {}) {
+		return this.transport.request(this.path(displayId, "/input"), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ events }),
+			signal: options.signal
+		});
+	}
+	async iceServers(options = {}) {
+		if (this.ice && this.ice.refreshAt > Date.now()) return this.ice.value;
+		const value = await this.transport.request(`/api/spaces/${this.spaceId}/rtc/ice-servers`, { signal: options.signal });
+		this.ice = {
+			value,
+			refreshAt: Date.parse(value.expiresAt) - ICE_REFRESH_MARGIN_MS
+		};
+		return value;
+	}
+	connect(displayId, options) {
+		return connectDisplay(this, displayId, options);
+	}
+	openSession(displayId, body, options = {}) {
+		return this.transport.request(this.path(displayId, "/sessions"), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+			signal: options.signal
+		});
+	}
+	closeSession(displayId, sessionId) {
+		return this.transport.request(this.path(displayId, `/sessions/${sessionId}`), { method: "DELETE" });
+	}
+};
+//#endregion
 //#region src/session-patch-reducer.ts
 const blockSubPathPattern = /^\/message\/content\/blocks\/(\d+)\/(.+)$/;
 const blockPathPattern = /^\/message\/content\/blocks\/(\d+)$/;
@@ -2165,6 +2018,9 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 	messageOrdinal = null;
 	intermediateMessages = [];
 	patchState = null;
+	recovery = null;
+	resyncedMessageKey = null;
+	disposed = false;
 	constructor(websocketClient, spaceId, sessionId, fetchStreamSnapshot) {
 		this.websocketClient = websocketClient;
 		this.spaceId = spaceId;
@@ -2175,48 +2031,80 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 		if (!this.websocketClient) throw new Error("realtime transport is not configured for this client");
 		ensureRealtimeConnected(this.websocketClient);
 		const stream = new SessionGenerationStreamClient(this.websocketClient, this.spaceId, this.sessionId, this.fetchStreamSnapshot);
-		const shouldRecover = options.recover === true || options.initialSnapshot !== void 0;
-		let recovering = shouldRecover;
-		let disposed = false;
-		let recoveryAborted = false;
-		let bufferedEvents = [];
-		let bufferedEventsReplayed = false;
 		const releaseRoom = this.websocketClient.retainRooms([getRealtimeSpaceRoom(this.spaceId)]);
 		const unsubscribe = this.websocketClient.on("event", (event) => {
 			if (event.spaceId !== this.spaceId || event.sessionId !== this.sessionId) return;
-			if (recovering && isGenerationRealtimeEvent(event)) {
-				bufferedEvents.push(event);
-				if (bufferedEvents.length > SNAPSHOT_RECOVERY_MAX_BUFFERED_EVENTS) {
-					recoveryAborted = true;
-					recovering = false;
-					stream.replayBufferedEvents(bufferedEvents, handlers);
-					bufferedEvents = [];
-					bufferedEventsReplayed = true;
-				}
-				return;
-			}
-			stream.handleEvent(event, handlers);
-		});
-		if (shouldRecover) stream.recoverFromSnapshot(handlers, options, () => !recoveryAborted && !disposed).finally(() => {
-			if (disposed || bufferedEventsReplayed) return;
-			recovering = false;
-			stream.replayBufferedEvents(bufferedEvents, handlers);
-			bufferedEventsReplayed = true;
+			stream.receive(event, handlers);
 		});
+		const { initialSnapshot } = options;
+		if (initialSnapshot !== void 0) stream.recover(handlers, async () => initialSnapshot, options);
+		else if (options.recover === true) stream.recover(handlers, () => stream.loadSnapshot(), options);
 		return () => {
-			disposed = true;
+			stream.dispose();
 			unsubscribe();
 			releaseRoom();
 		};
 	}
-	async recoverFromSnapshot(handlers, options, shouldContinue) {
-		const snapshot = options.initialSnapshot !== void 0 ? options.initialSnapshot : options.recover === true && this.fetchStreamSnapshot ? (await withTimeout(this.fetchStreamSnapshot(), SNAPSHOT_RECOVERY_TIMEOUT_MS).catch((error) => {
+	receive(event, handlers) {
+		if (this.disposed) return;
+		const recovery = this.recovery;
+		if (recovery && isGenerationRealtimeEvent(event)) {
+			recovery.events.push(event);
+			if (recovery.events.length > SNAPSHOT_RECOVERY_MAX_BUFFERED_EVENTS) this.finishRecovery(recovery, handlers);
+			return;
+		}
+		this.handleEvent(event, handlers);
+	}
+	dispose() {
+		this.disposed = true;
+		this.recovery = null;
+	}
+	async loadSnapshot() {
+		if (!this.fetchStreamSnapshot) return null;
+		try {
+			return (await withTimeout(this.fetchStreamSnapshot(), SNAPSHOT_RECOVERY_TIMEOUT_MS)).snapshot;
+		} catch (error) {
 			console.warn("[SessionGenerationStreamClient] Failed to recover stream snapshot:", error);
-			return { snapshot: null };
-		})).snapshot : null;
-		if (!shouldContinue()) return;
-		if (!snapshot) return;
-		this.seedFromSnapshot(snapshot, handlers, options);
+			return null;
+		}
+	}
+	async recover(handlers, load, options, resync) {
+		const recovery = { events: resync ? [resync.event] : [] };
+		this.recovery = recovery;
+		const snapshot = await load().catch(() => null);
+		if (this.recovery !== recovery) return;
+		const expectedTurnId = resync?.turnId;
+		if (snapshot && (!expectedTurnId || !snapshot.turnId || snapshot.turnId === expectedTurnId)) this.seedFromSnapshot(snapshot, handlers, options);
+		this.finishRecovery(recovery, handlers);
+	}
+	finishRecovery(recovery, handlers) {
+		if (this.recovery !== recovery) return;
+		this.recovery = null;
+		this.replayBufferedEvents(recovery.events, handlers);
+	}
+	shouldResync(turnId, messageId) {
+		if (!this.fetchStreamSnapshot || this.recovery) return false;
+		const key = `${turnId ?? ""}:${messageId ?? ""}`;
+		if (key === this.resyncedMessageKey) return false;
+		this.resyncedMessageKey = key;
+		return true;
+	}
+	liveState() {
+		return this.reducer.get({
+			spaceId: this.spaceId,
+			sessionId: this.sessionId
+		});
+	}
+	isForeignTurn(turnId) {
+		if (!turnId) return false;
+		const live = this.liveState();
+		return (live.status === "streaming" || live.status === "pending") && live.turnId != null && live.turnId !== turnId;
+	}
+	isLiveMessage(message) {
+		if (this.messageId == null && this.messageOrdinal == null) return true;
+		const meta = message.meta ?? {};
+		if (typeof meta.messageOrdinal === "number" && this.messageOrdinal != null) return meta.messageOrdinal === this.messageOrdinal;
+		return typeof meta.streamMessageId === "string" && meta.streamMessageId === this.messageId;
 	}
 	seedFromSnapshot(snapshot, handlers, options) {
 		if (snapshot.spaceId !== this.spaceId || snapshot.sessionId !== this.sessionId) return false;
@@ -2255,7 +2143,7 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 			const sameMessage = sameTurn && Boolean(this.messageId && (identity.messageId && identity.messageId === this.messageId || identity.messageId == null && identity.messageOrdinal != null && identity.messageOrdinal === this.messageOrdinal));
 			const olderMessageInSameTurn = sameTurn && identity.messageOrdinal != null && this.messageOrdinal != null && identity.messageOrdinal < this.messageOrdinal;
 			if ((sameMessage || olderMessageInSameTurn) && this.patchState && seq != null && seq <= this.patchState.patchSeq) continue;
-			this.handleEvent(event, handlers);
+			this.receive(event, handlers);
 		}
 	}
 	emit(handlers, event) {
@@ -2377,36 +2265,41 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 			anchorUserMessageId
 		};
 		const result = this.reducer.applyPatch(input);
+		if (!result.applied && result.reason === "version_mismatch" && this.shouldResync(turnId, messageId)) {
+			this.recover(handlers, () => this.loadSnapshot(), void 0, {
+				turnId,
+				event
+			});
+			return;
+		}
 		this.handleAppliedState(handlers, "patch", result, event, messageId, messageOrdinal);
 	}
 	handlePersisted(event, handlers) {
 		const message = event.payload.message;
 		if (!isRecord(message)) return;
 		const commit = parseAssistantMessageCommit(message);
-		if (commit.kind === "intermediate") {
-			const intermediate = messageRecordToIntermediate(commit.message);
-			if (intermediate) this.addIntermediateMessage(intermediate);
-			this.reducer.reset({
-				spaceId: this.spaceId,
-				sessionId: this.sessionId
-			});
-			this.resetCurrentMessage();
-		}
-		if (commit.kind === "final") {
-			this.reducer.complete({
-				spaceId: this.spaceId,
-				sessionId: this.sessionId,
-				turnId: getTurnIdFromMessage(commit.message)
-			});
-			this.resetCurrentMessage();
-		}
-		if (commit.kind === "error") {
-			this.reducer.fail({
-				spaceId: this.spaceId,
-				sessionId: this.sessionId,
-				turnId: getTurnIdFromMessage(commit.message)
-			});
-			this.resetCurrentMessage();
+		const turnId = getTurnIdFromMessage(commit.message);
+		const key = {
+			spaceId: this.spaceId,
+			sessionId: this.sessionId,
+			turnId
+		};
+		if (commit.kind !== "ignored" && !this.isForeignTurn(turnId)) {
+			if (commit.kind === "intermediate") {
+				const intermediate = messageRecordToIntermediate(commit.message);
+				if (intermediate) this.addIntermediateMessage(intermediate);
+				if (this.isLiveMessage(commit.message)) {
+					this.reducer.start({
+						...key,
+						turnId: turnId ?? this.liveState().turnId
+					});
+					this.resetCurrentMessage();
+				}
+			} else {
+				if (commit.kind === "final") this.reducer.complete(key);
+				else this.reducer.fail(key);
+				this.resetCurrentMessage();
+			}
 		}
 		this.emit(handlers, {
 			type: "commit",
@@ -2418,17 +2311,16 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 		const turn = event.payload.turn;
 		if (!isRecord(turn)) return;
 		const typedTurn = turn;
-		if (typedTurn.status === "interrupted") this.reducer.interrupt({
-			spaceId: this.spaceId,
-			sessionId: this.sessionId,
-			turnId: typedTurn.id
-		});
-		else this.reducer.complete({
-			spaceId: this.spaceId,
-			sessionId: this.sessionId,
-			turnId: typedTurn.id
-		});
-		this.resetCurrentMessage();
+		if (!this.isForeignTurn(typedTurn.id)) {
+			const key = {
+				spaceId: this.spaceId,
+				sessionId: this.sessionId,
+				turnId: typedTurn.id
+			};
+			if (typedTurn.status === "interrupted") this.reducer.interrupt(key);
+			else this.reducer.complete(key);
+			this.resetCurrentMessage();
+		}
 		this.emit(handlers, {
 			type: "finalized",
 			turn: typedTurn,
@@ -2635,17 +2527,22 @@ var SpacesApi = class {
 	constructor(transport) {
 		this.transport = transport;
 	}
-	list(customFetch) {
-		return this.transport.request("/api/spaces", {
-			method: "GET",
-			fetch: customFetch
-		});
+	list(optionsOrFetch = {}, customFetch) {
+		const options = typeof optionsOrFetch === "function" ? {} : optionsOrFetch;
+		const fetch = typeof optionsOrFetch === "function" ? optionsOrFetch : customFetch;
+		const params = new URLSearchParams();
+		params.set("filter", options.filter ?? "recent");
+		if (options.limit) params.set("limit", String(options.limit));
+		if (options.cursor) params.set("cursor", options.cursor);
+		if (options.query) params.set("q", options.query);
+		if (options.name) params.set("name", options.name);
+		for (const recent of options.recentSpaces ?? []) {
+			params.append("recentSpaceId", recent.id);
+			params.append("recentSpaceAt", new Date(recent.timestamp).toISOString());
+		}
+		return this.transport.request(`/api/spaces?${params}`, { fetch });
 	}
-	/**
-	* Resolve the user's default space (owned/member home, else most recent).
-	* When the account has no accessible space, the API creates a blank Home
-	* space (`slug=home`) and returns it.
-	*/
+	/** Landing Space within the user's own Spaces; use `ensureHome()` for a write target. */
 	getDefault(customFetch) {
 		return this.transport.request("/api/spaces/default", {
 			method: "GET",
@@ -2658,6 +2555,16 @@ var SpacesApi = class {
 	getBySlug(username, slug, customFetch) {
 		return this.transport.request(`/api/spaces/by-slug/${encodeURIComponent(username)}/${encodeURIComponent(slug)}`, { fetch: customFetch });
 	}
+	getOwnedBySlug(slug, customFetch) {
+		return this.transport.request(`/api/me/spaces/by-slug/${encodeURIComponent(slug)}`, { fetch: customFetch });
+	}
+	/** The account's own Home Space, created on first use. */
+	ensureHome(customFetch) {
+		return this.transport.request("/api/me/spaces/home", {
+			method: "POST",
+			fetch: customFetch
+		});
+	}
 	create(input, headers) {
 		return this.transport.request("/api/spaces", {
 			method: "POST",
@@ -2758,7 +2665,7 @@ var SpaceFilesApi = class {
 	}
 	read(path, customFetch, signal) {
 		const params = new URLSearchParams({ path });
-		return this.transport.request(`/api/spaces/${this.spaceId}/fs/file?${params.toString()}`, {
+		return this.transport.requestRevalidated(`/api/spaces/${this.spaceId}/fs/file?${params.toString()}`, {
 			fetch: customFetch,
 			signal
 		});
@@ -2821,15 +2728,33 @@ var SpaceFilesApi = class {
 			fetch: customFetch
 		});
 	}
-	async download(path, customFetch) {
+	async open(path, options = {}) {
 		const params = new URLSearchParams({ path });
-		const raw = await this.transport.raw(`/api/spaces/${this.spaceId}/fs/download?${params.toString()}`, { fetch: customFetch });
-		if (raw.response.status === 202) throw new HttpError("File is being prepared. Please retry shortly.", 202, await raw.json().catch(() => null));
-		const blob = await raw.blob();
+		const deadlineAt = Date.now() + Math.max(0, options.timeoutMs ?? 6e4);
+		while (true) {
+			const raw = await this.transport.raw(`/api/spaces/${this.spaceId}/fs/download?${params.toString()}`, {
+				fetch: options.fetch,
+				signal: options.signal
+			});
+			const { response } = raw;
+			if (response.status !== 202) return {
+				response,
+				filename: getFilenameFromContentDisposition(response.headers.get("content-disposition")) ?? path.split("/").pop() ?? "download",
+				mimeType: response.headers.get("content-type") ?? "application/octet-stream"
+			};
+			const body = await raw.json().catch(() => null);
+			const remainingMs = deadlineAt - Date.now();
+			if (remainingMs <= 0) throw new HttpError("File is being prepared. Please retry shortly.", 202, body);
+			const retryAfterMs = typeof body?.retryAfterMs === "number" ? body.retryAfterMs : 2e3;
+			await waitForSpaceFileRetry(Math.min(Math.max(250, Math.min(retryAfterMs, 2e3)), remainingMs), options.signal);
+		}
+	}
+	async download(path, customFetch) {
+		const { response, filename, mimeType } = await this.open(path, { fetch: customFetch });
 		return {
-			blob,
-			filename: getFilenameFromContentDisposition(raw.response.headers.get("content-disposition")) ?? path.split("/").pop() ?? "download",
-			mimeType: raw.response.headers.get("content-type") ?? blob.type ?? "application/octet-stream"
+			blob: await response.blob(),
+			filename,
+			mimeType
 		};
 	}
 	write(input) {
@@ -2839,6 +2764,31 @@ var SpaceFilesApi = class {
 			body: JSON.stringify(input)
 		});
 	}
+	copy(input) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/copy`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input)
+		});
+	}
+	getCopy(copyId, options = {}) {
+		const params = new URLSearchParams();
+		if (options.waitMs) params.set("waitMs", String(options.waitMs));
+		const query = params.toString();
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/copies/${encodeURIComponent(copyId)}${query ? `?${query}` : ""}`, { signal: options.signal });
+	}
+	async waitForCopy(copy, options = {}) {
+		let current = copy;
+		while (current.status !== "completed" || !current.result) {
+			if (current.progress) options.onProgress?.(current.progress);
+			options.signal?.throwIfAborted();
+			current = await this.getCopy(current.copyId, {
+				waitMs: options.pollMs ?? 5e3,
+				signal: options.signal
+			});
+		}
+		return current.result;
+	}
 	createDir(path, mutationId) {
 		return this.transport.request(`/api/spaces/${this.spaceId}/fs/dir`, {
 			method: "POST",
@@ -3115,6 +3065,11 @@ var SessionClient = class {
 	get(customFetch) {
 		return this.transport.request(`/api/sessions/${this.id}`, { fetch: customFetch });
 	}
+	async stats(options = {}) {
+		const stats = readSessionStats({ stats: (await this.transport.request(`/api/sessions/${this.id}/stats`, options)).stats });
+		if (!stats) throw new Error("Invalid session statistics");
+		return { stats };
+	}
 	/** Space files changed by this session's agent write/edit tool calls. */
 	files(options = {}) {
 		const query = options.limit ? `?limit=${options.limit}` : "";
@@ -3699,34 +3654,111 @@ var BoardRealtimeClient = class {
 var BoardClient = class {
 	spaceId;
 	id;
+	transport;
 	websocketClient;
 	realtime;
-	boards;
 	constructor(spaceId, id, transport, websocketClient) {
 		this.spaceId = spaceId;
 		this.id = id;
+		this.transport = transport;
 		this.websocketClient = websocketClient;
-		this.boards = new SpaceBoardsApi(transport, spaceId, websocketClient);
 		this.realtime = new BoardRealtimeClient(websocketClient, spaceId, id);
 	}
-	capabilities(customFetch) {
-		return this.boards.capabilities(this.id, customFetch);
+	get path() {
+		return `/api/spaces/${this.spaceId}/boards/${this.id}`;
 	}
-	summary(customFetch) {
-		return this.boards.summary(this.id, customFetch);
+	/** Read the Board, or part of it. Every value is complete, defaults included. */
+	get(input = {}, customFetch) {
+		const params = new URLSearchParams();
+		if (input.only?.length) params.set("only", input.only.join(","));
+		if (input.rect) params.set("rect", [
+			input.rect.x,
+			input.rect.y,
+			input.rect.width,
+			input.rect.height
+		].join(","));
+		if (input.within) params.set("within", input.within);
+		if (input.items?.length) params.set("items", input.items.join(","));
+		if (input.animations?.length) params.set("animations", input.animations.join(","));
+		if (input.limit !== void 0) params.set("limit", String(input.limit));
+		if (input.cursor) params.set("cursor", input.cursor);
+		const query = params.toString();
+		return this.transport.request(`${this.path}${query ? `?${query}` : ""}`, { fetch: customFetch });
 	}
-	authoring(input = {}, customFetch) {
-		return this.boards.authoring(this.id, input, customFetch);
+	/** Merge a patch into the Board: fields merge, `null` deletes. */
+	apply(patch, options = {}) {
+		return this.transport.request(`${this.path}/apply`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				...options,
+				patch,
+				mutationId: options.mutationId ?? randomBoardId()
+			})
+		});
 	}
-	/** Read-only transaction log, newest first; the first page carries the current rows. */
-	transactions(input = {}, customFetch) {
-		return this.boards.transactions(this.id, input, customFetch);
+	/** Transactions newest first, each with the before/after state of what it changed. */
+	history(input = {}, customFetch) {
+		const params = new URLSearchParams();
+		if (input.before !== void 0) params.set("before", String(input.before));
+		if (input.limit !== void 0) params.set("limit", String(input.limit));
+		const query = params.toString();
+		return this.transport.request(`${this.path}/history${query ? `?${query}` : ""}`, { fetch: customFetch });
 	}
-	mutateSemantic(input) {
-		return this.boards.mutateSemantic(this.id, {
-			...input,
-			mutationId: input.mutationId ?? randomBoardId(),
-			dryRun: input.dryRun ?? false
+	/** Return the Board to an earlier version as a new write. */
+	restore(version) {
+		return this.transport.request(`${this.path}/restore`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ version })
+		});
+	}
+	playback(command) {
+		return this.transport.request(`${this.path}/playback`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(command)
+		}).then((response) => response.playback);
+	}
+	/** Shared playback: every viewer follows the same clock. */
+	play(animationId, options = {}) {
+		return this.playback({
+			commandId: randomBoardId(),
+			type: "play",
+			animationId,
+			...options
+		});
+	}
+	pause() {
+		return this.playback({
+			commandId: randomBoardId(),
+			type: "pause"
+		});
+	}
+	resume() {
+		return this.playback({
+			commandId: randomBoardId(),
+			type: "resume"
+		});
+	}
+	seek(position) {
+		return this.playback({
+			commandId: randomBoardId(),
+			type: "seek",
+			position
+		});
+	}
+	/** Continue past the marker a presentation is holding at. */
+	next() {
+		return this.playback({
+			commandId: randomBoardId(),
+			type: "next"
+		});
+	}
+	stop() {
+		return this.playback({
+			commandId: randomBoardId(),
+			type: "stop"
 		});
 	}
 	updateAwareness(seq, update) {
@@ -3738,18 +3770,6 @@ var BoardClient = class {
 			update
 		});
 	}
-	play(command) {
-		return this.boards.play(this.id, command);
-	}
-	pause(command) {
-		return this.boards.pause(this.id, command);
-	}
-	seek(command) {
-		return this.boards.seek(this.id, command);
-	}
-	stop(command) {
-		return this.boards.stop(this.id, command);
-	}
 	subscribe(handlers) {
 		return this.realtime.subscribe(handlers);
 	}
@@ -3771,66 +3791,14 @@ var SpaceBoardsApi = class {
 	byId(boardId) {
 		return new BoardClient(this.spaceId, boardId, this.transport, this.websocketClient);
 	}
-	async create(input) {
-		for (const item of input.items ?? []) BoardAuthoringItemSchema.parse(item);
+	/** Create a `.board` file and its Board, optionally with an initial document. */
+	create(input) {
 		return this.transport.request(`/api/spaces/${this.spaceId}/boards`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(input)
 		});
 	}
-	authoring(boardId, input = {}, customFetch) {
-		if (input.include?.length === 0) throw new Error("Board authoring include must not be empty.");
-		const params = new URLSearchParams();
-		for (const section of input.include ?? []) params.append("include", section);
-		if (input.itemIds?.length) params.set("itemIds", input.itemIds.join(","));
-		if (input.connectionIds?.length) params.set("connectionIds", input.connectionIds.join(","));
-		if (input.effectIds?.length) params.set("effectIds", input.effectIds.join(","));
-		if (input.compositionIds?.length) params.set("compositionIds", input.compositionIds.join(","));
-		if (input.viewport) params.set("viewport", JSON.stringify(input.viewport));
-		const query = params.toString();
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/authoring${query ? `?${query}` : ""}`, { fetch: customFetch });
-	}
-	mutateSemantic(boardId, mutation) {
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/mutations`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(mutation)
-		});
-	}
-	summary(boardId, customFetch) {
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/summary`, { fetch: customFetch });
-	}
-	capabilities(boardId, customFetch) {
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/capabilities`, { fetch: customFetch });
-	}
-	transactions(boardId, input = {}, customFetch) {
-		const params = new URLSearchParams();
-		if (input.before !== void 0) params.set("before", String(input.before));
-		if (input.limit !== void 0) params.set("limit", String(input.limit));
-		if (input.snapshot !== void 0) params.set("snapshot", String(input.snapshot));
-		const query = params.toString();
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/transactions${query ? `?${query}` : ""}`, { fetch: customFetch });
-	}
-	playback(boardId, command) {
-		return this.transport.request(`/api/spaces/${this.spaceId}/boards/${boardId}/playback`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(command)
-		});
-	}
-	play(boardId, command) {
-		return this.playback(boardId, command);
-	}
-	pause(boardId, command) {
-		return this.playback(boardId, command);
-	}
-	seek(boardId, command) {
-		return this.playback(boardId, command);
-	}
-	stop(boardId, command) {
-		return this.playback(boardId, command);
-	}
 };
 var SpaceCheckpointFilesApi = class {
 	transport;
@@ -3970,6 +3938,7 @@ var SpaceClient = class {
 	webhooks;
 	env;
 	sandbox;
+	displays;
 	invitations;
 	labels;
 	boards;
@@ -3993,6 +3962,7 @@ var SpaceClient = class {
 		this.webhooks = new SpaceWebhooksApi(transport, id);
 		this.env = new SpaceEnvApi(transport, id);
 		this.sandbox = new SpaceSandboxApi(transport, id);
+		this.displays = new SpaceDisplaysApi(transport, id);
 		this.invitations = new SpaceInvitationsApi(transport, id);
 		this.labels = new SpaceLabelsApi(transport, id);
 		this.boards = new SpaceBoardsApi(transport, id, websocketClient);
@@ -4398,6 +4368,7 @@ var UserApi = class {
 		if (options?.limit !== void 0) params.set("limit", String(options.limit));
 		if (options?.cursor) params.set("cursor", options.cursor);
 		if (options?.source?.length) params.set("source", options.source.join(","));
+		if (options?.includeForks) params.set("includeForks", "1");
 		const query = params.toString();
 		return this.transport.request(`/api/me/sessions${query ? `?${query}` : ""}`, { fetch });
 	}
@@ -4434,6 +4405,53 @@ var UserLabelsApi = class {
 	constructor(transport) {
 		this.transport = transport;
 	}
+	list() {
+		return this.transport.request("/api/me/labels");
+	}
+	create(labelRef) {
+		return this.transport.request("/api/me/labels", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ labelRef })
+		});
+	}
+	resolve(labelRefs) {
+		return this.transport.request("/api/me/labels/resolve", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ labelRefs })
+		});
+	}
+	update(labelRef, input) {
+		return this.transport.request("/api/me/labels/by-ref", {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				labelRef,
+				...input
+			})
+		});
+	}
+	delete(labelRef) {
+		return this.transport.request(`/api/me/labels/by-ref?${new URLSearchParams({ ref: labelRef })}`, { method: "DELETE" });
+	}
+	reorder(labelRefs) {
+		return this.transport.request("/api/me/labels/reorder", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ labelRefs })
+		});
+	}
+	patchResources(resourceRefs, input) {
+		return this.transport.request("/api/me/resources/space/labels/batch", {
+			method: "PATCH",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				resourceRefs,
+				...input
+			})
+		});
+	}
 	getResourceLabels(resourceType, resourceRef) {
 		const params = new URLSearchParams({ resourceRef });
 		return this.transport.request(`/api/me/resources/${resourceType}/labels?${params.toString()}`);
@@ -4789,4 +4807,4 @@ var CohubHttpClient = class {
 };
 const createHttpClient = (options) => new CohubHttpClient(options);
 //#endregion
-export { BoardItemPatchSchema as $, SkillsApi as A, DESKTOP_COMMAND_PAYLOAD_MAX_BYTES as B, SessionPatchReducer as C, ReferencesApi as D, SessionAccessApi as E, ChannelsApi as F, defaultDesktopCommandTimeoutMs as G, DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS as H, DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS as I, parseDesktopCommand as J, isDesktopCallMethod as K, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS as L, ModelsApi as M, GenerationsApi as N, SearchApi as O, CronJobsApi as P, BoardAuthoringItemSchema as Q, DESKTOP_COMMAND_MAX_TIMEOUT_MS as R, parseAssistantMessageCommit as S, ensureRealtimeConnected as T, DESKTOP_COMMAND_TERMINAL_TTL_SECONDS as U, DESKTOP_COMMAND_PENDING_TTL_SECONDS as V, DESKTOP_COMMAND_VERSION as W, resolveOpenSurface as X, parseDesktopCommandId as Y, NAVIGATION_ERROR_MESSAGE_MAX_LENGTH as Z, PublicInviteApi as _, DEFAULT_BOARD_RENDER_LIMITS as _t, DesktopCommandsApi as a, BOARD_ANIMATION_CHANNELS as at, SessionGenerationStreamClient as b, ReferralsApi as c, BoardCompositionSchema as ct, TasksApi as d, parseBoardCompositionInput as dt, BoardSemanticCommandSchema as et, BoardClient as f, BoardConnectionSchema as ft, SpacesApi as g, BOARD_BUILTIN_EFFECT_KINDS as gt, SpaceWebhooksApi as h, BOARD_BUILTIN_CLIP_KINDS as ht, WorkCommerceApi as i, parseBoardEffectInput as it, PromptsApi as j, PublicAssetsApi as k, UsersApi as l, BoardProceduralClipSchema as lt, SpacePublicFilesApi as m, BOARD_BUILTIN_CAPABILITIES as mt, createHttpClient as n, BoardEffectInputSchema as nt, UiCommandsApi as o, BOARD_ANIMATION_CHANNEL_CAPABILITIES as ot, SpaceClient as p, BOARD_ARROW_STROKE_SIZE as pt, isTerminalDesktopCommandStatus as q, AppCommerceApi as r, BoardEffectSchema as rt, AppsApi as s, BoardCompositionInputSchema as st, CohubHttpClient as t, BoardSemanticMutationSchema as tt, UserApi as u, BoardTrackSchema as ut, buildSpaceInvitePath as v, createSessionPatchReducer as w, createSessionGenerationStreamClient as x, buildSpacePath as y, DESKTOP_COMMAND_OPEN_TIMEOUT_MS as z };
+export { resolveOpenSurface as $, ReferencesApi as A, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS as B, SessionPatchReducer as C, connectDisplay as D, DisplayConnection as E, ModelsApi as F, DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS as G, DESKTOP_COMMAND_OPEN_TIMEOUT_MS as H, GenerationsApi as I, defaultDesktopCommandTimeoutMs as J, DESKTOP_COMMAND_TERMINAL_TTL_SECONDS as K, CronJobsApi as L, PublicAssetsApi as M, SkillsApi as N, ensureRealtimeConnected as O, PromptsApi as P, parseDesktopCommandId as Q, ChannelsApi as R, parseAssistantMessageCommit as S, SpaceDisplaysApi as T, DESKTOP_COMMAND_PAYLOAD_MAX_BYTES as U, DESKTOP_COMMAND_MAX_TIMEOUT_MS as V, DESKTOP_COMMAND_PENDING_TTL_SECONDS as W, isTerminalDesktopCommandStatus as X, isDesktopCallMethod as Y, parseDesktopCommand as Z, PublicInviteApi as _, DesktopCommandsApi as a, normalizeDisplayPoint as at, SessionGenerationStreamClient as b, ReferralsApi as c, TasksApi as d, NAVIGATION_ERROR_MESSAGE_MAX_LENGTH as et, BoardClient as f, SpacesApi as g, SpaceWebhooksApi as h, WorkCommerceApi as i, DISPLAY_SYSTEM_ACTIONS as it, SearchApi as j, SessionAccessApi as k, UsersApi as l, SpacePublicFilesApi as m, createHttpClient as n, DISPLAY_INPUT_MAX_SCHEDULE_MS as nt, UiCommandsApi as o, splitDisplayText as ot, SpaceClient as p, DESKTOP_COMMAND_VERSION as q, AppCommerceApi as r, DISPLAY_INPUT_MAX_TEXT as rt, AppsApi as s, CohubHttpClient as t, DISPLAY_ELEMENT_REF_PATTERN as tt, UserApi as u, buildSpaceInvitePath as v, createSessionPatchReducer as w, createSessionGenerationStreamClient as x, buildSpacePath as y, DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS as z };