@neta-art/cohub 6.0.0 → 8.0.0

package/dist/index.js

@@ -1,9 +1,880 @@
-import { $ as BOARD_GEO_KINDS, A as buildWorkComposerChipSet, B as UI_COMMAND_MAX_TIMEOUT_MS, C as ensureRealtimeConnected, Ct as SkillsApi, D as WORK_SURFACE_READY_TIMEOUT_MS, Dt as CronJobsApi, E as WORK_COMPOSER_CHIP_LABEL_MAX_LENGTH, Et as GenerationsApi, F as parseWorkComposerChipSet, G as UI_COMMAND_VERSION, H as UI_COMMAND_PENDING_TTL_SECONDS, I as parseWorkSurfaceReady, J as parseUiCommand, K as isTerminalUiCommandStatus, L as parseWorkSurfaceRequest, M as buildWorkSurfaceRequest, N as buildWorkSurfaceResponse, O as WORK_SURFACE_REQUEST_TIMEOUT_MS, Ot as ChannelsApi, P as parseWorkComposerChipClear, Q as BOARD_COLOR_IDS, R as parseWorkSurfaceResponse, S as createSessionPatchReducer, St as PublicAssetsApi, T as WORK_COMPOSER_CHIP_KEY_MAX_LENGTH, Tt as ModelsApi, U as UI_COMMAND_SETTLEMENT_GRACE_SECONDS, V as UI_COMMAND_PAYLOAD_MAX_BYTES, W as UI_COMMAND_TERMINAL_TTL_SECONDS, X as parseUsername, Y as parseSpaceSlug, Z as BoardAwarenessClientPayloadSchema, _ as buildSpacePath, _t as BOARD_BUILTIN_CAPABILITIES, a as ReferralsApi, at as BoardEffectSchema, b as parseAssistantMessageCommit, bt as ReferencesApi, c as UiCommandsApi, ct as BoardAuthoringItemSchema, d as BoardTransactionError, dt as BOARD_ANIMATION_CHANNEL_CAPABILITIES, et as BOARD_NATIVE_NODE_TYPES, f as SpaceClient, ft as BoardCompositionInputSchema, g as buildSpaceInvitePath, gt as parseBoardCompositionInput, h as PublicInviteApi, ht as BoardTrackSchema, i as WorksApi, it as validateBuiltinBoardClip, j as buildWorkSurfaceReady, k as buildWorkComposerChipClear, l as TasksApi, lt as BoardItemPatchSchema, m as SpacesApi, mt as BoardProceduralClipSchema, n as createHttpClient, nt as validateBoardNodeInput, o as UsersApi, ot as BoardPlaybackPolicySchema, p as SpacePublicFilesApi, pt as BoardCompositionSchema, q as isUiSurfaceMethod, r as WorkCommerceApi, rt as estimateBuiltinBoardClipCost, s as UserApi, st as parseBoardPlaybackPolicy, t as CohubHttpClient, tt as BOARD_NODE_CONTRACT, u as BoardClient, ut as BOARD_ANIMATION_CHANNELS, v as SessionGenerationStreamClient, vt as DEFAULT_BOARD_RENDER_LIMITS, w as WORK_COMPOSER_CHIP_CONTENT_MAX_BYTES, wt as PromptsApi, x as SessionPatchReducer, xt as SearchApi, y as createSessionGenerationStreamClient, yt as SessionAccessApi, z as UI_COMMAND_DEFAULT_TIMEOUT_MS } from "./chunks/http.js";
-import { _ as requestSourceToHeaders, a as sanitizeAccessToken, b as REALTIME_DOMAINS, c as REQUEST_SOURCE_VIA_MAX_LENGTH, d as isRequestSourceEmpty, f as isRequestSourceUuid, g as readRequestSourceFromEnv, h as parseRequestSourceFromHeaders, i as matchesUnauthorizedErrorToken, l as hasRequestSourceIdentity, m as normalizeRequestSource, n as HttpTransport, o as COHUB_SOURCE_HEADER, p as mergeRequestSourceIntoMeta, r as joinApiUrl, s as COHUB_SOURCE_HEADER_NAMES, t as HttpError, u as isRequestSourceClientId, v as resolveRequestSourceChannel, x as REALTIME_ROOM_EVENT_NAME_PATTERN, y as isUuid } from "./chunks/transport.js";
+import { $ as BOARD_BUILTIN_EFFECT_KINDS, A as DESKTOP_COMMAND_TERMINAL_TTL_SECONDS, B as BoardEffectSchema, C as createSessionPatchReducer, D as DESKTOP_COMMAND_PAYLOAD_MAX_BYTES, E as DESKTOP_COMMAND_MAX_TIMEOUT_MS, F as parseDesktopCommandId, G as BoardCompositionSchema, H as BOARD_ANIMATION_CHANNELS, I as BoardAuthoringItemSchema, J as parseBoardCompositionInput, K as BoardProceduralClipSchema, L as BoardItemPatchSchema, M as isDesktopCallMethod, N as isTerminalDesktopCommandStatus, O as DESKTOP_COMMAND_PENDING_TTL_SECONDS, P as parseDesktopCommand, Q as BOARD_BUILTIN_CLIP_KINDS, R as BoardSemanticMutationSchema, S as SessionPatchReducer, T as DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, U as BOARD_ANIMATION_CHANNEL_CAPABILITIES, V as parseBoardEffectInput, W as BoardCompositionInputSchema, X as BOARD_ARROW_STROKE_SIZE, Y as BoardConnectionSchema, Z as BOARD_BUILTIN_CAPABILITIES, _ as buildSpaceInvitePath, a as DesktopCommandsApi, at as SkillsApi, b as createSessionGenerationStreamClient, c as ReferralsApi, ct as GenerationsApi, d as TasksApi, et as DEFAULT_BOARD_RENDER_LIMITS, f as BoardClient, g as PublicInviteApi, h as SpacesApi, i as WorkCommerceApi, it as PublicAssetsApi, j as DESKTOP_COMMAND_VERSION, k as DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS, l as UsersApi, lt as CronJobsApi, m as SpacePublicFilesApi, n as createHttpClient, nt as ReferencesApi, o as UiCommandsApi, ot as PromptsApi, p as SpaceClient, q as BoardTrackSchema, r as AppCommerceApi, rt as SearchApi, s as AppsApi, st as ModelsApi, t as CohubHttpClient, tt as SessionAccessApi, u as UserApi, ut as ChannelsApi, v as buildSpacePath, w as ensureRealtimeConnected, x as parseAssistantMessageCommit, y as SessionGenerationStreamClient, z as BoardEffectInputSchema } from "./chunks/http.js";
+import { _ as requestSourceToHeaders, a as sanitizeAccessToken, b as REALTIME_ROOM_EVENT_NAME_PATTERN, c as REQUEST_SOURCE_VIA_MAX_LENGTH, d as isRequestSourceEmpty, f as isRequestSourceUuid, g as readRequestSourceFromEnv, h as parseRequestSourceFromHeaders, i as matchesUnauthorizedErrorToken, l as hasRequestSourceIdentity, m as normalizeRequestSource, n as HttpTransport, o as COHUB_SOURCE_HEADER, p as mergeRequestSourceIntoMeta, r as joinApiUrl, s as COHUB_SOURCE_HEADER_NAMES, t as HttpError, u as isRequestSourceClientId, v as resolveRequestSourceChannel, y as isUuid } from "./chunks/transport.js";
 import { a as resolveApiBaseUrl, c as resolveWebsocketUrl, i as normalizeWebsocketUrl, n as normalizeBaseUrl, o as resolveCohubEnvironment, r as normalizeVoiceInputWebsocketUrl, s as resolveVoiceInputWebsocketUrl, t as COHUB_ENVIRONMENTS } from "./chunks/environment.js";
 import { a as extractBillingPayload, c as isFeatureNotEntitledError, i as FEATURE_NOT_ENTITLED_ERROR_CODE, l as isHttpErrorCode, n as createWebsocketClient, o as isBillingAccessBlockedCode, r as BILLING_ACCESS_BLOCKED_ERROR_CODE, s as isBillingAccessBlockedError, t as WebsocketClient } from "./chunks/websocket.js";
 import { VoiceApi, VoiceInputClient, createVoiceInputClient } from "./voice-input.js";
 import { z } from "zod";
