@duckmind/dm-darwin-x64 0.35.4 → 0.35.5

package/extensions/dm-alps/src/features/animations/runtime.ts

@@ -1,574 +0,0 @@
-
-import type { Component } from "@mariozechner/pi-tui";
-import { type AnimationsSettings, cloneDefaultAnimationsSettings, normalizeAnimationsSettings } from "./settings.ts";
-import { pickRandomAnimation, renderAnimationFrame, resolveAnimationWidth, type AnimationPhase } from "./registry.ts";
-import { isAnimationDebugEnabled, summarizeWorkingLineWidths, writeAnimationDebugLog, type AnimationDebugEvent } from "./debug.ts";
-
-const WORKING_WIDGET_KEY = "dm-alps-animations";
-export const THINKING_DONE_LABEL = "Thinking complete";
-
-export type AnimationRuntimeState = {
-	settings: AnimationsSettings;
-	frame: number;
-	timer: ReturnType<typeof setInterval> | undefined;
-	currentUiCtx: any;
-	currentEventCtx: any;
-	currentCtx: any;
-	activeComponents: Set<AnimatedThinkingComponent>;
-	randomWorking: string | undefined;
-	randomThinking: string | undefined;
-	randomTool: string | undefined;
-	previousRandomWorking: string | undefined;
-	previousRandomThinking: string | undefined;
-	previousRandomTool: string | undefined;
-	animating: boolean;
-	thinkingActive: boolean;
-	toolCallIds: Set<string>;
-	agentGeneration: number;
-	closedAgentGeneration: number;
-	toolOwners: Map<string, number>;
-	ignoredAgentContexts: WeakSet<object>;
-	hiddenLabelApplied: boolean;
-	workingMessageApplied: boolean;
-	workingWidgetApplied: boolean;
-	workingIndicatorHidden: boolean;
-	lastWorkingMessage: string | undefined;
-	lastWorkingLines: number;
-	lastWorkingLineWidths: number[];
-	currentAssistantMessage: any;
-	freezeGeneration: number;
-};
-
-const ANIMATIONS_STATE_KEY = Symbol.for("alps.dm.animations.runtime.v1");
-
-export class AnimatedThinkingComponent implements Component {
-	private readonly state: AnimationRuntimeState;
-	private readonly animationName: string | undefined;
-	private readonly completionLabel: string | undefined;
-	private frozen = false;
-
-	constructor(state = getAnimationsRuntimeState(), animationName?: string, frozen = false, completionLabel?: string) {
-		this.state = state;
-		this.animationName = animationName;
-		this.completionLabel = completionLabel;
-		this.frozen = frozen;
-		if (!this.frozen) {
-			this.state.activeComponents.add(this);
-			if (shouldRunTimer(this.state)) startTimer(this.state);
-		}
-	}
-
-	dispose(): void {
-		this.state.activeComponents.delete(this);
-		if (!shouldRunTimer(this.state)) stopTimer(this.state);
-	}
-
-	freeze(): void {
-		if (this.frozen) return;
-		this.frozen = true;
-		this.state.activeComponents.delete(this);
-		if (!shouldRunTimer(this.state)) stopTimer(this.state);
-	}
-
-	render(width: number): string[] {
-		if (!this.state.settings.enabled) return [" Thinking... "];
-		if (this.frozen) return [` ${this.completionLabel ?? renderThinkingCompleteLabel()} `];
-		const terminalWidth = Math.max(1, Math.floor(width));
-		const animationWidth = Math.min(resolveAnimationWidth(this.state.settings.width, terminalWidth), Math.max(1, terminalWidth - 2));
-		const name = this.animationName ?? resolveAnimationNameForPhase(this.state, "thinking");
-		return renderAnimationFrame(name, this.state.frame, animationWidth, "thinking").map((line) => ` ${line} `);
-	}
-
-	invalidate(): void {}
-}
-
-export function getAnimationsRuntimeState(): AnimationRuntimeState {
-	const existing = (globalThis as any)[ANIMATIONS_STATE_KEY] as Partial<AnimationRuntimeState> | undefined;
-	if (existing) return migrateAnimationsRuntimeState(existing);
-	const state = createDefaultAnimationsRuntimeState();
-	(globalThis as any)[ANIMATIONS_STATE_KEY] = state;
-	return state;
-}
-
-function createDefaultAnimationsRuntimeState(): AnimationRuntimeState {
-	return {
-		settings: cloneDefaultAnimationsSettings(),
-		frame: 0,
-		timer: undefined,
-		currentUiCtx: undefined,
-		currentEventCtx: undefined,
-		currentCtx: undefined,
-		activeComponents: new Set(),
-		randomWorking: undefined,
-		randomThinking: undefined,
-		randomTool: undefined,
-		previousRandomWorking: undefined,
-		previousRandomThinking: undefined,
-		previousRandomTool: undefined,
-		animating: false,
-		thinkingActive: false,
-		toolCallIds: new Set(),
-		agentGeneration: 0,
-		closedAgentGeneration: 0,
-		toolOwners: new Map(),
-		ignoredAgentContexts: new WeakSet(),
-		hiddenLabelApplied: false,
-			workingMessageApplied: false,
-			workingWidgetApplied: false,
-			workingIndicatorHidden: false,
-			lastWorkingMessage: undefined,
-			lastWorkingLines: 0,
-		lastWorkingLineWidths: [],
-		currentAssistantMessage: undefined,
-		freezeGeneration: 0,
-	};
-}
-
-function migrateAnimationsRuntimeState(existing: Partial<AnimationRuntimeState>): AnimationRuntimeState {
-	existing.settings = normalizeAnimationsSettings(existing.settings ?? cloneDefaultAnimationsSettings());
-	if (typeof existing.frame !== "number") existing.frame = 0;
-	if (!(existing.activeComponents instanceof Set)) existing.activeComponents = new Set();
-	if (!('currentUiCtx' in existing)) existing.currentUiCtx = canWriteWorkingAnimation(existing.currentCtx) ? existing.currentCtx : undefined;
-	if (!('currentEventCtx' in existing)) existing.currentEventCtx = undefined;
-	if (!(existing.toolCallIds instanceof Set)) existing.toolCallIds = new Set();
-	if (typeof existing.agentGeneration !== "number") existing.agentGeneration = 0;
-	if (typeof existing.closedAgentGeneration !== "number") existing.closedAgentGeneration = 0;
-	if (!(existing.toolOwners instanceof Map)) existing.toolOwners = new Map();
-	if (!(existing.ignoredAgentContexts instanceof WeakSet)) existing.ignoredAgentContexts = new WeakSet();
-	if (typeof existing.animating !== "boolean") existing.animating = false;
-	if (typeof existing.thinkingActive !== "boolean") existing.thinkingActive = false;
-	if (typeof existing.previousRandomWorking !== "string") existing.previousRandomWorking = undefined;
-	if (typeof existing.previousRandomThinking !== "string") existing.previousRandomThinking = undefined;
-	if (typeof existing.previousRandomTool !== "string") existing.previousRandomTool = undefined;
-	if (typeof existing.hiddenLabelApplied !== "boolean") existing.hiddenLabelApplied = false;
-	if (typeof existing.workingMessageApplied !== "boolean") existing.workingMessageApplied = false;
-	if (typeof existing.workingWidgetApplied !== "boolean") existing.workingWidgetApplied = false;
-	if (typeof existing.workingIndicatorHidden !== "boolean") existing.workingIndicatorHidden = false;
-	if (typeof existing.lastWorkingMessage !== "string") existing.lastWorkingMessage = undefined;
-	if (typeof existing.lastWorkingLines !== "number") existing.lastWorkingLines = 0;
-	if (!Array.isArray(existing.lastWorkingLineWidths)) existing.lastWorkingLineWidths = [];
-	if (!("currentAssistantMessage" in existing)) existing.currentAssistantMessage = undefined;
-	if (typeof existing.freezeGeneration !== "number") existing.freezeGeneration = 0;
-	return existing as AnimationRuntimeState;
-}
-
-export function configureAnimationsRuntime(settings: AnimationsSettings): void {
-	const state = getAnimationsRuntimeState();
-	writeAnimationDebugLog({ event: "configure", state });
-	const previousFps = state.settings.fps;
-	const previousRandomMode = state.settings.randomMode;
-	state.settings = normalizeAnimationsSettings(settings);
-	if (previousRandomMode !== state.settings.randomMode) resetRandomAnimations(state);
-	if (!state.settings.enabled) {
-		stopTimer(state);
-		resetRandomAnimations(state);
-		clearWorkingAnimation(state);
-		resetHiddenThinkingLabel(state);
-		requestAnimationsRender(state);
-		return;
-	}
-	if (shouldRunTimer(state) && (!state.timer || previousFps !== state.settings.fps)) startTimer(state);
-	requestAnimationsRender(state);
-}
-
-export function bindAnimationsRuntimeSession(ctx: any): void {
-	const state = getAnimationsRuntimeState();
-	state.currentEventCtx = ctx;
-	if (canWriteWorkingAnimation(ctx)) {
-		state.currentUiCtx = ctx;
-		state.currentCtx = ctx;
-		writeAnimationDebugLog({ event: "bind_session", state, ctx });
-		return;
-	}
-	writeAnimationDebugLog({ event: "bind_session", state, ctx, note: "ignored_no_ui_target" });
-}
-
-export function handleAnimationsAgentStart(event?: any, ctx?: any): void {
-	const state = getAnimationsRuntimeState();
-	if (isStaleEventCtx(ctx)) {
-		writeAnimationDebugLog({ event: "agent_start", state, ctx, payload: event, note: "ignored_stale_ctx" });
-		return;
-	}
-	if (isNestedAgentStart(state, ctx)) {
-		rememberIgnoredAgentContext(state, ctx);
-		writeAnimationDebugLog({ event: "agent_start", state, ctx, payload: event, note: "ignored_nested_agent" });
-		return;
-	}
-	bindEventCtx(state, ctx);
-	resumeAnimationsRuntime();
-}
-
-export function handleAnimationsAgentEnd(event?: any, ctx?: any): void {
-	const state = getAnimationsRuntimeState();
-	if (isIgnoredAgentContext(state, ctx) || isNestedNonWritableEvent(state, ctx)) {
-		rememberIgnoredAgentContext(state, ctx);
-		writeAnimationDebugLog({ event: "agent_end", state, ctx, payload: event, note: "ignored_nested_agent" });
-		return;
-	}
-	if (isStaleEventCtx(ctx)) {
-		writeAnimationDebugLog({ event: "agent_end", state, ctx, payload: event, note: hasActiveAnimationState(state) ? "stale_ctx_cleanup_current" : "stale_ctx_no_active_runtime" });
-		if (hasActiveAnimationState(state)) pauseAnimationsRuntime();
-		return;
-	}
-	bindEventCtx(state, ctx);
-	pauseAnimationsRuntime();
-}
-
-export function recordAnimationsLifecycleEvent(event: AnimationDebugEvent, ctx?: any, payload?: any): void {
-	writeAnimationDebugLog({ event, state: getAnimationsRuntimeState(), ctx, payload });
-}
-
-export function resumeAnimationsRuntime(): void {
-	const state = getAnimationsRuntimeState();
-	writeAnimationDebugLog({ event: "resume", state });
-	state.animating = true;
-	state.thinkingActive = false;
-	state.agentGeneration += 1;
-	state.toolCallIds.clear();
-	state.toolOwners.clear();
-	state.currentAssistantMessage = undefined;
-	state.frame = 0;
-	state.freezeGeneration += 1;
-	state.workingWidgetApplied = true;
-	resetRandomAnimations(state);
-	if (state.settings.enabled) startTimer(state);
-	requestAnimationsRender(state);
-}
-
-export function pauseAnimationsRuntime(): void {
-	const state = getAnimationsRuntimeState();
-	writeAnimationDebugLog({ event: "pause", state });
-	state.animating = false;
-	state.thinkingActive = false;
-	state.closedAgentGeneration = state.agentGeneration;
-	state.toolCallIds.clear();
-	state.toolOwners.clear();
-	state.currentAssistantMessage = undefined;
-	freezeAnimatedThinkingComponentsSoon(state);
-	stopTimer(state);
-	clearWorkingAnimation(state);
-	resetHiddenThinkingLabel(state);
-}
-
-export function handleAnimationsMessageUpdate(event: any, ctx?: any): void {
-	const state = getAnimationsRuntimeState();
-	if (shouldIgnoreScopedEvent(state, ctx)) {
-		writeAnimationDebugLog({ event: "message_update", state, ctx, payload: event, note: "ignored_scoped_event" });
-		return;
-	}
-	bindEventCtx(state, ctx);
-	if (event?.message) state.currentAssistantMessage = event.message;
-	const type = event?.assistantMessageEvent?.type;
-	if (type === "thinking_start" || type === "thinking_delta") {
-		state.thinkingActive = true;
-	} else if (type === "thinking_end" || type === "text_delta") {
-		state.thinkingActive = false;
-		freezeAnimatedThinkingComponentsSoon(state);
-	}
-	if (shouldRunTimer(state) && !state.timer) startTimer(state);
-	requestAnimationsRender(state);
-}
-
-export function handleAnimationsMessageEnd(ctx?: any): void {
-	const state = getAnimationsRuntimeState();
-	if (shouldIgnoreScopedEvent(state, ctx)) {
-		writeAnimationDebugLog({ event: "message_end", state, ctx, note: "ignored_scoped_event" });
-		return;
-	}
-	bindEventCtx(state, ctx);
-	state.thinkingActive = false;
-	state.currentAssistantMessage = undefined;
-	freezeAnimatedThinkingComponentsSoon(state);
-	requestAnimationsRender(state);
-}
-
-export function handleAnimationsToolExecutionStart(event: any, ctx?: any): void {
-	const state = getAnimationsRuntimeState();
-	if (shouldIgnoreScopedEvent(state, ctx)) {
-		writeAnimationDebugLog({ event: "tool_execution_start", state, ctx, payload: event, note: "ignored_scoped_event" });
-		return;
-	}
-	bindEventCtx(state, ctx);
-	const id = readToolCallId(event);
-	state.toolCallIds.add(id);
-	state.toolOwners.set(id, state.agentGeneration);
-	requestAnimationsRender(state);
-}
-
-export function handleAnimationsToolExecutionEnd(event: any, ctx?: any): void {
-	const state = getAnimationsRuntimeState();
-	const stale = isStaleEventCtx(ctx) || isIgnoredAgentContext(state, ctx) || isNestedNoUiEvent(state, ctx);
-	const generation = state.agentGeneration;
-	if (event?.toolCallId === undefined) {
-		if (!stale) clearToolsForGeneration(state, generation);
-		writeAnimationDebugLog({ event: "tool_execution_end", state, ctx, payload: event, note: stale ? "ignored_stale_unknown_tool" : "cleared_current_generation_tools" });
-		if (!stale && state.animating) requestAnimationsRender(state);
-		return;
-	}
-	const id = readToolCallId(event);
-	const owner = state.toolOwners.get(id);
-	if (owner !== undefined && !isIgnoredAgentContext(state, ctx) && !isNestedNoUiEvent(state, ctx)) {
-		state.toolOwners.delete(id);
-		state.toolCallIds.delete(id);
-	} else if (!stale) {
-		state.toolCallIds.delete(id);
-	}
-	writeAnimationDebugLog({ event: "tool_execution_end", state, ctx, payload: event, note: stale ? "bookkeeping_only" : undefined });
-	if (!stale && state.animating && (owner === undefined || owner === generation)) requestAnimationsRender(state);
-}
-
-export function disposeAnimationsRuntime(): void {
-	const state = getAnimationsRuntimeState();
-	pauseAnimationsRuntime();
-	for (const component of state.activeComponents) component.dispose();
-	state.activeComponents.clear();
-	state.currentUiCtx = undefined;
-	state.currentEventCtx = undefined;
-	state.currentCtx = undefined;
-	resetRandomAnimations(state);
-}
-
-function startTimer(state: AnimationRuntimeState): void {
-	stopTimer(state);
-	const fps = Math.max(1, state.settings.fps);
-	state.timer = setInterval(() => {
-		state.frame += 1;
-		writeAnimationDebugLog({ event: "timer_tick", state });
-		requestAnimationsRender(state);
-	}, Math.max(16, Math.round(1000 / fps)));
-	state.timer.unref?.();
-}
-
-function stopTimer(state: AnimationRuntimeState): void {
-	if (!state.timer) return;
-	clearInterval(state.timer);
-	state.timer = undefined;
-}
-
-function requestAnimationsRender(state: AnimationRuntimeState): void {
-	try {
-		for (const component of state.activeComponents) component.invalidate();
-		const ui = getCurrentUi(state);
-		renderWorkingAnimationFrame(state, ui);
-		if (typeof ui?.requestRender === "function") {
-			ui.requestRender();
-		}
-	} catch (error) {
-		writeAnimationDebugLog({ event: "render_fail", state, error });
-		if (!isStaleCtxError(error)) console.debug?.("[dm-alps] Animations render request failed:", error);
-	}
-}
-
-function renderWorkingAnimationFrame(state: AnimationRuntimeState, ui: any): boolean {
-	if (!state.settings.enabled || !state.animating) return false;
-	if (typeof ui?.setWorkingMessage !== "function") {
-		writeAnimationDebugLog({ event: "working_render_skipped", state, note: "no_ui_target" });
-		return false;
-	}
-	const phase = resolveCurrentPhase(state);
-	const width = resolveAnimationWidth(state.settings.width, process.stdout.columns || 80);
-	const lines = renderAnimationFrame(resolveAnimationNameForPhase(state, phase), state.frame, width, phase);
-	if (isAnimationDebugEnabled()) state.lastWorkingLineWidths = summarizeWorkingLineWidths(lines);
-	restoreWorkingIndicator(state, ui);
-	const message = stableWorkingMessageForPhase(phase);
-	if (state.lastWorkingMessage !== message) {
-		ui.setWorkingMessage(message);
-		state.lastWorkingMessage = message;
-	}
-	state.workingMessageApplied = true;
-	writeAnimationDebugLog({ event: "working_render", state });
-	if (state.workingWidgetApplied && typeof ui?.setWidget === "function") {
-		ui.setWidget(WORKING_WIDGET_KEY, undefined);
-		state.workingWidgetApplied = false;
-	}
-	state.lastWorkingLines = lines.length;
-	return true;
-}
-
-function syncWorkingIndicatorForLines(state: AnimationRuntimeState, ui: any, lineCount: number): void {
-	if (lineCount > 1) {
-		hideWorkingIndicator(state, ui);
-		return;
-	}
-	restoreWorkingIndicator(state, ui);
-}
-
-function hideWorkingIndicator(state: AnimationRuntimeState, ui: any): void {
-	if (state.workingIndicatorHidden || typeof ui?.setWorkingIndicator !== "function") return;
-	try {
-		ui.setWorkingIndicator({ frames: [] });
-		state.workingIndicatorHidden = true;
-	} catch (error) {
-		if (!isStaleCtxError(error)) console.debug?.("[dm-alps] Animations working indicator hide failed:", error);
-	}
-}
-
-function restoreWorkingIndicator(state: AnimationRuntimeState, ui: any): void {
-	if (!state.workingIndicatorHidden || typeof ui?.setWorkingIndicator !== "function") return;
-	try {
-		ui.setWorkingIndicator(undefined);
-		state.workingIndicatorHidden = false;
-	} catch (error) {
-		if (!isStaleCtxError(error)) console.debug?.("[dm-alps] Animations working indicator restore failed:", error);
-	}
-}
-
-function clearWorkingAnimation(state: AnimationRuntimeState): void {
-	const shouldClearMessage = state.workingMessageApplied;
-	const shouldClearWidget = state.workingWidgetApplied;
-	const shouldRestoreIndicator = state.workingIndicatorHidden;
-	state.workingMessageApplied = false;
-	state.workingWidgetApplied = false;
-	state.workingIndicatorHidden = false;
-	state.lastWorkingMessage = undefined;
-	state.lastWorkingLines = 0;
-	state.lastWorkingLineWidths = [];
-	if (!shouldClearMessage && !shouldClearWidget && !shouldRestoreIndicator) return;
-	try {
-		const ui = getCurrentUi(state);
-		if (shouldClearWidget && typeof ui?.setWidget === "function") ui.setWidget(WORKING_WIDGET_KEY, undefined);
-		if (shouldClearMessage && typeof ui?.setWorkingMessage === "function") ui.setWorkingMessage(undefined);
-		if (shouldRestoreIndicator && typeof ui?.setWorkingIndicator === "function") ui.setWorkingIndicator(undefined);
-	} catch (error) {
-		if (!isStaleCtxError(error)) console.debug?.("[dm-alps] Animations working reset failed:", error);
-	}
-}
-
-function resetHiddenThinkingLabel(state: AnimationRuntimeState): void {
-	if (!state.hiddenLabelApplied) return;
-	try {
-		getCurrentUi(state)?.setHiddenThinkingLabel?.(undefined);
-	} catch (error) {
-		if (!isStaleCtxError(error)) console.debug?.("[dm-alps] Animations hidden label reset failed:", error);
-	}
-	state.hiddenLabelApplied = false;
-}
-
-function getCurrentUi(state: AnimationRuntimeState): any {
-	const ctx = canWriteWorkingAnimation(state.currentUiCtx) ? state.currentUiCtx : canWriteWorkingAnimation(state.currentCtx) ? state.currentCtx : undefined;
-	return ctx?.ui;
-}
-
-function resolveCurrentPhase(state: AnimationRuntimeState): AnimationPhase {
-	if (state.thinkingActive) return "thinking";
-	if (state.toolCallIds.size > 0) return "tool";
-	return "working";
-}
-
-function stableWorkingMessageForPhase(phase: AnimationPhase): string {
-	return phase === "tool" ? "Running..." : "Working...";
-}
-
-function resolveAnimationNameForPhase(state: AnimationRuntimeState, phase: AnimationPhase): string {
-	if (!state.settings.randomMode) {
-		if (phase === "thinking") return state.settings.thinking;
-		if (phase === "tool") return state.settings.tool;
-		return state.settings.working;
-	}
-	if (phase === "thinking") {
-		if (!state.randomThinking) state.randomThinking = state.previousRandomThinking = pickRandomAnimation("thinking", state.previousRandomThinking);
-		return state.randomThinking;
-	}
-	if (phase === "tool") {
-		if (!state.randomTool) state.randomTool = state.previousRandomTool = pickRandomAnimation("working", state.previousRandomTool);
-		return state.randomTool;
-	}
-	if (!state.randomWorking) state.randomWorking = state.previousRandomWorking = pickRandomAnimation("working", state.previousRandomWorking);
-	return state.randomWorking;
-}
-
-function renderThinkingCompleteLabel(): string {
-	return `\x1b[3m\x1b[38;5;141m${THINKING_DONE_LABEL}\x1b[39m\x1b[23m`;
-}
-
-function freezeAnimatedThinkingComponentsSoon(state: AnimationRuntimeState): void {
-	const freezeGeneration = state.freezeGeneration;
-	const timer = setTimeout(() => {
-		if (state.freezeGeneration !== freezeGeneration) return;
-		for (const component of [...state.activeComponents]) component.freeze();
-		requestAnimationsRender(state);
-	}, 0);
-	timer.unref?.();
-}
-
-function resetRandomAnimations(state: AnimationRuntimeState): void {
-	state.randomWorking = undefined;
-	state.randomThinking = undefined;
-	state.randomTool = undefined;
-}
-
-function shouldRunTimer(state: AnimationRuntimeState): boolean {
-	return state.settings.enabled && state.animating;
-}
-
-function hasActiveAnimationState(state: AnimationRuntimeState): boolean {
-	return Boolean(
-		state.animating
-		|| state.timer
-		|| state.thinkingActive
-		|| state.toolCallIds.size > 0
-		|| state.workingMessageApplied
-		|| state.workingWidgetApplied
-		|| state.workingIndicatorHidden
-		|| state.activeComponents.size > 0
-	);
-}
-
-function readToolCallId(event: any): string {
-	return String(event?.toolCallId ?? "__unknown_tool__");
-}
-
-function bindEventCtx(state: AnimationRuntimeState, ctx?: any): void {
-	if (!ctx || isStaleEventCtx(ctx)) return;
-	state.currentEventCtx = ctx;
-	if (!canWriteWorkingAnimation(ctx)) return;
-	state.currentUiCtx = ctx;
-	state.currentCtx = ctx;
-}
-
-function canWriteWorkingAnimation(ctx: any): boolean {
-	return Boolean(ctx && ctx.hasUI !== false && typeof ctx.ui?.setWorkingMessage === "function");
-}
-
-function isStaleEventCtx(ctx?: any): boolean {
-	return Boolean(ctx && ctx.isCurrent === false);
-}
-
-function rememberIgnoredAgentContext(state: AnimationRuntimeState, ctx?: any): void {
-	if (ctx && (typeof ctx === "object" || typeof ctx === "function")) state.ignoredAgentContexts.add(ctx);
-}
-
-function isIgnoredAgentContext(state: AnimationRuntimeState, ctx?: any): boolean {
-	return Boolean(ctx && (typeof ctx === "object" || typeof ctx === "function") && state.ignoredAgentContexts.has(ctx));
-}
-
-function isNestedAgentStart(state: AnimationRuntimeState, ctx?: any): boolean {
-	if (!state.animating || !ctx) return false;
-	if (ctx.hasUI === false && ctx !== state.currentUiCtx) return true;
-	return Boolean(state.toolCallIds.size > 0 && ctx !== state.currentCtx);
-}
-
-function shouldIgnoreScopedEvent(state: AnimationRuntimeState, ctx?: any): boolean {
-	return isStaleEventCtx(ctx) || isIgnoredAgentContext(state, ctx) || isNestedNonWritableEvent(state, ctx);
-}
-
-function isNestedNoUiEvent(state: AnimationRuntimeState, ctx?: any): boolean {
-	return isNestedNonWritableEvent(state, ctx);
-}
-
-function isNestedNonWritableEvent(state: AnimationRuntimeState, ctx?: any): boolean {
-	return Boolean(state.animating && ctx && ctx !== state.currentUiCtx && !isStaleEventCtx(ctx) && !canWriteWorkingAnimation(ctx));
-}
-
-function clearToolsForGeneration(state: AnimationRuntimeState, generation: number): void {
-	for (const [id, owner] of [...state.toolOwners]) {
-		if (owner !== generation) continue;
-		state.toolOwners.delete(id);
-		state.toolCallIds.delete(id);
-	}
-}
-
-function isStaleCtxError(error: unknown): boolean {
-	const message = error instanceof Error ? error.message : String(error);
-	return message.includes("extension ctx is stale") || message.includes("stale ctx");
-}

