@neta-art/cohub 5.7.0 → 5.8.0

package/dist/chunks/http.js

@@ -1,6 +1,7 @@
 import { D as getRealtimeSpaceRoom, E as getRealtimeBoardRoom, n as HttpTransport, t as HttpError } from "./transport.js";
 import { a as resolveApiBaseUrl } from "./environment.js";
 import { z } from "zod";
+import "perfect-freehand";
 //#region src/apis/channels.ts
 var ChannelsApi = class {
 	transport;
@@ -641,6 +642,1412 @@ function ensureRealtimeConnected(websocketClient) {
 	});
 }
 //#endregion
+//#region ../protocol/dist/board.js
+const BOARD_DOCUMENT_KIND = "cohub.board";
+const BOARD_MANIFEST_KIND = "cohub.board.manifest";
+const idSchema$1 = z.string().min(1).max(160);
+const extensionIdSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const finiteSchema$1 = 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)
+});
+const BoardTargetSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("node"),
+		nodeId: idSchema$1
+	}),
+	z.object({
+		type: z.literal("effect"),
+		effectId: idSchema$1
+	}),
+	z.object({ type: z.literal("board") }),
+	z.object({ type: z.literal("camera") })
+]);
+const BoardAssetRefSchema = z.object({
+	type: z.enum(["space-file", "extension"]),
+	ref: z.string().min(1).max(4096),
+	digest: z.string().min(16).max(160).optional()
+});
+const BoardKeyframeSchema = z.object({
+	at: finiteSchema$1.nonnegative(),
+	value: z.unknown(),
+	easing: z.string().min(1).max(80).optional()
+});
+const BoardClipSchema = z.object({
+	id: idSchema$1,
+	sequenceId: idSchema$1,
+	kind: extensionIdSchema,
+	kindVersion: z.number().int().positive(),
+	target: BoardTargetSchema,
+	start: finiteSchema$1.nonnegative(),
+	duration: finiteSchema$1.positive(),
+	layer: z.enum([
+		"behind",
+		"content",
+		"front",
+		"screen"
+	]).default("content"),
+	fill: z.enum([
+		"none",
+		"backwards",
+		"forwards",
+		"both"
+	]).default("none"),
+	easing: z.string().min(1).max(80).default("linear"),
+	params: jsonObjectSchema.default({}),
+	keyframes: z.array(BoardKeyframeSchema).default([]),
+	assetRefs: z.array(BoardAssetRefSchema).default([]),
+	seed: z.string().min(1).max(160),
+	metadata: jsonObjectSchema.default({})
+});
+const BoardEffectSchema = z.object({
+	id: idSchema$1,
+	boardId: z.string().uuid(),
+	target: z.discriminatedUnion("type", [z.object({
+		type: z.literal("node"),
+		nodeId: idSchema$1
+	}), z.object({ type: z.literal("board") })]),
+	kind: extensionIdSchema,
+	kindVersion: z.number().int().positive(),
+	enabled: z.boolean().default(true),
+	lifecycle: z.enum([
+		"persistent",
+		"when-visible",
+		"manual"
+	]),
+	timeOrigin: z.enum([
+		"board",
+		"visible",
+		"activation"
+	]),
+	layer: z.enum([
+		"behind",
+		"front",
+		"screen"
+	]).default("front"),
+	seed: z.string().min(1).max(160),
+	params: jsonObjectSchema.default({}),
+	assetRefs: z.array(BoardAssetRefSchema).default([]),
+	metadata: jsonObjectSchema.default({}),
+	revision: z.number().int().nonnegative()
+});
+const BoardSequenceSchema = z.object({
+	id: idSchema$1,
+	boardId: z.string().uuid(),
+	name: z.string().min(1).max(255),
+	duration: finiteSchema$1.nonnegative(),
+	seed: z.string().min(1).max(160),
+	restPose: jsonObjectSchema.default({}),
+	metadata: jsonObjectSchema.default({}),
+	revision: z.number().int().nonnegative()
+});
+const BoardNodeInputSchema = z.object({
+	nodeId: idSchema$1,
+	type: z.string().min(1).max(40),
+	parentId: idSchema$1.nullable(),
+	orderKey: z.string().max(4096).nullable(),
+	x: finiteSchema$1,
+	y: finiteSchema$1,
+	width: finiteSchema$1.positive(),
+	height: finiteSchema$1.positive(),
+	rotation: finiteSchema$1,
+	refKind: z.string().max(40).nullable(),
+	refPath: z.string().max(4096).nullable(),
+	refUrl: z.string().max(4096).nullable(),
+	view: jsonObjectSchema,
+	style: jsonObjectSchema,
+	data: jsonObjectSchema
+});
+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(),
+	nodes: z.array(BoardNodeInputSchema).max(5e4).optional(),
+	connections: z.array(BoardConnectionSchema).max(5e4).optional(),
+	effects: z.array(BoardEffectSchema.omit({
+		boardId: true,
+		revision: true
+	})).optional(),
+	sequences: z.array(z.object({
+		sequence: BoardSequenceSchema.omit({
+			boardId: true,
+			revision: true
+		}),
+		clips: z.array(BoardClipSchema.omit({ sequenceId: true }))
+	})).optional()
+});
+z.object({
+	include: z.array(z.enum([
+		"nodes",
+		"connections",
+		"effects",
+		"sequences",
+		"clips",
+		"playback"
+	])).optional(),
+	viewport: z.object({
+		x: finiteSchema$1,
+		y: finiteSchema$1,
+		width: finiteSchema$1.positive(),
+		height: finiteSchema$1.positive()
+	}).optional()
+});
+/** Persisted on `boards.metadata.playback`: how a Board plays when opened. */
+const BoardPlaybackPolicySchema = z.object({
+	sequenceId: idSchema$1,
+	/** Delay before the first local playback after opening the Board, in milliseconds. */
+	delayMs: finiteSchema$1.nonnegative().default(0),
+	loop: z.boolean().default(false)
+});
+function parseBoardPlaybackPolicy(metadata) {
+	const parsed = BoardPlaybackPolicySchema.safeParse(metadata.playback);
+	return parsed.success ? parsed.data : null;
+}
+z.discriminatedUnion("type", [
+	z.object({
+		commandId: idSchema$1,
+		type: z.literal("play"),
+		sequenceId: idSchema$1,
+		position: finiteSchema$1.nonnegative().optional(),
+		timeScale: finiteSchema$1.positive().max(4).optional(),
+		shared: z.boolean().optional(),
+		seed: idSchema$1.optional()
+	}),
+	z.object({
+		commandId: idSchema$1,
+		type: z.literal("pause"),
+		playbackId: z.string().uuid()
+	}),
+	z.object({
+		commandId: idSchema$1,
+		type: z.literal("seek"),
+		playbackId: z.string().uuid(),
+		position: finiteSchema$1.nonnegative()
+	}),
+	z.object({
+		commandId: idSchema$1,
+		type: z.literal("stop"),
+		playbackId: z.string().uuid()
+	})
+]);
+//#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 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)) return isBlockedIpv4(host);
+	return host.includes(":") && isBlockedIpv6(host);
+}
+/**
+* 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: z.string().url().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,
+	/** 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
+		},
+		...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);
+}
+const BOARD_NODE_CONTRACT = {
+	types: BOARD_NATIVE_NODE_TYPES,
+	colors: BOARD_COLOR_IDS,
+	geos: BOARD_GEO_KINDS,
+	coordinates: {
+		frame: "world",
+		drawPoints: "frame-local",
+		arrowEndpoints: "world"
+	},
+	references: {
+		nodeTypes: [
+			"image",
+			"video",
+			"audio",
+			"file"
+		],
+		kind: "space_file",
+		pathField: "refPath"
+	},
+	schemas: {
+		envelope: jsonSchema(nodeEnvelopeSchema),
+		data: Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(dataSchemas[type])])),
+		view: Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(viewSchemas[type])]))
+	}
+};
+function issueDiagnostic(issue, path) {
+	const fullPath = [path, ...issue.path].join(".");
+	const values = "values" in issue && Array.isArray(issue.values) ? issue.values.filter((value) => typeof value === "string") : void 0;
+	return {
+		severity: "error",
+		code: "INVALID_BOARD_NODE",
+		message: `${fullPath}: ${issue.message}`,
+		path: fullPath,
+		...values?.length ? { allowedValues: values } : {}
+	};
+}
+function drawGeometryDiagnostic(node, data, path) {
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of data.points) {
+		const radius = Math.max(.5, data.size / 2 * (.5 + point.p));
+		minX = Math.min(minX, point.x - radius);
+		minY = Math.min(minY, point.y - radius);
+		maxX = Math.max(maxX, point.x + radius);
+		maxY = Math.max(maxY, point.y + radius);
+	}
+	const width = Math.max(1, maxX - minX);
+	const height = Math.max(1, maxY - minY);
+	const tolerance = Math.max(.01, node.width * 1e-6, node.height * 1e-6);
+	if (Math.abs(minX) <= tolerance && Math.abs(minY) <= tolerance && Math.abs(width - node.width) <= tolerance && Math.abs(height - node.height) <= tolerance) return null;
+	return {
+		severity: "error",
+		code: "INVALID_BOARD_GEOMETRY",
+		message: `${path}.data.points must use frame-local coordinates and match the node frame`,
+		path: `${path}.data.points`,
+		expected: "frame-local points with bounds matching width and height",
+		coordinateSpace: "frame-local"
+	};
+}
+function validateBoardNodeInput(node, path = "node") {
+	const envelopeResult = nodeEnvelopeSchema.safeParse(node);
+	if (!envelopeResult.success) return envelopeResult.error.issues.map((issue) => issueDiagnostic(issue, path));
+	if (typeof node.type !== "string" || !BOARD_NATIVE_NODE_TYPES.includes(node.type)) return [{
+		severity: "error",
+		code: "INVALID_BOARD_NODE",
+		message: `${path}.type is not supported`,
+		path: `${path}.type`,
+		expected: "BoardNativeNodeType",
+		received: node.type,
+		allowedValues: BOARD_NATIVE_NODE_TYPES
+	}];
+	const type = node.type;
+	const dataResult = dataSchemas[type].safeParse(node.data ?? {});
+	if (!dataResult.success) return dataResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.data`));
+	const viewResult = viewSchemas[type].safeParse(node.view ?? {});
+	if (!viewResult.success) return viewResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.view`));
+	if (type === "image" || type === "video" || type === "audio" || type === "file") {
+		if (node.refKind !== "space_file" || typeof node.refPath !== "string" || !node.refPath) return [{
+			severity: "error",
+			code: "INVALID_BOARD_NODE",
+			message: `${path} requires a space file reference`,
+			path: `${path}.refPath`,
+			expected: "non-empty refPath with refKind space_file"
+		}];
+	}
+	if (type === "draw") {
+		const diagnostic = drawGeometryDiagnostic(node, dataResult.data, path);
+		return diagnostic ? [diagnostic] : [];
+	}
+	if (type === "arrow") {
+		const data = dataResult.data;
+		const inside = (point) => point.x >= node.x && point.x <= node.x + node.width && point.y >= node.y && point.y <= node.y + node.height;
+		if (!inside(data.start) || !inside(data.end)) return [{
+			severity: "error",
+			code: "INVALID_BOARD_GEOMETRY",
+			message: `${path}.data endpoints must be covered by the node frame`,
+			path: `${path}.data`,
+			expected: "world-space endpoints inside the node frame",
+			coordinateSpace: "world"
+		}];
+	}
+	return [];
+}
+//#endregion
+//#region ../protocol/dist/realtime/board-awareness.js
+const idSchema = z.string().min(1).max(160);
+const finiteSchema = z.number().finite();
+const BoardAwarenessPointSchema = z.object({
+	x: finiteSchema,
+	y: finiteSchema
+});
+const BoardAwarenessDrawPointSchema = BoardAwarenessPointSchema.extend({ p: finiteSchema.min(0).max(1) });
+const BoardAwarenessFrameSchema = z.object({
+	x: finiteSchema,
+	y: finiteSchema,
+	width: finiteSchema.positive(),
+	height: finiteSchema.positive(),
+	rotation: finiteSchema
+});
+const BoardAwarenessNodePreviewSchema = z.object({
+	nodeId: idSchema,
+	frame: BoardAwarenessFrameSchema,
+	/** Live endpoints of a free arrow being dragged. */
+	arrow: z.object({
+		start: BoardAwarenessPointSchema,
+		end: BoardAwarenessPointSchema,
+		bend: finiteSchema
+	}).optional()
+});
+const BoardAwarenessStateUpdateSchema = z.object({
+	type: z.literal("state"),
+	client: z.object({ formFactor: z.enum(["desktop", "mobile"]) }).optional(),
+	cursor: BoardAwarenessPointSchema.extend({ pointerType: z.enum([
+		"mouse",
+		"pen",
+		"touch"
+	]) }).nullable(),
+	tool: z.string().min(1).max(40),
+	selection: z.object({
+		ids: z.array(idSchema).max(64),
+		count: z.number().int().nonnegative().max(5e4),
+		bounds: BoardAwarenessFrameSchema.nullable()
+	}),
+	editingId: idSchema.nullable()
+});
+const BoardAwarenessGestureSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("draw"),
+		id: idSchema,
+		nodeId: idSchema,
+		color: z.string().min(1).max(64),
+		size: finiteSchema.positive().max(256),
+		from: z.number().int().nonnegative().max(1e5),
+		points: z.array(BoardAwarenessDrawPointSchema).min(1).max(64)
+	}),
+	z.object({
+		kind: z.literal("arrow"),
+		id: idSchema,
+		nodeId: idSchema,
+		start: BoardAwarenessPointSchema,
+		current: BoardAwarenessPointSchema,
+		color: z.string().min(1).max(64),
+		size: finiteSchema.positive().max(256).default(BOARD_ARROW_STROKE_SIZE)
+	}),
+	z.object({
+		kind: z.literal("box"),
+		id: idSchema,
+		nodeId: idSchema,
+		shape: z.enum(["geo", "frame"]),
+		start: BoardAwarenessPointSchema,
+		current: BoardAwarenessPointSchema,
+		color: z.string().min(1).max(64),
+		geo: z.string().min(1).max(40)
+	}),
+	z.object({
+		kind: z.literal("connection"),
+		id: idSchema,
+		sourceNodeId: idSchema,
+		targetNodeId: idSchema.nullable(),
+		current: BoardAwarenessPointSchema,
+		color: z.string().min(1).max(64),
+		size: finiteSchema.positive().max(256).default(BOARD_CONNECTION_STROKE_SIZE)
+	}),
+	z.object({
+		kind: z.literal("transform"),
+		id: idSchema,
+		mode: z.enum([
+			"translate",
+			"resize",
+			"rotate",
+			"arrow",
+			"connection"
+		]),
+		nodes: z.array(BoardAwarenessNodePreviewSchema).max(64),
+		bounds: BoardAwarenessFrameSchema.nullable()
+	})
+]);
+const BoardAwarenessUpdateSchema = z.discriminatedUnion("type", [
+	BoardAwarenessStateUpdateSchema,
+	z.object({
+		type: z.literal("gesture"),
+		gesture: BoardAwarenessGestureSchema
+	}),
+	z.object({
+		type: z.literal("gesture.end"),
+		gestureId: idSchema,
+		resultingNodeIds: z.array(idSchema).max(64)
+	}),
+	z.object({
+		type: z.literal("gesture.cancel"),
+		gestureId: idSchema
+	})
+]);
+const BoardAwarenessClientPayloadSchema = z.object({
+	spaceId: z.string().uuid(),
+	boardId: z.string().uuid(),
+	seq: z.number().int().nonnegative(),
+	update: BoardAwarenessUpdateSchema
+});
+//#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"
+]);
+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/ui-command.js
+/**
+* Lets an agent drive the Cohub frontend that originated the work. Routing comes
+* from request provenance, never a caller-supplied target, so a command only
+* reaches the actor's own instances.
+*/
+const UI_COMMAND_VERSION = 1;
+/** Persisted and broadcast, so every field is capped; MAX_BYTES bounds the whole. */
+const UI_COMMAND_PAYLOAD_MAX_BYTES = 32 * 1024;
+const UI_COMMAND_MAX_BYTES = 40 * 1024;
+const UI_COMMAND_LAUNCH_MAX_LENGTH = 2048;
+const UI_COMMAND_DEFAULT_TIMEOUT_MS = 600 * 1e3;
+const UI_COMMAND_MAX_TIMEOUT_MS = 720 * 60 * 1e3;
+const UI_COMMAND_SETTLEMENT_GRACE_SECONDS = 600;
+/** Keeps pending commands reportable for the full wait window plus settlement grace. */
+const UI_COMMAND_PENDING_TTL_SECONDS = 43800;
+const UI_COMMAND_TERMINAL_TTL_SECONDS = 1800;
+const UI_COMMAND_TERMINAL_STATUSES = [
+	"applied",
+	"no_active_client",
+	"ui_host_unavailable",
+	"rejected",
+	"unsupported",
+	"timeout"
+];
+const isTerminalUiCommandStatus = (status) => UI_COMMAND_TERMINAL_STATUSES.includes(status);
+const METHOD_RE = /^[A-Za-z][A-Za-z0-9_.:-]{0,63}$/;
+const isUiSurfaceMethod = (value) => typeof value === "string" && METHOD_RE.test(value);
+const WORK_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const UI_COMMAND_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+const parseUiCommandId = (value) => {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return UI_COMMAND_ID_RE.test(trimmed) ? trimmed : null;
+};
+const isRecord$1 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const asTrimmed = (value) => {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : null;
+};
+const parseLaunch = (value) => {
+	if (!isRecord$1(value)) return void 0;
+	const search = asTrimmed(value.search);
+	const hash = asTrimmed(value.hash);
+	if (!search && !hash) return void 0;
+	return {
+		...search ? { search: search.startsWith("?") ? search : `?${search}` } : {},
+		...hash ? { hash: hash.startsWith("#") ? hash : `#${hash}` } : {}
+	};
+};
+const measureUiCommandPayload = (value) => {
+	if (value === void 0) return 0;
+	try {
+		return new TextEncoder().encode(JSON.stringify(value) ?? "").length;
+	} catch {
+		return null;
+	}
+};
+const parseUiCommand = (input) => {
+	if (!isRecord$1(input)) return {
+		command: null,
+		error: "command must be an object"
+	};
+	if (input.type !== "preview.show") return {
+		command: null,
+		error: "command.type must be one of: preview.show"
+	};
+	const preview = input.preview;
+	if (!isRecord$1(preview)) return {
+		command: null,
+		error: "command.preview is required"
+	};
+	if (preview.kind !== "work") return {
+		command: null,
+		error: "command.preview.kind must be one of: work"
+	};
+	const workId = asTrimmed(preview.workId);
+	if (!workId) return {
+		command: null,
+		error: "command.preview.workId is required"
+	};
+	if (!WORK_ID_RE.test(workId)) return {
+		command: null,
+		error: "command.preview.workId must be a Work id"
+	};
+	const label = asTrimmed(preview.label);
+	if (label && label.length > 200) return {
+		command: null,
+		error: `command.preview.label exceeds 200 characters`
+	};
+	const launch = parseLaunch(preview.launch);
+	if (launch) {
+		for (const [field, value] of [["search", launch.search], ["hash", launch.hash]]) if (value && value.length > 2048) return {
+			command: null,
+			error: `command.preview.launch.${field} exceeds ${UI_COMMAND_LAUNCH_MAX_LENGTH} characters`
+		};
+	}
+	let request;
+	if (input.request !== void 0 && input.request !== null) {
+		if (!isRecord$1(input.request)) return {
+			command: null,
+			error: "command.request must be an object"
+		};
+		const method = asTrimmed(input.request.method);
+		if (!method) return {
+			command: null,
+			error: "command.request.method is required"
+		};
+		if (!isUiSurfaceMethod(method)) return {
+			command: null,
+			error: "command.request.method has an unsupported format"
+		};
+		const size = measureUiCommandPayload(input.request.input);
+		if (size === null) return {
+			command: null,
+			error: "command.request.input must be JSON-serializable"
+		};
+		if (size > 32768) return {
+			command: null,
+			error: `command.request.input exceeds ${UI_COMMAND_PAYLOAD_MAX_BYTES} bytes`
+		};
+		request = {
+			method,
+			...input.request.input === void 0 ? {} : { input: input.request.input }
+		};
+	}
+	const command = {
+		type: "preview.show",
+		preview: {
+			kind: "work",
+			workId,
+			...label ? { label } : {},
+			...launch ? { launch } : {}
+		},
+		...request ? { request } : {}
+	};
+	const totalSize = measureUiCommandPayload(command);
+	if (totalSize === null) return {
+		command: null,
+		error: "command must be JSON-serializable"
+	};
+	if (totalSize > 40960) return {
+		command: null,
+		error: `command exceeds ${UI_COMMAND_MAX_BYTES} bytes`
+	};
+	return {
+		command,
+		error: null
+	};
+};
+//#endregion
+//#region src/board/core/draw-geometry.ts
+/** Radius of a sample in world units given the stroke size and pressure. */
+function sampleRadius(size, pressure) {
+	const clamped = Math.min(1, Math.max(0, pressure));
+	return Math.max(.5, size / 2 * (.5 + clamped));
+}
+/** Axis-aligned bounds of a stroke in its local space, padded by stroke width. */
+function computeDrawBounds(points, size) {
+	if (points.length === 0) return {
+		x: 0,
+		y: 0,
+		width: 1,
+		height: 1
+	};
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (const point of points) {
+		const r = sampleRadius(size, point.p);
+		minX = Math.min(minX, point.x - r);
+		minY = Math.min(minY, point.y - r);
+		maxX = Math.max(maxX, point.x + r);
+		maxY = Math.max(maxY, point.y + r);
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: Math.max(1, maxX - minX),
+		height: Math.max(1, maxY - minY)
+	};
+}
+//#endregion
+//#region src/board/nodes.ts
+var BoardInputError = class extends Error {
+	code = "INVALID_BOARD_NODE";
+	diagnostics;
+	body;
+	constructor(diagnostics) {
+		const message = diagnostics[0]?.message ?? "Invalid Board node";
+		super(message);
+		this.name = "BoardInputError";
+		this.diagnostics = diagnostics;
+		this.body = {
+			code: this.code,
+			message,
+			diagnostics
+		};
+	}
+};
+function baseNode(spec, frame) {
+	return {
+		nodeId: spec.id,
+		type: spec.type,
+		parentId: spec.parentId ?? null,
+		orderKey: spec.orderKey ?? null,
+		x: frame.x,
+		y: frame.y,
+		width: frame.width,
+		height: frame.height,
+		rotation: frame.rotation ?? 0,
+		refKind: null,
+		refPath: null,
+		refUrl: null,
+		view: {},
+		style: spec.style ?? {},
+		data: {}
+	};
+}
+function arrowFrame(start, end) {
+	const padding = 16;
+	return {
+		x: Math.min(start.x, end.x) - padding,
+		y: Math.min(start.y, end.y) - padding,
+		width: Math.max(1, Math.abs(end.x - start.x) + padding * 2),
+		height: Math.max(1, Math.abs(end.y - start.y) + padding * 2)
+	};
+}
+/**
+* Create one validated wire node from semantic Board input.
+*
+* Box nodes take an explicit world-space frame. Draw samples and arrow endpoints
+* take world coordinates; the builder derives their frame and local storage form.
+*/
+function createBoardNode(spec) {
+	let node;
+	if (spec.type === "draw") {
+		const size = spec.size ?? 4;
+		const worldPoints = spec.points.map((point) => ({
+			x: point.x,
+			y: point.y,
+			p: point.p ?? .5
+		}));
+		const bounds = computeDrawBounds(worldPoints, size);
+		node = baseNode(spec, bounds);
+		node.data = {
+			points: worldPoints.map((point) => ({
+				x: point.x - bounds.x,
+				y: point.y - bounds.y,
+				p: point.p
+			})),
+			color: spec.color ?? "brand",
+			size
+		};
+	} else if (spec.type === "arrow") {
+		node = baseNode(spec, arrowFrame(spec.start, spec.end));
+		node.data = {
+			start: spec.start,
+			end: spec.end,
+			bend: spec.bend ?? 0,
+			color: spec.color ?? "brand",
+			size: spec.size ?? 2.5,
+			arrowStart: spec.arrowStart ?? false,
+			arrowEnd: spec.arrowEnd ?? true,
+			label: spec.label ?? ""
+		};
+	} else {
+		node = baseNode(spec, spec.frame);
+		switch (spec.type) {
+			case "text":
+				node.data = {
+					text: spec.text ?? "",
+					color: spec.color ?? "neutral",
+					fontSize: spec.fontSize ?? 24
+				};
+				break;
+			case "geo":
+				node.data = {
+					geo: spec.geo ?? "rectangle",
+					text: spec.text ?? "",
+					color: spec.color ?? "brand",
+					fillOpacity: spec.fillOpacity ?? 0
+				};
+				break;
+			case "frame":
+				node.data = {
+					label: spec.label ?? "Frame",
+					color: spec.color ?? "neutral"
+				};
+				break;
+			case "image":
+				node.refKind = "space_file";
+				node.refPath = spec.path;
+				node.view = spec.snapshot ?? {};
+				node.data = spec.crop ? { crop: spec.crop } : {};
+				break;
+			case "video":
+			case "audio":
+				node.refKind = "space_file";
+				node.refPath = spec.path;
+				node.view = spec.snapshot ?? {};
+				break;
+			case "file":
+				node.refKind = "space_file";
+				node.refPath = spec.path;
+				node.view = spec.snapshot ?? {};
+				break;
+			case "task":
+				node.view = spec.snapshot;
+				node.data = { taskRunId: spec.taskRunId };
+				break;
+		}
+	}
+	assertBoardNodes([node]);
+	return node;
+}
+function validateBoardNodes(nodes, path = "nodes") {
+	return nodes.flatMap((node, index) => validateBoardNodeInput(node, `${path}.${index}`));
+}
+function assertBoardNodes(nodes, path = "nodes") {
+	const diagnostics = validateBoardNodes(nodes, path);
+	if (diagnostics.length > 0) throw new BoardInputError(diagnostics);
+}
+function assertBoardTransactionNodeCreates(operations) {
+	const diagnostics = operations.flatMap((operation, index) => {
+		if (operation.type !== "node.create") return [];
+		const payload = operation.payload;
+		return payload.node ? validateBoardNodeInput(payload.node, `operations.${index}.payload.node`) : [];
+	});
+	if (diagnostics.length > 0) throw new BoardInputError(diagnostics);
+}
+//#endregion
 //#region src/session-patch-reducer.ts
 const blockSubPathPattern = /^\/message\/content\/blocks\/(\d+)\/(.+)$/;
 const blockPathPattern = /^\/message\/content\/blocks\/(\d+)$/;
