@neta-art/cohub 8.10.1 → 8.11.0

package/dist/board/render/renderers/file-card-renderer.js

@@ -1,5 +1,6 @@
-import { BOARD_FONT_STACK } from "../../../protocol/dist/board-constants.js";
-import { fileBaseName, filePreviewKind } from "../../core/file-preview.js";
+import { BOARD_FONT_STACK, BOARD_MONO_FONT_STACK } from "../../../protocol/dist/board-constants.js";
+import { fileCategory, fileStem } from "../../core/file-snapshot.js";
+import { fileCategoryAccent, fileMetaLine, filePreviewKind, fileTypeLabel } from "../../core/file-preview.js";
 import { syncTextResolution } from "../text-resolution.js";
 import { positionShell } from "./base-card-renderer.js";
 import { drawFarPlate } from "./far-plate.js";
@@ -31,8 +32,12 @@ const TITLE_LINE = TITLE_SIZE * 1.35;
 const TITLE_MAX_LINES = 2;
 const EXCERPT_SIZE = 11;
 const EXCERPT_LINE = EXCERPT_SIZE * 1.45;
-const EXCERPT_MAX_LINES = 4;
+const EXCERPT_MAX_LINES = 3;
+const META_SIZE = 10;
+const META_LINE = 14;
+const TYPE_MARK_SIZE = 28;
 const GAP = 4;
+const STRIPE = 2;
 /** Zoom below which the title is dropped (glyphs are sub-pixel). */
 const LOD_TITLE_ZOOM = .35;
 /** Zoom below which the excerpt is dropped. */
