@neta-art/cohub 8.24.0 → 9.0.0

package/dist/board/render/stroke.d.ts

@@ -0,0 +1,12 @@
+import { BoardDash } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { WorldPoint } from "../geometry.js";
+import { Graphics } from "pixi.js";
+//#region src/board/render/stroke.d.ts
+declare function dashPattern(dash: BoardDash | undefined, width: number): [number, number] | null;
+declare function trimPolyline(path: readonly WorldPoint[], trim: number | undefined): readonly WorldPoint[];
+declare function tracePolyline(graphics: Graphics, path: readonly WorldPoint[], pattern: [number, number] | null, closed?: boolean): void;
+declare function traceArrowhead(graphics: Graphics, tip: WorldPoint, angle: number, size: number): void;
+declare function endAngle(path: readonly WorldPoint[], atStart: boolean): number | null;
+//#endregion
+export { dashPattern, endAngle, traceArrowhead, tracePolyline, trimPolyline };

package/dist/board/render/stroke.js

@@ -0,0 +1,90 @@
+import { worldPoint } from "../geometry.js";
+//#region src/board/render/stroke.ts
+const HEAD_SPREAD = Math.PI / 6;
+function dashPattern(dash, width) {
+	if (dash === "dashed") return [Math.max(6, width * 4), Math.max(4, width * 3)];
+	if (dash === "dotted") return [Math.max(.5, width * .01), Math.max(3, width * 2)];
+	return null;
+}
+function trimPolyline(path, trim) {
+	if (trim === void 0 || trim >= 1 || path.length < 2) return path;
+	if (trim <= 0) return [];
+	let total = 0;
+	for (let index = 1; index < path.length; index += 1) {
+		const a = path[index - 1];
+		const b = path[index];
+		total += Math.hypot(b.x - a.x, b.y - a.y);
+	}
+	let remaining = total * trim;
+	const out = [path[0]];
+	for (let index = 1; index < path.length; index += 1) {
+		const a = path[index - 1];
+		const b = path[index];
+		const length = Math.hypot(b.x - a.x, b.y - a.y);
+		if (length >= remaining) {
+			const t = length > 0 ? remaining / length : 0;
+			out.push(worldPoint(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t));
+			return out;
+		}
+		out.push(b);
+		remaining -= length;
+	}
+	return out;
+}
+function tracePolyline(graphics, path, pattern, closed = false) {
+	const points = closed && path.length > 2 ? [...path, path[0]] : path;
+	if (points.length < 2) return;
+	if (!pattern) {
+		const first = points[0];
+		graphics.moveTo(first.x, first.y);
+		for (let index = 1; index < points.length; index += 1) {
+			const point = points[index];
+			graphics.lineTo(point.x, point.y);
+		}
+		if (closed) graphics.closePath();
+		return;
+	}
+	const [dash, gap] = pattern;
+	let penDown = true;
+	let fresh = true;
+	let remaining = dash;
+	for (let index = 1; index < points.length; index += 1) {
+		const a = points[index - 1];
+		const b = points[index];
+		const dx = b.x - a.x;
+		const dy = b.y - a.y;
+		const length = Math.hypot(dx, dy);
+		let travelled = 0;
+		while (length - travelled > 1e-4) {
+			const step = Math.min(length - travelled, remaining);
+			if (penDown) {
+				const t0 = travelled / length;
+				const t1 = (travelled + step) / length;
+				if (fresh) graphics.moveTo(a.x + dx * t0, a.y + dy * t0);
+				fresh = false;
+				graphics.lineTo(a.x + dx * t1, a.y + dy * t1);
+			}
+			travelled += step;
+			remaining -= step;
+			if (remaining <= 1e-4) {
+				penDown = !penDown;
+				fresh = penDown;
+				remaining = penDown ? dash : gap;
+			}
+		}
+	}
+}
+function traceArrowhead(graphics, tip, angle, size) {
+	graphics.moveTo(tip.x - size * Math.cos(angle - HEAD_SPREAD), tip.y - size * Math.sin(angle - HEAD_SPREAD)).lineTo(tip.x, tip.y).lineTo(tip.x - size * Math.cos(angle + HEAD_SPREAD), tip.y - size * Math.sin(angle + HEAD_SPREAD));
+}
+function endAngle(path, atStart) {
+	if (path.length < 2) return null;
+	const tip = atStart ? path[0] : path[path.length - 1];
+	for (let offset = 1; offset < path.length; offset += 1) {
+		const other = atStart ? path[offset] : path[path.length - 1 - offset];
+		if (Math.hypot(tip.x - other.x, tip.y - other.y) > .001) return Math.atan2(tip.y - other.y, tip.x - other.x);
+	}
+	return null;
+}
+//#endregion
+export { dashPattern, endAngle, traceArrowhead, tracePolyline, trimPolyline };