+//#region ../protocol/dist/board.js
+const BOARD_DOCUMENT_KIND = "cohub.board";
+const BOARD_MANIFEST_KIND = "cohub.board.manifest";
+const idSchema = z.string().min(1).max(160);
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const finiteSchema = z.number().finite();
+z.object({
+	kind: z.literal(BOARD_MANIFEST_KIND),
+	version: z.literal(1),
+	boardId: z.string().uuid(),
+	title: z.string().min(1).max(255)
+});
+z.object({
+	centerX: finiteSchema,
+	centerY: finiteSchema,
+	zoom: finiteSchema.positive()
+});
+const BoardCameraFocusSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("rect"),
+		rect: z.object({
+			x: finiteSchema,
+			y: finiteSchema,
+			width: finiteSchema.positive(),
+			height: finiteSchema.positive()
+		})
+	}),
+	z.object({
+		type: z.literal("item"),
+		itemId: idSchema
+	}),
+	z.object({
+		type: z.literal("items"),
+		itemIds: z.array(idSchema).min(1).max(1e3)
+	}),
+	z.object({
+		type: z.literal("frame"),
+		frameId: idSchema
+	})
+]);
+const BoardCameraFocusParamsSchema = z.object({
+	focus: BoardCameraFocusSchema,
+	fit: z.enum(["contain", "cover"]).default("contain"),
+	padding: finiteSchema.nonnegative().default(32),
+	minZoom: finiteSchema.positive().optional(),
+	maxZoom: finiteSchema.positive().optional()
+}).superRefine((value, context) => {
+	if (value.minZoom !== void 0 && value.maxZoom !== void 0 && value.minZoom > value.maxZoom) context.addIssue({
+		code: "custom",
+		message: "minZoom must not exceed maxZoom",
+		path: ["minZoom"]
+	});
+});
+z.object({
+	nodeId: idSchema,
+	type: z.string().min(1).max(40),
+	parentId: idSchema.nullable(),
+	orderKey: z.string().max(4096).nullable(),
+	x: finiteSchema,
+	y: finiteSchema,
+	width: finiteSchema.positive(),
+	height: finiteSchema.positive(),
+	rotation: finiteSchema,
+	refKind: z.string().max(40).nullable(),
+	refPath: z.string().max(4096).nullable(),
+	refUrl: z.string().max(4096).nullable(),
+	view: jsonObjectSchema,
+	style: jsonObjectSchema,
+	data: jsonObjectSchema
+});
+const stripBoardServerFields = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	const { boardId: _boardId, revision: _revision, ...input } = value;
+	return input;
+};
+const BoardCreateEffectInputSchema = z.preprocess(stripBoardServerFields, BoardEffectInputSchema);
+const BoardCreateCompositionInputSchema = z.preprocess(stripBoardServerFields, BoardCompositionInputSchema);
+const BoardCreateInputSchema = z.object({
+	path: z.string().min(1),
+	/** Reused by clients when board creation is interrupted and retried. */
+	mutationId: z.string().max(128).optional(),
+	title: z.string().min(1).max(255).optional(),
+	metadata: jsonObjectSchema.optional(),
+	items: z.array(BoardAuthoringItemSchema).max(5e4).optional(),
+	connections: z.array(BoardConnectionSchema).max(5e4).optional(),
+	effects: z.array(BoardCreateEffectInputSchema).max(5e4).optional(),
+	compositions: z.array(BoardCreateCompositionInputSchema).max(5e4).optional()
+});
+const jsonSchema$1 = (schema) => z.toJSONSchema(schema);
+const authoringSchemaFactories = {
+	item: () => jsonSchema$1(BoardAuthoringItemSchema),
+	itemPatch: () => jsonSchema$1(BoardItemPatchSchema),
+	mutation: () => jsonSchema$1(BoardSemanticMutationSchema),
+	composition: () => jsonSchema$1(BoardCompositionInputSchema),
+	effect: () => jsonSchema$1(BoardEffectInputSchema),
+	create: () => jsonSchema$1(BoardCreateInputSchema)
+};
+/**
+* JSON Schemas for the semantic authoring surface. Each property is enumerable
+* for Object.keys/JSON.stringify, but generated only when that property is
+* requested. This keeps protocol imports cheap while capabilities still returns
+* the complete machine-readable schema object.
+*/
+const BOARD_AUTHORING_SCHEMAS = {};
+for (const key of Object.keys(authoringSchemaFactories)) {
+	let cached;
+	Object.defineProperty(BOARD_AUTHORING_SCHEMAS, key, {
+		enumerable: true,
+		configurable: false,
+		get() {
+			cached ??= authoringSchemaFactories[key]();
+			return cached;
+		}
+	});
+}
+z.object({
+	include: z.array(z.enum([
+		"nodes",
+		"connections",
+		"effects",
+		"compositions",
+		"playback"
+	])).optional(),
+	nodeIds: 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()
+});
+/** Persisted on `boards.metadata.playback`: how a Board plays when opened. */
+const BoardPlaybackPolicySchema = z.object({
+	compositionId: idSchema,
+	/** Delay before the first local playback after opening the Board, in milliseconds. */
+	delayMs: finiteSchema.nonnegative().default(0)
+});
+function parseBoardPlaybackPolicy(metadata) {
+	const parsed = BoardPlaybackPolicySchema.safeParse(metadata.playback);
+	return parsed.success ? parsed.data : null;
+}
+z.discriminatedUnion("type", [
+	z.object({
+		commandId: idSchema,
+		type: z.literal("play"),
+		compositionId: idSchema,
+		position: finiteSchema.nonnegative().optional(),
+		timeScale: finiteSchema.positive().max(4).optional(),
+		shared: z.boolean().optional(),
+		seed: idSchema.optional()
+	}),
+	z.object({
+		commandId: idSchema,
+		type: z.literal("pause"),
+		playbackId: z.string().uuid()
+	}),
+	z.object({
+		commandId: idSchema,
+		type: z.literal("seek"),
+		playbackId: z.string().uuid(),
+		position: finiteSchema.nonnegative()
+	}),
+	z.object({
+		commandId: idSchema,
+		type: z.literal("stop"),
+		playbackId: z.string().uuid()
+	})
+]);
+//#endregion
+//#region ../protocol/dist/board-capability-registry.js
+const CLIPS = new Set(BOARD_BUILTIN_CLIP_KINDS);
+new Set(BOARD_BUILTIN_EFFECT_KINDS);
+const record = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+function validateBuiltinBoardClip(clip, path = "clip") {
+	if (!CLIPS.has(clip.kind)) return [];
+	const errors = [];
+	const error = (message, suffix, coordinateSpace, code = "INVALID_BOARD_CLIP") => {
+		errors.push({
+			severity: "error",
+			code,
+			message,
+			path: `${path}.${suffix}`,
+			...coordinateSpace ? { coordinateSpace } : {}
+		});
+	};
+	if ((clip.kind.startsWith("motion.") || clip.kind.startsWith("draw.") || clip.kind === "text.reveal" || clip.kind === "effects.trail") && clip.target.type !== "item") error(`${clip.kind} must target an item`, "target");
+	if (clip.kind.startsWith("camera.") && clip.target.type !== "camera") error(`${clip.kind} must target the camera`, "target");
+	if (clip.kind === "motion.path") {
+		const points = clip.params.points;
+		if (!Array.isArray(points) || points.length < 2 || points.length > 1e4) error("motion path must contain 2 to 10000 world-offset points", "params.points", "world-offset");
+		else for (const [index, point] of points.entries()) if (!record(point) || !finite(point.x) || !finite(point.y)) error("motion path point must contain finite x and y", `params.points.${index}`, "world-offset");
+	}
+	if (clip.kind === "effects.particles") {
+		const count = clip.params.count;
+		if (!Number.isSafeInteger(count) || count < 1 || count > DEFAULT_BOARD_RENDER_LIMITS.particles) error(`particle count must be an integer from 1 to ${DEFAULT_BOARD_RENDER_LIMITS.particles}`, "params.count", void 0, "INVALID_PARTICLE_COUNT");
+		const bounds = clip.params.bounds;
+		if (!record(bounds) || !finite(bounds.x) || !finite(bounds.y) || !finite(bounds.width) || !finite(bounds.height) || bounds.width <= 0 || bounds.height <= 0) error("particles require positive finite world bounds", "params.bounds", "world", "PARTICLE_BOUNDS_REQUIRED");
+	}
+	if (clip.kind === "camera.focus") {
+		const parsed = BoardCameraFocusParamsSchema.safeParse(clip.params);
+		if (!parsed.success) error(parsed.error.issues[0]?.message ?? "invalid camera focus", "params", "world");
+	}
+	return errors;
+}
+function estimateBuiltinBoardClipCost(clip) {
+	switch (clip.kind) {
+		case "effects.particles": {
+			const count = Number.isSafeInteger(clip.params.count) ? Math.max(0, clip.params.count) : 0;
+			return {
+				particles: count,
+				vertices: count * 4,
+				dynamicVertices: count * 4,
+				drawCalls: 1,
+				bufferBytes: count * 48,
+				simulationSteps: count
+			};
+		}
+		case "effects.trail": return {
+			vertices: 32,
+			dynamicVertices: 32,
+			drawCalls: 1,
+			bufferBytes: 1024,
+			simulationSteps: 16
+		};
+		case "effects.impact":
+		case "effects.flash": return {
+			vertices: 64,
+			drawCalls: 1
+		};
+		case "draw.reveal":
+		case "draw.handwrite": return {
+			drawCalls: 1,
+			dynamicVertices: 1
+		};
+		case "motion.path": return { simulationSteps: Array.isArray(clip.params.points) ? clip.params.points.length : 0 };
+		default: return {};
+	}
+}
+//#endregion
+//#region ../protocol/dist/board-url.js
+const BOARD_REMOTE_URL_MAX_LENGTH = 4096;
+function parseIpv4(host) {
+	const parts = host.split(".").map(Number);
+	return parts.length === 4 && parts.every((part) => Number.isInteger(part) && part >= 0 && part <= 255) ? parts : null;
+}
+function isBlockedIpv4(host) {
+	const parts = parseIpv4(host);
+	if (!parts) return false;
+	const [first, second, third] = parts;
+	if (first === 0 || first === 10 || first === 127) return true;
+	if (first === 100 && second >= 64 && second <= 127) return true;
+	if (first === 169 && second === 254) return true;
+	if (first === 172 && second >= 16 && second <= 31) return true;
+	if (first === 192 && second === 168) return true;
+	if (first === 192 && second === 0 && (third === 0 || third === 2)) return true;
+	if (first === 192 && second === 88 && third === 99) return true;
+	if (first === 198 && (second === 18 || second === 19)) return true;
+	if (first === 198 && second === 51 && third === 100) return true;
+	if (first === 203 && second === 0 && third === 113) return true;
+	return first >= 224;
+}
+function expandIpv6(host) {
+	const [head, tail, extra] = host.toLowerCase().split("::");
+	if (extra !== void 0) return null;
+	const headParts = head ? head.split(":").filter(Boolean) : [];
+	const tailParts = tail ? tail.split(":").filter(Boolean) : [];
+	const missing = 8 - headParts.length - tailParts.length;
+	if (missing < 0 || tail === void 0 && missing !== 0) return null;
+	const parts = [
+		...headParts,
+		...Array.from({ length: missing }, () => "0"),
+		...tailParts
+	];
+	if (parts.length !== 8 || parts.some((part) => !/^[0-9a-f]{1,4}$/.test(part))) return null;
+	return parts.map((part) => part.padStart(4, "0"));
+}
+function isBlockedIpv6(host) {
+	const parts = expandIpv6(host);
+	if (!parts) return true;
+	if (parts.every((part) => part === "0000")) return true;
+	if (parts.slice(0, 7).every((part) => part === "0000") && parts[7] === "0001") return true;
+	if (parts.slice(0, 5).every((part) => part === "0000") && parts[5] === "ffff") {
+		const high = Number.parseInt(parts[6] ?? "0", 16);
+		const low = Number.parseInt(parts[7] ?? "0", 16);
+		return isBlockedIpv4(`${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`);
+	}
+	if (parts.slice(0, 6).every((part) => part === "0000")) return true;
+	const first = Number.parseInt(parts[0] ?? "0", 16);
+	if ((first & 65024) === 64512) return true;
+	if ((first & 65472) === 65152 || (first & 65472) === 65216) return true;
+	if ((first & 65280) === 65280) return true;
+	return parts[0] === "2001" && parts[1] === "0db8";
+}
+function isPublicBoardRemoteAddress(value) {
+	const address = value.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+	if (parseIpv4(address)) return !isBlockedIpv4(address);
+	return address.includes(":") && !isBlockedIpv6(address);
+}
+function isBlockedHost(hostname) {
+	const host = hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+	if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) return true;
+	if (parseIpv4(host) || host.includes(":")) return !isPublicBoardRemoteAddress(host);
+	return false;
+}
+/**
+* Normalize a browser-loadable public HTTP(S) URL. This blocks explicit local
+* addresses; any future server-side fetcher must additionally validate DNS
+* resolution to defend against rebinding.
+*/
+function normalizeBoardRemoteUrl(value) {
+	if (typeof value !== "string") return void 0;
+	const input = value.trim();
+	if (!input || input.length > 4096) return void 0;
+	try {
+		const url = new URL(input);
+		if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
+		if (url.username || url.password || isBlockedHost(url.hostname)) return;
+		const normalized = url.toString();
+		return normalized.length <= 4096 ? normalized : void 0;
+	} catch {
+		return;
+	}
+}
+const BoardRemoteUrlSchema = z.string().max(BOARD_REMOTE_URL_MAX_LENGTH).refine((value) => normalizeBoardRemoteUrl(value) !== void 0, { message: "URL must be a public HTTP(S) URL without credentials" });
+//#endregion
+//#region ../protocol/dist/board-document.js
+const BoardFrameSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite(),
+	width: z.number().finite().positive(),
+	height: z.number().finite().positive(),
+	rotation: z.number().finite().default(0)
+});
+/**
+* The board camera. This is local UI state, not synced content: semantic ops
+* (see diffBoardDocuments) never describe the viewport, and the editor holds
+* the live camera separately from the persisted document. Here it only serves
+* as an initial camera hint when a document is first loaded.
+*/
+const BoardViewportSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite(),
+	zoom: z.number().finite().min(.05).max(8)
+});
+const BoardAppearanceSchema = z.object({
+	theme: z.string().min(1).default("clean"),
+	background: z.object({
+		kind: z.enum([
+			"solid",
+			"dots",
+			"grid",
+			"image",
+			"shader",
+			"custom"
+		]).default("dots"),
+		color: z.string().optional(),
+		imageUrl: BoardRemoteUrlSchema.optional(),
+		fit: z.enum([
+			"cover",
+			"contain",
+			"repeat"
+		]).optional(),
+		position: z.enum([
+			"center",
+			"top",
+			"bottom",
+			"left",
+			"right"
+		]).optional(),
+		opacity: z.number().finite().min(0).max(1).optional()
+	}).default({ kind: "solid" }),
+	grid: z.object({
+		visible: z.boolean().default(false),
+		size: z.number().finite().min(4).default(24),
+		opacity: z.number().finite().min(0).max(1).default(.12)
+	}).default({
+		visible: false,
+		size: 24,
+		opacity: .12
+	}),
+	mood: z.enum([
+		"clean",
+		"playful",
+		"arcane",
+		"cyber",
+		"natural"
+	]).default("clean")
+});
+/** Optional visual chrome still carried by a few older shapes. */
+const BoardItemStyleSchema = z.object({
+	variant: z.string().min(1).default("default"),
+	theme: z.string().min(1).optional(),
+	accentColor: z.string().optional(),
+	size: z.enum([
+		"sm",
+		"md",
+		"lg"
+	]).default("md"),
+	emphasis: z.enum([
+		"normal",
+		"rare",
+		"epic",
+		"legendary"
+	]).default("normal"),
+	effects: z.array(z.string().min(1)).default([])
+});
+const SpaceFileRefSchema = z.object({
+	kind: z.literal("space-file"),
+	path: z.string().min(1)
+});
+const BoardMediaSnapshotSchema = z.object({
+	title: z.string().optional(),
+	mimeType: z.string().optional(),
+	size: z.number().finite().nonnegative().optional(),
+	mtimeMs: z.number().finite().nonnegative().optional(),
+	/** Intrinsic pixel size once known. */
+	naturalWidth: z.number().finite().positive().optional(),
+	naturalHeight: z.number().finite().positive().optional()
+});
+const BoardItemBaseSchema = z.object({
+	id: z.string().min(1),
+	frame: BoardFrameSchema,
+	parentId: z.string().min(1).nullable().optional(),
+	/** When true the shape cannot be moved, resized, or deleted. */
+	locked: z.boolean().optional(),
+	style: BoardItemStyleSchema.optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+/** Freestanding text — no card chrome; its frame always follows the glyphs. */
+const BoardTextItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("text"),
+	text: z.string().default(""),
+	color: z.string().min(1).default("neutral"),
+	fontSize: z.number().finite().min(2).max(512).default(24)
+});
+const BoardGeoItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("geo"),
+	geo: z.string().min(1).default("rectangle"),
+	text: z.string().default(""),
+	color: z.string().min(1).default("brand"),
+	fillOpacity: z.number().finite().min(0).max(1).default(0)
+});
+/** A raw freehand sample. Pressure defaults to 0.5 (mouse) when absent. */
+const DrawPointSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite(),
+	p: z.number().finite().min(0).max(1).default(.5)
+});
+/** A world-space point. */
+const BoardPointSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite()
+});
+const BoardDrawItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("draw"),
+	points: z.array(DrawPointSchema).default([]),
+	color: z.string().min(1).default("brand"),
+	size: z.number().finite().positive().default(4)
+});
+/**
+* A free arrow — a standalone annotation stroke between two world points.
+*
+* Arrows do not relate nodes. A relation between two nodes is a
+* `BoardConnection`, which is stored separately and resolves its geometry from
+* the live node frames. Keeping the two apart is what lets an arrow be a plain
+* shape (its own frame, freely movable) while a connection stays purely
+* semantic — neither has to pretend to be the other.
+*/
+const BoardArrowItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("arrow"),
+	start: BoardPointSchema,
+	end: BoardPointSchema,
+	bend: z.number().finite().min(-.85).max(.85).default(0),
+	color: z.string().min(1).default("brand"),
+	size: z.number().finite().positive().default(BOARD_ARROW_STROKE_SIZE),
+	arrowStart: z.boolean().default(false),
+	arrowEnd: z.boolean().default(true),
+	label: z.string().default("")
+});
+/** A frame container for organising shapes. */
+const BoardFrameItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("frame"),
+	label: z.string().default("Frame"),
+	color: z.string().min(1).default("neutral")
+});
+/** Image node — space file only, natural aspect, no chrome. */
+const BoardImageItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("image"),
+	ref: SpaceFileRefSchema,
+	snapshot: BoardMediaSnapshotSchema.optional(),
+	/** Optional normalized crop in source image space (0..1). */
+	crop: z.object({
+		x: z.number().finite().min(0).max(1).default(0),
+		y: z.number().finite().min(0).max(1).default(0),
+		w: z.number().finite().min(0).max(1).default(1),
+		h: z.number().finite().min(0).max(1).default(1)
+	}).optional()
+});
+/** Video node — space file only. Playback state is local UI, never synced. */
+const BoardVideoItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("video"),
+	ref: SpaceFileRefSchema,
+	snapshot: BoardMediaSnapshotSchema.optional()
+});
+/** Audio node — space file only. Playback state is local UI, never synced. */
+const BoardAudioItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("audio"),
+	ref: SpaceFileRefSchema,
+	snapshot: BoardMediaSnapshotSchema.extend({ durationMs: z.number().finite().nonnegative().optional() }).optional()
+});
+/**
+* Cached display facts for a file card.
+*
+* Purely derived from the referenced file and versioned by `mtimeMs`, so it is a
+* cache and never a second source of truth: the workspace file remains
+* authoritative, and a stale snapshot is detectable rather than silently wrong.
+* It is stored so that opening a board renders complete cards immediately, with
+* no per-node file read on the first paint.
+*/
+const BoardFileSnapshotSchema = z.object({
+	title: z.string().optional(),
+	mimeType: z.string().optional(),
+	size: z.number().finite().nonnegative().optional(),
+	mtimeMs: z.number().finite().nonnegative().optional(),
+	/** Cleaned leading prose. Capped when written (see FILE_EXCERPT_MAX_CHARS). */
+	excerpt: z.string().optional(),
+	/** Cover image inside the space, already resolved to a workspace path. */
+	coverPath: z.string().optional(),
+	/** Cover image at an absolute https URL, as declared by the file itself. */
+	coverUrl: z.string().optional()
+});
+/**
+* File node — a thumbnail entry point to any workspace file.
+*
+* This is the fallback for every dropped file that is not natively an image or
+* video, including binaries and unknown extensions: a board should never refuse
+* a file, only present it with less detail. Presentation tiers are derived from
+* the snapshot (see filePreviewKind), not stored, so there is no display state
+* to drift from the facts.
+*/
+const BoardFileItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("file"),
+	ref: SpaceFileRefSchema,
+	snapshot: BoardFileSnapshotSchema.optional()
+});
+const BoardTaskMediaArtifactFields = {
+	id: z.string().min(1).max(240),
+	title: z.string().max(240).optional(),
+	url: BoardRemoteUrlSchema,
+	mimeType: z.string().max(160).optional()
+};
+const BoardTaskArtifactSchema = z.discriminatedUnion("type", [
+	z.object({
+		...BoardTaskMediaArtifactFields,
+		type: z.literal("image"),
+		naturalWidth: z.number().positive().optional(),
+		naturalHeight: z.number().positive().optional()
+	}).strict(),
+	z.object({
+		...BoardTaskMediaArtifactFields,
+		type: z.literal("video"),
+		previewUrl: BoardRemoteUrlSchema.optional(),
+		durationMs: z.number().int().positive().optional(),
+		naturalWidth: z.number().positive().optional(),
+		naturalHeight: z.number().positive().optional()
+	}).strict(),
+	z.object({
+		...BoardTaskMediaArtifactFields,
+		type: z.literal("audio"),
+		previewUrl: BoardRemoteUrlSchema.optional(),
+		durationMs: z.number().int().positive().optional()
+	}).strict(),
+	z.object({
+		id: z.string().min(1).max(240),
+		type: z.literal("text"),
+		title: z.string().max(240).optional(),
+		textExcerpt: z.string().min(1).max(480)
+	}).strict()
+]);
+/**
+* Cached task facts used for an immediate first paint. The task run remains the
+* source of truth and live clients refresh this projection by `taskRunId`.
+*/
+const BoardTaskSnapshotSchema = z.object({
+	taskType: z.string().min(1).max(120),
+	status: z.enum([
+		"pending",
+		"running",
+		"completed",
+		"failed"
+	]),
+	title: z.string().min(1).max(240),
+	model: z.string().max(160).optional(),
+	promptExcerpt: z.string().max(480).optional(),
+	artifactCount: z.number().int().nonnegative(),
+	artifacts: z.array(BoardTaskArtifactSchema).max(6).default([]),
+	updatedAt: z.string().optional()
+}).strict();
+/** A stable reference to a task run with a small, replaceable display cache. */
+const BoardTaskItemSchema = BoardItemBaseSchema.extend({
+	type: z.literal("task"),
+	taskRunId: z.string().min(1),
+	snapshot: BoardTaskSnapshotSchema
+});
+/**
+* A forward-compatible carrier for shape types this client does not recognise.
+* Its discriminant is the literal `"unknown"` so the item union still narrows
+* cleanly on `type`. The real type string and every original field are preserved
+* verbatim in `raw`.
+*/
+const UNKNOWN_BOARD_ITEM_TYPE = "unknown";
+const BoardItemSchema = z.any().transform((raw) => parseBoardItemLoose(raw));
+/**
+* Parse a single item leniently: known types are validated and normalised;
+* anything else becomes a lossless unknown item. Never throws on shape data —
+* a malformed known item degrades to unknown rather than failing the document.
+*/
+function parseBoardItemLoose(raw) {
+	if (!raw || typeof raw !== "object") return makeUnknownItem(raw);
+	switch (raw.type) {
+		case "image": {
+			const parsed = BoardImageItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "video": {
+			const parsed = BoardVideoItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "audio": {
+			const parsed = BoardAudioItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "file": {
+			const parsed = BoardFileItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "task": {
+			const parsed = BoardTaskItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "text": {
+			const parsed = BoardTextItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "geo": {
+			const parsed = BoardGeoItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "draw": {
+			const parsed = BoardDrawItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "arrow": {
+			const parsed = BoardArrowItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		case "frame": {
+			const parsed = BoardFrameItemSchema.safeParse(raw);
+			return parsed.success ? parsed.data : makeUnknownItem(raw);
+		}
+		default: return makeUnknownItem(raw);
+	}
+}
+function makeUnknownItem(raw) {
+	const record = raw && typeof raw === "object" ? raw : {};
+	const frameParsed = BoardFrameSchema.safeParse(record.frame);
+	const styleParsed = BoardItemStyleSchema.safeParse(record.style);
+	return {
+		id: typeof record.id === "string" && record.id ? record.id : "unknown",
+		type: UNKNOWN_BOARD_ITEM_TYPE,
+		frame: frameParsed.success ? frameParsed.data : {
+			x: 0,
+			y: 0,
+			width: 120,
+			height: 80,
+			rotation: 0
+		},
+		...typeof record.parentId === "string" || record.parentId === null ? { parentId: record.parentId } : {},
+		...record.locked === true ? { locked: true } : {},
+		...styleParsed.success && record.style ? { style: styleParsed.data } : {},
+		...record.metadata && typeof record.metadata === "object" ? { metadata: record.metadata } : {},
+		raw: record
+	};
+}
+z.object({
+	kind: z.literal(BOARD_DOCUMENT_KIND),
+	version: z.literal(1),
+	appearance: BoardAppearanceSchema.default({
+		theme: "clean",
+		background: { kind: "solid" },
+		grid: {
+			visible: false,
+			size: 24,
+			opacity: .12
+		},
+		mood: "clean"
+	}),
+	viewport: BoardViewportSchema,
+	items: z.array(BoardItemSchema),
+	/**
+	* Node relations. Separate from `items` because a connection has no frame of
+	* its own — its geometry is derived from the nodes it joins, so it is a
+	* relation over the item set rather than a member of it.
+	*
+	* Connections referencing a missing node are dropped on parse: a relation to
+	* nothing is not a relation, and keeping one would let an invisible dangling
+	* edge accumulate silently. Callers that need to know write through the
+	* transaction API, which reports the reference error instead.
+	*/
+	connections: z.array(BoardConnectionSchema).default([])
+});
+//#endregion
+//#region ../protocol/dist/board-node.js
+const BOARD_COLOR_IDS = [
+	"brand",
+	"neutral",
+	"black",
+	"white",
+	"blue",
+	"green",
+	"amber",
+	"violet",
+	"rose"
+];
+const BoardColorIdSchema = z.enum(BOARD_COLOR_IDS);
+const BOARD_GEO_KINDS = [
+	"rectangle",
+	"rounded",
+	"ellipse",
+	"diamond",
+	"triangle"
+];
+const BoardGeoKindSchema = z.enum(BOARD_GEO_KINDS);
+const BOARD_NATIVE_NODE_TYPES = [
+	"image",
+	"video",
+	"audio",
+	"file",
+	"task",
+	"text",
+	"geo",
+	"draw",
+	"arrow",
+	"frame"
+];
+const metadataSchema = z.record(z.string(), z.unknown());
+const commonData = {
+	locked: z.boolean().optional(),
+	metadata: metadataSchema.optional()
+};
+const pointSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite(),
+	p: z.number().finite().min(0).max(1).default(.5)
+}).strict();
+const worldPointSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite()
+}).strict();
+const strokeSizeSchema = z.number().finite().min(1).max(64);
+const mediaViewSchema = z.object({
+	title: z.string().optional(),
+	mimeType: z.string().optional(),
+	size: z.number().finite().nonnegative().optional(),
+	mtimeMs: z.number().finite().nonnegative().optional(),
+	naturalWidth: z.number().finite().positive().optional(),
+	naturalHeight: z.number().finite().positive().optional()
+}).strict();
+const audioViewSchema = mediaViewSchema.extend({ durationMs: z.number().finite().nonnegative().optional() });
+const dataSchemas = {
+	text: z.object({
+		...commonData,
+		text: z.string().default(""),
+		color: BoardColorIdSchema.default("neutral"),
+		fontSize: z.number().finite().min(2).max(512).default(24)
+	}).strict(),
+	geo: z.object({
+		...commonData,
+		geo: BoardGeoKindSchema.default("rectangle"),
+		text: z.string().default(""),
+		color: BoardColorIdSchema.default("brand"),
+		fillOpacity: z.number().finite().min(0).max(1).default(0)
+	}).strict(),
+	draw: z.object({
+		...commonData,
+		points: z.array(pointSchema).min(1),
+		color: BoardColorIdSchema.default("brand"),
+		size: strokeSizeSchema.default(4)
+	}).strict(),
+	arrow: z.object({
+		...commonData,
+		start: worldPointSchema,
+		end: worldPointSchema,
+		bend: z.number().finite().min(-.85).max(.85).default(0),
+		color: BoardColorIdSchema.default("brand"),
+		size: strokeSizeSchema.default(BOARD_ARROW_STROKE_SIZE),
+		arrowStart: z.boolean().default(false),
+		arrowEnd: z.boolean().default(true),
+		label: z.string().default("")
+	}).strict(),
+	frame: z.object({
+		...commonData,
+		label: z.string().default("Frame"),
+		color: BoardColorIdSchema.default("neutral")
+	}).strict(),
+	image: z.object({
+		...commonData,
+		crop: z.object({
+			x: z.number().finite().min(0).max(1),
+			y: z.number().finite().min(0).max(1),
+			w: z.number().finite().min(0).max(1),
+			h: z.number().finite().min(0).max(1)
+		}).strict().optional()
+	}).strict(),
+	video: z.object(commonData).strict(),
+	audio: z.object(commonData).strict(),
+	file: z.object(commonData).strict(),
+	task: z.object({
+		...commonData,
+		taskRunId: z.string().min(1)
+	}).strict()
+};
+const fileViewSchema = z.object({
+	title: z.string().optional(),
+	mimeType: z.string().optional(),
+	size: z.number().finite().nonnegative().optional(),
+	mtimeMs: z.number().finite().nonnegative().optional(),
+	excerpt: z.string().optional(),
+	coverPath: z.string().optional(),
+	coverUrl: z.string().url().optional()
+}).strict();
+const taskViewSchema = BoardTaskSnapshotSchema;
+const emptyViewSchema = z.object({}).strict();
+const viewSchemas = {
+	image: mediaViewSchema,
+	video: mediaViewSchema,
+	audio: audioViewSchema,
+	file: fileViewSchema,
+	task: taskViewSchema,
+	text: emptyViewSchema,
+	geo: emptyViewSchema,
+	draw: emptyViewSchema,
+	arrow: emptyViewSchema,
+	frame: emptyViewSchema
+};
+const nodeEnvelopeSchema = z.object({
+	nodeId: z.string().min(1).max(160),
+	type: z.string().min(1).max(40),
+	parentId: z.string().min(1).max(160).nullable(),
+	orderKey: z.string().max(4096).nullable(),
+	x: z.number().finite(),
+	y: z.number().finite(),
+	width: z.number().finite().positive(),
+	height: z.number().finite().positive(),
+	rotation: z.number().finite(),
+	refKind: z.string().max(40).nullable(),
+	refPath: z.string().max(4096).nullable(),
+	refUrl: z.string().max(4096).nullable(),
+	view: z.record(z.string(), z.unknown()),
+	style: z.record(z.string(), z.unknown()),
+	data: z.record(z.string(), z.unknown())
+}).strict();
+function jsonSchema(schema) {
+	return z.toJSONSchema(schema);
+}
+jsonSchema(nodeEnvelopeSchema), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(dataSchemas[type])])), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(viewSchemas[type])]));
+//#endregion
 //#region ../protocol/dist/generation/catalog.js
 function isGenerationModelHidden(model) {
 	return model.hidden === true;
@@ -21,14 +892,14 @@ var GenerationPolicyError = class extends Error {
 		this.name = "GenerationPolicyError";
 	}
 };