@@ -1041,8 +2448,8 @@ const createSessionPatchReducer = () => new SessionPatchReducer();
 //#region src/session-generation-stream.ts
 const SNAPSHOT_RECOVERY_TIMEOUT_MS = 2500;
 const SNAPSHOT_RECOVERY_MAX_BUFFERED_EVENTS = 256;
-const isRecord$1 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
-const isContentBlockArray = (value) => Array.isArray(value) && value.every((item) => isRecord$1(item) && typeof item.type === "string");
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const isContentBlockArray = (value) => Array.isArray(value) && value.every((item) => isRecord(item) && typeof item.type === "string");
 const getMessageKind = (message) => {
 	const kind = message.meta?.messageKind;
 	return typeof kind === "string" ? kind : null;
@@ -1082,7 +2489,7 @@ function parseAssistantMessageCommit(message) {
 }
 function messageRecordToIntermediate(message) {
 	if (!isContentBlockArray(message.content) || message.content.length === 0) return null;
-	const meta = isRecord$1(message.meta) ? message.meta : {};
+	const meta = isRecord(message.meta) ? message.meta : {};
 	return {
 		id: message.id,
 		sessionId: message.sessionId,
@@ -1200,9 +2607,9 @@ function mergeMessagesSharingToolUseId(messages) {
 	return merged;
 }
 function getCompactionPlacement(message) {
-	const meta = isRecord$1(message.meta) ? message.meta : null;
-	const compaction = isRecord$1(meta?.compaction) ? meta.compaction : null;
-	const placement = isRecord$1(compaction?.placement) ? compaction.placement : null;
+	const meta = isRecord(message.meta) ? message.meta : null;
+	const compaction = isRecord(meta?.compaction) ? meta.compaction : null;
+	const placement = isRecord(compaction?.placement) ? compaction.placement : null;
 	return meta?.messageKind === "compacted" ? {
 		beforeMessageId: typeof placement?.beforeMessageId === "string" ? placement.beforeMessageId : null,
 		sequence: typeof message.sequence === "number" ? message.sequence : null
@@ -1476,7 +2883,7 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 	}
 	handlePersisted(event, handlers) {
 		const message = event.payload.message;
-		if (!isRecord$1(message)) return;
+		if (!isRecord(message)) return;
 		const commit = parseAssistantMessageCommit(message);
 		if (commit.kind === "intermediate") {
 			const intermediate = messageRecordToIntermediate(commit.message);
@@ -1511,7 +2918,7 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 	}
 	handleFinalized(event, handlers) {
 		const turn = event.payload.turn;
-		if (!isRecord$1(turn)) return;
+		if (!isRecord(turn)) return;
 		const typedTurn = turn;
 		if (typedTurn.status === "interrupted") this.reducer.interrupt({
 			spaceId: this.spaceId,
@@ -1543,7 +2950,7 @@ var SessionGenerationStreamClient = class SessionGenerationStreamClient {
 				return;
 			case "session.turn.updated": {
 				const turn = event.payload.turn;
-				if (!isRecord$1(turn)) return;
+				if (!isRecord(turn)) return;
 				this.emit(handlers, {
 					type: "turn_updated",
 					turn,
@@ -1756,6 +3163,80 @@ var SpacesApi = class {
 		});
 	}
 };
+function inlineFileDataUrl(file) {
+	const mimeType = file.mimeType ?? "application/octet-stream";
+	return file.encoding === "base64" ? `data:${mimeType};base64,${file.content}` : `data:${mimeType};charset=utf-8,${encodeURIComponent(file.content)}`;
+}
+function spaceFileAbortReason(signal) {
+	return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+function waitForSpaceFileRetry(ms, signal) {
+	if (signal?.aborted) return Promise.reject(spaceFileAbortReason(signal));
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(finish, ms);
+		const onAbort = () => {
+			if (signal) finish(spaceFileAbortReason(signal));
+		};
+		function finish(error) {
+			clearTimeout(timeout);
+			signal?.removeEventListener("abort", onAbort);
+			if (error !== void 0) reject(error);
+			else resolve();
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function createSpaceFileDeadlineSignal(signal, timeoutMs) {
+	const controller = new AbortController();
+	let timedOut = false;
+	const onAbort = () => {
+		if (signal) controller.abort(spaceFileAbortReason(signal));
+	};
+	if (signal?.aborted) onAbort();
+	else signal?.addEventListener("abort", onAbort, { once: true });
+	const timeout = setTimeout(() => {
+		if (controller.signal.aborted) return;
+		timedOut = true;
+		controller.abort(new DOMException("Space file URL resolution timed out", "TimeoutError"));
+	}, timeoutMs);
+	return {
+		signal: controller.signal,
+		timedOut: () => timedOut,
+		dispose: () => {
+			clearTimeout(timeout);
+			signal?.removeEventListener("abort", onAbort);
+		}
+	};
+}
+var SpacePublicFilesApi = class {
+	transport;
+	spaceId;
+	constructor(transport, spaceId) {
+		this.transport = transport;
+		this.spaceId = spaceId;
+	}
+	createUpload(input, options = {}) {
+		return this.transport.request(`/api/spaces/${this.spaceId}/public/uploads`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(input),
+			signal: options.signal
+		});
+	}
+	list(path = "", options = {}) {
+		const params = new URLSearchParams();
+		if (path) params.set("path", path);
+		if (options.recursive) params.set("recursive", "true");
+		if (options.limit != null) params.set("limit", String(options.limit));
+		if (options.cursor) params.set("cursor", options.cursor);
+		const query = params.toString();
+		return this.transport.request(`/api/spaces/${this.spaceId}/public${query ? `?${query}` : ""}`, { fetch: options.fetch });
+	}
+	url(path, customFetch) {
+		const params = new URLSearchParams({ path });
+		return this.transport.request(`/api/spaces/${this.spaceId}/public/url?${params.toString()}`, { fetch: customFetch });
+	}
+};
 var SpaceFilesApi = class {
 	transport;
 	spaceId;
@@ -1769,9 +3250,39 @@ var SpaceFilesApi = class {
 		const query = params.toString();
 		return this.transport.request(`/api/spaces/${this.spaceId}/fs/tree${query ? `?${query}` : ""}`, { fetch: customFetch });
 	}
-	read(path, customFetch) {
+	read(path, customFetch, signal) {
 		const params = new URLSearchParams({ path });
-		return this.transport.request(`/api/spaces/${this.spaceId}/fs/file?${params.toString()}`, { fetch: customFetch });
+		return this.transport.request(`/api/spaces/${this.spaceId}/fs/file?${params.toString()}`, {
+			fetch: customFetch,
+			signal
+		});
+	}
+	/** Resolve a browser-ready file URL, waiting for CDN delivery when necessary. */
+	async resolveUrl(path, options = {}) {
+		const purpose = options.purpose ?? "preview";
+		const requestedTimeoutMs = options.timeoutMs ?? 15e3;
+		const timeoutMs = Number.isFinite(requestedTimeoutMs) ? Math.max(0, requestedTimeoutMs) : 15e3;
+		const deadlineAt = Date.now() + timeoutMs;
+		const deadline = createSpaceFileDeadlineSignal(options.signal, timeoutMs);
+		try {
+			while (true) {
+				const file = await this.read(path, options.fetch, deadline.signal);
+				if (deadline.timedOut()) return null;
+				if ("content" in file) {
+					if (file.delivery === "url" && file.url) return file.url;
+					return purpose === "preview" ? inlineFileDataUrl(file) : null;
+				}
+				const remainingMs = deadlineAt - Date.now();
+				if (remainingMs <= 0) return null;
+				const retryAfterMs = Math.max(250, Math.min(file.retryAfterMs, 2e3));
+				await waitForSpaceFileRetry(Math.min(retryAfterMs, remainingMs), deadline.signal);
+			}
+		} catch (error) {
+			if (deadline.timedOut()) return null;
+			throw error;
+		} finally {
+			deadline.dispose();
+		}
 	}
 	/** Pending workspace changes vs the space head checkpoint. */
 	diff(customFetch) {
@@ -2725,6 +4236,7 @@ var SpaceBoardsApi = class {
 		return new BoardClient(this.spaceId, boardId, this.transport, this.websocketClient);
 	}
 	create(input) {
+		assertBoardNodes(input.nodes ?? []);
 		return this.transport.request(`/api/spaces/${this.spaceId}/boards`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
@@ -2749,6 +4261,7 @@ var SpaceBoardsApi = class {
 		});
 	}
 	async apply(transaction) {
+		assertBoardTransactionNodeCreates(transaction.operations);
 		try {
 			return await this.transport.request(`/api/spaces/${this.spaceId}/boards/${transaction.boardId}/transactions`, {
 				method: "POST",
@@ -2904,6 +4417,7 @@ var SpaceClient = class {
 	transport;
 	websocketClient;
 	files;
+	publicFiles;
 	sessions;
 	turns;
 	members;
@@ -2924,6 +4438,7 @@ var SpaceClient = class {
 		this.transport = transport;
 		this.websocketClient = websocketClient;
 		this.files = new SpaceFilesApi(transport, id);
+		this.publicFiles = new SpacePublicFilesApi(transport, id);
 		this.sessions = new SpaceSessionsApi(transport, id, websocketClient);
 		this.turns = new SpaceTurnsApi(transport, id);
 		this.members = new SpaceMembersApi(transport, id);
@@ -3160,158 +4675,6 @@ var TasksApi = class {
 	}
 };
 //#endregion
-//#region ../protocol/dist/ui-command.js
-/**
-* Lets an agent drive the Cohub frontend that originated the work. Routing comes
-* from request provenance, never a caller-supplied target, so a command only
-* reaches the actor's own instances.
-*/
-const UI_COMMAND_VERSION = 1;
-/** Persisted and broadcast, so every field is capped; MAX_BYTES bounds the whole. */
-const UI_COMMAND_PAYLOAD_MAX_BYTES = 32 * 1024;
-const UI_COMMAND_MAX_BYTES = 40 * 1024;
-const UI_COMMAND_LAUNCH_MAX_LENGTH = 2048;
-const UI_COMMAND_DEFAULT_TIMEOUT_MS = 600 * 1e3;
-const UI_COMMAND_MAX_TIMEOUT_MS = 720 * 60 * 1e3;
-const UI_COMMAND_SETTLEMENT_GRACE_SECONDS = 600;
-/** Keeps pending commands reportable for the full wait window plus settlement grace. */
-const UI_COMMAND_PENDING_TTL_SECONDS = 43800;
-const UI_COMMAND_TERMINAL_TTL_SECONDS = 1800;
-const UI_COMMAND_TERMINAL_STATUSES = [
-	"applied",
-	"no_active_client",
-	"ui_host_unavailable",
-	"rejected",
-	"unsupported",
-	"timeout"
-];
-const isTerminalUiCommandStatus = (status) => UI_COMMAND_TERMINAL_STATUSES.includes(status);
-const METHOD_RE = /^[A-Za-z][A-Za-z0-9_.:-]{0,63}$/;
-const isUiSurfaceMethod = (value) => typeof value === "string" && METHOD_RE.test(value);
-const WORK_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const UI_COMMAND_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
-const parseUiCommandId = (value) => {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	return UI_COMMAND_ID_RE.test(trimmed) ? trimmed : null;
-};
-const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
-const asTrimmed = (value) => {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	return trimmed ? trimmed : null;
-};
-const parseLaunch = (value) => {
-	if (!isRecord(value)) return void 0;
-	const search = asTrimmed(value.search);
-	const hash = asTrimmed(value.hash);
-	if (!search && !hash) return void 0;
-	return {
-		...search ? { search: search.startsWith("?") ? search : `?${search}` } : {},
-		...hash ? { hash: hash.startsWith("#") ? hash : `#${hash}` } : {}
-	};
-};
-const measureUiCommandPayload = (value) => {
-	if (value === void 0) return 0;
-	try {
-		return new TextEncoder().encode(JSON.stringify(value) ?? "").length;
-	} catch {
-		return null;
-	}
-};
-const parseUiCommand = (input) => {
-	if (!isRecord(input)) return {
-		command: null,
-		error: "command must be an object"
-	};
-	if (input.type !== "preview.show") return {
-		command: null,
-		error: "command.type must be one of: preview.show"
-	};
-	const preview = input.preview;
-	if (!isRecord(preview)) return {
-		command: null,
-		error: "command.preview is required"
-	};
-	if (preview.kind !== "work") return {
-		command: null,
-		error: "command.preview.kind must be one of: work"
-	};
-	const workId = asTrimmed(preview.workId);
-	if (!workId) return {
-		command: null,
-		error: "command.preview.workId is required"
-	};
-	if (!WORK_ID_RE.test(workId)) return {
-		command: null,
-		error: "command.preview.workId must be a Work id"
-	};
-	const label = asTrimmed(preview.label);
-	if (label && label.length > 200) return {
-		command: null,
-		error: `command.preview.label exceeds 200 characters`
-	};
-	const launch = parseLaunch(preview.launch);
-	if (launch) {
-		for (const [field, value] of [["search", launch.search], ["hash", launch.hash]]) if (value && value.length > 2048) return {
-			command: null,
-			error: `command.preview.launch.${field} exceeds ${UI_COMMAND_LAUNCH_MAX_LENGTH} characters`
-		};
-	}
-	let request;
-	if (input.request !== void 0 && input.request !== null) {
-		if (!isRecord(input.request)) return {
-			command: null,
-			error: "command.request must be an object"
-		};
-		const method = asTrimmed(input.request.method);
-		if (!method) return {
-			command: null,
-			error: "command.request.method is required"
-		};
-		if (!isUiSurfaceMethod(method)) return {
-			command: null,
-			error: "command.request.method has an unsupported format"
-		};
-		const size = measureUiCommandPayload(input.request.input);
-		if (size === null) return {
-			command: null,
-			error: "command.request.input must be JSON-serializable"
-		};
-		if (size > 32768) return {
-			command: null,
-			error: `command.request.input exceeds ${UI_COMMAND_PAYLOAD_MAX_BYTES} bytes`
-		};
-		request = {
-			method,
-			...input.request.input === void 0 ? {} : { input: input.request.input }
-		};
-	}
-	const command = {
-		type: "preview.show",
-		preview: {
-			kind: "work",
-			workId,
-			...label ? { label } : {},
-			...launch ? { launch } : {}
-		},
-		...request ? { request } : {}
-	};
-	const totalSize = measureUiCommandPayload(command);
-	if (totalSize === null) return {
-		command: null,
-		error: "command must be JSON-serializable"
-	};
-	if (totalSize > 40960) return {
-		command: null,
-		error: `command exceeds ${UI_COMMAND_MAX_BYTES} bytes`
-	};
-	return {
-		command,
-		error: null
-	};
-};
-//#endregion
 //#region src/apis/ui-commands.ts
 const DEFAULT_POLL_INTERVAL_MS = 300;
 const resolveTimeoutMs = (timeoutMs) => {
@@ -3386,6 +4749,7 @@ var UiCommandsApi = class {
 };
 //#endregion
 //#region src/apis/user.ts
+const usageDate = (value) => value instanceof Date ? value.toISOString() : value;
 var UserApi = class {
 	transport;
 	transportBaseUrl;
@@ -3428,9 +4792,13 @@ var UserApi = class {
 	getSession(sessionId, customFetch) {
 		return this.transport.request(`/api/sessions/${sessionId}`, { fetch: customFetch });
 	}
-	getUsage(days = 30, customFetch) {
-		const params = new URLSearchParams({ days: String(days) });
-		return this.transport.request(`/api/me/usage?${params.toString()}`, { fetch: customFetch });
+	getActivity(options = {}, customFetch) {
+		const params = new URLSearchParams();
+		if (options.days !== void 0) params.set("days", String(options.days));
+		if (options.from !== void 0) params.set("from", usageDate(options.from));
+		if (options.to !== void 0) params.set("to", usageDate(options.to));
+		const query = params.toString();
+		return this.transport.request(`/api/me/activity${query ? `?${query}` : ""}`, { fetch: customFetch });
 	}
 	async setAuthToken(token) {
 		const trimmedToken = token.trim();
@@ -3657,4 +5025,4 @@ var CohubHttpClient = class {
 };
 const createHttpClient = (options) => new CohubHttpClient(options);
 //#endregion
-export { parseAssistantMessageCommit as A, ReferencesApi as B, SpaceClient as C, buildSpacePath as D, buildSpaceInvitePath as E, BOARD_ARROW_STROKE_SIZE as F, ModelsApi as G, PublicAssetsApi as H, BOARD_BUILTIN_CAPABILITIES as I, ChannelsApi as J, GenerationsApi as K, BOARD_CONNECTION_STROKE_SIZE as L, createSessionPatchReducer as M, ensureRealtimeConnected as N, SessionGenerationStreamClient as O, BoardConnectionSchema as P, DEFAULT_BOARD_RENDER_LIMITS as R, BoardTransactionError as S, PublicInviteApi as T, SkillsApi as U, SearchApi as V, PromptsApi as W, isUiSurfaceMethod as _, ReferralsApi as a, TasksApi as b, UiCommandsApi as c, UI_COMMAND_PAYLOAD_MAX_BYTES as d, UI_COMMAND_PENDING_TTL_SECONDS as f, isTerminalUiCommandStatus as g, UI_COMMAND_VERSION as h, WorksApi as i, SessionPatchReducer as j, createSessionGenerationStreamClient as k, UI_COMMAND_DEFAULT_TIMEOUT_MS as l, UI_COMMAND_TERMINAL_TTL_SECONDS as m, createHttpClient as n, UsersApi as o, UI_COMMAND_SETTLEMENT_GRACE_SECONDS as p, CronJobsApi as q, WorkCommerceApi as r, UserApi as s, CohubHttpClient as t, UI_COMMAND_MAX_TIMEOUT_MS as u, parseUiCommand as v, SpacesApi as w, BoardClient as x, parseUiCommandId as y, SessionAccessApi as z };
+export { SearchApi as $, UI_COMMAND_PENDING_TTL_SECONDS as A, BoardAwarenessClientPayloadSchema as B, BoardInputError as C, UI_COMMAND_DEFAULT_TIMEOUT_MS as D, validateBoardNodes as E, isUiSurfaceMethod as F, validateBoardNodeInput as G, BOARD_GEO_KINDS as H, parseUiCommand as I, ensureRealtimeConnected as J, BoardPlaybackPolicySchema as K, parseUiCommandId as L, UI_COMMAND_TERMINAL_TTL_SECONDS as M, UI_COMMAND_VERSION as N, UI_COMMAND_MAX_TIMEOUT_MS as O, isTerminalUiCommandStatus as P, ReferencesApi as Q, parseSpaceSlug as R, createSessionPatchReducer as S, createBoardNode as T, BOARD_NATIVE_NODE_TYPES as U, BOARD_COLOR_IDS as V, BOARD_NODE_CONTRACT as W, DEFAULT_BOARD_RENDER_LIMITS as X, BOARD_BUILTIN_CAPABILITIES as Y, SessionAccessApi as Z, buildSpacePath as _, ReferralsApi as a, CronJobsApi as at, parseAssistantMessageCommit as b, UiCommandsApi as c, BoardTransactionError as d, PublicAssetsApi as et, SpaceClient as f, buildSpaceInvitePath as g, PublicInviteApi as h, WorksApi as i, GenerationsApi as it, UI_COMMAND_SETTLEMENT_GRACE_SECONDS as j, UI_COMMAND_PAYLOAD_MAX_BYTES as k, TasksApi as l, SpacesApi as m, createHttpClient as n, PromptsApi as nt, UsersApi as o, ChannelsApi as ot, SpacePublicFilesApi as p, parseBoardPlaybackPolicy as q, WorkCommerceApi as r, ModelsApi as rt, UserApi as s, CohubHttpClient as t, SkillsApi as tt, BoardClient as u, SessionGenerationStreamClient as v, assertBoardNodes as w, SessionPatchReducer as x, createSessionGenerationStreamClient as y, parseUsername as z };