@neta-art/cohub 5.3.2 → 5.4.0

package/dist/chunks/http.js

@@ -1,5 +1,6 @@
 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";
 //#region src/apis/channels.ts
 var ChannelsApi = class {
 	transport;
@@ -439,6 +440,199 @@ var SessionAccessApi = class {
 	}
 };
 //#endregion
+//#region ../protocol/dist/board-constants.js
+const DEFAULT_BOARD_RENDER_LIMITS = {
+	particles: 2e4,
+	vertices: 5e5,
+	dynamicVertices: 15e4,
+	drawCalls: 400,
+	filterPasses: 24,
+	renderTexturePixels: 16777216,
+	textureBytes: 512 * 1024 * 1024,
+	bufferBytes: 256 * 1024 * 1024,
+	simulationSteps: 1e5
+};
+const BOARD_BUILTIN_CLIP_KINDS = [
+	"motion.keyframes",
+	"motion.path",
+	"draw.reveal",
+	"draw.handwrite",
+	"text.reveal",
+	"effects.particles",
+	"effects.trail",
+	"effects.impact",
+	"effects.flash",
+	"effects.color",
+	"camera.pan",
+	"camera.zoom",
+	"camera.shake"
+];
+const BOARD_BUILTIN_EFFECT_KINDS = ["effects.pulse", "effects.float"];
+const BOARD_ARROW_STROKE_SIZE = 2.5;
+const BOARD_CONNECTION_STROKE_SIZE = 2.5;
+function clampBoardStrokeSize(size) {
+	if (!Number.isFinite(size)) return BOARD_CONNECTION_STROKE_SIZE;
+	return Math.min(64, Math.max(1, size));
+}
+const BOARD_BUILTIN_CAPABILITIES = [...BOARD_BUILTIN_CLIP_KINDS.map((id) => ({
+	kind: "clip",
+	id,
+	version: 1,
+	renderers: ["webgpu", "webgl"]
+})), ...BOARD_BUILTIN_EFFECT_KINDS.map((id) => ({
+	kind: "effect",
+	id,
+	version: 1,
+	renderers: ["webgpu", "webgl"]
+}))];
+/**
+* Where a connection meets its node.
+*
+* - `auto` — the side is chosen from the live geometry of both endpoints, so the
+*   connection stays sensible through any move or resize. This is the default and
+*   what almost every connection should use.
+* - `side` — the user pinned a side; `offset` (0..1) positions it along that edge.
+* - `fixed` — the user pinned an exact normalized point on the frame.
+*
+* `auto` is a *declaration of intent*, not a computed value: the resolved side is
+* never written back, so the connection keeps adapting instead of freezing the
+* first layout it happened to have.
+*/
+const BoardConnectionAnchorSchema = z.union([
+	z.object({ kind: z.literal("auto") }),
+	z.object({
+		kind: z.literal("side"),
+		side: z.enum([
+			"top",
+			"right",
+			"bottom",
+			"left"
+		]),
+		offset: z.number().finite().min(0).max(1).default(.5)
+	}),
+	z.object({
+		kind: z.literal("fixed"),
+		nx: z.number().finite().min(0).max(1),
+		ny: z.number().finite().min(0).max(1)
+	})
+]);
+const AUTO_BOARD_CONNECTION_ANCHOR = { kind: "auto" };
+const BoardConnectionEndpointSchema = z.object({
+	nodeId: z.string().min(1).max(160),
+	anchor: BoardConnectionAnchorSchema.default(AUTO_BOARD_CONNECTION_ANCHOR)
+});
+/**
+* Which ends carry an arrowhead.
+*
+* This is the *semantic* direction, not a style flag: `forward` means the
+* relation reads source → target, `backward` means target → source, and `none`
+* means the relation is symmetric. Renderers derive arrowheads from it, so the
+* drawing can never disagree with the meaning.
+*/
+const BOARD_CONNECTION_DIRECTIONS = [
+	"none",
+	"forward",
+	"backward",
+	"both"
+];
+/** How the line travels between its two resolved endpoints. */
+const BOARD_CONNECTION_ROUTINGS = [
+	"straight",
+	"curve",
+	"orthogonal"
+];
+const BOARD_CONNECTION_LINES = ["solid", "dashed"];
+/**
+* Relation kind — a free-form slug, not an enum.
+*
+* Boards are used for domains we do not control, so a closed vocabulary would
+* force unrelated meanings into the wrong bucket. The format is constrained
+* (lowercase, dash/dot separated) so relations stay comparable and queryable
+* across clients instead of accumulating near-duplicate spellings.
+*/
+const BoardRelationSchema = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/, "relation must be a lowercase slug").default("related");
+/**
+* Waypoints a user dragged the line through, in world space.
+*
+* Stored because they are *input*, not output: the resolved path is recomputed
+* from them on every read, but the intent behind a hand-routed line cannot be
+* recovered once discarded.
+*/
+const BoardConnectionWaypointSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite()
+});
+const BoardConnectionRoutingSchema = z.object({
+	kind: z.enum(BOARD_CONNECTION_ROUTINGS).default("curve"),
+	/** Curve bow as a fraction of endpoint distance (-0.85..0.85). */
+	bend: z.number().finite().min(-.85).max(.85).default(0),
+	waypoints: z.array(BoardConnectionWaypointSchema).max(64).default([])
+});
+const BoardConnectionStyleSchema = z.object({
+	/** Palette color id, resolved to a theme token at render time. */
+	color: z.string().min(1).max(40).default("brand"),
+	size: z.number().finite().positive().default(BOARD_CONNECTION_STROKE_SIZE),
+	line: z.enum(BOARD_CONNECTION_LINES).default("solid")
+});
+const DEFAULT_BOARD_CONNECTION_ROUTING = {
+	kind: "curve",
+	bend: 0,
+	waypoints: []
+};
+const DEFAULT_BOARD_CONNECTION_STYLE = {
+	color: "brand",
+	size: BOARD_CONNECTION_STROKE_SIZE,
+	line: "solid"
+};
+const BoardConnectionSchema = z.object({
+	id: z.string().min(1).max(160),
+	source: BoardConnectionEndpointSchema,
+	target: BoardConnectionEndpointSchema,
+	relation: BoardRelationSchema,
+	direction: z.enum(BOARD_CONNECTION_DIRECTIONS).default("forward"),
+	label: z.string().max(280).default(""),
+	routing: BoardConnectionRoutingSchema.default(DEFAULT_BOARD_CONNECTION_ROUTING),
+	style: BoardConnectionStyleSchema.default(DEFAULT_BOARD_CONNECTION_STYLE),
+	metadata: z.record(z.string(), z.unknown()).default({})
+});
+BoardConnectionSchema.omit({ id: true }).partial();
+function normalizeBoardConnectionStyle(style) {
+	return {
+		color: style?.color?.trim() || DEFAULT_BOARD_CONNECTION_STYLE.color,
+		size: clampBoardStrokeSize(typeof style?.size === "number" && Number.isFinite(style.size) ? style.size : DEFAULT_BOARD_CONNECTION_STYLE.size),
+		line: style?.line ?? DEFAULT_BOARD_CONNECTION_STYLE.line
+	};
+}
+/**
+* Build a connection with every default filled in.
+*
+* Callers only state what they mean (which nodes, and optionally the relation),
+* so a connection created by the editor, an agent or the CLI is byte-identical
+* for the same intent.
+*/
+function createBoardConnection(input) {
+	return {
+		id: input.id,
+		source: {
+			nodeId: input.sourceNodeId,
+			anchor: input.sourceAnchor ?? AUTO_BOARD_CONNECTION_ANCHOR
+		},
+		target: {
+			nodeId: input.targetNodeId,
+			anchor: input.targetAnchor ?? AUTO_BOARD_CONNECTION_ANCHOR
+		},
+		relation: input.relation ?? "related",
+		direction: input.direction ?? "forward",
+		label: input.label ?? "",
+		routing: {
+			...DEFAULT_BOARD_CONNECTION_ROUTING,
+			...input.routing
+		},
+		style: normalizeBoardConnectionStyle(input.style),
+		metadata: input.metadata ?? {}
+	};
+}
+//#endregion
 //#region src/realtime.ts
 function ensureRealtimeConnected(websocketClient) {
 	if (websocketClient.state === "open" || websocketClient.state === "connecting" || websocketClient.state === "reconnecting") return;
@@ -1476,6 +1670,18 @@ var BoardTransactionError = class extends Error {
 		return this.code === "VERSION_CONFLICT";
 	}
 };