-function isRecord(value) {
+function isRecord$1(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isPrimitiveEnumValue(value) {
 	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
 function normalizeConstraint(value) {
-	if (!isRecord(value) || typeof value.kind !== "string") return null;
+	if (!isRecord$1(value) || typeof value.kind !== "string") return null;
 	if (value.kind === "enum") {
 		if (!Array.isArray(value.values) || value.values.length === 0 || !value.values.every(isPrimitiveEnumValue)) return null;
 		return {
@@ -58,7 +929,7 @@ function normalizeConstraint(value) {
 	return null;
 }
 function normalizeGenerationPolicy(value) {
-	if (!isRecord(value) || value.version !== 1) return null;
+	if (!isRecord$1(value) || value.version !== 1) return null;
 	if (value.mode === "auto") return {
 		version: 1,
 		mode: "auto"
@@ -66,10 +937,10 @@ function normalizeGenerationPolicy(value) {
 	if (value.mode !== "limited" || !Array.isArray(value.models) || value.models.length === 0) return null;
 	const models = [];
 	for (const item of value.models) {
-		if (!isRecord(item) || typeof item.model !== "string" || !item.model.trim()) return null;
+		if (!isRecord$1(item) || typeof item.model !== "string" || !item.model.trim()) return null;
 		const modelPolicy = { model: item.model.trim() };
 		if (item.parameters !== void 0) {
-			if (!isRecord(item.parameters)) return null;
+			if (!isRecord$1(item.parameters)) return null;
 			const parameters = {};
 			for (const [key, rawConstraint] of Object.entries(item.parameters)) {
 				if (!key.trim()) return null;
@@ -244,6 +1115,181 @@ function filterGenerationDeclarationsByPolicy(declarations, policy) {
 	});
 }
 //#endregion
+//#region ../protocol/dist/public-identifiers.js
+const USERNAME_PATTERN = /^(?!-)(?!.*--)[a-z0-9-]{1,39}(?<!-)$/;
+const SPACE_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9_-]{0,78}[a-z0-9])?$/;
+/**
+* Platform-owned path segments that must not be newly assigned to public
+* identities. Existing stored values remain readable through parse helpers.
+*/
+const RESERVED_PLATFORM_PATH_SEGMENTS = Object.freeze([
+	"admin",
+	"api",
+	"assets",
+	"auth",
+	"callback",
+	"changelog",
+	"docs",
+	"explore",
+	"invite",
+	"landing",
+	"login",
+	"logout",
+	"new",
+	"org",
+	"pricing",
+	"pwa",
+	"referrals",
+	"sessions",
+	"settings",
+	"spaces",
+	"static",
+	"teams",
+	"trending",
+	"u",
+	"user",
+	"users",
+	"work-auth",
+	"app-auth"
+]);
+new Set(RESERVED_PLATFORM_PATH_SEGMENTS);
+[...RESERVED_PLATFORM_PATH_SEGMENTS];
+function parseUsername(value) {
+	if (value === null || value === void 0) return null;
+	const normalized = value.trim().toLowerCase();
+	return USERNAME_PATTERN.test(normalized) ? normalized : null;
+}
+function parseSpaceSlug(value) {
+	if (value === null || value === void 0) return null;
+	const normalized = value.trim();
+	return SPACE_SLUG_PATTERN.test(normalized) ? normalized : null;
+}
+//#endregion
+//#region ../protocol/dist/app-surface.js
+const APP_SURFACE_PROTOCOL = "cohub.app.surface";
+const APP_SURFACE_READY_TIMEOUT_MS = 1e4;
+const APP_SURFACE_REQUEST_TIMEOUT_MS = 15e3;
+const APP_COMPOSER_CHIP_KEY_MAX_LENGTH = 80;
+const APP_COMPOSER_CHIP_LABEL_MAX_LENGTH = 120;
+const APP_COMPOSER_CHIP_CONTENT_MAX_BYTES = 32 * 1024;
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const isSurfaceEnvelope = (value) => isRecord(value) && value.protocol === "cohub.app.surface" && value.version === 1;
+const parseAppSurfaceReady = (value) => {
+	if (!isSurfaceEnvelope(value) || value.type !== "ready") return null;
+	const methods = Array.isArray(value.methods) ? value.methods.filter((method) => typeof method === "string" && Boolean(method)) : [];
+	return {
+		protocol: APP_SURFACE_PROTOCOL,
+		version: 1,
+		type: "ready",
+		methods
+	};
+};
+const parseAppSurfaceResponse = (value) => {
+	if (!isSurfaceEnvelope(value) || value.type !== "response") return null;
+	if (typeof value.requestId !== "string" || !value.requestId) return null;
+	const error = isRecord(value.error) ? {
+		code: typeof value.error.code === "string" && value.error.code ? value.error.code : "surface_error",
+		message: typeof value.error.message === "string" ? value.error.message : "App surface call failed"
+	} : void 0;
+	return {
+		protocol: APP_SURFACE_PROTOCOL,
+		version: 1,
+		type: "response",
+		requestId: value.requestId,
+		ok: value.ok === true,
+		...error ? { error } : {}
+	};
+};
+const parseComposerChipKey = (value) => {
+	if (typeof value !== "string") return null;
+	const key = value.trim();
+	if (!key || key.length > 80) return null;
+	return key;
+};
+const parseAppComposerChipSet = (value) => {
+	if (!isSurfaceEnvelope(value) || value.type !== "composer.chip.set" || !isRecord(value.chip)) return null;
+	const key = parseComposerChipKey(value.chip.key);
+	if (!key || typeof value.chip.label !== "string" || typeof value.chip.content !== "string") return null;
+	const label = value.chip.label.trim();
+	if (!label || label.length > 120) return null;
+	if (!value.chip.content.trim()) return null;
+	if (new TextEncoder().encode(value.chip.content).length > 32768) return null;
+	return {
+		protocol: APP_SURFACE_PROTOCOL,
+		version: 1,
+		type: "composer.chip.set",
+		chip: {
+			key,
+			label,
+			content: value.chip.content
+		}
+	};
+};
+const parseAppComposerChipClear = (value) => {
+	if (!isSurfaceEnvelope(value) || value.type !== "composer.chip.clear") return null;
+	const key = parseComposerChipKey(value.key);
+	return key ? {
+		protocol: APP_SURFACE_PROTOCOL,
+		version: 1,
+		type: "composer.chip.clear",
+		key
+	} : null;
+};
+const parseAppSurfaceRequest = (value) => {
+	if (!isSurfaceEnvelope(value) || value.type !== "request") return null;
+	if (typeof value.requestId !== "string" || !value.requestId) return null;
+	if (typeof value.method !== "string" || !value.method) return null;
+	const commandId = parseDesktopCommandId(value.commandId);
+	if (!commandId) return null;
+	return {
+		protocol: APP_SURFACE_PROTOCOL,
+		version: 1,
+		type: "request",
+		requestId: value.requestId,
+		method: value.method,
+		...value.input === void 0 ? {} : { input: value.input },
+		commandId
+	};
+};
+const buildAppSurfaceReady = (methods) => ({
+	protocol: APP_SURFACE_PROTOCOL,
+	version: 1,
+	type: "ready",
+	methods: [...methods]
+});
+const buildAppSurfaceRequest = (input) => ({
+	protocol: APP_SURFACE_PROTOCOL,
+	version: 1,
+	type: "request",
+	...input
+});
+const buildAppSurfaceResponse = (input) => ({
+	protocol: APP_SURFACE_PROTOCOL,
+	version: 1,
+	type: "response",
+	...input
+});
+const buildAppComposerChipSet = (chip) => ({
+	protocol: APP_SURFACE_PROTOCOL,
+	version: 1,
+	type: "composer.chip.set",
+	chip
+});
+const buildAppComposerChipClear = (key) => ({
+	protocol: APP_SURFACE_PROTOCOL,
+	version: 1,
+	type: "composer.chip.clear",
+	key
+});
+//#endregion
+//#region ../protocol/dist/app-runtime.js
+const APP_RUNTIME_PROTOCOL = "cohub.app.runtime";
+const buildAppRuntimeReady = () => ({
+	protocol: APP_RUNTIME_PROTOCOL,
+	version: 1,
+	type: "ready"
+});
+//#endregion
 //#region src/apis/billing.ts
 var BillingApi = class {
 	transport;
@@ -316,194 +1362,7 @@ var BillingApi = class {
 	}
 };
 //#endregion
-//#region ../protocol/dist/realtime/schema.js
-const contentBlockMetaSchema = z.record(z.string(), z.unknown());
-const realtimeRoomSchema = z.string().regex(/^(space|user|board|room):[^:]+$/);
-const contentBlockSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("text"),
-		text: z.string(),
-		_meta: contentBlockMetaSchema.optional()
-	}),
-	z.object({
-		type: z.literal("thinking"),
-		thinking: z.string(),
-		signature: z.string().optional(),
-		_meta: contentBlockMetaSchema.optional()
-	}),
-	z.object({
-		type: z.literal("image"),
-		source: z.union([z.object({
-			type: z.literal("url"),
-			url: z.string().url()
-		}), z.object({
-			type: z.literal("base64"),
-			media_type: z.string(),
-			data: z.string()
-		})]),
-		_meta: contentBlockMetaSchema.optional()
-	}),
-	z.object({
-		type: z.literal("shell_command"),
-		command: z.string(),
-		rawText: z.string(),
-		_meta: contentBlockMetaSchema.optional()
-	}),
-	z.object({
-		type: z.literal("tool_use"),
-		id: z.string(),
-		name: z.string(),
-		input: z.record(z.string(), z.unknown()),
-		_meta: contentBlockMetaSchema.optional()
-	}),
-	z.object({
-		type: z.literal("tool_result"),
-		tool_use_id: z.string(),
-		content: z.union([z.string(), z.array(z.unknown())]),
-		is_error: z.boolean().optional(),
-		_meta: contentBlockMetaSchema.optional()
-	}),
-	z.object({
-		type: z.literal("system_note"),
-		note_type: z.enum([
-			"session_created",
-			"forked",
-			"compacted",
-			"info"
-		]),
-		text: z.string(),
-		_meta: contentBlockMetaSchema.optional()
-	})
-]);
-z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("auth"),
-		requestId: z.string().optional(),
-		payload: z.object({
-			token: z.string().min(1),
-			capabilities: z.array(z.string().min(1)).optional()
-		})
-	}),
-	z.object({
-		type: z.literal("subscribe"),
-		requestId: z.string().optional(),
-		payload: z.object({ rooms: z.array(realtimeRoomSchema).min(1) })
-	}),
-	z.object({
-		type: z.literal("unsubscribe"),
-		requestId: z.string().optional(),
-		payload: z.object({ rooms: z.array(realtimeRoomSchema).min(1) })
-	}),
-	z.object({
-		type: z.literal("session.message.create"),
-		requestId: z.string().optional(),
-		payload: z.object({
-			spaceId: z.string().uuid(),
-			sessionId: z.string().uuid(),
-			clientMessageId: z.string().optional(),
-			content: z.array(contentBlockSchema).min(1),
-			model: z.string().optional(),
-			provider: z.string().optional(),
-			thinkingLevel: z.enum([
-				"off",
-				"minimal",
-				"low",
-				"medium",
-				"high",
-				"xhigh",
-				"max"
-			]).optional()
-		})
-	}),
-	z.object({
-		type: z.literal("presence.update"),
-		requestId: z.string().optional(),
-		payload: z.object({
-			spaceId: z.string().uuid(),
-			meta: z.record(z.string(), z.unknown()).nullable().optional()
-		})
-	}),
-	z.object({
-		type: z.literal("board.awareness.update"),
-		requestId: z.string().optional(),
-		payload: BoardAwarenessClientPayloadSchema
-	}),
-	z.object({
-		type: z.literal("realtime.room.join"),
-		requestId: z.string().optional(),
-		payload: z.object({
-			roomId: z.string().uuid(),
-			ticket: z.string().min(1)
-		})
-	}),
-	z.object({
-		type: z.literal("realtime.room.publish"),
-		requestId: z.string().optional(),
-		payload: z.object({
-			roomId: z.string().uuid(),
-			event: z.string().regex(REALTIME_ROOM_EVENT_NAME_PATTERN),
-			data: z.unknown(),
-			clientEventId: z.string().max(128).optional()
-		})
-	}),
-	z.object({
-		type: z.literal("realtime.room.leave"),
-		requestId: z.string().optional(),
-		payload: z.object({ roomId: z.string().uuid() })
-	}),
-	z.object({
-		type: z.literal("realtime.room.presence.update"),
-		requestId: z.string().optional(),
-		payload: z.object({
-			roomId: z.string().uuid(),
-			presence: z.record(z.string(), z.unknown()).nullable()
-		})
-	}),
-	z.object({
-		type: z.literal("ping"),
-		requestId: z.string().optional(),
-		payload: z.record(z.string(), z.unknown()).optional()
-	}),
-	z.object({
-		type: z.literal("ack"),
-		requestId: z.string().optional(),
-		payload: z.object({ eventId: z.string().optional() }).optional()
-	})
-]);
-z.object({
-	id: z.string(),
-	timestamp: z.number(),
-	domain: z.enum(REALTIME_DOMAINS),
-	type: z.string(),
-	requestId: z.string().nullable().optional(),
-	spaceId: z.string().nullable().optional(),
-	sessionId: z.string().nullable().optional(),
-	rooms: z.array(realtimeRoomSchema).optional(),
-	payload: z.record(z.string(), z.unknown())
-});
-z.discriminatedUnion("t", [z.object({
-	t: z.literal("d"),
-	sid: z.string().min(1),
-	s: z.number().int().nonnegative(),
-	b: z.number().int().nonnegative(),
-	v: z.unknown()
-}), z.object({
-	t: z.literal("p"),
-	sid: z.string().min(1),
-	s: z.number().int().nonnegative(),
-	b: z.number().int().nonnegative(),
-	o: z.enum([
-		"append",
-		"replace",
-		"add",
-		"merge",
-		"remove"
-	]),
-	p: z.string().min(1),
-	v: z.unknown().optional()
-})]);
-//#endregion
-//#region src/apis/work-realtime.ts
+//#region src/apis/app-realtime.ts
 const randomId = () => globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
 const textEncoder = new TextEncoder();
 const byteLength = (text) => textEncoder.encode(text).byteLength;
