@neta-art/cohub 5.3.2 → 5.4.0

package/dist/protocol/dist/realtime/board-awareness.js

@@ -1,4 +1,4 @@
-import { BOARD_ARROW_STROKE_SIZE } from "../board-constants.js";
+import { BOARD_ARROW_STROKE_SIZE, BOARD_CONNECTION_STROKE_SIZE } from "../board-constants.js";
 import { z } from "zod";
 //#region ../protocol/dist/realtime/board-awareness.js
 const idSchema = z.string().min(1).max(160);
@@ -15,23 +15,13 @@ const BoardAwarenessFrameSchema = z.object({
 	height: finiteSchema.positive(),
 	rotation: finiteSchema
 });
-const arrowEndpointSchema = z.union([z.object({
-	kind: z.literal("point"),
-	x: finiteSchema,
-	y: finiteSchema
-}), z.object({
-	kind: z.literal("binding"),
-	target: idSchema,
-	nx: finiteSchema,
-	ny: finiteSchema,
-	precise: z.boolean()
-})]);
 const BoardAwarenessNodePreviewSchema = z.object({
 	nodeId: idSchema,
 	frame: BoardAwarenessFrameSchema,
+	/** Live endpoints of a free arrow being dragged. */
 	arrow: z.object({
-		start: arrowEndpointSchema,
-		end: arrowEndpointSchema,
+		start: BoardAwarenessPointSchema,
+		end: BoardAwarenessPointSchema,
 		bend: finiteSchema
 	}).optional()
 });
