@kirkchinese/dsh-citeciter 0.9.0-beta.2 → 0.9.0-beta.3

package/lib/{update-B_0nN1_f.js → update-CGteMuNJ.js}

@@ -152,6 +152,641 @@ const nativeStateSchema = z.object({
 		attachments: z.array(nativeAttachmentSchema)
 	}).strict())
 }).strict();
+const ANIMATION_MAX_DURATION_MS = 3e4;
+/** Offset in canvas percent used by directional appear and disappear. */
+const SLIDE_DISTANCE = 6;
+const easingSchema = z.enum([
+	"linear",
+	"ease-in",
+	"ease-out",
+	"ease-in-out"
+]);
+const directionSchema = z.enum([
+	"left",
+	"right",
+	"up",
+	"down"
+]);
+const timeSchema = z.number().int().min(0).max(ANIMATION_MAX_DURATION_MS);
+const coordinateSchema = z.number().min(-50).max(150);
+const expressionSchema = z.string().min(1).max(240);
+/** One verb applied to one board element. */
+const animationTrackSchema = z.object({
+	target: z.string().min(1).max(80),
+	verb: z.enum([
+		"appear",
+		"disappear",
+		"move",
+		"scale",
+		"rotate",
+		"highlight",
+		"reveal",
+		"follow",
+		"keyframes",
+		"parametric"
+	]),
+	startMs: timeSchema.optional(),
+	endMs: timeSchema.optional(),
+	easing: easingSchema.optional(),
+	to: z.object({
+		x: coordinateSchema,
+		y: coordinateSchema
+	}).strict().optional(),
+	scale: z.number().min(.05).max(10).optional(),
+	degrees: z.number().min(-3600).max(3600).optional(),
+	direction: directionSchema.optional(),
+	path: z.string().min(1).max(4e3).optional(),
+	orient: z.boolean().optional(),
+	frames: z.array(z.object({
+		atMs: timeSchema,
+		x: coordinateSchema.optional(),
+		y: coordinateSchema.optional(),
+		opacity: z.number().min(0).max(1).optional(),
+		scale: z.number().min(.05).max(10).optional(),
+		rotate: z.number().min(-3600).max(3600).optional()
+	}).strict()).min(1).max(40).optional(),
+	x: expressionSchema.optional(),
+	y: expressionSchema.optional(),
+	t: z.tuple([z.number().min(-1e6).max(1e6), z.number().min(-1e6).max(1e6)]).optional()
+}).strict();
+/** One complete timeline as written by the model. */
+const animationSpecSchema = z.object({
+	durationMs: z.number().int().min(200).max(ANIMATION_MAX_DURATION_MS),
+	loop: z.boolean().optional(),
+	beats: z.array(z.object({
+		atMs: timeSchema,
+		caption: z.string().min(1).max(160)
+	}).strict()).max(20).optional(),
+	tracks: z.array(animationTrackSchema).min(1).max(40)
+}).strict();
+/** The board's current timeline: the spec of the latest successful call, keyed by that call. */
+const boardTimelineSchema = z.object({
+	id: z.string().min(1),
+	spec: animationSpecSchema
+}).strict();
+const FUNCTIONS = {
+	sin: Math.sin,
+	cos: Math.cos,
+	tan: Math.tan,
+	asin: Math.asin,
+	acos: Math.acos,
+	atan: Math.atan,
+	atan2: Math.atan2,
+	sqrt: Math.sqrt,
+	abs: Math.abs,
+	exp: Math.exp,
+	log: Math.log,
+	min: Math.min,
+	max: Math.max,
+	pow: Math.pow,
+	floor: Math.floor,
+	ceil: Math.ceil,
+	round: Math.round,
+	sign: Math.sign
+};
+const CONSTANTS = {
+	pi: Math.PI,
+	e: Math.E,
+	tau: Math.PI * 2
+};
+/**
+* Compile a restricted arithmetic expression of `t`: numbers, `+ - * / ^`, parentheses,
+* the constants pi, e, tau and a fixed set of Math functions. Nothing else is accepted.
+* @throws an Error naming the first unexpected token.
+*/
+function compileExpression(source) {
+	const tokens = source.match(/\d+(?:\.\d+)?(?:e[+-]?\d+)?|\.\d+|[a-z_][a-z0-9_]*|\*\*|[-+*/^(),]|\S/giu) ?? [];
+	let index = 0;
+	const peek = () => tokens[index];
+	const take = (expected) => {
+		const token = tokens[index];
+		if (token === void 0 || expected !== void 0 && token !== expected) throw new Error(`expression "${source}": expected ${expected ?? "a value"} at ${token ?? "end"}`);
+		index += 1;
+		return token;
+	};
+	const primary = () => {
+		const token = take();
+		if (/^(?:\d|\.\d)/u.test(token)) {
+			const value = Number(token);
+			return () => value;
+		}
+		if (token === "(") {
+			const inner = sum();
+			take(")");
+			return inner;
+		}
+		if (token === "-") {
+			const inner = power();
+			return (t) => -inner(t);
+		}
+		if (token === "+") return power();
+		const name = token.toLowerCase();
+		if (name === "t") return (t) => t;
+		if (Object.hasOwn(CONSTANTS, name)) {
+			const value = CONSTANTS[name];
+			return () => value;
+		}
+		if (Object.hasOwn(FUNCTIONS, name)) {
+			const fn = FUNCTIONS[name];
+			take("(");
+			const args = [sum()];
+			while (peek() === ",") {
+				take(",");
+				args.push(sum());
+			}
+			take(")");
+			return (t) => fn(...args.map((arg) => arg(t)));
+		}
+		throw new Error(`expression "${source}": unknown name or symbol "${token}"`);
+	};
+	const power = () => {
+		const base = primary();
+		if (peek() === "^" || peek() === "**") {
+			take();
+			const exponent = power();
+			return (t) => base(t) ** exponent(t);
+		}
+		return base;
+	};
+	const product = () => {
+		let left = power();
+		while (peek() === "*" || peek() === "/") {
+			const op = take();
+			const right = power();
+			const previous = left;
+			left = op === "*" ? (t) => previous(t) * right(t) : (t) => previous(t) / right(t);
+		}
+		return left;
+	};
+	const sum = () => {
+		let left = product();
+		while (peek() === "+" || peek() === "-") {
+			const op = take();
+			const right = product();
+			const previous = left;
+			left = op === "+" ? (t) => previous(t) + right(t) : (t) => previous(t) - right(t);
+		}
+		return left;
+	};
+	const expression = sum();
+	if (index !== tokens.length) throw new Error(`expression "${source}": unexpected "${tokens[index]}"`);
+	return expression;
+}
+const CURVE_STEPS = 24;
+function arcPoints(from, rx, ry, rotation, large, sweep, to) {
+	if (rx === 0 || ry === 0) return [to];
+	const phi = rotation * Math.PI / 180;
+	const cos = Math.cos(phi);
+	const sin = Math.sin(phi);
+	const dx = (from.x - to.x) / 2;
+	const dy = (from.y - to.y) / 2;
+	const x1 = cos * dx + sin * dy;
+	const y1 = -sin * dx + cos * dy;
+	let a = Math.abs(rx);
+	let b = Math.abs(ry);
+	const lambda = x1 * x1 / (a * a) + y1 * y1 / (b * b);
+	if (lambda > 1) {
+		a *= Math.sqrt(lambda);
+		b *= Math.sqrt(lambda);
+	}
+	const numerator = a * a * b * b - a * a * y1 * y1 - b * b * x1 * x1;
+	const factor = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, numerator / (a * a * y1 * y1 + b * b * x1 * x1)));
+	const cx1 = factor * (a * y1) / b;
+	const cy1 = factor * -(b * x1) / a;
+	const cx = cos * cx1 - sin * cy1 + (from.x + to.x) / 2;
+	const cy = sin * cx1 + cos * cy1 + (from.y + to.y) / 2;
+	const angle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+	const start = angle(1, 0, (x1 - cx1) / a, (y1 - cy1) / b);
+	let delta = angle((x1 - cx1) / a, (y1 - cy1) / b, (-x1 - cx1) / a, (-y1 - cy1) / b);
+	if (!sweep && delta > 0) delta -= Math.PI * 2;
+	if (sweep && delta < 0) delta += Math.PI * 2;
+	const points = [];
+	for (let step = 1; step <= CURVE_STEPS; step += 1) {
+		const theta = start + delta * step / CURVE_STEPS;
+		points.push({
+			x: cos * a * Math.cos(theta) - sin * b * Math.sin(theta) + cx,
+			y: sin * a * Math.cos(theta) + cos * b * Math.sin(theta) + cy
+		});
+	}
+	return points;
+}
+/**
+* Sample an SVG path (M L H V C S Q T A Z, absolute and relative) into a polyline.
+* @throws an Error for unsupported commands or malformed numbers.
+*/
+function samplePath(d) {
+	const tokens = d.match(/[a-z]|[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/giu) ?? [];
+	if (tokens.join("").length < d.replace(/[\s,]/gu, "").length) throw new Error("path contains unsupported characters");
+	const points = [];
+	let index = 0;
+	let command = "";
+	let current = {
+		x: 0,
+		y: 0
+	};
+	let start = {
+		x: 0,
+		y: 0
+	};
+	let control = null;
+	const number = () => {
+		const token = tokens[index];
+		if (token === void 0 || /^[a-z]$/iu.test(token)) throw new Error(`path command ${command} is missing a number`);
+		index += 1;
+		return Number(token);
+	};
+	const flag = () => number() !== 0;
+	while (index < tokens.length) {
+		if (/^[a-z]$/iu.test(tokens[index])) command = tokens[index++];
+		else if (command === "") throw new Error("path must start with a command");
+		const relative = command === command.toLowerCase();
+		const base = relative ? current : {
+			x: 0,
+			y: 0
+		};
+		const at = (x, y) => ({
+			x: base.x + x,
+			y: base.y + y
+		});
+		switch (command.toUpperCase()) {
+			case "M":
+				current = at(number(), number());
+				start = current;
+				points.push(current);
+				control = null;
+				command = relative ? "l" : "L";
+				break;
+			case "L":
+				current = at(number(), number());
+				points.push(current);
+				control = null;
+				break;
+			case "H":
+				current = {
+					x: (relative ? current.x : 0) + number(),
+					y: current.y
+				};
+				points.push(current);
+				control = null;
+				break;
+			case "V":
+				current = {
+					x: current.x,
+					y: (relative ? current.y : 0) + number()
+				};
+				points.push(current);
+				control = null;
+				break;
+			case "Z":
+				current = start;
+				points.push(current);
+				control = null;
+				break;
+			case "C":
+			case "S": {
+				const first = command.toUpperCase() === "C" ? at(number(), number()) : control === null ? current : {
+					x: 2 * current.x - control.x,
+					y: 2 * current.y - control.y
+				};
+				const second = at(number(), number());
+				const end = at(number(), number());
+				for (let step = 1; step <= CURVE_STEPS; step += 1) {
+					const s = step / CURVE_STEPS;
+					const r = 1 - s;
+					points.push({
+						x: r ** 3 * current.x + 3 * r * r * s * first.x + 3 * r * s * s * second.x + s ** 3 * end.x,
+						y: r ** 3 * current.y + 3 * r * r * s * first.y + 3 * r * s * s * second.y + s ** 3 * end.y
+					});
+				}
+				control = second;
+				current = end;
+				break;
+			}
+			case "Q":
+			case "T": {
+				const middle = command.toUpperCase() === "Q" ? at(number(), number()) : control === null ? current : {
+					x: 2 * current.x - control.x,
+					y: 2 * current.y - control.y
+				};
+				const end = at(number(), number());
+				for (let step = 1; step <= CURVE_STEPS; step += 1) {
+					const s = step / CURVE_STEPS;
+					const r = 1 - s;
+					points.push({
+						x: r * r * current.x + 2 * r * s * middle.x + s * s * end.x,
+						y: r * r * current.y + 2 * r * s * middle.y + s * s * end.y
+					});
+				}
+				control = middle;
+				current = end;
+				break;
+			}
+			case "A": {
+				const rx = number();
+				const ry = number();
+				const rotation = number();
+				const large = flag();
+				const sweep = flag();
+				const end = at(number(), number());
+				points.push(...arcPoints(current, rx, ry, rotation, large, sweep, end));
+				current = end;
+				control = null;
+				break;
+			}
+			default: throw new Error(`unsupported path command ${command}`);
+		}
+		if (command.toUpperCase() === "Z" && index < tokens.length && !/^[a-z]$/iu.test(tokens[index])) throw new Error("numbers after Z need a command");
+	}
+	if (points.length < 2) throw new Error("path needs at least two points");
+	if (points.some((point) => !Number.isFinite(point.x) || !Number.isFinite(point.y))) throw new Error("path has non-finite coordinates");
+	const lengths = [0];
+	for (let i = 1; i < points.length; i += 1) lengths.push(lengths[i - 1] + Math.hypot(points[i].x - points[i - 1].x, points[i].y - points[i - 1].y));
+	return {
+		points,
+		lengths,
+		total: lengths.at(-1)
+	};
+}
+/** Position and tangent angle (degrees) at a fraction of a sampled path's length. */
+function pointAlong(path, fraction) {
+	const target = Math.min(1, Math.max(0, fraction)) * path.total;
+	let i = 1;
+	while (i < path.points.length - 1 && path.lengths[i] < target) i += 1;
+	const a = path.points[i - 1];
+	const b = path.points[i];
+	const span = path.lengths[i] - path.lengths[i - 1];
+	const local = span === 0 ? 0 : (target - path.lengths[i - 1]) / span;
+	return {
+		x: a.x + (b.x - a.x) * local,
+		y: a.y + (b.y - a.y) * local,
+		angle: Math.atan2(b.y - a.y, b.x - a.x) * 180 / Math.PI
+	};
+}
+const BASE = {
+	dx: 0,
+	dy: 0,
+	scale: 1,
+	rotate: 0,
+	opacity: 1,
+	clip: 0,
+	glow: 0,
+	slideX: 0,
+	slideY: 0
+};
+function ease(kind, p) {
+	if (kind === "ease-in") return p ** 3;
+	if (kind === "ease-out") return 1 - (1 - p) ** 3;
+	if (kind === "ease-in-out") return p < .5 ? 4 * p ** 3 : 1 - (-2 * p + 2) ** 3 / 2;
+	return p;
+}
+const lerp = (a, b, p) => a + (b - a) * p;
+function direction(value) {
+	if (value === "left") return {
+		x: -1,
+		y: 0
+	};
+	if (value === "right") return {
+		x: 1,
+		y: 0
+	};
+	if (value === "up") return {
+		x: 0,
+		y: -1
+	};
+	return {
+		x: 0,
+		y: 1
+	};
+}
+function valueAt(segments, from, base, t) {
+	let active;
+	for (const segment of segments) {
+		if (segment.start > t) break;
+		active = segment;
+	}
+	if (active === void 0) return segments[0]?.before ?? base;
+	return active.at(t, from.get(active) ?? base);
+}
+/**
+* Validate and compile a timeline against the current board.
+* @param spec - parsed timeline spec.
+* @param targets - current board element envelopes.
+* @returns the compiled timeline.
+* @throws an Error describing the first invalid track.
+*/
+function compileTimeline(spec, targets) {
+	const byId = new Map(targets.map((target) => [target.id, target]));
+	const pending = /* @__PURE__ */ new Map();
+	const clipSides = /* @__PURE__ */ new Map();
+	spec.tracks.forEach((track, index) => {
+		const label = `track ${index + 1} (${track.verb} ${track.target})`;
+		const target = byId.get(track.target);
+		if (target === void 0) throw new Error(`${label}: no board element with id "${track.target}"`);
+		const cx = target.x + target.w / 2;
+		const cy = target.y + target.h / 2;
+		const start = track.startMs ?? 0;
+		const end = track.endMs ?? spec.durationMs;
+		if (track.verb !== "keyframes" && (end <= start || end > spec.durationMs)) throw new Error(`${label}: needs 0 <= startMs < endMs <= durationMs`);
+		const easing = track.easing ?? (track.verb === "follow" || track.verb === "parametric" ? "linear" : "ease-in-out");
+		const progress = (t) => ease(easing, Math.min(1, Math.max(0, (t - start) / (end - start))));
+		const props = pending.get(track.target) ?? /* @__PURE__ */ new Map();
+		pending.set(track.target, props);
+		const add = (prop, segment) => {
+			props.set(prop, [...props.get(prop) ?? [], segment]);
+		};
+		const require = (value, name) => {
+			if (value === void 0) throw new Error(`${label}: ${track.verb} requires ${name}`);
+			return value;
+		};
+		switch (track.verb) {
+			case "appear":
+			case "disappear": {
+				const showing = track.verb === "appear";
+				add("opacity", {
+					start,
+					end,
+					...showing ? { before: 0 } : {},
+					at: (t, from) => showing ? progress(t) : lerp(from, 0, progress(t))
+				});
+				if (track.direction !== void 0) {
+					const unit = direction(track.direction);
+					add("slideX", {
+						start,
+						end,
+						at: (t) => (showing ? -unit.x * (1 - progress(t)) : unit.x * progress(t)) * SLIDE_DISTANCE
+					});
+					add("slideY", {
+						start,
+						end,
+						at: (t) => (showing ? -unit.y * (1 - progress(t)) : unit.y * progress(t)) * SLIDE_DISTANCE
+					});
+				}
+				break;
+			}
+			case "move": {
+				const to = require(track.to, "to");
+				add("dx", {
+					start,
+					end,
+					at: (t, from) => lerp(from, to.x - cx, progress(t))
+				});
+				add("dy", {
+					start,
+					end,
+					at: (t, from) => lerp(from, to.y - cy, progress(t))
+				});
+				break;
+			}
+			case "scale": {
+				const factor = require(track.scale, "scale");
+				add("scale", {
+					start,
+					end,
+					at: (t, from) => lerp(from, factor, progress(t))
+				});
+				break;
+			}
+			case "rotate": {
+				const degrees = require(track.degrees, "degrees");
+				add("rotate", {
+					start,
+					end,
+					at: (t, from) => from + degrees * progress(t)
+				});
+				break;
+			}
+			case "highlight":
+				add("glow", {
+					start,
+					end,
+					at: (t) => t >= end ? 0 : Math.sin(Math.PI * Math.min(1, Math.max(0, (t - start) / (end - start))))
+				});
+				break;
+			case "reveal": {
+				const side = track.direction ?? "right";
+				clipSides.set(track.target, side === "right" ? "right" : side === "left" ? "left" : side === "up" ? "top" : "bottom");
+				add("clip", {
+					start,
+					end,
+					before: 100,
+					at: (t) => 100 * (1 - progress(t))
+				});
+				break;
+			}
+			case "follow": {
+				let path;
+				try {
+					path = samplePath(require(track.path, "path"));
+				} catch (error) {
+					throw new Error(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				add("dx", {
+					start,
+					end,
+					at: (t) => pointAlong(path, progress(t)).x - cx
+				});
+				add("dy", {
+					start,
+					end,
+					at: (t) => pointAlong(path, progress(t)).y - cy
+				});
+				if (track.orient === true) add("rotate", {
+					start,
+					end,
+					at: (t) => pointAlong(path, progress(t)).angle
+				});
+				break;
+			}
+			case "parametric": {
+				let x;
+				let y;
+				try {
+					x = compileExpression(require(track.x, "x"));
+					y = compileExpression(require(track.y, "y"));
+				} catch (error) {
+					throw new Error(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				const [t0, t1] = track.t ?? [0, 1];
+				const param = (t) => lerp(t0, t1, Math.min(1, Math.max(0, (t - start) / (end - start))));
+				for (let step = 0; step <= 16; step += 1) {
+					const value = lerp(t0, t1, step / 16);
+					if (!Number.isFinite(x(value)) || !Number.isFinite(y(value))) throw new Error(`${label}: x or y is not finite at t = ${value}`);
+				}
+				add("dx", {
+					start,
+					end,
+					at: (t) => x(param(t)) - cx
+				});
+				add("dy", {
+					start,
+					end,
+					at: (t) => y(param(t)) - cy
+				});
+				break;
+			}
+			case "keyframes": {
+				const frames = [...require(track.frames, "frames")].sort((a, b) => a.atMs - b.atMs);
+				if (frames.some((frame) => frame.atMs > spec.durationMs)) throw new Error(`${label}: frame atMs exceeds durationMs`);
+				const channels = [
+					["dx", (frame) => frame.x === void 0 ? void 0 : frame.x - cx],
+					["dy", (frame) => frame.y === void 0 ? void 0 : frame.y - cy],
+					["opacity", (frame) => frame.opacity],
+					["scale", (frame) => frame.scale],
+					["rotate", (frame) => frame.rotate]
+				];
+				for (const [prop, read] of channels) {
+					const stops = frames.flatMap((frame) => {
+						const value = read(frame);
+						return value === void 0 ? [] : [{
+							at: frame.atMs,
+							value
+						}];
+					});
+					if (stops.length === 0) continue;
+					const first = stops[0];
+					const last = stops.at(-1);
+					add(prop, {
+						start: first.at,
+						end: Math.max(first.at + 1, last.at),
+						at: (t) => {
+							if (t >= last.at) return last.value;
+							let i = 1;
+							while (i < stops.length - 1 && stops[i].at <= t) i += 1;
+							const a = stops[i - 1];
+							const b = stops[i];
+							return lerp(a.value, b.value, ease(easing, b.at === a.at ? 1 : Math.min(1, Math.max(0, (t - a.at) / (b.at - a.at)))));
+						}
+					});
+				}
+				break;
+			}
+			default: return track.verb;
+		}
+	});
+	const elements = /* @__PURE__ */ new Map();
+	for (const [id, props] of pending) {
+		const segments = /* @__PURE__ */ new Map();
+		const from = /* @__PURE__ */ new Map();
+		for (const [prop, list] of props) {
+			const sorted = [...list].sort((a, b) => a.start - b.start);
+			sorted.forEach((segment, index) => {
+				from.set(segment, valueAt(sorted.slice(0, index), from, BASE[prop], segment.start));
+			});
+			segments.set(prop, sorted);
+		}
+		elements.set(id, {
+			segments,
+			from,
+			clipSide: clipSides.get(id) ?? "right"
+		});
+	}
+	return {
+		durationMs: spec.durationMs,
+		loop: spec.loop ?? false,
+		beats: [...spec.beats ?? []].sort((a, b) => a.atMs - b.atMs),
+		elements
+	};
+}
 /** Maximum combined UTF-8 element-content bytes retained on one board. */
 const BOARD_MAX_CONTENT_BYTES = 5e5;
 /** Element kinds the blackboard renders safely on the chalk canvas. */
@@ -398,7 +1033,9 @@ const boardSnapshotSchema = z.object({
 	version: z.literal(4),
 	revision: z.number().int().nonnegative(),
 	elements: z.array(boardElementStateSchema).max(50),
-	invalid: z.number().int().nonnegative()
+	invalid: z.number().int().nonnegative(),
+	/** Latest animation timeline; absent in snapshots from earlier versions. */
+	timeline: boardTimelineSchema.nullable().optional()
 }).strict();
 Object.freeze({
 	version: 4,
@@ -412,7 +1049,9 @@ Object.freeze({
 const boardCaptureJobSchema = z.object({
 	id: z.string().min(1),
 	sessionId: z.string().min(1),
-	board: boardSnapshotSchema
+	board: boardSnapshotSchema,
+	/** Render the board's timeline frozen at this time instead of its resting state. */
+	atMs: z.number().int().min(0).max(ANIMATION_MAX_DURATION_MS).optional()
 }).strict();
 //#endregion
 //#region lib/types/learning-example.js
@@ -712,7 +1351,13 @@ const citeCiterSettingsSchema = z.object({
 		"workspace-write",
 		"danger-full-access"
 	]).optional(),
-	learningRoute: z.boolean().optional()
+	learningRoute: z.boolean().optional(),
+	autoReadSource: z.boolean().optional(),
+	workspaceChanges: z.enum([
+		"off",
+		"summary",
+		"diff"
+	]).optional()
 }).strict();
 /** Settings used before an optional DSH settings provider becomes available. */
 const DEFAULT_CITECITER_SETTINGS = Object.freeze({
@@ -724,6 +1369,8 @@ const DEFAULT_CITECITER_SETTINGS = Object.freeze({
 	activeRecall: false,
 	defaultPermission: "read-only",
 	learningRoute: false,
+	autoReadSource: false,
+	workspaceChanges: "summary",
 	updateNotifications: true,
 	selectionToolbar: true,
 	actionDelivery: "send",
@@ -1602,4 +2249,4 @@ function waitForCaller(operation, signal) {
 	});
 }
 //#endregion
-export { applyBoardOps as A, questionReplyText as C, learningCardsInputSchema as D, LEARNING_CARD_FIELD_DESCRIPTIONS as E, DRAFT_CHUNK_BYTES as F, EMPTY_DRAFT_STATE as I, draftFileSchema as L, EMPTY_QUESTION_DRAFT_STATE as M, questionDraftKeySchema as N, LEARNING_EXAMPLE_PARAMETER as O, questionDraftRecordSchema as P, draftStateSchema as R, topicSummarySchema as S, DEFAULT_WHEEL_SLOTS as T, readCiteCiterSettings as _, DEFAULT_CITECITER_SETTINGS as a, topicMetadataSchema as b, citationDraftSchema as c, citeCiterRequestSchema as d, citeCiterResponseSchema as f, parseTopicMetadataFile as g, documentSummarySchema as h, CITECITER_SETTINGS_NAMESPACE as i, boardBatchSchema as j, EMPTY_BOARD_STATE as k, citationRecordSchema as l, documentEvidenceClaimSchema as m, updateCheckErrorCodeSchema as n, TUTOR_SECTION_NAME as o, documentContentSchema as p, updateCheckResponseSchema as r, canonicalCitationIdentity as s, UpdateChecker as t, citationSelectionClaimSchema as u, toolEvidenceClaimSchema as v, readQuestionReply as w, topicSnapshotSchema as x, topicDisplayTitle as y, subtractSubmitted as z };
+export { applyBoardOps as A, draftFileSchema as B, questionReplyText as C, learningCardsInputSchema as D, LEARNING_CARD_FIELD_DESCRIPTIONS as E, EMPTY_QUESTION_DRAFT_STATE as F, subtractSubmitted as H, questionDraftKeySchema as I, questionDraftRecordSchema as L, ANIMATION_MAX_DURATION_MS as M, animationSpecSchema as N, LEARNING_EXAMPLE_PARAMETER as O, compileTimeline as P, DRAFT_CHUNK_BYTES as R, topicSummarySchema as S, DEFAULT_WHEEL_SLOTS as T, draftStateSchema as V, readCiteCiterSettings as _, DEFAULT_CITECITER_SETTINGS as a, topicMetadataSchema as b, citationDraftSchema as c, citeCiterRequestSchema as d, citeCiterResponseSchema as f, parseTopicMetadataFile as g, documentSummarySchema as h, CITECITER_SETTINGS_NAMESPACE as i, boardBatchSchema as j, EMPTY_BOARD_STATE as k, citationRecordSchema as l, documentEvidenceClaimSchema as m, updateCheckErrorCodeSchema as n, TUTOR_SECTION_NAME as o, documentContentSchema as p, updateCheckResponseSchema as r, canonicalCitationIdentity as s, UpdateChecker as t, citationSelectionClaimSchema as u, toolEvidenceClaimSchema as v, readQuestionReply as w, topicSnapshotSchema as x, topicDisplayTitle as y, EMPTY_DRAFT_STATE as z };