@@ -527,7 +1386,7 @@ const isRoomEvent = (event, roomId) => {
 	if (event.domain !== "room") return false;
 	return event.payload.roomId === roomId || event.rooms?.includes(`room:${roomId}`);
 };
-var WorkRoom = class {
+var AppRoom = class {
 	websocket;
 	admission;
 	id;
@@ -719,7 +1578,7 @@ var WorkRoom = class {
 			if (this.state === "expired") return;
 			this.setState("closed");
 			this.dispose();
-			console.warn("[Cohub WorkRoom] failed to rejoin room", error);
+			console.warn("[Cohub AppRoom] failed to rejoin room", error);
 		}
 	}
 	async joinOverWebsocket(isReconnect) {
@@ -884,7 +1743,7 @@ var WorkRoom = class {
 		this.expiryTimer = null;
 	}
 };
-var WorkRealtimeApi = class {
+var AppRealtimeApi = class {
 	transport;
 	websocket;
 	getContext;
@@ -894,7 +1753,7 @@ var WorkRealtimeApi = class {
 		this.getContext = getContext;
 	}
 	async createRoom(input = {}) {
-		const admission = await this.transport.request(`/api/works/${encodeURIComponent(await this.requireWorkId())}/realtime/rooms`, {
+		const admission = await this.transport.request(`/api/apps/${encodeURIComponent(await this.requireAppId())}/realtime/rooms`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(input)
@@ -902,20 +1761,20 @@ var WorkRealtimeApi = class {
 		return this.openRoom(admission);
 	}
 	async joinRoom(input) {
-		const admission = await this.transport.request(`/api/works/${encodeURIComponent(await this.requireWorkId())}/realtime/rooms/join`, {
+		const admission = await this.transport.request(`/api/apps/${encodeURIComponent(await this.requireAppId())}/realtime/rooms/join`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(input)
 		});
 		return this.openRoom(admission);
 	}
-	async requireWorkId() {
+	async requireAppId() {
 		const context = await this.getContext();
-		if (!context?.work?.id) throw new Error("Work context is unavailable — not running inside a published Work runtime.");
-		return context.work.id;
+		if (!context?.app?.id) throw new Error("App context is unavailable — not running inside a published app runtime.");
+		return context.app.id;
 	}
 	async openRoom(admission) {
-		const room = new WorkRoom(this.websocket, admission);
+		const room = new AppRoom(this.websocket, admission);
 		try {
 			await room.connect();
 			return room;
@@ -925,11 +1784,15 @@ var WorkRealtimeApi = class {
 		}
 	}
 };
+/** @deprecated Use `AppRealtimeApi`. */
+var WorkRealtimeApi = class extends AppRealtimeApi {};
+/** @deprecated Use `AppRoom`. */
+var WorkRoom = class extends AppRoom {};
 //#endregion
-//#region src/work-surface.ts
+//#region src/app-surface.ts
 /**
-* Explicit app origins, not a Cohub suffix match: Works themselves are
-* served from Cohub subdomains, so a suffix match would let one Work call into
+* Explicit app origins, not a Cohub suffix match: apps themselves are
+* served from Cohub subdomains, so a suffix match would let one app call into
 * another and turn a subdomain takeover into surface access.
 */
 const COHUB_APP_ORIGINS = [
@@ -952,7 +1815,7 @@ const resolveEmbedderOrigin = () => {
 		return null;
 	}
 };
-var WorkSurfaceApi = class {
+var AppSurfaceApi = class {
 	handlers = /* @__PURE__ */ new Map();
 	listening = false;
 	allowedOrigins = null;
@@ -970,7 +1833,7 @@ var WorkSurfaceApi = class {
 	}
 	handle(method, handler) {
 		const name = method.trim();
-		if (!name) throw new Error("Work surface method name is required");
+		if (!name) throw new Error("App surface method name is required");
 		this.handlers.set(name, handler);
 		this.start();
 		this.announce();
@@ -985,17 +1848,17 @@ var WorkSurfaceApi = class {
 		return [...this.handlers.keys()];
 	}
 	setComposerChip(chip) {
-		const message = parseWorkComposerChipSet(buildWorkComposerChipSet(chip));
-		if (!message) throw new Error("Invalid Work composer chip");
+		const message = parseAppComposerChipSet(buildAppComposerChipSet(chip));
+		if (!message) throw new Error("Invalid App composer chip");
 		this.post(message);
 	}
 	clearComposerChip(key) {
-		const message = parseWorkComposerChipClear(buildWorkComposerChipClear(key));
-		if (!message) throw new Error("Invalid Work composer chip key");
+		const message = parseAppComposerChipClear(buildAppComposerChipClear(key));
+		if (!message) throw new Error("Invalid App composer chip key");
 		this.post(message);
 	}
 	announce() {
-		this.post(buildWorkSurfaceReady(this.methods));
+		this.post(buildAppSurfaceReady(this.methods));
 	}
 	isTrusted(origin) {
 		if (!origin || origin === "null") return false;
@@ -1016,7 +1879,7 @@ var WorkSurfaceApi = class {
 	onMessage = (event) => {
 		if (typeof window === "undefined" || event.source !== window.parent) return;
 		if (!this.isTrusted(event.origin)) return;
-		const request = parseWorkSurfaceRequest(event.data);
+		const request = parseAppSurfaceRequest(event.data);
 		if (!request) return;
 		const commandId = request.commandId;
 		if (!commandId) return;
@@ -1026,24 +1889,24 @@ var WorkSurfaceApi = class {
 	async dispatch(requestId, method, input, commandId) {
 		const handler = this.handlers.get(method);
 		if (!handler) {
-			this.post(buildWorkSurfaceResponse({
+			this.post(buildAppSurfaceResponse({
 				requestId,
 				ok: false,
 				error: {
 					code: "method_not_found",
-					message: `This Work does not expose "${method}".`
+					message: `This app does not expose "${method}".`
 				}
 			}));
 			return;
 		}
 		try {
 			await handler(input, { commandId });
-			this.post(buildWorkSurfaceResponse({
+			this.post(buildAppSurfaceResponse({
 				requestId,
 				ok: true
 			}));
 		} catch (error) {
-			this.post(buildWorkSurfaceResponse({
+			this.post(buildAppSurfaceResponse({
 				requestId,
 				ok: false,
 				error: {
@@ -1062,8 +1925,10 @@ var WorkSurfaceApi = class {
 		} catch {}
 	}
 };
+/** @deprecated Use `AppSurfaceApi`. */
+var WorkSurfaceApi = class extends AppSurfaceApi {};
 //#endregion
-//#region src/work-runtime.ts
+//#region src/app-runtime.ts
 const isBrowser$1 = () => typeof window !== "undefined" && typeof window.parent !== "undefined";
 const hasParent = () => isBrowser$1() && window.parent !== window;
 const getParentOrigin = () => {
@@ -1079,11 +1944,39 @@ const getParentOrigin = () => {
 const generateRequestId = () => globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
 /**
 * Bridge-mode transport: posts messages to `window.parent` (the Cohub host
-* embedding the work in an iframe) and listens for the matching reply.
+* embedding the app in an iframe) and listens for the matching reply.
 * Behaviorally identical to the previous module-level `request()` helper.
 */
 var ParentBridgeTransport = class {
 	trustedParentOrigin = null;
+	contextListeners = /* @__PURE__ */ new Set();
+	contextListener = null;
+	subscribeContextChanged(listener) {
+		if (!hasParent()) return () => {};
+		this.contextListeners.add(listener);
+		if (!this.contextListener) {
+			this.contextListener = (event) => {
+				if (event.source !== window.parent) return;
+				const parentOrigin = this.trustedParentOrigin ?? getParentOrigin();
+				if (parentOrigin && event.origin !== parentOrigin) return;
+				const data = event.data;
+				if (data?.type !== "cohub.app.context.changed" || !data.context) return;
+				for (const current of this.contextListeners) current(data.context);
+			};
+			window.addEventListener("message", this.contextListener);
+			const parentOrigin = this.trustedParentOrigin ?? getParentOrigin();
+			if (parentOrigin) try {
+				window.parent.postMessage(buildAppRuntimeReady(), parentOrigin);
+			} catch {}
+		}
+		return () => {
+			this.contextListeners.delete(listener);
+			if (this.contextListeners.size === 0 && this.contextListener) {
+				window.removeEventListener("message", this.contextListener);
+				this.contextListener = null;
+			}
+		};
+	}
 	request(message, options) {
 		const timeoutMs = options?.timeoutMs ?? 1200;
 		const retryIntervalMs = options?.retryIntervalMs;
@@ -1118,7 +2011,7 @@ var ParentBridgeTransport = class {
 				if (!data || data.requestId !== requestId) return;
 				cleanup();
 				this.trustedParentOrigin = event.origin;
-				if (data.type === "cohub.work.error") {
+				if (data.type === "cohub.app.error") {
 					reject(new Error(data.message));
 					return;
 				}
@@ -1131,64 +2024,64 @@ var ParentBridgeTransport = class {
 	}
 };
 /**
-* Broker-mode transport for standalone-deployed works. Opens a popup window to
+* Broker-mode transport for standalone-deployed apps. Opens a popup window to
 * the Cohub auth broker page, performs a ready-handshake, sends the request via
 * postMessage, and resolves with the broker's response. The popup is closed
 * after a single request is fulfilled (one-shot, per §7.2 of the plan).
 *
 * Non-interactive messages (`context`, `checkout-state`) are answered locally
-* without opening a popup — the work already knows its own workId, and
-* checkout state is not available on the work's own origin in broker mode.
+* without opening a popup — the app already knows its own appId, and
+* checkout state is not available on the app's own origin in broker mode.
 */
 var PopupBrokerTransport = class {
 	brokerOrigin;
-	workId;
-	getWorkId;
+	appId;
+	getAppId;
 	constructor(config) {
 		this.brokerOrigin = config.brokerOrigin;
-		this.workId = config.workId;
-		this.getWorkId = config.getWorkId;
-		if (!this.workId && this.getWorkId) this.getWorkId();
+		this.appId = config.appId;
+		this.getAppId = config.getAppId;
+		if (!this.appId && this.getAppId) this.getAppId();
 	}
-	resolveWorkId() {
-		if (this.workId) return Promise.resolve(this.workId);
-		if (this.getWorkId) return this.getWorkId();
+	resolveAppId() {
+		if (this.appId) return Promise.resolve(this.appId);
+		if (this.getAppId) return this.getAppId();
 		return Promise.resolve(null);
 	}
 	async request(message, options) {
-		if (message.type === "cohub.work.context") return {
-			type: "cohub.work.context.result",
+		if (message.type === "cohub.app.context") return {
+			type: "cohub.app.context.result",
 			context: {
-				work: {
-					id: await this.resolveWorkId() ?? "",
+				app: {
+					id: await this.resolveAppId() ?? "",
 					slug: "",
 					url: null
 				},
 				space: { id: "" },
 				permissions: {
 					scopes: [],
-					workScopes: [],
+					appScopes: [],
 					viewerScopes: []
 				}
 			}
 		};
-		if (message.type === "cohub.work.checkout-state") return {
-			type: "cohub.work.checkout-state.result",
+		if (message.type === "cohub.app.checkout-state") return {
+			type: "cohub.app.checkout-state.result",
 			status: null,
 			orderId: null
 		};
 		const timeoutMs = options?.timeoutMs ?? 12e4;
 		const requestId = generateRequestId();
-		const workId = await this.resolveWorkId();
-		if (!workId) throw new Error("Unable to resolve the work id for broker mode. Provide `workId` or a valid slug triple (ownerUsername, spaceSlug, workSlug).");
+		const appId = await this.resolveAppId();
+		if (!appId) throw new Error("Unable to resolve the app id for broker mode. Provide `appId` or a valid slug triple (ownerUsername, spaceSlug, appSlug).");
 		return new Promise((resolve, reject) => {
 			if (typeof window === "undefined" || typeof window.open !== "function") {
 				resolve(null);
 				return;
 			}
-			const workOrigin = window.location.origin;
-			const brokerUrl = `${this.brokerOrigin}/work-auth?work=${encodeURIComponent(workId)}&origin=${encodeURIComponent(workOrigin)}`;
-			const popup = window.open(brokerUrl, "cohub-work-auth", "popup,width=480,height=640");
+			const appOrigin = window.location.origin;
+			const brokerUrl = `${this.brokerOrigin}/app-auth?app=${encodeURIComponent(appId)}&origin=${encodeURIComponent(appOrigin)}`;
+			const popup = window.open(brokerUrl, "cohub-app-auth", "popup,width=480,height=640");
 			if (!popup) {
 				reject(/* @__PURE__ */ new Error("Failed to open authorization window. Please allow popups for this site."));
 				return;
@@ -1219,7 +2112,7 @@ var PopupBrokerTransport = class {
 				if (event.origin !== this.brokerOrigin) return;
 				const data = event.data;
 				if (!data) return;
-				if (data.type === "cohub.work.broker.ready" && !ready) {
+				if (data.type === "cohub.app.broker.ready" && !ready) {
 					ready = true;
 					try {
 						popup.postMessage({
@@ -1233,7 +2126,7 @@ var PopupBrokerTransport = class {
 				}
 				if (data.requestId !== requestId) return;
 				finish(() => {
-					if (data.type === "cohub.work.error") {
+					if (data.type === "cohub.app.error") {
 						reject(new Error(data.message));
 						return;
 					}
@@ -1250,30 +2143,30 @@ var PopupBrokerTransport = class {
 		});
 	}
 };
-const TOKEN_STORAGE_PREFIX = "cohub:work-token";
-const AUTHORIZED_SCOPES_STORAGE_PREFIX = "cohub:work-auth-scopes";
-var WorkRuntimeApi = class {
+const TOKEN_STORAGE_PREFIX = "cohub:app-token";
+const AUTHORIZED_SCOPES_STORAGE_PREFIX = "cohub:app-auth-scopes";
+var AppRuntimeApi = class {
 	token = null;
 	transport;
 	tokenStorageKey;
 	scopesStorageKey;
-	workIdResolver;
+	appIdResolver;
 	/** Ensures storage keys are resolved (via slug lookup) at most once. */
 	storageKeysReady;
 	/** Scopes previously granted via requestAuthorization, retained so token
 	* refreshes can re-authorize (preserving viewerScopes) instead of falling
-	* back to a base session token that only carries workScopes. */
+	* back to a base session token that only carries appScopes. */
 	authorizedScopes = null;
-	constructor(transport = new ParentBridgeTransport(), workId, workIdResolver) {
+	constructor(transport = new ParentBridgeTransport(), appId, appIdResolver) {
 		this.transport = transport;
-		this.workIdResolver = workIdResolver;
-		if (workId) {
-			this.tokenStorageKey = `${TOKEN_STORAGE_PREFIX}:${workId}`;
-			this.scopesStorageKey = `${AUTHORIZED_SCOPES_STORAGE_PREFIX}:${workId}`;
+		this.appIdResolver = appIdResolver;
+		if (appId) {
+			this.tokenStorageKey = `${TOKEN_STORAGE_PREFIX}:${appId}`;
+			this.scopesStorageKey = `${AUTHORIZED_SCOPES_STORAGE_PREFIX}:${appId}`;
 			this.storageKeysReady = Promise.resolve();
 			this.token = this.readStoredToken();
 			this.authorizedScopes = this.readStoredScopes();
-		} else if (workIdResolver) {
+		} else if (appIdResolver) {
 			this.tokenStorageKey = null;
 			this.scopesStorageKey = null;
 			this.storageKeysReady = null;
@@ -1284,17 +2177,17 @@ var WorkRuntimeApi = class {
 		}
 	}
 	/**
-	* Resolves the localStorage keys once the workId is known. When the workId is
+	* Resolves the localStorage keys once the appId is known. When the appId is
 	* only available via slug reverse lookup, this performs the lookup on first
-	* use and then restores any cached token/scopes for that workId.
+	* use and then restores any cached token/scopes for that appId.
 	*/
 	ensureStorageKeys() {
 		if (this.storageKeysReady) return this.storageKeysReady;
 		this.storageKeysReady = (async () => {
-			const workId = this.workIdResolver ? await this.workIdResolver() : null;
-			if (workId) {
-				this.tokenStorageKey = `${TOKEN_STORAGE_PREFIX}:${workId}`;
-				this.scopesStorageKey = `${AUTHORIZED_SCOPES_STORAGE_PREFIX}:${workId}`;
+			const appId = this.appIdResolver ? await this.appIdResolver() : null;
+			if (appId) {
+				this.tokenStorageKey = `${TOKEN_STORAGE_PREFIX}:${appId}`;
+				this.scopesStorageKey = `${AUTHORIZED_SCOPES_STORAGE_PREFIX}:${appId}`;
 				const stored = this.readStoredToken();
 				if (stored && !this.token) this.token = stored;
 				const storedScopes = this.readStoredScopes();
@@ -1337,11 +2230,14 @@ var WorkRuntimeApi = class {
 		} catch {}
 	}
 	async context() {
-		return (await this.transport.request({ type: "cohub.work.context" }, {
+		return (await this.transport.request({ type: "cohub.app.context" }, {
 			timeoutMs: 8e3,
 			retryIntervalMs: 250
 		}))?.context ?? null;
 	}
+	onContextChanged(listener) {
+		return this.transport.subscribeContextChanged?.(listener) ?? (() => {});
+	}
 	async getAccessToken(options) {
 		await this.ensureStorageKeys();
 		if (this.token && !options?.forceRefresh) return this.token;
@@ -1351,7 +2247,7 @@ var WorkRuntimeApi = class {
 		}
 		if (options?.forceRefresh && this.authorizedScopes && this.authorizedScopes.length > 0) {
 			const response = await this.transport.request({
-				type: "cohub.work.authorize",
+				type: "cohub.app.authorize",
 				scopes: this.authorizedScopes
 			}, { timeoutMs: 12e4 });
 			this.token = response?.token ?? null;
@@ -1359,7 +2255,7 @@ var WorkRuntimeApi = class {
 			return this.token;
 		}
 		const response = await this.transport.request({
-			type: "cohub.work.token",
+			type: "cohub.app.token",
 			forceRefresh: Boolean(options?.forceRefresh)
 		}, { timeoutMs: 2e4 });
 		this.token = response?.token ?? null;
@@ -1369,7 +2265,7 @@ var WorkRuntimeApi = class {
 	async requestAuthorization(input) {
 		await this.ensureStorageKeys();
 		const response = await this.transport.request({
-			type: "cohub.work.authorize",
+			type: "cohub.app.authorize",
 			scopes: input.scopes,
 			reason: input.reason
 		}, { timeoutMs: 12e4 });
@@ -1384,32 +2280,34 @@ var WorkRuntimeApi = class {
 	async purchase(input) {
 		const purchaseAttemptId = input.purchaseAttemptId?.trim() || generateRequestId();
 		return (await this.transport.request({
-			type: "cohub.work.purchase",
+			type: "cohub.app.purchase",
 			productKey: input.productKey,
 			purchaseAttemptId
 		}, { timeoutMs: 12e4 }))?.checkout ?? null;
 	}
 	async checkoutState() {
-		return await this.transport.request({ type: "cohub.work.checkout-state" }, {
+		return await this.transport.request({ type: "cohub.app.checkout-state" }, {
 			timeoutMs: 8e3,
 			retryIntervalMs: 250
 		}) ?? null;
 	}
 };
 /**
-* Builds a memoized workId resolver that reverse-looks-up the workId from the
-* public slug triple via `GET /api/works/by-slug/:username/:spaceSlug/:workSlug`.
-* The endpoint is anonymous (no auth) for public works, so no token is needed.
-* The result is cached; a failed lookup is not cached so it can be retried.
+* Builds a memoized appId resolver that reverse-looks-up the appId from the
+* public slug triple via `GET /api/apps/by-slug/:username/:spaceSlug/:appSlug`
+* (the works REST routes are dual-mounted; `/api/works` keeps serving older
+* consumers with identical payloads). The endpoint is
+* anonymous (no auth) for public apps, so no token is needed. The result is
+* cached; a failed lookup is not cached so it can be retried.
 */
-function createSlugWorkIdResolver(deps) {
+function createSlugAppIdResolver(deps) {
 	let cached = null;
 	return () => {
 		if (cached) return cached;
 		const run = (async () => {
 			const doFetch = deps.fetch ?? globalThis.fetch;
 			if (typeof doFetch !== "function") return null;
-			const response = await doFetch(`${deps.apiBaseUrl}/api/works/by-slug/${encodeURIComponent(deps.ownerUsername)}/${encodeURIComponent(deps.spaceSlug)}/${encodeURIComponent(deps.workSlug)}`);
+			const response = await doFetch(`${deps.apiBaseUrl}/api/apps/by-slug/${encodeURIComponent(deps.ownerUsername)}/${encodeURIComponent(deps.spaceSlug)}/${encodeURIComponent(deps.appSlug)}`);
 			if (!response.ok) throw new Error(`getBySlug failed: ${response.status}`);
 			return (await response.json())?.work?.id ?? null;
 		})().catch(() => {
@@ -1421,27 +2319,27 @@ function createSlugWorkIdResolver(deps) {
 	};
 }
 /**
-* Resolves the appropriate transport based on the work mode configuration.
+* Resolves the appropriate transport based on the app mode configuration.
 * Auto-detection: inside an iframe → bridge; standalone with broker config →
-* broker; otherwise → bridge (returns null for non-work contexts).
+* broker; otherwise → bridge (returns null for non-app contexts).
 */
-function resolveWorkTransport(config, workIdResolver) {
+function resolveAppTransport(config, appIdResolver) {
 	const explicitMode = config?.mode;
 	const brokerOrigin = config?.brokerOrigin;
-	const workId = config?.workId;
-	const canResolveWorkId = Boolean(workId || workIdResolver);
-	const hasBrokerConfig = Boolean(brokerOrigin && canResolveWorkId);
-	const createBroker = () => brokerOrigin && canResolveWorkId ? new PopupBrokerTransport({
+	const appId = config?.appId;
+	const canResolveAppId = Boolean(appId || appIdResolver);
+	const hasBrokerConfig = Boolean(brokerOrigin && canResolveAppId);
+	const createBroker = () => brokerOrigin && canResolveAppId ? new PopupBrokerTransport({
 		brokerOrigin,
-		workId,
-		getWorkId: workIdResolver
+		appId,
+		getAppId: appIdResolver
 	}) : new ParentBridgeTransport();
 	if (explicitMode === "bridge") return new ParentBridgeTransport();
 	if (explicitMode === "broker") return createBroker();
 	if (typeof window !== "undefined" && window.parent !== window) return new ParentBridgeTransport();
 	return hasBrokerConfig ? createBroker() : new ParentBridgeTransport();
 }
-const createWorkRuntime = (transport, workId, workIdResolver) => new WorkRuntimeApi(transport, workId, workIdResolver);
+const createAppRuntime = (transport, appId, appIdResolver) => new AppRuntimeApi(transport, appId, appIdResolver);
 //#endregion
 //#region src/client.ts
 var CohubClient = class {
@@ -1460,27 +2358,40 @@ var CohubClient = class {
 	references;
 	tasks;
 	cronJobs;
-	ui;
+	desktop;
 	invite;
 	referrals;
 	voice;
-	works;
-	workCommerce;
+	apps;
+	appCommerce;
+	/** @deprecated Use `client.desktop`. */
+	get ui() {
+		return this.desktop;
+	}
+	/** @deprecated Use `client.apps`. */
+	get works() {
+		return this.apps;
+	}
+	/** @deprecated Use `client.appCommerce`. */
+	get workCommerce() {
+		return this.appCommerce;
+	}
 	transport;
 	websocketClient;
-	workRuntime;
+	appRuntime;
 	constructor(options = {}) {
 		const apiBaseUrl = resolveApiBaseUrl(options);
-		const workIdResolver = !options.work?.workId && options.work?.ownerUsername && options.work?.spaceSlug && options.work?.workSlug ? createSlugWorkIdResolver({
+		const appRuntime = options.app ?? options.work;
+		const appIdResolver = !appRuntime?.appId && appRuntime?.ownerUsername && appRuntime?.spaceSlug && appRuntime?.appSlug ? createSlugAppIdResolver({
 			apiBaseUrl,
 			fetch: options.fetch,
-			ownerUsername: options.work.ownerUsername,
-			spaceSlug: options.work.spaceSlug,
-			workSlug: options.work.workSlug
+			ownerUsername: appRuntime.ownerUsername,
+			spaceSlug: appRuntime.spaceSlug,
+			appSlug: appRuntime.appSlug
 		}) : void 0;
-		const workTransport = resolveWorkTransport(options.work, workIdResolver);
-		this.workRuntime = createWorkRuntime(workTransport, options.work?.workId, workIdResolver);
-		const getAccessToken = options.getAccessToken ?? ((tokenOptions) => this.workRuntime.getAccessToken(tokenOptions));
+		const appTransport = resolveAppTransport(appRuntime, appIdResolver);
+		this.appRuntime = createAppRuntime(appTransport, appRuntime?.appId, appIdResolver);
+		const getAccessToken = options.getAccessToken ?? ((tokenOptions) => this.appRuntime.getAccessToken(tokenOptions));
 		const resolvedOptions = {
 			...options,
 			getAccessToken
@@ -1517,55 +2428,56 @@ var CohubClient = class {
 		this.references = new ReferencesApi(this.transport);
 		this.tasks = new TasksApi(this.transport);
 		this.cronJobs = new CronJobsApi(this.transport);
-		this.ui = new UiCommandsApi(this.transport);
+		this.desktop = new DesktopCommandsApi(this.transport);
 		this.invite = new PublicInviteApi(this.transport);
 		this.referrals = new ReferralsApi(this.transport);
-		this.works = new WorksApi(this.transport);
-		this.workCommerce = new WorkCommerceApi(this.transport);
-		this.work.realtime = new WorkRealtimeApi(this.transport, this.websocketClient, () => this.workRuntime.context());
+		this.apps = new AppsApi(this.transport);
+		this.appCommerce = new AppCommerceApi(this.transport);
+		this.app.realtime = new AppRealtimeApi(this.transport, this.websocketClient, () => this.appRuntime.context());
 	}
 	context() {
-		return this.workRuntime.context();
+		return this.appRuntime.context();
 	}
-	auth = { request: (input) => this.workRuntime.requestAuthorization(input) };
-	work = {
+	auth = { request: (input) => this.appRuntime.requestAuthorization(input) };
+	app = {
 		realtime: null,
-		/** Expose callable methods from inside a published Work. */
-		surface: new WorkSurfaceApi(),
+		/** Expose callable methods from inside a published app. */
+		surface: new AppSurfaceApi(),
+		onContextChanged: (listener) => this.appRuntime.onContextChanged(listener),
 		composer: {
-			/** Attach or update context from this Work in the Cohub composer. */
-			setChip: (chip) => this.work.surface.setComposerChip(chip),
-			/** Remove context previously attached by this Work. */
-			clearChip: (key) => this.work.surface.clearComposerChip(key)
+			/** Attach or update context from this app in the Cohub composer. */
+			setChip: (chip) => this.app.surface.setComposerChip(chip),
+			/** Remove context previously attached by this app. */
+			clearChip: (key) => this.app.surface.clearComposerChip(key)
 		},
 		commerce: {
 			resolveProducts: async (input) => {
-				const context = await this.workRuntime.context();
-				if (!context?.work?.id) throw new Error("Work context is unavailable — not running inside a published Work runtime.");
-				return this.workCommerce.resolveProducts(context.work.id, input);
+				const context = await this.appRuntime.context();
+				if (!context?.app?.id) throw new Error("App context is unavailable — not running inside a published app runtime.");
+				return this.appCommerce.resolveProducts(context.app.id, input);
 			},
 			getEntitlements: async () => {
-				const context = await this.workRuntime.context();
-				if (!context?.work?.id) throw new Error("Work context is unavailable — not running inside a published Work runtime.");
-				return this.workCommerce.getEntitlements(context.work.id);
+				const context = await this.appRuntime.context();
+				if (!context?.app?.id) throw new Error("App context is unavailable — not running inside a published app runtime.");
+				return this.appCommerce.getEntitlements(context.app.id);
 			},
 			consumeCredits: async (input) => {
-				const context = await this.workRuntime.context();
-				if (!context?.work?.id) throw new Error("Work context is unavailable — not running inside a published Work runtime.");
-				return this.workCommerce.consumeCredits(context.work.id, input);
+				const context = await this.appRuntime.context();
+				if (!context?.app?.id) throw new Error("App context is unavailable — not running inside a published app runtime.");
+				return this.appCommerce.consumeCredits(context.app.id, input);
 			},
-			purchase: async (input) => this.workRuntime.purchase(input),
+			purchase: async (input) => this.appRuntime.purchase(input),
 			getCheckoutState: async () => {
-				const result = await this.workRuntime.checkoutState();
+				const result = await this.appRuntime.checkoutState();
 				return {
 					status: result?.status ?? null,
 					orderId: result?.orderId ?? null
 				};
 			},
 			getOrder: async (orderId) => {
-				const context = await this.workRuntime.context();
-				if (!context?.work?.id) throw new Error("Work context is unavailable — not running inside a published Work runtime.");
-				return this.workCommerce.getOrder(context.work.id, orderId);
+				const context = await this.appRuntime.context();
+				if (!context?.app?.id) throw new Error("App context is unavailable — not running inside a published app runtime.");
+				return this.appCommerce.getOrder(context.app.id, orderId);
 			}
 		}
 	};
@@ -1623,8 +2535,8 @@ var CohubClient = class {
 };
 const createCohubClient = (options) => new CohubClient(options);
 //#endregion
-//#region src/work-ref.ts
-const isWorkId = (value) => isUuid(value.trim());
+//#region src/app-ref.ts
+const isAppId = (value) => isUuid(value.trim());
 function decodePart(value) {
 	try {
 		return decodeURIComponent(value).trim();
@@ -1634,14 +2546,14 @@ function decodePart(value) {
 }
 function publicRef(parts) {
 	if (parts.length !== 3) return null;
-	const [usernameRaw = "", spaceSlugRaw = "", workSlugRaw = ""] = parts.map(decodePart);
+	const [usernameRaw = "", spaceSlugRaw = "", appSlugRaw = ""] = parts.map(decodePart);
 	const username = parseUsername(usernameRaw);
 	const spaceSlug = parseSpaceSlug(spaceSlugRaw);
-	const workSlug = parseSpaceSlug(workSlugRaw);
-	return username && spaceSlug && workSlug ? {
+	const appSlug = parseSpaceSlug(appSlugRaw);
+	return username && spaceSlug && appSlug ? {
 		username,
 		spaceSlug,
-		workSlug
+		appSlug
 	} : null;
 }
 function launchState(url) {
@@ -1658,15 +2570,22 @@ function parseUrlRef(value) {
 		return null;
 	}
 	const parts = url.pathname.split("/").filter(Boolean);
-	if (url.protocol === "cohub:" && url.hostname === "works") {
+	if (url.protocol === "cohub:" && (url.hostname === "apps" || url.hostname === "works")) {
 		const ref = publicRef(parts);
 		return ref ? {
 			...ref,
 			...launchState(url)
 		} : null;
 	}
+	if (url.protocol === "app:" || url.protocol === "work:") {
+		const ref = publicRef([url.hostname, ...parts]);
+		return ref ? {
+			...ref,
+			...launchState(url)
+		} : null;
+	}
 	if (url.protocol !== "http:" && url.protocol !== "https:") return null;
-	if (parts.length === 4 && parts[0] === "spaces" && isUuid(parts[1] ?? "") && parts[2] === "works" && isUuid(parts[3] ?? "")) return { id: parts[3] };
+	if (parts.length === 4 && parts[0] === "spaces" && isUuid(parts[1] ?? "") && (parts[2] === "apps" || parts[2] === "works") && isUuid(parts[3] ?? "")) return { id: parts[3] };
 	if (parts.length === 4 && parts[2] === "w") {
 		const ref = publicRef([
 			parts[0],
@@ -1680,13 +2599,13 @@ function parseUrlRef(value) {
 	}
 	return null;
 }
-var WorkRefParseError = class extends Error {
+var AppRefParseError = class extends Error {
 	constructor() {
-		super("Work must be an id, public URL, cohub://works URI, or username/space/work reference");
-		this.name = "WorkRefParseError";
+		super("App must be an id, public URL, cohub://apps URI, or username/space/app reference");
+		this.name = "AppRefParseError";
 	}
 };
-function parseWorkRef(input) {
+function parseAppRef(input) {
 	const value = input.trim();
 	if (isUuid(value)) return { id: value };
 	const parsedUrl = parseUrlRef(value.includes("://") ? value : value.startsWith("/") ? `https://cohub.invalid${value}` : value);
@@ -1694,21 +2613,29 @@ function parseWorkRef(input) {
 	const parts = value.split("/").filter(Boolean);
 	const parsedPublic = parts.length === 3 ? publicRef(parts) : null;
 	if (parsedPublic) return parsedPublic;
-	throw new WorkRefParseError();
+	throw new AppRefParseError();
 }
-function formatWorkRef(ref) {
-	return "id" in ref ? ref.id : `${ref.username}/${ref.spaceSlug}/${ref.workSlug}`;
+function formatAppRef(ref) {
+	return "id" in ref ? ref.id : `${ref.username}/${ref.spaceSlug}/${ref.appSlug}`;
 }
+/** @deprecated Use `isAppId`. */
+const isWorkId = isAppId;
+/** @deprecated Use `AppRefParseError`. */
+const WorkRefParseError = AppRefParseError;
+/** @deprecated Use `parseAppRef`. */
+const parseWorkRef = parseAppRef;
+/** @deprecated Use `formatAppRef`. */
+const formatWorkRef = formatAppRef;
 //#endregion
-//#region src/work-grant-cache.ts
+//#region src/app-grant-cache.ts
 const STORAGE_PREFIX = "cohub:work-grants";
 const CACHE_VERSION = 1;
 const MAX_AGE_MS = 336 * 60 * 60 * 1e3;
 function isBrowser() {
 	return typeof localStorage !== "undefined";
 }
-function storageKey(userUuid, workId) {
-	return `${STORAGE_PREFIX}:${encodeURIComponent(userUuid)}:${encodeURIComponent(workId)}:v${CACHE_VERSION}`;
+function storageKey(userUuid, appId) {
+	return `${STORAGE_PREFIX}:${encodeURIComponent(userUuid)}:${encodeURIComponent(appId)}:v${CACHE_VERSION}`;
 }
 function userPrefix(userUuid) {
 	return `${STORAGE_PREFIX}:${encodeURIComponent(userUuid)}:`;
@@ -1719,16 +2646,16 @@ function isPermissionArray(value) {
 function isCachedWorkGrant(value) {
 	if (!value || typeof value !== "object") return false;
 	const record = value;
-	return record.version === CACHE_VERSION && typeof record.userUuid === "string" && typeof record.workId === "string" && isPermissionArray(record.scopes) && typeof record.updatedAt === "number";
+	return record.version === CACHE_VERSION && typeof record.userUuid === "string" && typeof record.appId === "string" && isPermissionArray(record.scopes) && typeof record.updatedAt === "number";
 }
-function readEntry(userUuid, workId) {
+function readEntry(userUuid, appId) {
 	if (!isBrowser()) return null;
-	const key = storageKey(userUuid, workId);
+	const key = storageKey(userUuid, appId);
 	try {
 		const raw = localStorage.getItem(key);
 		if (!raw) return null;
 		const parsed = JSON.parse(raw);
-		if (!isCachedWorkGrant(parsed) || parsed.userUuid !== userUuid || parsed.workId !== workId) {
+		if (!isCachedWorkGrant(parsed) || parsed.userUuid !== userUuid || parsed.appId !== appId) {
 			localStorage.removeItem(key);
 			return null;
 		}
@@ -1748,9 +2675,9 @@ function readEntry(userUuid, workId) {
 * Returns true when the viewer has previously granted every requested scope
 * for this work, allowing a silent re-authorization.
 */
-function hasGrantedWorkScopes(userUuid, workId, scopes) {
-	if (!userUuid || !workId || scopes.length === 0) return false;
-	const entry = readEntry(userUuid, workId);
+function hasGrantedAppScopes(userUuid, appId, scopes) {
+	if (!userUuid || !appId || scopes.length === 0) return false;
+	const entry = readEntry(userUuid, appId);
 	if (!entry) return false;
 	const granted = new Set(entry.scopes);
 	return scopes.every((scope) => granted.has(scope));
@@ -1759,31 +2686,31 @@ function hasGrantedWorkScopes(userUuid, workId, scopes) {
 * Records the granted scopes for a work, merged with any previously granted
 * scopes so a growing permission set stays covered.
 */
-function setGrantedWorkScopes(userUuid, workId, scopes) {
-	if (!userUuid || !workId || scopes.length === 0) return;
-	const existing = readEntry(userUuid, workId);
+function setGrantedAppScopes(userUuid, appId, scopes) {
+	if (!userUuid || !appId || scopes.length === 0) return;
+	const existing = readEntry(userUuid, appId);
 	const merged = Array.from(/* @__PURE__ */ new Set([...existing?.scopes ?? [], ...scopes]));
 	const entry = {
 		version: CACHE_VERSION,
 		userUuid,
-		workId,
+		appId,
 		scopes: merged,
 		updatedAt: Date.now()
 	};
 	if (!isBrowser()) return;
 	try {
-		localStorage.setItem(storageKey(userUuid, workId), JSON.stringify(entry));
+		localStorage.setItem(storageKey(userUuid, appId), JSON.stringify(entry));
 	} catch {}
 }
 /**
-* Clears cached grants. Pass a workId to clear a single work, or omit it to
+* Clears cached grants. Pass a appId to clear a single work, or omit it to
 * clear every cached grant for the user (used on sign-out).
 */
-function clearGrantedWorkScopes(userUuid, workId) {
+function clearGrantedAppScopes(userUuid, appId) {
 	if (!isBrowser() || !userUuid) return;
 	try {
-		if (workId) {
-			localStorage.removeItem(storageKey(userUuid, workId));
+		if (appId) {
+			localStorage.removeItem(storageKey(userUuid, appId));
 			return;
 		}
 		const prefix = userPrefix(userUuid);
@@ -1794,7 +2721,7 @@ function clearGrantedWorkScopes(userUuid, workId) {
 	} catch {}
 }
 //#endregion
-//#region src/work-bridge-core.ts
+//#region src/app-bridge-core.ts
 function readTokenResponse(value) {
 	if (!value || typeof value !== "object") return null;
 	const token = value.token;
@@ -1804,20 +2731,78 @@ function clonePermissionScopes(scopes) {
 	return Array.from(scopes ?? []).filter((scope) => typeof scope === "string");
 }
 /**
-* Framework-agnostic work bridge host core — message handling, work session
+* Framework-agnostic app bridge host core — message handling, app session
 * token minting, authorization (with silent re-grant cache), and
 * purchase/checkout flow — without any rendering or reactive primitives.
 *
-* Both the Cohub iframe host (WorkSurface, Svelte) and the standalone broker
+* Both the Cohub iframe host (AppSurface, Svelte) and the standalone broker
 * page compose this with their own transport-specific reply and auth
 * dependencies. External hosts (e.g. Neta-Studio in React) can do the same.
 */
-function createWorkBridgeCore(config) {
-	const { work, reply, getCheckoutState, getAccessToken, getViewerUuid } = config;
+function createAppBridgeCore(config) {
+	const { app, reply, getCheckoutState, getAccessToken, getViewerUuid } = config;
 	const apiOrigin = config.apiOrigin;
 	const authorizationContext = config.authorizationContext ?? (config.isBackground ? { surface: "background" } : { surface: "page" });
 	const onStateChange = config.onStateChange;
-	let workToken = null;
+	let appToken = null;
+	let activeInvocation;
+	let contextChangeVersion = 0;
+	const legacyRequestIds = /* @__PURE__ */ new Set();
+	async function getContext() {
+		const invocation = activeInvocation !== void 0 ? activeInvocation : config.getInvocation?.() ?? config.invocation;
+		const appScopes = clonePermissionScopes(app.appScopes);
+		const viewerUuid = await getViewerUuid();
+		return {
+			app: {
+				id: app.id,
+				slug: app.slug,
+				url: typeof location !== "undefined" ? location.href : ""
+			},
+			space: { id: app.spaceId },
+			viewer: viewerUuid ? { userUuid: viewerUuid } : null,
+			...invocation ? { invocation: { ...invocation } } : {},
+			permissions: {
+				scopes: appScopes,
+				appScopes,
+				viewerScopes: []
+			}
+		};
+	}
+	function replyForRequest(requestId, payload, complete = false) {
+		const namespace = legacyRequestIds.has(requestId) ? "work" : "app";
+		const type = payload.type;
+		reply(requestId, {
+			...payload,
+			...typeof type === "string" && type.startsWith("cohub.app.") ? { type: type.replace("cohub.app.", `cohub.${namespace}.`) } : {}
+		});
+		if (complete) legacyRequestIds.delete(requestId);
+	}
+	function toLegacyWorkContext(context) {
+		const permissions = context.permissions ? {
+			scopes: context.permissions.scopes,
+			workScopes: context.permissions.appScopes,
+			appScopes: context.permissions.appScopes,
+			viewerScopes: context.permissions.viewerScopes
+		} : void 0;
+		return {
+			work: context.app,
+			space: context.space,
+			...context.viewer !== void 0 ? { viewer: context.viewer } : {},
+			...context.invocation ? { invocation: context.invocation } : {},
+			...permissions ? { permissions } : {}
+		};
+	}
+	async function notifyContextChanged(invocation) {
+		activeInvocation = invocation;
+		const version = ++contextChangeVersion;
+		if (!config.notify) return;
+		const context = await getContext();
+		if (version !== contextChangeVersion) return;
+		config.notify({
+			type: "cohub.app.context.changed",
+			context
+		});
+	}
 	const state = {
 		authOpen: false,
 		pendingAuth: null,
@@ -1831,30 +2816,30 @@ function createWorkBridgeCore(config) {
 	function notify() {
 		onStateChange?.({ ...state });
 	}
-	const pendingPurchaseStorageKey = `cohub-work-purchase:${work.id}`;
-	async function isCurrentViewerWorkOwner() {
+	const pendingPurchaseStorageKey = `cohub-app-purchase:${app.id}`;
+	async function isCurrentViewerAppOwner() {
 		const viewerUuid = await getViewerUuid();
-		return Boolean(viewerUuid && viewerUuid === work.userUuid);
+		return Boolean(viewerUuid && viewerUuid === app.userUuid);
 	}
 	function allowsOwnerAutoAuthorization() {
-		return authorizationContext.surface === "background" || authorizationContext.surface === "preview";
+		return authorizationContext.surface === "background" || authorizationContext.surface === "app";
 	}
 	async function ensureBaseToken(forceRefresh = false) {
-		if (workToken && !forceRefresh) return workToken;
+		if (appToken && !forceRefresh) return appToken;
 		const userToken = await getAccessToken({ forceRefresh });
 		if (!userToken) {
 			await config.requestSignIn(typeof location !== "undefined" ? location.pathname : "/");
 			return null;
 		}
-		const response = await fetch(`${apiOrigin}/api/works/${work.id}/session`, {
+		const response = await fetch(`${apiOrigin}/api/apps/${app.id}/session`, {
 			method: "POST",
 			headers: { Authorization: `Bearer ${userToken}` }
 		});
-		if (!response.ok) throw new Error("Failed to create work session.");
+		if (!response.ok) throw new Error("Failed to create app session.");
 		const token = readTokenResponse(await response.json());
-		if (!token) throw new Error("Invalid work session response.");
-		workToken = token;
-		return workToken;
+		if (!token) throw new Error("Invalid app session response.");
+		appToken = token;
+		return appToken;
 	}
 	async function authorize(scopes) {
 		const userToken = await getAccessToken();
@@ -1862,7 +2847,7 @@ function createWorkBridgeCore(config) {
 			await config.requestSignIn(typeof location !== "undefined" ? location.pathname : "/");
 			return null;
 		}
-		const response = await fetch(`${apiOrigin}/api/works/${work.id}/authorize`, {
+		const response = await fetch(`${apiOrigin}/api/apps/${app.id}/authorize`, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${userToken}`,
@@ -1872,9 +2857,9 @@ function createWorkBridgeCore(config) {
 		});
 		if (!response.ok) throw new Error((await response.json().catch(() => null))?.message ?? "Authorization failed.");
 		const token = readTokenResponse(await response.json());
-		if (!token) throw new Error("Invalid work authorization response.");
-		workToken = token;
-		return workToken;
+		if (!token) throw new Error("Invalid app authorization response.");
+		appToken = token;
+		return appToken;
 	}
 	function writePendingPurchase(input) {
 		if (typeof sessionStorage === "undefined") return;
@@ -1913,7 +2898,7 @@ function createWorkBridgeCore(config) {
 			return null;
 		}
 		const promotionAttribution = config.getPromotionAttribution?.() ?? null;
-		const response = await fetch(`${apiOrigin}/api/works/${work.id}/commerce/purchase`, {
+		const response = await fetch(`${apiOrigin}/api/apps/${app.id}/commerce/purchase`, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${userToken}`,
@@ -1931,62 +2916,49 @@ function createWorkBridgeCore(config) {
 	async function handleMessage(event) {
 		const data = event.data;
 		if (!data?.requestId) return;
+		const isLegacyWork = data.type?.startsWith("cohub.work.") === true;
+		if (isLegacyWork) legacyRequestIds.add(data.requestId);
 		try {
-			if (data.type === "cohub.work.context") {
-				const workScopes = clonePermissionScopes(work.workScopes);
-				const viewerUuid = await getViewerUuid();
-				reply(data.requestId, {
-					type: "cohub.work.context.result",
-					context: {
-						work: {
-							id: work.id,
-							slug: work.slug,
-							url: typeof location !== "undefined" ? location.href : ""
-						},
-						space: { id: work.spaceId },
-						viewer: viewerUuid ? { userUuid: viewerUuid } : null,
-						...config.invocation ? { invocation: { ...config.invocation } } : {},
-						permissions: {
-							scopes: workScopes,
-							workScopes,
-							viewerScopes: []
-						}
-					}
-				});
+			if (data.type === "cohub.app.context" || data.type === "cohub.work.context") {
+				const context = await getContext();
+				replyForRequest(data.requestId, {
+					type: "cohub.app.context.result",
+					context: isLegacyWork ? toLegacyWorkContext(context) : context
+				}, true);
 			}
-			if (data.type === "cohub.work.token") {
+			if (data.type === "cohub.app.token" || data.type === "cohub.work.token") {
 				const token = await ensureBaseToken(Boolean(data.forceRefresh));
-				reply(data.requestId, {
-					type: "cohub.work.token.result",
+				replyForRequest(data.requestId, {
+					type: "cohub.app.token.result",
 					token
-				});
+				}, true);
 			}
-			if (data.type === "cohub.work.checkout-state") {
+			if (data.type === "cohub.app.checkout-state" || data.type === "cohub.work.checkout-state") {
 				const pending = readPendingPurchase();
 				const checkoutState = getCheckoutState();
 				const orderId = checkoutState.orderId ?? pending?.orderId ?? null;
 				if (checkoutState.status && checkoutState.orderId) clearPendingPurchase();
-				reply(data.requestId, {
-					type: "cohub.work.checkout-state.result",
+				replyForRequest(data.requestId, {
+					type: "cohub.app.checkout-state.result",
 					status: checkoutState.status,
 					orderId
-				});
+				}, true);
 			}
-			if (data.type === "cohub.work.purchase") {
+			if (data.type === "cohub.app.purchase" || data.type === "cohub.work.purchase") {
 				const productKey = typeof data.productKey === "string" ? data.productKey.trim() : "";
 				if (!productKey) {
-					reply(data.requestId, {
-						type: "cohub.work.error",
+					replyForRequest(data.requestId, {
+						type: "cohub.app.error",
 						message: "Product key is required."
-					});
+					}, true);
 					return;
 				}
 				const purchaseAttemptId = (typeof data.purchaseAttemptId === "string" ? data.purchaseAttemptId.trim() : "") || data.requestId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 128);
 				if (!/^[a-zA-Z0-9_-]{1,128}$/.test(purchaseAttemptId)) {
-					reply(data.requestId, {
-						type: "cohub.work.error",
+					replyForRequest(data.requestId, {
+						type: "cohub.app.error",
 						message: "Purchase attempt id is invalid."
-					});
+					}, true);
 					return;
 				}
 				state.pendingPurchase = {
@@ -1999,34 +2971,34 @@ function createWorkBridgeCore(config) {
 				notify();
 				config.onPurchaseRequested?.({ ...state.pendingPurchase });
 			}
-			if (data.type === "cohub.work.authorize") {
-				const allowedViewerScopes = clonePermissionScopes(work.allowedViewerScopes);
+			if (data.type === "cohub.app.authorize" || data.type === "cohub.work.authorize") {
+				const allowedViewerScopes = clonePermissionScopes(app.allowedViewerScopes);
 				const scopes = clonePermissionScopes(data.scopes).filter((scope) => allowedViewerScopes.includes(scope));
 				if (scopes.length === 0) {
-					reply(data.requestId, {
-						type: "cohub.work.error",
+					replyForRequest(data.requestId, {
+						type: "cohub.app.error",
 						message: "No allowed scopes requested."
-					});
+					}, true);
 					return;
 				}
-				if (allowsOwnerAutoAuthorization() && await isCurrentViewerWorkOwner()) {
+				if (allowsOwnerAutoAuthorization() && await isCurrentViewerAppOwner()) {
 					const token = await authorize(scopes);
-					reply(data.requestId, {
-						type: "cohub.work.authorize.result",
+					replyForRequest(data.requestId, {
+						type: "cohub.app.authorize.result",
 						token
-					});
+					}, true);
 					return;
 				}
 				const viewerUuid = await getViewerUuid();
-				if (viewerUuid && hasGrantedWorkScopes(viewerUuid, work.id, scopes)) try {
+				if (viewerUuid && hasGrantedAppScopes(viewerUuid, app.id, scopes)) try {
 					const token = await authorize(scopes);
-					reply(data.requestId, {
-						type: "cohub.work.authorize.result",
+					replyForRequest(data.requestId, {
+						type: "cohub.app.authorize.result",
 						token
-					});
+					}, true);
 					return;
 				} catch {
-					clearGrantedWorkScopes(viewerUuid, work.id);
+					clearGrantedAppScopes(viewerUuid, app.id);
 				}
 				state.pendingAuth = {
 					requestId: data.requestId,
@@ -2038,19 +3010,19 @@ function createWorkBridgeCore(config) {
 				notify();
 			}
 		} catch (error) {
-			reply(data.requestId, {
-				type: "cohub.work.error",
+			replyForRequest(data.requestId, {
+				type: "cohub.app.error",
 				message: error instanceof Error ? error.message : "Request failed."
-			});
+			}, true);
 		}
 	}
 	function cancelAuth() {
 		if (state.authSaving) return;
 		if (!state.pendingAuth) return;
-		reply(state.pendingAuth.requestId, {
-			type: "cohub.work.authorize.result",
+		replyForRequest(state.pendingAuth.requestId, {
+			type: "cohub.app.authorize.result",
 			token: null
-		});
+		}, true);
 		state.authOpen = false;
 		state.pendingAuth = null;
 		state.authError = null;
@@ -2060,10 +3032,10 @@ function createWorkBridgeCore(config) {
 	function cancelPurchase() {
 		if (state.purchaseSaving) return;
 		if (!state.pendingPurchase) return;
-		reply(state.pendingPurchase.requestId, {
-			type: "cohub.work.purchase.result",
+		replyForRequest(state.pendingPurchase.requestId, {
+			type: "cohub.app.purchase.result",
 			checkout: null
-		});
+		}, true);
 		state.purchaseOpen = false;
 		state.purchaseError = null;
 		state.pendingPurchase = null;
@@ -2077,10 +3049,10 @@ function createWorkBridgeCore(config) {
 		notify();
 		try {
 			const checkout = await createPurchase(state.pendingPurchase.productKey, state.pendingPurchase.purchaseAttemptId);
-			reply(state.pendingPurchase.requestId, {
-				type: "cohub.work.purchase.result",
+			replyForRequest(state.pendingPurchase.requestId, {
+				type: "cohub.app.purchase.result",
 				checkout
-			});
+			}, true);
 			if (checkout && typeof checkout === "object") {
 				const next = checkout;
 				if (typeof next.orderId === "string" && typeof next.productKey === "string") writePendingPurchase({
@@ -2113,11 +3085,11 @@ function createWorkBridgeCore(config) {
 		notify();
 		try {
 			const token = await authorize(state.pendingAuth.scopes);
-			setGrantedWorkScopes(await getViewerUuid(), work.id, state.pendingAuth.scopes);
-			reply(state.pendingAuth.requestId, {
-				type: "cohub.work.authorize.result",
+			setGrantedAppScopes(await getViewerUuid(), app.id, state.pendingAuth.scopes);
+			replyForRequest(state.pendingAuth.requestId, {
+				type: "cohub.app.authorize.result",
 				token
-			});
+			}, true);
 			state.authOpen = false;
 			state.pendingAuth = null;
 		} catch (error) {
@@ -2130,6 +3102,7 @@ function createWorkBridgeCore(config) {
 	return {
 		getState: () => ({ ...state }),
 		handleMessage,
+		notifyContextChanged,
 		confirmAuth,
 		cancelAuth,
 		confirmPurchase,
@@ -2370,4 +3343,4 @@ function createBoardExtensionRegistry() {
 }
 const BOARD_CHANNELS = BOARD_ANIMATION_CHANNELS;
 //#endregion
-export { BILLING_ACCESS_BLOCKED_ERROR_CODE, BOARD_ANIMATION_CHANNEL_CAPABILITIES, BOARD_CHANNELS, BOARD_COLOR_IDS, BOARD_GEO_KINDS, BOARD_NATIVE_NODE_TYPES, BOARD_NODE_CONTRACT, BillingApi, BoardAuthoringItemSchema, BoardClient, BoardCompositionInputSchema, BoardCompositionSchema, BoardEffectSchema, BoardExtensionRegistry, BoardItemPatchSchema, BoardPlaybackPolicySchema, BoardTransactionError, COHUB_ENVIRONMENTS, COHUB_SOURCE_HEADER, COHUB_SOURCE_HEADER_NAMES, CohubClient, CohubHttpClient, DEFAULT_BOARD_LIMITS, FEATURE_NOT_ENTITLED_ERROR_CODE, GenerationPolicyError, HttpError, ParentBridgeTransport, PopupBrokerTransport, REQUEST_SOURCE_VIA_MAX_LENGTH, ReferencesApi, ReferralsApi, SessionGenerationStreamClient, SessionPatchReducer, SpacePublicFilesApi, UI_COMMAND_DEFAULT_TIMEOUT_MS, UI_COMMAND_MAX_TIMEOUT_MS, UI_COMMAND_PAYLOAD_MAX_BYTES, UI_COMMAND_PENDING_TTL_SECONDS, UI_COMMAND_SETTLEMENT_GRACE_SECONDS, UI_COMMAND_TERMINAL_TTL_SECONDS, UI_COMMAND_VERSION, UiCommandsApi, UsersApi, VoiceApi, VoiceInputClient, WORK_COMPOSER_CHIP_CONTENT_MAX_BYTES, WORK_COMPOSER_CHIP_KEY_MAX_LENGTH, WORK_COMPOSER_CHIP_LABEL_MAX_LENGTH, WORK_SURFACE_READY_TIMEOUT_MS, WORK_SURFACE_REQUEST_TIMEOUT_MS, WebsocketClient, WorkCommerceApi, WorkRealtimeApi, WorkRefParseError, WorkRoom, WorkRuntimeApi, WorkSurfaceApi, WorksApi, assertGenerationRequestAllowedByPolicy, buildSpaceInvitePath, buildSpacePath, buildWorkSurfaceRequest, clearGrantedWorkScopes, compileComposition, composition, createBoardExtensionRegistry, createCohubClient, createHttpClient, createSessionGenerationStreamClient, createSessionPatchReducer, createSlugWorkIdResolver, createVoiceInputClient, createWebsocketClient, createWorkBridgeCore, createWorkRuntime, decodeGenerationPolicy, encodeGenerationPolicy, extractBillingPayload, filterDiscoverableGenerationModels, filterGenerationDeclarationsByPolicy, findGenerationModelPolicy, formatWorkRef, getAllowedGenerationModelIds, hasGrantedWorkScopes, hasRequestSourceIdentity, isBillingAccessBlockedCode, isBillingAccessBlockedError, isFeatureNotEntitledError, isGenerationModelHidden, isHttpErrorCode, isRequestSourceClientId, isRequestSourceEmpty, isRequestSourceUuid, isTerminalUiCommandStatus, isUiSurfaceMethod, isUuid, isWorkId, joinApiUrl, matchesUnauthorizedErrorToken, mergeRequestSourceIntoMeta, normalizeBaseUrl, normalizeGenerationPolicy, normalizeRequestSource, normalizeVoiceInputWebsocketUrl, normalizeWebsocketUrl, parseAssistantMessageCommit, parseBoardCompositionInput, parseBoardPlaybackPolicy, parseGenerationPolicyFromEnv, parseRequestSourceFromHeaders, parseUiCommand, parseWorkRef, parseWorkSurfaceReady, parseWorkSurfaceResponse, proceduralClip, readRequestSourceFromEnv, requestSourceToHeaders, resolveApiBaseUrl, resolveCohubEnvironment, resolveRequestSourceChannel, resolveVoiceInputWebsocketUrl, resolveWebsocketUrl, resolveWorkTransport, sampleCompositionTracks, sampleEasing, sampleTrack, sanitizeAccessToken, setGrantedWorkScopes, track, validateBoardNodeInput };
+export { APP_COMPOSER_CHIP_CONTENT_MAX_BYTES, APP_COMPOSER_CHIP_KEY_MAX_LENGTH, APP_COMPOSER_CHIP_LABEL_MAX_LENGTH, APP_SURFACE_READY_TIMEOUT_MS, APP_SURFACE_REQUEST_TIMEOUT_MS, AppCommerceApi, AppRealtimeApi, AppRefParseError, AppRoom, AppRuntimeApi, AppRuntimeApi as WorkRuntimeApi, AppSurfaceApi, AppsApi, BILLING_ACCESS_BLOCKED_ERROR_CODE, BOARD_ANIMATION_CHANNEL_CAPABILITIES, BOARD_CHANNELS, BOARD_COLOR_IDS, BOARD_GEO_KINDS, BillingApi, BoardAuthoringItemSchema, BoardClient, BoardCompositionInputSchema, BoardCompositionSchema, BoardEffectInputSchema, BoardEffectSchema, BoardExtensionRegistry, BoardItemPatchSchema, BoardPlaybackPolicySchema, COHUB_ENVIRONMENTS, COHUB_SOURCE_HEADER, COHUB_SOURCE_HEADER_NAMES, CohubClient, CohubHttpClient, DEFAULT_BOARD_LIMITS, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, DESKTOP_COMMAND_PAYLOAD_MAX_BYTES, DESKTOP_COMMAND_PENDING_TTL_SECONDS, DESKTOP_COMMAND_SETTLEMENT_GRACE_SECONDS, DESKTOP_COMMAND_TERMINAL_TTL_SECONDS, DESKTOP_COMMAND_VERSION, DesktopCommandsApi, FEATURE_NOT_ENTITLED_ERROR_CODE, GenerationPolicyError, HttpError, ParentBridgeTransport, PopupBrokerTransport, REQUEST_SOURCE_VIA_MAX_LENGTH, ReferencesApi, ReferralsApi, SessionGenerationStreamClient, SessionPatchReducer, SpacePublicFilesApi, UiCommandsApi, UsersApi, VoiceApi, VoiceInputClient, WebsocketClient, WorkCommerceApi, WorkRealtimeApi, WorkRefParseError, WorkRoom, WorkSurfaceApi, assertGenerationRequestAllowedByPolicy, buildAppSurfaceRequest, buildSpaceInvitePath, buildSpacePath, clearGrantedAppScopes, compileComposition, composition, createAppBridgeCore, createAppBridgeCore as createWorkBridgeCore, createAppRuntime, createAppRuntime as createWorkRuntime, createBoardExtensionRegistry, createCohubClient, createHttpClient, createSessionGenerationStreamClient, createSessionPatchReducer, createSlugAppIdResolver, createSlugAppIdResolver as createSlugWorkIdResolver, createVoiceInputClient, createWebsocketClient, decodeGenerationPolicy, encodeGenerationPolicy, extractBillingPayload, filterDiscoverableGenerationModels, filterGenerationDeclarationsByPolicy, findGenerationModelPolicy, formatAppRef, formatWorkRef, getAllowedGenerationModelIds, hasGrantedAppScopes, hasRequestSourceIdentity, isAppId, isBillingAccessBlockedCode, isBillingAccessBlockedError, isDesktopCallMethod, isFeatureNotEntitledError, isGenerationModelHidden, isHttpErrorCode, isRequestSourceClientId, isRequestSourceEmpty, isRequestSourceUuid, isTerminalDesktopCommandStatus, isUuid, isWorkId, joinApiUrl, matchesUnauthorizedErrorToken, mergeRequestSourceIntoMeta, normalizeBaseUrl, normalizeGenerationPolicy, normalizeRequestSource, normalizeVoiceInputWebsocketUrl, normalizeWebsocketUrl, parseAppRef, parseAppSurfaceReady, parseAppSurfaceResponse, parseAssistantMessageCommit, parseBoardCompositionInput, parseBoardEffectInput, parseBoardPlaybackPolicy, parseDesktopCommand, parseGenerationPolicyFromEnv, parseRequestSourceFromHeaders, parseWorkRef, proceduralClip, readRequestSourceFromEnv, requestSourceToHeaders, resolveApiBaseUrl, resolveAppTransport, resolveAppTransport as resolveWorkTransport, resolveCohubEnvironment, resolveRequestSourceChannel, resolveVoiceInputWebsocketUrl, resolveWebsocketUrl, sampleCompositionTracks, sampleEasing, sampleTrack, sanitizeAccessToken, setGrantedAppScopes, track };