@@ -80,6 +70,15 @@ const BoardAwarenessGestureSchema = z.discriminatedUnion("kind", [
 		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,
@@ -87,7 +86,8 @@ const BoardAwarenessGestureSchema = z.discriminatedUnion("kind", [
 			"translate",
 			"resize",
 			"rotate",
-			"arrow"
+			"arrow",
+			"connection"
 		]),
 		nodes: z.array(BoardAwarenessNodePreviewSchema).max(64),
 		bounds: BoardAwarenessFrameSchema.nullable()

package/docs/work-runtime-guide.md

@@ -61,7 +61,7 @@ Four runtime-only APIs form the foundation; everything else is standard SDK:
 | API | What it does | Returns |
 |---|---|---|
 | `client.context()` | Asks the host for the Work's identity | `{ work, space, viewer?, permissions }` or `null` |
-| `client.auth.request({ scopes, reason })` | Shows the viewer a consent dialog; on approval, caches a token carrying those scopes | `true` / `false` |
+| `client.auth.request({ scopes, reason })` | Requests viewer authorization and caches a scoped token; Cohub may silently approve the publisher's own workspace preview or background | `true` / `false` |
 | `client.work.commerce.*` | Entitlement checks, credit consumption, purchases | (see Commerce section) |
 | `client.work.realtime.*` | Temporary rooms, events, presence, and membership | (see Realtime rooms section) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub",
-  "version": "5.3.2",
+  "version": "5.4.0",
   "description": "Cohub SDK for spaces, sessions, boards, and realtime agent collaboration.",
   "license": "Apache-2.0",
   "private": false,

package/dist/board/core/bindings.d.ts

@@ -1,45 +0,0 @@
-import { ArrowEndpoint, BoardArrowItem, BoardFrame } from "../../protocol/dist/board-document.js";
-import { Rect, WorldPoint } from "../geometry.js";
-//#region src/board/core/bindings.d.ts
-type FrameLookup = (id: string) => BoardFrame | undefined;
-/** Denormalize a binding anchor to a world point on the (rotated) frame. */
-declare function anchorToWorld(frame: BoardFrame, nx: number, ny: number): WorldPoint;
-/** Normalize a world point to a binding anchor on the (rotated) frame, clamped. */
-declare function worldToAnchor(frame: BoardFrame, point: WorldPoint): {
-  nx: number;
-  ny: number;
-};
-/** Resolve an endpoint to a world point, or null if a binding target is gone. */
-declare function resolveEndpoint(endpoint: ArrowEndpoint, getFrame: FrameLookup): WorldPoint | null;
-type ResolvedArrow = {
-  start: WorldPoint;
-  end: WorldPoint;
-  /** Quadratic control point (already bent); equals midpoint when bend is 0. */
-  control: WorldPoint;
-};
-/** Resolve both endpoints and compute the bent control point. */
-declare function resolveArrow(item: BoardArrowItem, getFrame: FrameLookup): ResolvedArrow | null;
-/** World-space bounds of an arrow, sampling the curve for accuracy. */
-declare function arrowBounds(item: BoardArrowItem, getFrame: FrameLookup): Rect | null;
-/** Sample the arrow's quadratic curve into world points (for render/hit-test). */
-declare function sampleQuadratic(resolved: ResolvedArrow, segments: number): WorldPoint[];
-/** Distance from a world point to the arrow curve (hit testing). */
-declare function distanceToArrow(item: BoardArrowItem, getFrame: FrameLookup, point: WorldPoint): number;
-/**
- * Turn a free endpoint into a binding if a candidate target frame contains the
- * point; otherwise keep it free. Used while dragging an arrow handle so the
- * arrow "connects" to shapes it lands on.
- */
-declare function bindEndpointAt(point: WorldPoint, target: {
-  id: string;
-  frame: BoardFrame;
-} | null): ArrowEndpoint;
-/**
- * Translate an arrow by a delta: free endpoints move; bindings stay attached to
- * their targets (so a bound end anchors while the rest of the arrow moves). The
- * frame — a derived bounding box, not a transform — is recomputed from the new
- * endpoint geometry.
- */
-declare function translateArrow(item: BoardArrowItem, dx: number, dy: number, getFrame: FrameLookup): BoardArrowItem;
-//#endregion
-export { FrameLookup, ResolvedArrow, anchorToWorld, arrowBounds, bindEndpointAt, distanceToArrow, resolveArrow, resolveEndpoint, sampleQuadratic, translateArrow, worldToAnchor };

package/dist/board/core/bindings.js

@@ -1,162 +0,0 @@
-import { degToRad, rectCenter, rotatePointAround, worldPoint } from "../geometry.js";
-//#region src/board/core/bindings.ts
-/**
-* Arrow bindings — pure geometry for connecting arrows to shapes.
-*
-* An arrow endpoint is either a free world point or a *binding*: a normalized
-* anchor (0..1) on a target shape's frame. Because the anchor is relative, the
-* arrow tracks the target through move and resize with no stored absolute
-* coordinates — the binding never goes stale. Resolution to world space happens
-* here, given a frame lookup, so it is fully testable and renderer-independent.
-*/
-/** Denormalize a binding anchor to a world point on the (rotated) frame. */
-function anchorToWorld(frame, nx, ny) {
-	const unrotated = worldPoint(frame.x + nx * frame.width, frame.y + ny * frame.height);
-	if (!frame.rotation) return unrotated;
-	return rotatePointAround(unrotated, rectCenter(frame), degToRad(frame.rotation));
-}
-/** Normalize a world point to a binding anchor on the (rotated) frame, clamped. */
-function worldToAnchor(frame, point) {
-	let local = point;
-	if (frame.rotation) local = rotatePointAround(point, rectCenter(frame), -degToRad(frame.rotation));
-	return {
-		nx: clamp01((local.x - frame.x) / frame.width),
-		ny: clamp01((local.y - frame.y) / frame.height)
-	};
-}
-function clamp01(value) {
-	return Math.min(1, Math.max(0, value));
-}
-/** Resolve an endpoint to a world point, or null if a binding target is gone. */
-function resolveEndpoint(endpoint, getFrame) {
-	if (endpoint.kind === "point") return worldPoint(endpoint.x, endpoint.y);
-	const frame = getFrame(endpoint.target);
-	if (!frame) return null;
-	return anchorToWorld(frame, endpoint.nx, endpoint.ny);
-}
-/** Resolve both endpoints and compute the bent control point. */
-function resolveArrow(item, getFrame) {
-	const start = resolveEndpoint(item.start, getFrame);
-	const end = resolveEndpoint(item.end, getFrame);
-	if (!start || !end) return null;
-	const mid = worldPoint((start.x + end.x) / 2, (start.y + end.y) / 2);
-	if (!item.bend) return {
-		start,
-		end,
-		control: mid
-	};
-	const dx = end.x - start.x;
-	const dy = end.y - start.y;
-	const length = Math.hypot(dx, dy) || 1;
-	const offset = item.bend * length;
-	return {
-		start,
-		end,
-		control: worldPoint(mid.x + -dy / length * offset, mid.y + dx / length * offset)
-	};
-}
-/** World-space bounds of an arrow, sampling the curve for accuracy. */
-function arrowBounds(item, getFrame) {
-	const resolved = resolveArrow(item, getFrame);
-	if (!resolved) return null;
-	const samples = sampleQuadratic(resolved, 12);
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const p of samples) {
-		minX = Math.min(minX, p.x);
-		minY = Math.min(minY, p.y);
-		maxX = Math.max(maxX, p.x);
-		maxY = Math.max(maxY, p.y);
-	}
-	const pad = Math.max(8, item.size * 2);
-	return {
-		x: minX - pad,
-		y: minY - pad,
-		width: Math.max(1, maxX - minX + pad * 2),
-		height: Math.max(1, maxY - minY + pad * 2)
-	};
-}
-/** Sample the arrow's quadratic curve into world points (for render/hit-test). */
-function sampleQuadratic(resolved, segments) {
-	const { start, control, end } = resolved;
-	const out = [];
-	for (let i = 0; i <= segments; i += 1) {
-		const t = i / segments;
-		const mt = 1 - t;
-		out.push(worldPoint(mt * mt * start.x + 2 * mt * t * control.x + t * t * end.x, mt * mt * start.y + 2 * mt * t * control.y + t * t * end.y));
-	}
-	return out;
-}
-/** Distance from a world point to the arrow curve (hit testing). */
-function distanceToArrow(item, getFrame, point) {
-	const resolved = resolveArrow(item, getFrame);
-	if (!resolved) return Number.POSITIVE_INFINITY;
-	const samples = sampleQuadratic(resolved, 16);
-	let min = Number.POSITIVE_INFINITY;
-	for (let i = 0; i < samples.length - 1; i += 1) {
-		const from = samples[i];
-		const to = samples[i + 1];
-		if (!from || !to) continue;
-		const d = segmentDistance(point, from, to);
-		if (d < min) min = d;
-	}
-	return min;
-}
-function segmentDistance(p, a, b) {
-	const dx = b.x - a.x;
-	const dy = b.y - a.y;
-	const lengthSq = dx * dx + dy * dy;
-	if (lengthSq === 0) return Math.hypot(p.x - a.x, p.y - a.y);
-	const t = Math.min(1, Math.max(0, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSq));
-	return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
-}
-/**
-* Turn a free endpoint into a binding if a candidate target frame contains the
-* point; otherwise keep it free. Used while dragging an arrow handle so the
-* arrow "connects" to shapes it lands on.
-*/
-function bindEndpointAt(point, target) {
-	if (!target) return {
-		kind: "point",
-		x: point.x,
-		y: point.y
-	};
-	const { nx, ny } = worldToAnchor(target.frame, point);
-	return {
-		kind: "binding",
-		target: target.id,
-		nx,
-		ny,
-		precise: true
-	};
-}
-/**
-* Translate an arrow by a delta: free endpoints move; bindings stay attached to
-* their targets (so a bound end anchors while the rest of the arrow moves). The
-* frame — a derived bounding box, not a transform — is recomputed from the new
-* endpoint geometry.
-*/
-function translateArrow(item, dx, dy, getFrame) {
-	const move = (endpoint) => endpoint.kind === "point" ? {
-		kind: "point",
-		x: endpoint.x + dx,
-		y: endpoint.y + dy
-	} : endpoint;
-	const next = {
-		...item,
-		start: move(item.start),
-		end: move(item.end)
-	};
-	const bounds = arrowBounds(next, getFrame);
-	return bounds ? {
-		...next,
-		frame: {
-			...bounds,
-			rotation: 0
-		}
-	} : next;
-}
-//#endregion
-export { anchorToWorld, arrowBounds, bindEndpointAt, distanceToArrow, resolveArrow, resolveEndpoint, sampleQuadratic, translateArrow, worldToAnchor };