@@ -168,8 +173,13 @@ function sync(container, item, context) {
 	const coverFailed = Boolean(key && !texture && context.hasError(key));
 	const fileState = context.fileState(item.ref.path);
 	const band = coverHeight(item, height);
+	const kind = filePreviewKind(item.snapshot);
+	const category = fileCategory(item.ref.path, item.snapshot?.mimeType);
+	const accent = fileCategoryAccent(category, context.palette);
 	syncTextResolution(parts.title, parts.titleRes, context.zoom);
 	syncTextResolution(parts.excerpt, parts.excerptRes, context.zoom);
+	syncTextResolution(parts.meta, parts.metaRes, context.zoom);
+	syncTextResolution(parts.typeMark, parts.typeMarkRes, context.zoom);
 	const visualSig = [
 		key ?? "",
 		width,
@@ -180,9 +190,12 @@ function sync(container, item, context) {
 		texture ? `${texture.width}x${texture.height}` : "none",
 		coverFailed,
 		fileState,
+		kind,
+		category,
 		context.colorScheme,
 		context.palette.surface,
-		context.palette.hover
+		context.palette.hover,
+		accent
 	].join("|");
 	if (visualSig !== parts.visualSig) {
 		parts.visualSig = visualSig;
@@ -218,41 +231,67 @@ function sync(container, item, context) {
 		}
 		parts.cover.visible = showCover;
 		parts.coverMask.visible = showCover;
-		if (!band) parts.plate.rect(1, 1, 2, height - 2).fill({
-			color: context.palette.muted,
-			alpha: .35
+		if (!band) parts.plate.rect(1, 1, STRIPE, height - 2).fill({
+			color: accent,
+			alpha: .55
 		});
 		parts.title.visible = detail !== "plate";
 		parts.excerpt.visible = detail === "full";
+		parts.meta.visible = detail === "full";
+		parts.typeMark.visible = kind === "blank" && detail !== "plate";
 	}
-	if (detail === "plate") return;
-	const title = item.snapshot?.title || fileBaseName(item.ref.path);
+	if (detail === "plate") {
+		parts.typeMark.visible = false;
+		parts.meta.visible = false;
+		return;
+	}
+	const title = item.snapshot?.title || fileStem(item.ref.path);
 	const excerpt = item.snapshot?.excerpt ?? "";
+	const meta = fileMetaLine(item.ref.path, item.snapshot?.size);
+	const mark = fileTypeLabel(item.ref.path);
 	const innerWidth = Math.max(1, width - 20);
+	const showTypeMark = kind === "blank";
 	const textSig = [
 		title,
 		excerpt,
+		meta,
+		mark,
 		detail,
 		innerWidth,
 		band,
 		height,
+		kind,
 		context.palette.text,
-		context.palette.muted
+		context.palette.muted,
+		accent
 	].join("|");
 	if (textSig === parts.textSig) return;
 	parts.textSig = textSig;
 	const top = band > 0 ? band + PADDING * .8 : PADDING;
-	const contentBottom = height - PADDING;
-	const titleLines = linesInRoom(Math.max(0, contentBottom - top), TITLE_LINE, TITLE_MAX_LINES);
+	const metaReserve = detail === "full" && meta ? META_LINE : 0;
+	const contentBottom = height - PADDING - metaReserve;
+	let cursor = top;
+	if (showTypeMark) {
+		const markSize = Math.max(18, Math.min(TYPE_MARK_SIZE, Math.round(height * .22)));
+		parts.typeMark.style.fill = accent;
+		parts.typeMark.style.fontSize = markSize;
+		parts.typeMark.style.lineHeight = markSize * 1.1;
+		if (parts.typeMark.text !== mark) parts.typeMark.text = mark;
+		parts.typeMark.position.set(PADDING, cursor);
+		parts.typeMark.visible = true;
+		cursor += parts.typeMark.height + GAP;
+	} else parts.typeMark.visible = false;
+	const titleLines = linesInRoom(Math.max(0, contentBottom - cursor), TITLE_LINE, TITLE_MAX_LINES);
 	parts.title.style.fill = context.palette.text;
 	fitTextToLines(parts.title, title, titleLines, innerWidth);
-	parts.title.position.set(PADDING, top);
+	parts.title.position.set(PADDING, cursor);
 	parts.title.visible = titleLines > 0;
 	if (detail !== "full") {
 		parts.excerpt.visible = false;
+		parts.meta.visible = false;
 		return;
 	}
-	const excerptTop = top + (titleLines > 0 ? parts.title.height + GAP : 0);
+	const excerptTop = cursor + (titleLines > 0 ? parts.title.height + GAP : 0);
 	const excerptLines = linesInRoom(contentBottom - excerptTop, EXCERPT_LINE, EXCERPT_MAX_LINES);
 	const showExcerpt = Boolean(excerpt) && excerptLines > 0;
 	if (showExcerpt) {
@@ -261,6 +300,12 @@ function sync(container, item, context) {
 		parts.excerpt.position.set(PADDING, excerptTop);
 	}
 	parts.excerpt.visible = showExcerpt;
+	if (meta) {
+		parts.meta.style.fill = context.palette.muted;
+		if (parts.meta.text !== meta) parts.meta.text = meta;
+		parts.meta.position.set(PADDING, height - PADDING - META_LINE + 2);
+		parts.meta.visible = true;
+	} else parts.meta.visible = false;
 }
 const fileCardRenderer = {
 	id: "file-card",
@@ -302,8 +347,32 @@ const fileCardRenderer = {
 			resolution,
 			roundPixels: true
 		});
+		const meta = new Text({
+			text: "",
+			style: {
+				fill: context.palette.muted,
+				fontFamily: BOARD_MONO_FONT_STACK,
+				fontSize: META_SIZE,
+				fontWeight: "500",
+				lineHeight: META_LINE
+			},
+			resolution,
+			roundPixels: true
+		});
+		const typeMark = new Text({
+			text: "",
+			style: {
+				fill: context.palette.muted,
+				fontFamily: BOARD_MONO_FONT_STACK,
+				fontSize: TYPE_MARK_SIZE,
+				fontWeight: "700",
+				lineHeight: TYPE_MARK_SIZE * 1.1
+			},
+			resolution,
+			roundPixels: true
+		});
 		body.mask = clip;
-		body.addChild(cover, coverMask, title, excerpt);
+		body.addChild(cover, coverMask, typeMark, title, excerpt, meta);
 		root.addChild(plate, body, clip);
 		partsByContainer.set(root, {
 			root,
@@ -312,12 +381,16 @@ const fileCardRenderer = {
 			clip,
 			cover,
 			coverMask,
+			typeMark,
 			title,
 			excerpt,
+			meta,
 			visualSig: "",
 			textSig: "",
 			titleRes: { resolution },
-			excerptRes: { resolution }
+			excerptRes: { resolution },
+			metaRes: { resolution },
+			typeMarkRes: { resolution }
 		});
 		if (item.type === "file") sync(root, item, context);
 		return root;
@@ -330,11 +403,12 @@ const fileCardRenderer = {
 	* would mean one draw call per distinct image and defeat the batch.
 	*/
 	renderFar: (graphics, item, context) => {
+		const category = fileCategory(item.type === "file" ? item.ref.path : "", item.type === "file" ? item.snapshot?.mimeType : void 0);
 		drawFarPlate(graphics, item.frame, {
 			fill: context.palette.surface,
 			fillAlpha: .96,
-			accent: context.palette.muted,
-			accentAlpha: .4
+			accent: fileCategoryAccent(category, context.palette),
+			accentAlpha: .45
 		});
 	},
 	destroy: (container) => {

package/dist/chunks/http.d.ts

@@ -268,15 +268,23 @@ type AppPromotionEventKey = typeof APP_PROMOTION_EVENT_KEYS[number];
 //#region src/app-runtime.d.ts
 type AppRuntimeInvocationContext = {
   surface: "page" | "app" | "background" | "broker";
-  source?: "desktop_command" | "user" | "route";
+  source?: "desktop_command" | "user" | "route" | "embed";
   spaceId?: string;
   sessionId?: string;
   turnId?: string;
   toolCallId?: string;
+  /**
+   * The App whose page embeds this one, when `source` is `embed`. Present only
+   * when that App's published content is served from the embedding frame.
+   */
+  embedder?: {
+    appId: string;
+    slug: string;
+  };
 };
 /** Current navigation context supplied by the embedding Cohub shell. */
 type AppRuntimeShellContext = {
-  surface: "workspace" | "background" | "broker";
+  surface: "workspace" | "background" | "broker" | "embed";
   space: {
     id: string;
     name?: string | null;
@@ -348,6 +356,8 @@ interface AppRuntimeTransport {
   subscribeContextChanged?: (listener: AppContextChangedListener) => () => void;
   /** Whether this transport can address the embedding Cohub workspace. */
   supportsNavigation?: boolean;
+  /** Posts a one-way message to the host; no reply is expected. */
+  notify?: (message: Record<string, unknown>) => void;
 }
 /**
  * Bridge-mode transport: posts messages to `window.parent` (the Cohub host
@@ -360,6 +370,7 @@ declare class ParentBridgeTransport implements AppRuntimeTransport {
   private contextListeners;
   private contextListener;
   subscribeContextChanged(listener: AppContextChangedListener): () => void;
+  notify(message: Record<string, unknown>): void;
   request<T>(message: Record<string, unknown>, options?: AppRuntimeRequestOptions): Promise<T | null>;
 }
 /**
@@ -392,9 +403,10 @@ declare class PopupBrokerTransport implements AppRuntimeTransport {
   private resolveAppId;
   request<T>(message: Record<string, unknown>, options?: AppRuntimeRequestOptions): Promise<T | null>;
 }
-/** Outcome of {@link AppRuntimeApi.requestSpaceAuthorization}. */
+/** Outcome of {@link AppRuntimeApi.requestSpaceAuthorization} / {@link AppRuntimeApi.requestCreateSpaceAuthorization}. */
 type AppRuntimeAuthorizationResult = {
   granted: boolean;
+  /** Picked or created Space. Null on deny. Set with `granted: false` when create persisted but did not provision. */
   space: {
     id: string;
     name: string | null;
@@ -426,6 +438,12 @@ declare class AppRuntimeApi {
   context(): Promise<AppRuntimeContext | null>;
   onContextChanged(listener: AppContextChangedListener): () => void;
   navigationOpen(target: AppNavigationTarget, call?: AppNavigationCall): Promise<AppNavigationOpenResponse>;
+  /**
+   * Asks the host to close this App: a workspace tab closes, an embedded page
+   * forwards the request to its embedder, a standalone page closes the tab.
+   * No-op in broker mode, where the App owns its own window.
+   */
+  requestClose(): void;
   getAccessToken(options?: {
     forceRefresh?: boolean;
   }): Promise<string | null>;
@@ -451,6 +469,19 @@ declare class AppRuntimeApi {
     reason?: string;
     alwaysAsk?: boolean;
   }): Promise<AppRuntimeAuthorizationResult>;
+  /**
+   * One consent: create a viewer-owned Space (full `CreateSpaceInput`, same
+   * as `spaces.create`) and grant the scopes on it. Never silent — each
+   * confirm mints a new Space. The host creates with the viewer's account
+   * token; the app never calls `POST /api/spaces` itself.
+   * `{ granted: false, space }` means the Space was created but not provisioned;
+   * no grant was issued. A viewer deny is `{ granted: false, space: null }`.
+   */
+  requestCreateSpaceAuthorization(input: {
+    scopes: Permission[];
+    space: CreateSpaceInput;
+    reason?: string;
+  }): Promise<AppRuntimeAuthorizationResult>;
   purchase(input: {
     productKey: string;
     purchaseAttemptId?: string;

package/dist/chunks/websocket.d.ts

@@ -18,6 +18,7 @@ type WebsocketClientOptions = {
   autoReconnect?: boolean;
   reconnectBaseDelayMs?: number;
   reconnectMaxDelayMs?: number;
+  connectTimeoutMs?: number;
   pingIntervalMs?: number;
   pongTimeoutMs?: number;
   debug?: boolean;
@@ -99,6 +100,7 @@ declare class WebsocketClient {
   private readonly autoReconnect;
   private readonly reconnectBaseDelayMs;
   private readonly reconnectMaxDelayMs;
+  private readonly connectTimeoutMs;
   private readonly pingIntervalMs;
   private readonly pongTimeoutMs;
   private readonly debug;
@@ -114,6 +116,7 @@ declare class WebsocketClient {
   private retryAuthClose;
   private manuallyClosed;
   private connectPromise;
+  private pendingConnectReject;
   private authWaiter;
   private awaitingPong;
   private lastPingRequestId;

package/dist/chunks/websocket.js

@@ -61,11 +61,16 @@ const normalizeOptions = (options = {}) => ({
 	autoReconnect: options.autoReconnect !== false,
 	reconnectBaseDelayMs: options.reconnectBaseDelayMs ?? 1e3,
 	reconnectMaxDelayMs: options.reconnectMaxDelayMs ?? 15e3,
+	connectTimeoutMs: normalizeConnectTimeoutMs(options.connectTimeoutMs ?? 15e3),
 	pingIntervalMs: options.pingIntervalMs ?? 2e4,
 	pongTimeoutMs: options.pongTimeoutMs ?? 15e3,
 	debug: options.debug === true
 });
 const formatCloseMessage = (code, reason) => `WebSocket closed: ${code ?? 0} ${reason || ""}`.trim();
+const normalizeConnectTimeoutMs = (value) => {
+	if (!Number.isInteger(value) || value < 1 || value > 2147483647) throw new Error("connectTimeoutMs must be an integer between 1 and 2147483647");
+	return value;
+};
 const AUTH_CLOSE_CODE = 4003;
 const AUTH_CLOSE_REASON = "authentication failed";
 const isRetryableCloseCode = (code) => {
@@ -135,6 +140,7 @@ var WebsocketClient = class {
 	autoReconnect;
 	reconnectBaseDelayMs;
 	reconnectMaxDelayMs;
+	connectTimeoutMs;
 	pingIntervalMs;
 	pongTimeoutMs;
 	debug;
@@ -150,6 +156,7 @@ var WebsocketClient = class {
 	retryAuthClose = false;
 	manuallyClosed = false;
 	connectPromise = null;
+	pendingConnectReject = null;
 	authWaiter = null;
 	awaitingPong = false;
 	lastPingRequestId = null;
@@ -170,6 +177,7 @@ var WebsocketClient = class {
 		this.autoReconnect = normalized.autoReconnect;
 		this.reconnectBaseDelayMs = normalized.reconnectBaseDelayMs;
 		this.reconnectMaxDelayMs = normalized.reconnectMaxDelayMs;
+		this.connectTimeoutMs = normalized.connectTimeoutMs;
 		this.pingIntervalMs = normalized.pingIntervalMs;
 		this.pongTimeoutMs = normalized.pongTimeoutMs;
 		this.debug = normalized.debug;
@@ -204,19 +212,70 @@ var WebsocketClient = class {
 			const ws = new this.WebSocketImpl(this.url);
 			this.ws = ws;
 			let settled = false;
+			let closed = false;
+			let connectTimer = null;
+			const clearConnectTimer = () => {
+				if (connectTimer === null) return;
+				clearTimeout(connectTimer);
+				connectTimer = null;
+			};
 			const rejectOnce = (error) => {
 				if (settled) return;
+				clearConnectTimer();
 				settled = true;
 				this.connectPromise = null;
+				if (this.pendingConnectReject === rejectOnce) this.pendingConnectReject = null;
 				reject(error);
 			};
 			const resolveOnce = () => {
 				if (settled) return;
+				clearConnectTimer();
 				settled = true;
 				this.connectPromise = null;
+				if (this.pendingConnectReject === rejectOnce) this.pendingConnectReject = null;
 				resolve();
 			};
+			const isCurrentConnection = () => this.ws === ws && !closed;
+			const cleanupSocket = () => {
+				ws.onopen = null;
+				ws.onmessage = null;
+				ws.onerror = null;
+				ws.onclose = null;
+			};
+			const handleClose = (event) => {
+				if (closed || this.ws !== ws) return;
+				closed = true;
+				clearConnectTimer();
+				this.stopPingLoop();
+				const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
+				this.state = "closed";
+				this.ws = null;
+				this.compactStreamContexts.clear();
+				this.patchStreamBuffers.clear();
+				this.resetRoomSubscriptions();
+				const closeError = new Error(formatCloseMessage(event.code, event.reason));
+				this.rejectAuthWaiter(closeError);
+				const retryAuthClose = event.code === AUTH_CLOSE_CODE && this.retryAuthClose;
+				this.retryAuthClose = false;
+				const willReconnect = !this.manuallyClosed && this.autoReconnect && (retryAuthClose || isRetryableCloseCode(event.code));
+				this.log("closed", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect,
+					wasConnecting
+				});
+				this.emit("close", {
+					code: event.code,
+					reason: event.reason,
+					willReconnect
+				});
+				cleanupSocket();
+				if (wasConnecting) rejectOnce(closeError);
+				if (willReconnect) this.scheduleReconnect(event.code, event.reason);
+			};
 			ws.onopen = async () => {
+				if (!isCurrentConnection()) return;
+				clearConnectTimer();
 				try {
 					this.log("connected", {
 						url: this.url,
@@ -225,12 +284,14 @@ var WebsocketClient = class {
 					});
 					this.startPingLoop();
 					await this.authenticate();
+					if (!isCurrentConnection()) return;
 					this.state = "open";
 					this.restoreRoomSubscriptions();
 					this.reconnectAttempt = 0;
 					this.emit("open", { connectionId: this.connectionId });
 					resolveOnce();
 				} catch (error) {
+					if (!isCurrentConnection()) return;
 					const authError = error instanceof Error ? error : /* @__PURE__ */ new Error("authentication failed");
 					const recoverable = Boolean(this.getAccessToken && this.autoReconnect && !this.manuallyClosed && !this.authReconnectAttempted);
 					this.retryAuthClose = recoverable;
@@ -247,41 +308,37 @@ var WebsocketClient = class {
 				}
 			};
 			ws.onmessage = (event) => {
+				if (!isCurrentConnection()) return;
 				this.handleMessage(event.data);
 			};
 			ws.onerror = (error) => {
+				if (!isCurrentConnection()) return;
 				this.emit("error", {
 					error,
 					recoverable: !this.manuallyClosed
 				});
 			};
 			ws.onclose = (event) => {
-				this.stopPingLoop();
-				const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
-				this.state = "closed";
-				this.ws = null;
-				this.compactStreamContexts.clear();
-				this.patchStreamBuffers.clear();
-				this.resetRoomSubscriptions();
-				const closeError = new Error(formatCloseMessage(event.code, event.reason));
-				this.rejectAuthWaiter(closeError);
-				const retryAuthClose = event.code === AUTH_CLOSE_CODE && this.retryAuthClose;
-				this.retryAuthClose = false;
-				const willReconnect = !this.manuallyClosed && this.autoReconnect && (retryAuthClose || isRetryableCloseCode(event.code));
-				this.log("closed", {
-					code: event.code,
-					reason: event.reason,
-					willReconnect,
-					wasConnecting
-				});
-				this.emit("close", {
-					code: event.code,
-					reason: event.reason,
-					willReconnect
-				});
-				if (wasConnecting) rejectOnce(closeError);
-				if (willReconnect) this.scheduleReconnect(event.code, event.reason);
+				handleClose(event);
 			};
+			this.pendingConnectReject = rejectOnce;
+			connectTimer = setTimeout(() => {
+				if (!isCurrentConnection() || settled) return;
+				const reason = "connect timeout";
+				const error = /* @__PURE__ */ new Error(`WebSocket ${reason} after ${this.connectTimeoutMs}ms`);
+				this.emit("error", {
+					error,
+					recoverable: !this.manuallyClosed && this.autoReconnect
+				});
+				try {
+					ws.close(4002, reason);
+				} finally {
+					handleClose({
+						code: 4002,
+						reason
+					});
+				}
+			}, this.connectTimeoutMs);
 		});
 		return this.connectPromise;
 	}
@@ -291,9 +348,23 @@ var WebsocketClient = class {
 		this.stopPingLoop();
 		this.state = "closed";
 		this.rejectAuthWaiter(/* @__PURE__ */ new Error("disconnected"));
-		this.ws?.close(code, reason);
+		const ws = this.ws;
 		this.ws = null;
+		ws?.close(code, reason);
+		this.pendingConnectReject?.(/* @__PURE__ */ new Error(`WebSocket disconnected: ${reason}`));
+		this.pendingConnectReject = null;
 		this.connectPromise = null;
+		if (ws) {
+			ws.onopen = null;
+			ws.onmessage = null;
+			ws.onerror = null;
+			ws.onclose = null;
+			this.emit("close", {
+				code,
+				reason,
+				willReconnect: false
+			});
+		}
 		this.authReconnectAttempted = false;
 		this.forceRefreshOnNextAuth = false;
 		this.retryAuthClose = false;