@neta-art/cohub 8.11.0 → 8.12.1

package/dist/board/replay.js

@@ -0,0 +1,261 @@
+import { BOARD_DOCUMENT_KIND } from "../protocol/dist/board.js";
+import { BoardAppearanceSchema, parseBoardDocument } from "../protocol/dist/board-document.js";
+import { boardNodeToAuthoringItem } from "../protocol/dist/board-codec.js";
+import { DEFAULT_BOARD_APPEARANCE, boardAuthoringItemToDocumentItem } from "./semantic-document.js";
+//#region src/board/replay.ts
+function boardReplayActorKind(source) {
+	if (!source) return "human";
+	if (source.toolCallId) return "agent";
+	return source.via === "cli" ? "cli" : "human";
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/** Apply one stored operation (forward payload or inverse) to the mutable state. */
+function applyOperation(state, type, payload) {
+	switch (type) {
+		case "board.patch": {
+			const patch = isRecord(payload.patch) ? payload.patch : {};
+			if (isRecord(patch.metadata)) state.metadata = patch.metadata;
+			if (isRecord(patch.metadataPatch)) state.metadata = {
+				...state.metadata,
+				...patch.metadataPatch
+			};
+			return;
+		}
+		case "node.create": {
+			const node = payload.node;
+			if (node) state.nodes.set(node.nodeId, node);
+			return;
+		}
+		case "node.patch": {
+			const nodeId = payload.nodeId;
+			const current = state.nodes.get(nodeId);
+			if (current && isRecord(payload.patch)) state.nodes.set(nodeId, {
+				...current,
+				...payload.patch,
+				nodeId
+			});
+			return;
+		}
+		case "node.delete":
+			state.nodes.delete(payload.nodeId);
+			return;
+		case "connection.create": {
+			const connection = payload.connection;
+			if (connection) state.connections.set(connection.id, connection);
+			return;
+		}
+		case "connection.patch": {
+			const connectionId = payload.connectionId;
+			const current = state.connections.get(connectionId);
+			if (current && isRecord(payload.patch)) state.connections.set(connectionId, {
+				...current,
+				...payload.patch,
+				id: connectionId
+			});
+			return;
+		}
+		case "connection.delete":
+			state.connections.delete(payload.connectionId);
+			return;
+		default: return;
+	}
+}
+/**
+* Inverses are stored either as a full operation (`{ type, payload }`) or, for
+* `board.patch`, as a bare `{ patch }`. Normalise both to `(type, payload)`.
+*/
+function inverseOf(operation) {
+	const inverse = operation.inverse;
+	if (!inverse) return null;
+	if (typeof inverse.type === "string" && isRecord(inverse.payload)) return {
+		type: inverse.type,
+		payload: inverse.payload
+	};
+	if (operation.type === "board.patch" && isRecord(inverse.patch)) return {
+		type: "board.patch",
+		payload: { patch: inverse.patch }
+	};
+	return null;
+}
+function operationItemIds(operation) {
+	const payload = operation.payload;
+	switch (operation.type) {
+		case "node.create": return isRecord(payload.node) && typeof payload.node.nodeId === "string" ? [payload.node.nodeId] : [];
+		case "node.patch":
+		case "node.delete": return typeof payload.nodeId === "string" ? [payload.nodeId] : [];
+		default: return [];
+	}
+}
+const VISUAL_OPERATION_TYPES = /* @__PURE__ */ new Set([
+	"board.patch",
+	"node.create",
+	"node.patch",
+	"node.delete",
+	"connection.create",
+	"connection.patch",
+	"connection.delete"
+]);
+function entryOf(transaction) {
+	return {
+		version: transaction.version,
+		actorId: transaction.actorId,
+		kind: boardReplayActorKind(transaction.source),
+		at: Date.parse(transaction.createdAt),
+		visual: transaction.operations.some((operation) => VISUAL_OPERATION_TYPES.has(operation.type))
+	};
+}
+function appearanceOf(metadata) {
+	const parsed = BoardAppearanceSchema.safeParse(metadata.appearance);
+	return parsed.success ? parsed.data : DEFAULT_BOARD_APPEARANCE;
+}
+function project(state) {
+	const nodes = [...state.nodes.values()].sort((a, b) => (a.orderKey ?? "").localeCompare(b.orderKey ?? ""));
+	return parseBoardDocument({
+		kind: BOARD_DOCUMENT_KIND,
+		version: 1,
+		appearance: appearanceOf(state.metadata),
+		viewport: {
+			x: 0,
+			y: 0,
+			zoom: 1
+		},
+		items: nodes.map((node) => boardAuthoringItemToDocumentItem(boardNodeToAuthoringItem(node))),
+		connections: [...state.connections.values()]
+	});
+}
+function stateFromSnapshot(snapshot) {
+	return {
+		nodes: new Map(snapshot.nodes.map(({ boardId: _boardId, version: _version, createdAt: _c, updatedAt: _u, ...node }) => [node.nodeId, node])),
+		connections: new Map(snapshot.connections.map(({ boardId: _boardId, revision: _revision, createdAt: _c, updatedAt: _u, ...connection }) => [connection.id, connection])),
+		metadata: snapshot.board.metadata
+	};
+}
+/**
+* Create a player positioned at the live version described by the first page.
+*
+* `transactions` are newest-first as served; the player keeps them oldest-first.
+* Older pages can be added with `prepend`, and newer transactions that arrive
+* live can be added with `append`, so the timeline grows in both directions
+* without a reset.
+*/
+function createBoardReplayPlayer(page) {
+	if (!page.snapshot) throw new Error("Board replay needs the first transactions page (with snapshot).");
+	const liveVersion = page.board.version;
+	const newest = page.transactions.reduce((max, transaction) => Math.max(max, transaction.version), 0);
+	if (page.transactions.length > 0 && newest !== liveVersion) throw new Error(`Board replay page is inconsistent: board is at v${liveVersion}, newest transaction is v${newest}.`);
+	let transactions = [...page.transactions].sort((a, b) => a.version - b.version);
+	let entries = transactions.map(entryOf);
+	const state = stateFromSnapshot(page.snapshot);
+	let cursor = liveVersion;
+	const documents = /* @__PURE__ */ new Map();
+	/** Oldest version reachable with the transactions loaded so far. */
+	let floor = transactions[0]?.baseVersion ?? liveVersion;
+	/**
+	* Index of the first transaction whose version is `>= version`. Versions are
+	* strictly increasing but not dense (a no-op mutation leaves a gap), so
+	* binary-search by value rather than indexing by offset.
+	*/
+	function lowerBound(version) {
+		let low = 0;
+		let high = transactions.length;
+		while (low < high) {
+			const mid = low + high >> 1;
+			if (transactions[mid].version < version) low = mid + 1;
+			else high = mid;
+		}
+		return low;
+	}
+	function transactionProducing(version) {
+		const candidate = transactions[lowerBound(version)];
+		return candidate?.version === version ? candidate : void 0;
+	}
+	/** Undo the transaction that produced `cursor`. */
+	function stepBackward() {
+		const transaction = transactionProducing(cursor);
+		if (!transaction) return false;
+		for (let index = transaction.operations.length - 1; index >= 0; index -= 1) {
+			const inverse = inverseOf(transaction.operations[index]);
+			if (inverse) applyOperation(state, inverse.type, inverse.payload);
+		}
+		cursor = transaction.baseVersion;
+		return true;
+	}
+	function stepForward(next) {
+		for (const operation of next.operations) applyOperation(state, operation.type, operation.payload);
+		cursor = next.version;
+	}
+	function head() {
+		return transactions.at(-1)?.version ?? liveVersion;
+	}
+	/**
+	* Move to `version`, clamped to the loaded range. Returns the version reached,
+	* which is the nearest loaded version at or below the request.
+	*/
+	function seek(version) {
+		const target = Math.max(floor, Math.min(head(), version));
+		while (cursor > target && stepBackward());
+		for (let next = transactions[lowerBound(cursor + 1)]; next && next.version <= target; next = transactions[lowerBound(cursor + 1)]) stepForward(next);
+		return cursor;
+	}
+	function documentAt(version) {
+		const reached = seek(version);
+		const cached = documents.get(reached);
+		if (cached) return cached;
+		const document = project(state);
+		documents.set(reached, document);
+		return document;
+	}
+	return {
+		/** Oldest version the loaded transactions can rewind to. */
+		get floor() {
+			return floor;
+		},
+		/** Newest version known to the player. */
+		get head() {
+			return head();
+		},
+		get entries() {
+			return entries;
+		},
+		/** Current position. */
+		get version() {
+			return cursor;
+		},
+		seek,
+		documentAt,
+		/** Item ids touched by the transaction that produced `version`, for camera follow. */
+		changedItemIds(version) {
+			return [...new Set(transactionProducing(version)?.operations.flatMap(operationItemIds))];
+		},
+		/** Add an older page (as served, newest-first). */
+		prepend(older) {
+			const current = floor;
+			const fresh = older.transactions.filter((transaction) => transaction.version <= current).sort((a, b) => a.version - b.version);
+			if (fresh.length === 0) return;
+			transactions = [...fresh, ...transactions];
+			entries = [...fresh.map(entryOf), ...entries];
+			floor = fresh[0].baseVersion;
+		},
+		/**
+		* Add transactions that landed after the current head. Forward payloads are
+		* enough to extend the timeline; the scrub position is untouched.
+		*
+		* Returns false when the page does not reach back to the head: the chain
+		* would have a hole, so nothing is appended and the caller must fetch an
+		* older page (`before` = the page's oldest version) and try again.
+		*/
+		append(latest) {
+			const current = head();
+			const fresh = latest.transactions.filter((transaction) => transaction.version > current).sort((a, b) => a.version - b.version);
+			if (fresh.length === 0) return true;
+			if (fresh[0].baseVersion > current) return false;
+			transactions = [...transactions, ...fresh];
+			entries = [...entries, ...fresh.map(entryOf)];
+			return true;
+		}
+	};
+}
+//#endregion
+export { boardReplayActorKind, createBoardReplayPlayer };

package/dist/board/semantic-document.d.ts

@@ -4,7 +4,15 @@ import { BoardDocument, BoardItem } from "../protocol/dist/board-document.js";
 import "../protocol/dist/index.js";
 //#region src/board/semantic-document.d.ts
 declare const DEFAULT_BOARD_APPEARANCE: {
-  theme: string;
+  theme?: string | undefined;
+  motion?: {
+    enter?: {
+      kind: string;
+      kindVersion: number;
+      params: Record<string, unknown>;
+    } | undefined;
+  } | undefined;
+  mood?: "arcane" | "clean" | "cyber" | "natural" | "playful" | undefined;
   background: {
     kind: "custom" | "dots" | "grid" | "image" | "shader" | "solid";
     color?: string | undefined;
@@ -18,7 +26,6 @@ declare const DEFAULT_BOARD_APPEARANCE: {
     size: number;
     opacity: number;
   };
-  mood: "arcane" | "clean" | "cyber" | "natural" | "playful";
 };
 /** Convert a public authoring Item to the renderer/editor document shape. */
 declare function boardAuthoringItemToDocumentItem(item: BoardAuthoringItem): BoardItem;

package/dist/board/semantic-document.js

@@ -5,14 +5,12 @@ import { boardDrawPointsToWorld } from "../protocol/dist/board-geometry.js";
 import { boardAuthoringItemToNode } from "../protocol/dist/board-codec.js";
 //#region src/board/semantic-document.ts
 const DEFAULT_BOARD_APPEARANCE = BoardAppearanceSchema.parse({
-	theme: "clean",
 	background: { kind: "solid" },
 	grid: {
 		visible: false,
 		size: 24,
 		opacity: .12
-	},
-	mood: "clean"
+	}
 });
 /** Convert a public authoring Item to the renderer/editor document shape. */
 function boardAuthoringItemToDocumentItem(item) {