Wire the brew flow through the run coordinator with link-loss recovery

Author: cubicj

src/i18n/locales/en.json

@@ -22,6 +22,8 @@
 	"brew.done": "Done",
 	"brew.startBrewing": "Start brewing",
 	"brew.redoBrew": "Redo brew",
+	"brew.linkLost": "Scale disconnected · reconnecting…",
+	"brew.convertToManual": "Switch to manual entry",
 	"brew.saving": "Saving...",
 	"brew.saved": "Saved",
 	"brew.saveFailed": "Save failed",

src/i18n/locales/ko.json

@@ -22,6 +22,8 @@
 	"brew.done": "완료",
 	"brew.startBrewing": "브루잉 시작",
 	"brew.redoBrew": "다시 추출",
+	"brew.linkLost": "저울 연결 끊김 · 재연결 중…",
+	"brew.convertToManual": "수동 입력으로 전환",
 	"brew.saving": "저장 중...",
 	"brew.saved": "저장 완료",
 	"brew.saveFailed": "저장 실패",

src/styles/base.css

@@ -647,6 +647,19 @@
 	color: var(--text-muted);
 }
 
+.brew-flow-link-lost {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 8px;
+	margin: 8px 0;
+	padding: 6px 10px;
+	border-radius: 6px;
+	background-color: var(--background-modifier-error);
+	color: var(--text-on-accent);
+	font-size: var(--font-ui-small);
+}
+
 .cubicj-brewing-view .brew-flow-stop-btn {
 	background: var(--interactive-accent);
 	color: var(--text-on-accent);

src/views/BrewingView.ts

@@ -10,9 +10,40 @@ import { ScaleDisplayManager } from './ScaleDisplayManager';
 import { type FlowStep, renderStep, getStepSummary, type StepRenderContext } from './StepRenderers';
 import { AccordionManager } from './AccordionManager';
 import { BrewProfileRecorder } from './BrewProfileRecorder';
+import { BrewRunCoordinator } from './BrewRunCoordinator';
 import { NobleInstallModal } from './NobleInstallModal';
 
 export const VIEW_TYPE_BREWING = 'cubicj-brewing';
+const TIMER_OPERATION_TIMEOUT_MS = 5000;
+
+export function withTimerOperationTimeout(operation: () => Promise<void>): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const rejectWithError = (reason: unknown) => {
+			reject(reason instanceof Error ? reason : new Error(String(reason)));
+		};
+		const timeoutId = window.setTimeout(() => {
+			reject(new Error(`Timer operation timed out after ${TIMER_OPERATION_TIMEOUT_MS}ms`));
+		}, TIMER_OPERATION_TIMEOUT_MS);
+		let pending: Promise<void>;
+		try {
+			pending = operation();
+		} catch (err) {
+			window.clearTimeout(timeoutId);
+			rejectWithError(err);
+			return;
+		}
+		pending.then(
+			() => {
+				window.clearTimeout(timeoutId);
+				resolve();
+			},
+			(err) => {
+				window.clearTimeout(timeoutId);
+				rejectWithError(err);
+			},
+		);
+	});
+}
 
 export class BrewingView extends ItemView {
 	private plugin: CubicJBrewingPlugin;
@@ -29,6 +60,7 @@ export class BrewingView extends ItemView {
 	private accordion!: AccordionManager;
 
 	private timerController!: TimerController;
+	private runCoordinator!: BrewRunCoordinator;
 	private recorder = new BrewProfileRecorder();
 
 	constructor(leaf: WorkspaceLeaf, plugin: CubicJBrewingPlugin) {
@@ -57,7 +89,7 @@ export class BrewingView extends ItemView {
 		const svc = this.plugin.acaiaService!;
 		this.scaleDisplay = new ScaleDisplayManager(this.scaleConnectBtn, this.scalePowerOffBtn, {
 			onTimerClick: () => {
-				void this.timerController.handleTimerClick();
+				this.runCoordinator.handleToolbarTimer();
 			},
 			onTare: () => {
 				void svc.tare();
@@ -71,8 +103,16 @@ export class BrewingView extends ItemView {
 		const scaleElems = this.scaleDisplay.buildData(dataEl);
 		this.timerController = new TimerController(
 			{ timerEl: scaleElems.timerEl, timerBtn: scaleElems.timerBtn },
-			{ startTimer: () => svc.startTimer(), stopTimer: () => svc.stopTimer(), resetTimer: () => svc.resetTimer() },
+			{
+				startTimer: () => withTimerOperationTimeout(() => svc.startTimer()),
+				stopTimer: () => withTimerOperationTimeout(() => svc.stopTimer()),
+				resetTimer: () => withTimerOperationTimeout(() => svc.resetTimer()),
+			},
 		);
+		this.runCoordinator = new BrewRunCoordinator(this.flowState, this.recorder, this.timerController, {
+			getScaleState: () => this.plugin.acaiaService?.state ?? 'idle',
+			renderContent: (focusStep) => this.renderContent(focusStep),
+		});
 
 		const contentArea = container.createDiv({ cls: 'brewing-content-area' });
 		this.accordion = new AccordionManager(contentArea, {
@@ -111,7 +151,7 @@ export class BrewingView extends ItemView {
 	}
 
 	toggleTimer(): void {
-		void this.timerController.handleTimerClick();
+		this.runCoordinator.handleToolbarTimer();
 	}
 
 	powerOff(): void {
@@ -202,14 +242,7 @@ export class BrewingView extends ItemView {
 	private resetFlow(): void {
 		this.log('resetFlow');
 		this.flowState.cancel();
-		this.recorder.reset();
-		if (this.plugin.acaiaService?.state === 'connected') {
-			this.timerController.cancelRun().catch((err) => {
-				console.error('[BrewingView] resetFlow timer cancel failed:', err);
-			});
-		} else {
-			this.timerController.resetToIdle();
-		}
+		this.runCoordinator.resetAll();
 		this.flowState.startBrew();
 		this.accordion.clearExpandedSteps();
 		this.lastFocusedStep = this.flowState.step;
@@ -229,6 +262,7 @@ export class BrewingView extends ItemView {
 				updateSummaries: () => this.accordion.updateSummaries(),
 			},
 			timerController: this.timerController,
+			runCoordinator: this.runCoordinator,
 			getWeightText: () => this.scaleDisplay.getWeightText(),
 			resetFlow: () => this.resetFlow(),
 			recorder: this.recorder,
@@ -241,8 +275,11 @@ export class BrewingView extends ItemView {
 	private bindServiceEvents(): void {
 		this.listen('state', (state: AcaiaState) => {
 			this.log(`state → ${state}`);
+			this.runCoordinator.handleScaleState(state);
 			this.scaleDisplay.updateHeader(state, this.plugin.acaiaService?.scaleName);
-			this.scaleDisplay.updateControls(state, () => this.timerController.resetToIdle());
+			this.scaleDisplay.updateControls(state, () => {
+				if (!this.runCoordinator.hasActiveRun()) this.timerController.resetToIdle();
+			});
 		});
 
 		this.listen('weight', (grams: number, stable: boolean) => {
@@ -255,7 +292,7 @@ export class BrewingView extends ItemView {
 		});
 
 		this.listen('button', (event: ButtonEvent) => {
-			this.timerController.handleScaleButton(event);
+			this.runCoordinator.handleScaleButton(event);
 		});
 
 		this.listen('battery', (percent: number) => {

src/views/StepRenderers.ts

@@ -4,6 +4,7 @@ import type { BrewFlowSelection, EquipmentSettings } from '../brew/types';
 import type { TimerController } from './TimerController';
 import { formatTimer } from './TimerController';
 import type { BrewProfileRecorder } from './BrewProfileRecorder';
+import type { BrewRunCoordinator } from './BrewRunCoordinator';
 import type { BrewProfileStorage } from '../services/BrewProfileStorage';
 import { getDrinkLabel, getMethodLabel, getTempLabel, calcRoastDays } from '../brew/constants';
 import { t } from '../i18n/index';
@@ -39,6 +40,7 @@ export interface StepRenderContext {
 	renderContent: (focusStep?: FlowStep) => void;
 	accordion: AccordionActions;
 	timerController: TimerController;
+	runCoordinator: BrewRunCoordinator;
 	getWeightText: () => string;
 	resetFlow: () => void;
 	recorder: BrewProfileRecorder;

src/views/steps/renderBrewing.ts

@@ -1,5 +1,4 @@
 import { Notice } from 'obsidian';
-import { estimateYield } from '../../brew/yieldEstimator';
 import { BrewProfileChart } from '../BrewProfileChart';
 import { BrewProfileModal } from '../BrewProfileModal';
 import { createStepper } from '../Stepper';
@@ -13,7 +12,6 @@ export function renderBrewing(container: HTMLElement, ctx: StepRenderContext): v
 		return;
 	}
 	const isEspresso = ctx.flowState.selection.method === 'espresso';
-	const scaleConnected = ctx.plugin.acaiaService?.state === 'connected';
 
 	if (isEspresso) {
 		container.createDiv({ cls: 'brew-flow-espresso-msg', text: t('brew.espressoMsg') });
@@ -46,7 +44,7 @@ export function renderBrewing(container: HTMLElement, ctx: StepRenderContext): v
 
 	if (ctx.flowState.brewingStarted) {
 		let chart: BrewProfileChart | null = null;
-		if (scaleConnected) {
+		if (ctx.runCoordinator.isScaleModeRun()) {
 			const chartContainer = container.createDiv({ cls: 'brew-profile-container' });
 			const liveChart = new BrewProfileChart(chartContainer);
 			chart = liveChart;
@@ -55,6 +53,17 @@ export function renderBrewing(container: HTMLElement, ctx: StepRenderContext): v
 		} else {
 			renderManualResultSteppers(container, ctx);
 		}
+		if (ctx.runCoordinator.isLinkLost()) {
+			const banner = container.createDiv({ cls: 'brew-flow-link-lost' });
+			banner.createSpan({ text: t('brew.linkLost') });
+			const convertBtn = banner.createEl('button', {
+				text: t('brew.convertToManual'),
+				cls: 'brewing-ctrl-btn brew-flow-convert-btn',
+			});
+			convertBtn.addEventListener('click', () => {
+				ctx.runCoordinator.convertToManual();
+			});
+		}
 		const controls = container.createDiv({ cls: 'brewing-controls' });
 		const stopBtn = controls.createEl('button', { text: t('brew.done'), cls: 'brewing-ctrl-btn brew-flow-stop-btn' });
 		const cancelBtn = controls.createEl('button', {
@@ -69,19 +78,7 @@ export function renderBrewing(container: HTMLElement, ctx: StepRenderContext): v
 			cancelBtn.disabled = true;
 			try {
 				if (chart) chart.stopLive();
-				if (scaleConnected) {
-					ctx.recorder.stop();
-					await ctx.timerController.freeze();
-					const totalSeconds = ctx.timerController.getElapsedSeconds();
-					const yieldGrams =
-						(ctx.flowState.selection.method === 'filter' ? estimateYield(ctx.recorder.getPoints()) : undefined) ??
-						(parseFloat(ctx.getWeightText()) || undefined);
-					ctx.flowState.finishBrewing(totalSeconds || undefined, yieldGrams);
-				} else {
-					const sel = ctx.flowState.selection;
-					ctx.flowState.finishBrewing(sel.time, sel.yield);
-				}
-				ctx.renderContent();
+				if (await ctx.runCoordinator.finishRun()) ctx.renderContent();
 			} catch (err) {
 				console.error('[StepRenderers] brew stop failed:', err);
 				new Notice(t('brew.unexpectedError'));
@@ -101,10 +98,7 @@ export function renderBrewing(container: HTMLElement, ctx: StepRenderContext): v
 			cancelBtn.disabled = true;
 			try {
 				if (chart) chart.stopLive();
-				ctx.recorder.reset();
-				ctx.flowState.cancelBrewingRun();
-				if (scaleConnected) await ctx.timerController.cancelRun();
-				else ctx.timerController.resetToIdle();
+				await ctx.runCoordinator.cancelRun();
 			} catch (err) {
 				console.error('[StepRenderers] brew cancel failed:', err);
 				new Notice(t('brew.unexpectedError'));
@@ -127,19 +121,13 @@ export function renderBrewing(container: HTMLElement, ctx: StepRenderContext): v
 			startPending = true;
 			startBtn.disabled = true;
 			try {
-				if (!ctx.flowState.beginBrewingRun()) return;
-				if (scaleConnected) {
-					ctx.recorder.start();
-					await ctx.timerController.handleTimerClick();
+				if (await ctx.runCoordinator.startRun()) {
+					ctx.accordion.update();
+					ctx.accordion.scrollToStep('brewing');
 				}
-				ctx.accordion.update();
-				ctx.accordion.scrollToStep('brewing');
 			} catch (err) {
 				console.error('[StepRenderers] brew start failed:', err);
 				new Notice(t('brew.unexpectedError'));
-				ctx.flowState.cancelBrewingRun();
-				ctx.recorder.reset();
-				ctx.renderContent('brewing');
 			} finally {
 				startPending = false;
 				startBtn.disabled = false;
@@ -199,9 +187,8 @@ function renderReview(container: HTMLElement, ctx: StepRenderContext): void {
 		const staticChart = new BrewProfileChart(chartContainer);
 		ctx.registerCleanup(() => staticChart.destroy());
 		staticChart.renderStatic(points);
-	} else {
-		renderManualResultSteppers(container, ctx);
 	}
+	renderManualResultSteppers(container, ctx);
 
 	const controls = container.createDiv({ cls: 'brewing-controls' });
 	const redoBtn = controls.createEl('button', { text: t('brew.redoBrew'), cls: 'brewing-ctrl-btn brew-flow-redo-btn' });

tests/views/steps/renderBean.test.ts

@@ -33,6 +33,7 @@ function makeContext(flowState: BrewFlowState): StepRenderContext {
 			updateSummaries: vi.fn(),
 		},
 		timerController: {} as StepRenderContext['timerController'],
+		runCoordinator: {} as StepRenderContext['runCoordinator'],
 		getWeightText: vi.fn(() => ''),
 		resetFlow: vi.fn(),
 		recorder: {} as StepRenderContext['recorder'],