package/dist/board/render/text-measurement.d.ts

@@ -1,30 +1,10 @@
 //#region src/board/render/text-measurement.d.ts
-/**
- * Canvas-backed text measurement.
- *
- * Measurement goes through Pixi's `DOMAdapter` rather than `document`, so the
- * browser and a headless export produce the same numbers. The core metrics
- * module owns the layout maths and only borrows this measurer, which is what
- * lets `@neta-art/cohub/board` lay text out with no PixiJS installed.
- */
-/**
- * Route board text measurement through the active Pixi DOM adapter.
- *
- * Call this after swapping the adapter (see `../headless`), which drops the
- * cached measuring context. Anything that goes through `getBoardCardRenderer`
- * is already covered by `ensureBoardTextMeasurement`.
- */
+declare const BOARD_FONT_STACKS: {
+  sans: string;
+  serif: string;
+  mono: string;
+};
 declare function installBoardTextMeasurement(): void;
-/**
- * Install the canvas measurer once, unless it already is.
- *
- * The core metrics module falls back to a per-character estimate when no
- * measurer is set, which is off by ~90% for real text — wrong enough to
- * misplace every label. Rather than make that a step consumers can forget, the
- * renderer registry calls this before handing a renderer out. It cannot be an
- * import-time side effect: the package is marked side-effect free, so a bundler
- * is entitled to drop a module whose only job happens at load time.
- */
 declare function ensureBoardTextMeasurement(): void;
 //#endregion
-export { ensureBoardTextMeasurement, installBoardTextMeasurement };
+export { BOARD_FONT_STACKS, ensureBoardTextMeasurement, installBoardTextMeasurement };

package/dist/board/render/text-measurement.js

@@ -1,15 +1,13 @@
-import { BOARD_FONT_STACK } from "../../protocol/dist/board-constants.js";
-import { setBoardTextMeasurer } from "../core/text-metrics.js";
+import { BOARD_FONT_STACK, BOARD_MONO_FONT_STACK } from "../../protocol/dist/board-constants.js";
+import { setBoardTextMeasurer } from "../../protocol/dist/board-layout.js";
+import { boardFontFamily } from "../core/text-metrics.js";
 import { DOMAdapter } from "pixi.js";
 //#region src/board/render/text-measurement.ts
-/**
-* Canvas-backed text measurement.
-*
-* Measurement goes through Pixi's `DOMAdapter` rather than `document`, so the
-* browser and a headless export produce the same numbers. The core metrics
-* module owns the layout maths and only borrows this measurer, which is what
-* lets `@neta-art/cohub/board` lay text out with no PixiJS installed.
-*/
+const BOARD_FONT_STACKS = {
+	sans: BOARD_FONT_STACK,
+	serif: "ui-serif, Georgia, \"Noto Serif CJK SC\", \"Songti SC\", serif",
+	mono: BOARD_MONO_FONT_STACK
+};
 let measureContext;
 let installed = false;
 function getMeasureContext() {
@@ -21,37 +19,20 @@ function getMeasureContext() {
 	}
 	return measureContext;
 }