package/extensions/dm-alps/src/features/animations/settings.ts

@@ -1,69 +0,0 @@
-
-import type { AnimationWidth } from "./registry.ts";
-import { getAnimation } from "./registry.ts";
-
-export type AnimationsSettings = {
-	enabled: boolean;
-	randomMode: boolean;
-	working: string;
-	thinking: string;
-	tool: string;
-	width: AnimationWidth;
-	fps: number;
-};
-
-export const DEFAULT_ANIMATIONS_SETTINGS: AnimationsSettings = {
-	enabled: true,
-	randomMode: false,
-	working: "typewriter",
-	thinking: "shimmer",
-	tool: "crush",
-	width: "default",
-	fps: 16,
-};
-
-export const ANIMATION_WIDTH_VALUES: AnimationWidth[] = ["full", "default", 20, 40, 60, 80];
-export const ANIMATION_FPS_VALUES = [8, 12, 16, 24, 30] as const;
-
-export function cloneDefaultAnimationsSettings(): AnimationsSettings {
-	return { ...DEFAULT_ANIMATIONS_SETTINGS };
-}
-
-export function normalizeAnimationsSettings(value: unknown, defaults: AnimationsSettings = DEFAULT_ANIMATIONS_SETTINGS): AnimationsSettings {
-	const raw = isRecord(value) ? value : {};
-	return {
-		enabled: readBoolean(raw, "enabled", defaults.enabled),
-		randomMode: readBoolean(raw, "randomMode", defaults.randomMode),
-		working: readAnimationName(raw.working, defaults.working),
-		thinking: readAnimationName(raw.thinking, defaults.thinking),
-		tool: readAnimationName(raw.tool, defaults.tool),
-		width: readWidth(raw.width, defaults.width),
-		fps: readFps(raw.fps, defaults.fps),
-	};
-}
-
-function readBoolean(parent: Record<string, unknown>, key: string, fallback: boolean): boolean {
-	return typeof parent[key] === "boolean" ? parent[key] : fallback;
-}
-
-function readAnimationName(value: unknown, fallback: string): string {
-	if (typeof value !== "string") return fallback;
-	return getAnimation(value) ? value : fallback;
-}
-
-function readWidth(value: unknown, fallback: AnimationWidth): AnimationWidth {
-	if (value === "full" || value === "default") return value;
-	const numeric = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : NaN;
-	if (!Number.isFinite(numeric)) return fallback;
-	const matched = ANIMATION_WIDTH_VALUES.find((item) => item === numeric);
-	return matched ?? fallback;
-}
-
-function readFps(value: unknown, fallback: number): number {
-	const numeric = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : NaN;
-	return (ANIMATION_FPS_VALUES as readonly number[]).includes(numeric) ? numeric : fallback;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/extensions/dm-alps/src/features/bottom-input/cluster.ts

@@ -1,2 +0,0 @@
-
-export * from "../fixed-bottom-editor/cluster.ts";

package/extensions/dm-alps/src/features/bottom-input/compositor.ts

@@ -1,2 +0,0 @@
-
-export * from "../fixed-bottom-editor/compositor.ts";