+/**
+* Identifier for a client-authored Board entity (connection id, transaction id).
+*
+* `crypto.randomUUID` is used where available and falls back to a random string
+* otherwise, so the SDK works in a plain browser, a worker and Node without
+* pulling in a polyfill.
+*/
+function randomBoardId() {
+	const cryptoRef = globalThis.crypto;
+	if (cryptoRef && typeof cryptoRef.randomUUID === "function") return cryptoRef.randomUUID();
+	return `c-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
 const toSessionEventName = (type) => {
 	switch (type) {
 		case "session.created": return "created";
@@ -2405,6 +2611,86 @@ var BoardClient = class {
 	playback(command) {
 		return this.boards.playback(this.id, command);
 	}
+	/**
+	* Read the Board's relations.
+	*
+	* A dedicated read rather than a filter over `inspect()`: a caller that wants
+	* the graph should not have to fetch every node's geometry to get it.
+	*/
+	async connections(customFetch) {
+		return (await this.boards.inspect(this.id, { include: ["connections"] }, customFetch)).connections;
+	}
+	/**
+	* Connections touching a node, in either direction.
+	*
+	* Filtered client-side from the Board's relation set, which is a single read and
+	* bounded by the Board rather than by the node's degree.
+	*/
+	async connectionsForNode(nodeId, customFetch) {
+		return (await this.connections(customFetch)).filter((connection) => connection.source.nodeId === nodeId || connection.target.nodeId === nodeId);
+	}
+	/**
+	* Connect two nodes.
+	*
+	* Wraps the transaction so the common case is one call: the caller supplies the
+	* two nodes and, optionally, the relation. `baseVersion` still has to be the
+	* version the caller last read, because a relation is only meaningful against
+	* the node set it was authored on.
+	*/
+	connect(input) {
+		const connection = createBoardConnection({
+			id: input.id ?? randomBoardId(),
+			sourceNodeId: input.sourceNodeId,
+			targetNodeId: input.targetNodeId,
+			...input.relation === void 0 ? {} : { relation: input.relation },
+			...input.direction === void 0 ? {} : { direction: input.direction },
+			...input.label === void 0 ? {} : { label: input.label }
+		});
+		return this.apply({
+			txId: input.txId ?? randomBoardId(),
+			baseVersion: input.baseVersion,
+			operations: [{
+				type: "connection.create",
+				payload: { connection }
+			}]
+		});
+	}
+	/** Remove a connection. The nodes it joined are untouched. */
+	disconnect(input) {
+		return this.apply({
+			txId: input.txId ?? randomBoardId(),
+			baseVersion: input.baseVersion,
+			operations: [{
+				type: "connection.delete",
+				payload: { connectionId: input.connectionId }
+			}]
+		});
+	}
+	/**
+	* Delete a node together with every relation that names it.
+	*
+	* The server refuses to orphan a relation, so the cascade is explicit and lands
+	* in one transaction: one undo step restores the node and its edges together.
+	* `connections` is the relation set the caller already read, so this stays a
+	* single round-trip.
+	*/
+	deleteNodeWithConnections(input) {
+		const incident = input.connections.filter((connection) => connection.source.nodeId === input.nodeId || connection.target.nodeId === input.nodeId);
+		return this.apply({
+			txId: input.txId ?? randomBoardId(),
+			baseVersion: input.baseVersion,
+			operations: [...incident.map((connection) => ({
+				type: "connection.delete",
+				payload: {
+					connectionId: connection.id,
+					reason: "node-cascade"
+				}
+			})), {
+				type: "node.delete",
+				payload: { nodeId: input.nodeId }
+			}]
+		});
+	}
 	play(command) {
 		return this.boards.play(this.id, command);
 	}
@@ -3360,4 +3646,4 @@ var CohubHttpClient = class {
 };
 const createHttpClient = (options) => new CohubHttpClient(options);
 //#endregion
-export { parseAssistantMessageCommit as A, ModelsApi as B, SpaceClient as C, buildSpacePath as D, buildSpaceInvitePath as E, ReferencesApi as F, CronJobsApi as H, SearchApi as I, PublicAssetsApi as L, createSessionPatchReducer as M, ensureRealtimeConnected as N, SessionGenerationStreamClient as O, SessionAccessApi as P, SkillsApi as R, BoardTransactionError as S, PublicInviteApi as T, ChannelsApi as U, GenerationsApi as V, 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, 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, PromptsApi as z };
+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 };