-function measureText(text, fontSize) {
+function measureText(text, fontSize, fontWeight, font) {
 	const context = getMeasureContext();
 	if (!context) return null;
-	context.font = `500 ${fontSize}px ${BOARD_FONT_STACK}`;
+	context.font = `${fontWeight} ${fontSize}px ${boardFontFamily(font, BOARD_FONT_STACKS)}`;
 	return context.measureText(text).width;
 }
-/**
-* Route board text measurement through the active Pixi DOM adapter.
-*
-* Call this after swapping the adapter (see `../headless`), which drops the
-* cached measuring context. Anything that goes through `getBoardCardRenderer`
-* is already covered by `ensureBoardTextMeasurement`.
-*/
 function installBoardTextMeasurement() {
 	measureContext = void 0;
 	installed = true;
 	setBoardTextMeasurer(measureText);
 }
-/**
-* Install the canvas measurer once, unless it already is.
-*
-* The core metrics module falls back to a per-character estimate when no
-* measurer is set, which is off by ~90% for real text — wrong enough to
-* misplace every label. Rather than make that a step consumers can forget, the
-* renderer registry calls this before handing a renderer out. It cannot be an
-* import-time side effect: the package is marked side-effect free, so a bundler
-* is entitled to drop a module whose only job happens at load time.
-*/
 function ensureBoardTextMeasurement() {
 	if (installed) return;
 	installBoardTextMeasurement();
 }
 //#endregion
-export { ensureBoardTextMeasurement, installBoardTextMeasurement };
+export { BOARD_FONT_STACKS, ensureBoardTextMeasurement, installBoardTextMeasurement };

package/dist/board/replay.d.ts

@@ -1,52 +1,27 @@
+import { BoardDocument } from "../protocol/dist/board-model.js";
 import { RequestSource } from "../protocol/dist/provenance.js";
-import { BoardTransactionsPage } from "../protocol/dist/board.js";
-import { BoardDocument } from "../protocol/dist/board-document.js";
+import { BoardHistoryPage } from "../protocol/dist/board.js";
 import "../protocol/dist/index.js";
 //#region src/board/replay.d.ts
 type BoardReplayActorKind = "human" | "cli" | "agent";
-/** One step on the replay timeline. */
 type BoardReplayEntry = {
   version: number;
   actorId: string;
   kind: BoardReplayActorKind;
-  /** Epoch milliseconds. */
   at: number;
-  /** Whether the step changed anything visible in the render document. */
-  visual: boolean;
 };
 type BoardReplayPlayer = ReturnType<typeof createBoardReplayPlayer>;
 declare function boardReplayActorKind(source: RequestSource | null): BoardReplayActorKind;
-/**
- * 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.
- */
-declare function createBoardReplayPlayer(page: BoardTransactionsPage): {
-  /** Oldest version the loaded transactions can rewind to. */
+declare function createBoardReplayPlayer(live: BoardDocument, page: BoardHistoryPage): {
   readonly floor: number;
-  /** Newest version known to the player. */
   readonly head: number;
   readonly entries: readonly BoardReplayEntry[];
-  /** Current position. */
   readonly version: number;
   seek: (version: number) => number;
-  documentAt: (version: number) => BoardDocument;
-  /** Item ids touched by the transaction that produced `version`, for camera follow. */
+  documentAt(version: number): BoardDocument;
   changedItemIds(version: number): string[];
-  /** Add an older page (as served, newest-first). */
-  prepend(older: BoardTransactionsPage): void;
-  /**
-   * 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: BoardTransactionsPage): boolean;
+  prepend(older: BoardHistoryPage): void;
+  append(latest: BoardHistoryPage): boolean;
 };
 //#endregion
 export { BoardReplayActorKind, BoardReplayEntry, BoardReplayPlayer, boardReplayActorKind, createBoardReplayPlayer };

package/dist/board/replay.js

@@ -1,162 +1,39 @@
-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";
+import { applyBoardDelta } from "../protocol/dist/board-patch.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
+		at: Date.parse(transaction.createdAt)
 	};
 }
-/**
-* 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 createBoardReplayPlayer(live, page) {
+	let transactions = [];
+	let entries = [];
+	let floor = page.version;
+	let document = live;
+	let cursor = page.version;
+	const documents = /* @__PURE__ */ new Map([[cursor, live]]);
+	function addOlder(older) {
+		const usable = [];
+		for (const transaction of [...older].sort((a, b) => b.version - a.version)) {
+			if (transaction.version > floor) continue;
+			if (!transaction.before || !transaction.after) break;
+			if (transaction.version !== floor) break;
+			usable.push(transaction);
+			floor = transaction.baseVersion;
+		}
+		usable.reverse();
+		transactions = [...usable, ...transactions];
+		entries = [...usable.map(entryOf), ...entries];
+	}
+	addOlder(page.transactions);
 	function lowerBound(version) {
 		let low = 0;
 		let high = transactions.length;
@@ -167,85 +44,50 @@ function createBoardReplayPlayer(page) {
 		}
 		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.
-	*/
+	const head = () => transactions.at(-1)?.version ?? page.version;
 	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);
+		while (cursor > target) {
+			const transaction = transactions[lowerBound(cursor)];
+			if (!transaction || transaction.version !== cursor || !transaction.before) break;
+			document = applyBoardDelta(document, transaction.before);
+			cursor = transaction.baseVersion;
+		}
+		for (let next = transactions[lowerBound(cursor + 1)]; next && next.version <= target; next = transactions[lowerBound(cursor + 1)]) {
+			if (!next.after) break;
+			document = applyBoardDelta(document, next.after);
+			cursor = next.version;
+		}
 		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. */
+		documentAt(version) {
+			const reached = seek(version);
+			const cached = documents.get(reached);
+			if (cached) return cached;
+			documents.set(reached, document);
+			return document;
+		},
 		changedItemIds(version) {
-			return [...new Set(transactionProducing(version)?.operations.flatMap(operationItemIds))];
+			const transaction = transactions[lowerBound(version)];
+			return transaction?.version === version ? Object.keys(transaction.after?.items ?? {}) : [];
 		},
-		/** 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;
+			addOlder(older.transactions);
 		},
-		/**
-		* 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);

package/dist/board/runtime/board-player.d.ts

@@ -0,0 +1,24 @@
+import { BoardDocument, BoardItem } from "../../protocol/dist/board-model.js";
+import { BoardPlaybackCommand, BoardPlaybackSnapshot } from "../../protocol/dist/board.js";
+import "../../protocol/dist/index.js";
+import { BoardCameraOverride, BoardColorResolver } from "../animation.js";
+//#region src/board/runtime/board-player.d.ts
+type BoardPlayerFrame = {
+  items: ReadonlyMap<string, BoardItem>;
+  camera: BoardCameraOverride;
+  time: number;
+  playbackTime: number | null;
+  running: boolean;
+};
+declare function playbackTimeAt(playback: BoardPlaybackSnapshot, document: BoardDocument, now: number): number | null;
+declare function createBoardPlayer(options?: {
+  resolveColor?: BoardColorResolver;
+}): {
+  reset(): void;
+  enter(ids: readonly string[], current: BoardDocument): void;
+  frame(current: BoardDocument, playback: BoardPlaybackSnapshot | null, now: number, wallNow: number, exclude: string | null): BoardPlayerFrame;
+};
+type BoardPlayer = ReturnType<typeof createBoardPlayer>;
+declare function nextLocalPlayback(current: BoardPlaybackSnapshot | null, command: BoardPlaybackCommand, document: BoardDocument, now?: number): BoardPlaybackSnapshot | null;
+//#endregion
+export { BoardPlayer, BoardPlayerFrame, createBoardPlayer, nextLocalPlayback, playbackTimeAt };