bb76963902
Roll back junction-contact / discharge / light-theme simulation changes to the previously stable production tree while keeping linear history. Co-authored-by: Cursor <cursoragent@cursor.com>
472 lines
16 KiB
TypeScript
472 lines
16 KiB
TypeScript
/**
|
|
* Continuous Playback Engine — manages auto-demo on main page.
|
|
* Classification is always driven by classifyItem (live rule engine).
|
|
* Supports speed control, case seek, seeded variability, and event journal.
|
|
*/
|
|
|
|
import type { Category, ClassificationResult, EventLogEntry } from './types';
|
|
import { DEMO_PLAYLIST, type PlaylistCase, PLAYLIST_LENGTH } from './demoPlaylist';
|
|
import { classifyItem } from './classifier';
|
|
import { resolveItem } from '../data/resolveItem';
|
|
import { createSeededRng, DEFAULT_DEMO_SEED, seededOffset } from './seededRng';
|
|
|
|
/** Playback status for the continuous demo. */
|
|
export type PlaybackStatus = 'idle' | 'running' | 'paused' | 'finished';
|
|
|
|
/** Phase within a single case timeline. */
|
|
export type CasePhase =
|
|
| 'spawn'
|
|
| 'move_to_detection'
|
|
| 'detection'
|
|
| 'measurement'
|
|
| 'classification'
|
|
| 'command_sent'
|
|
| 'routing'
|
|
| 'exit'
|
|
| 'clear_gap'
|
|
| 'fault_hold'
|
|
| 'emergency_hold'
|
|
| 'recover';
|
|
|
|
/** Phase configuration with duration based on conveyor speed (1 m/s). */
|
|
export interface PhaseConfig {
|
|
phase: CasePhase;
|
|
durationMs: number;
|
|
label: string;
|
|
}
|
|
|
|
/**
|
|
* Timeline phases for a single normal item.
|
|
* Distances are in meters, speed is 1 m/s, so duration = distance * 1000 ms.
|
|
*/
|
|
export const CASE_PHASES: PhaseConfig[] = [
|
|
{ phase: 'spawn', durationMs: 300, label: 'Spawn at A' },
|
|
// Stage 2B §10: 1900 ms so that feed(300)+1900+600+1000+1000+1000 = 5500 ms
|
|
// == A->GATE distance (5.5 m) at 1.0 m/s — continuous motion, no dwell.
|
|
{ phase: 'move_to_detection', durationMs: 1900, label: 'Moving to camera' },
|
|
{ phase: 'detection', durationMs: 600, label: 'CV Detection' },
|
|
{ phase: 'measurement', durationMs: 1000, label: 'Laser measurement' },
|
|
{ phase: 'classification', durationMs: 1000, label: 'Classification' },
|
|
{ phase: 'command_sent', durationMs: 1000, label: 'Command sent' },
|
|
{ phase: 'routing', durationMs: 2500, label: 'Routing to zone' },
|
|
{ phase: 'exit', durationMs: 400, label: 'Exit to zone' },
|
|
{ phase: 'clear_gap', durationMs: 500, label: 'Clear gap' },
|
|
];
|
|
|
|
/** Safety timeline: jam near gate then recover. */
|
|
export const JAM_CASE_PHASES: PhaseConfig[] = [
|
|
{ phase: 'spawn', durationMs: 300, label: 'Spawn at A' },
|
|
{ phase: 'move_to_detection', durationMs: 2000, label: 'Moving to camera' },
|
|
{ phase: 'detection', durationMs: 500, label: 'CV Detection' },
|
|
{ phase: 'measurement', durationMs: 800, label: 'Laser measurement' },
|
|
{ phase: 'classification', durationMs: 600, label: 'Classification' },
|
|
{ phase: 'fault_hold', durationMs: 2800, label: 'JAM / FAULT' },
|
|
{ phase: 'recover', durationMs: 1200, label: 'Recovery' },
|
|
{ phase: 'clear_gap', durationMs: 400, label: 'Clear gap' },
|
|
];
|
|
|
|
/** Safety timeline: emergency stop. */
|
|
export const ESTOP_CASE_PHASES: PhaseConfig[] = [
|
|
{ phase: 'spawn', durationMs: 300, label: 'Spawn at A' },
|
|
{ phase: 'move_to_detection', durationMs: 1800, label: 'Moving to camera' },
|
|
{ phase: 'detection', durationMs: 400, label: 'CV Detection' },
|
|
{ phase: 'emergency_hold', durationMs: 3000, label: 'EMERGENCY STOP' },
|
|
{ phase: 'recover', durationMs: 1500, label: 'System reset' },
|
|
{ phase: 'clear_gap', durationMs: 400, label: 'Clear gap' },
|
|
];
|
|
|
|
/** Total duration of one normal case in ms. */
|
|
export const CASE_DURATION_MS = CASE_PHASES.reduce((sum, p) => sum + p.durationMs, 0);
|
|
|
|
export type PlaybackSpeed = 0.5 | 1 | 1.5 | 2;
|
|
|
|
export interface ContinuousPlaybackState {
|
|
status: PlaybackStatus;
|
|
currentCaseIndex: number;
|
|
currentCase: PlaylistCase;
|
|
currentPhaseIndex: number;
|
|
currentPhase: CasePhase;
|
|
phaseElapsedMs: number;
|
|
caseElapsedMs: number;
|
|
totalElapsedMs: number;
|
|
loopMode: boolean;
|
|
targetCategory: Category | null;
|
|
classification: ClassificationResult | null;
|
|
command: string;
|
|
warning: string | null;
|
|
/** Playback speed multiplier */
|
|
speed: PlaybackSpeed;
|
|
/** Seed for reproducible variability */
|
|
seed: number;
|
|
/** Deterministic position jitter (mm-scale visual offsets stored as meters) */
|
|
positionJitter: { x: number; z: number; yaw: number };
|
|
/** Bounded event journal for proof / engineering HUD */
|
|
events: EventLogEntry[];
|
|
}
|
|
|
|
function phasesForCase(playlistCase: PlaylistCase): PhaseConfig[] {
|
|
if (playlistCase.faultType === 'jam') return JAM_CASE_PHASES;
|
|
if (playlistCase.faultType === 'emergency_stop') return ESTOP_CASE_PHASES;
|
|
return CASE_PHASES;
|
|
}
|
|
|
|
export function getPlaylistCaseDurationMs(playlistCase: PlaylistCase): number {
|
|
return phasesForCase(playlistCase).reduce((sum, p) => sum + p.durationMs, 0);
|
|
}
|
|
|
|
/** Cumulative playlist duration before case index (supports wrap for loops). */
|
|
export function cumulativePlaylistDurationMs(caseIndex: number): number {
|
|
let sum = 0;
|
|
for (let i = 0; i < caseIndex; i++) {
|
|
sum += getPlaylistCaseDurationMs(DEMO_PLAYLIST[i % PLAYLIST_LENGTH]);
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
function caseDurationMs(playlistCase: PlaylistCase): number {
|
|
return getPlaylistCaseDurationMs(playlistCase);
|
|
}
|
|
|
|
function classifyCase(playlistCase: PlaylistCase): ClassificationResult {
|
|
const item = resolveItem(playlistCase.itemId);
|
|
return classifyItem(item);
|
|
}
|
|
|
|
function buildJitter(seed: number, caseIndex: number): { x: number; z: number; yaw: number } {
|
|
const rng = createSeededRng(seed + caseIndex * 9973);
|
|
return {
|
|
x: seededOffset(rng, 0.012),
|
|
z: seededOffset(rng, 0.008),
|
|
yaw: seededOffset(rng, 0.04),
|
|
};
|
|
}
|
|
|
|
let eventCounter = 0;
|
|
|
|
function pushEvent(
|
|
events: EventLogEntry[],
|
|
timestampMs: number,
|
|
entry: Omit<EventLogEntry, 'id' | 'timestampMs'>,
|
|
): EventLogEntry[] {
|
|
eventCounter += 1;
|
|
const next: EventLogEntry = {
|
|
id: `pb-evt-${eventCounter}`,
|
|
timestampMs,
|
|
...entry,
|
|
};
|
|
return [next, ...events].slice(0, 40);
|
|
}
|
|
|
|
function initCaseFields(playlistCase: PlaylistCase, seed: number, caseIndex: number, events: EventLogEntry[], simTime: number) {
|
|
const classification = classifyCase(playlistCase);
|
|
const warnings = [
|
|
...(playlistCase.warning ? [playlistCase.warning] : []),
|
|
...classification.warnings,
|
|
];
|
|
return {
|
|
currentCase: playlistCase,
|
|
currentCaseIndex: caseIndex,
|
|
currentPhaseIndex: 0,
|
|
currentPhase: 'spawn' as CasePhase,
|
|
phaseElapsedMs: 0,
|
|
caseElapsedMs: 0,
|
|
targetCategory: classification.category,
|
|
classification,
|
|
command: 'IDLE',
|
|
warning: warnings[0] ?? null,
|
|
positionJitter: buildJitter(seed, caseIndex),
|
|
events: pushEvent(events, simTime, {
|
|
itemId: playlistCase.itemId,
|
|
type: 'system',
|
|
message: `Case start: ${playlistCase.title}`,
|
|
category: classification.category,
|
|
status: 'info',
|
|
}),
|
|
};
|
|
}
|
|
|
|
/** Create initial playback state. */
|
|
export function createPlaybackState(seed: number = DEFAULT_DEMO_SEED): ContinuousPlaybackState {
|
|
const firstCase = DEMO_PLAYLIST[0];
|
|
const classification = classifyCase(firstCase);
|
|
return {
|
|
status: 'idle',
|
|
currentCaseIndex: 0,
|
|
currentCase: firstCase,
|
|
currentPhaseIndex: 0,
|
|
currentPhase: 'spawn',
|
|
phaseElapsedMs: 0,
|
|
caseElapsedMs: 0,
|
|
totalElapsedMs: 0,
|
|
loopMode: false,
|
|
targetCategory: null,
|
|
classification: null,
|
|
command: 'IDLE',
|
|
warning: null,
|
|
speed: 1,
|
|
seed,
|
|
positionJitter: { x: 0, z: 0, yaw: 0 },
|
|
events: [],
|
|
};
|
|
}
|
|
|
|
/** Start playback from the beginning. */
|
|
export function startPlayback(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
const firstCase = DEMO_PLAYLIST[0];
|
|
const fields = initCaseFields(firstCase, state.seed, 0, [], 0);
|
|
return {
|
|
...state,
|
|
status: 'running',
|
|
totalElapsedMs: 0,
|
|
speed: state.speed,
|
|
seed: state.seed,
|
|
loopMode: state.loopMode,
|
|
...fields,
|
|
};
|
|
}
|
|
|
|
export function pausePlayback(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
if (state.status !== 'running') return state;
|
|
return { ...state, status: 'paused' };
|
|
}
|
|
|
|
export function resumePlayback(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
if (state.status !== 'paused') return state;
|
|
return { ...state, status: 'running' };
|
|
}
|
|
|
|
export function stopPlayback(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
return createPlaybackState(state.seed);
|
|
}
|
|
|
|
export function toggleLoopMode(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
return { ...state, loopMode: !state.loopMode };
|
|
}
|
|
|
|
export function setPlaybackSpeed(state: ContinuousPlaybackState, speed: PlaybackSpeed): ContinuousPlaybackState {
|
|
return { ...state, speed };
|
|
}
|
|
|
|
/** Jump to a playlist case index (keeps running/paused status). */
|
|
export function seekToCase(state: ContinuousPlaybackState, caseIndex: number): ContinuousPlaybackState {
|
|
const idx = ((caseIndex % PLAYLIST_LENGTH) + PLAYLIST_LENGTH) % PLAYLIST_LENGTH;
|
|
const nextCase = DEMO_PLAYLIST[idx];
|
|
const fields = initCaseFields(nextCase, state.seed, idx, state.events, state.totalElapsedMs);
|
|
const status = state.status === 'idle' || state.status === 'finished' ? 'running' : state.status;
|
|
return {
|
|
...state,
|
|
status,
|
|
...fields,
|
|
};
|
|
}
|
|
|
|
export function seekNextCase(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
return seekToCase(state, state.currentCaseIndex + 1);
|
|
}
|
|
|
|
export function seekPrevCase(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
return seekToCase(state, state.currentCaseIndex - 1);
|
|
}
|
|
|
|
function advanceToNextCase(state: ContinuousPlaybackState): ContinuousPlaybackState {
|
|
const nextIndex = state.currentCaseIndex + 1;
|
|
|
|
if (nextIndex >= PLAYLIST_LENGTH) {
|
|
if (state.loopMode) {
|
|
const firstCase = DEMO_PLAYLIST[0];
|
|
const fields = initCaseFields(firstCase, state.seed, 0, state.events, state.totalElapsedMs);
|
|
return { ...state, ...fields };
|
|
}
|
|
return {
|
|
...state,
|
|
status: 'finished',
|
|
command: 'COMPLETE',
|
|
events: pushEvent(state.events, state.totalElapsedMs, {
|
|
type: 'system',
|
|
message: 'Playlist complete',
|
|
status: 'success',
|
|
}),
|
|
};
|
|
}
|
|
|
|
const nextCase = DEMO_PLAYLIST[nextIndex];
|
|
const fields = initCaseFields(nextCase, state.seed, nextIndex, state.events, state.totalElapsedMs);
|
|
return { ...state, ...fields };
|
|
}
|
|
|
|
function getCommandForPhase(phase: CasePhase, category: Category): string {
|
|
switch (phase) {
|
|
case 'spawn':
|
|
case 'move_to_detection':
|
|
return 'MOVING_TO_CAMERA';
|
|
case 'detection':
|
|
return 'DETECTING';
|
|
case 'measurement':
|
|
return 'MEASURING';
|
|
case 'classification':
|
|
return 'CLASSIFYING';
|
|
case 'command_sent':
|
|
case 'routing':
|
|
case 'exit':
|
|
return `ROUTE_TO_${category}`;
|
|
case 'fault_hold':
|
|
return 'FAULT';
|
|
case 'emergency_hold':
|
|
return 'EMERGENCY_STOP';
|
|
case 'recover':
|
|
return 'RECOVERING';
|
|
case 'clear_gap':
|
|
return 'RETURN_HOME';
|
|
default:
|
|
return 'IDLE';
|
|
}
|
|
}
|
|
|
|
function maybeLogPhaseTransition(
|
|
state: ContinuousPlaybackState,
|
|
phase: CasePhase,
|
|
category: Category,
|
|
): EventLogEntry[] {
|
|
let events = state.events;
|
|
if (phase === 'classification' && state.classification) {
|
|
events = pushEvent(events, state.totalElapsedMs, {
|
|
itemId: state.currentCase.itemId,
|
|
type: 'classification',
|
|
message: `${state.classification.label}: ${state.classification.reason}`,
|
|
category: state.classification.category,
|
|
command: 'CLASSIFY_RULE_BASED',
|
|
status: state.classification.warnings.length ? 'warning' : 'success',
|
|
});
|
|
}
|
|
if (phase === 'command_sent') {
|
|
events = pushEvent(events, state.totalElapsedMs, {
|
|
itemId: state.currentCase.itemId,
|
|
type: 'routing',
|
|
message: `Command ROUTE_TO_${category}`,
|
|
category,
|
|
command: `ROUTE_TO_${category}`,
|
|
status: 'success',
|
|
});
|
|
}
|
|
if (phase === 'fault_hold') {
|
|
events = pushEvent(events, state.totalElapsedMs, {
|
|
itemId: state.currentCase.itemId,
|
|
type: 'fault',
|
|
message: 'Jam detected at stop-gate — conveyor halted',
|
|
command: 'FAULT',
|
|
status: 'error',
|
|
});
|
|
}
|
|
if (phase === 'emergency_hold') {
|
|
events = pushEvent(events, state.totalElapsedMs, {
|
|
itemId: state.currentCase.itemId,
|
|
type: 'fault',
|
|
message: 'Emergency stop engaged — all motion frozen',
|
|
command: 'EMERGENCY_STOP',
|
|
status: 'error',
|
|
});
|
|
}
|
|
if (phase === 'recover') {
|
|
events = pushEvent(events, state.totalElapsedMs, {
|
|
type: 'system',
|
|
message: 'Recovery sequence started',
|
|
command: 'RECOVER',
|
|
status: 'warning',
|
|
});
|
|
}
|
|
return events;
|
|
}
|
|
|
|
/** Update playback state with elapsed wall-clock time (scaled by speed). */
|
|
export function updatePlayback(
|
|
state: ContinuousPlaybackState,
|
|
deltaMs: number,
|
|
): ContinuousPlaybackState {
|
|
if (state.status !== 'running') {
|
|
return state;
|
|
}
|
|
|
|
const scaledDelta = deltaMs * state.speed;
|
|
let newState = { ...state };
|
|
newState.phaseElapsedMs += scaledDelta;
|
|
newState.caseElapsedMs += scaledDelta;
|
|
newState.totalElapsedMs += scaledDelta;
|
|
|
|
const phases = phasesForCase(newState.currentCase);
|
|
const currentPhaseConfig = phases[newState.currentPhaseIndex];
|
|
|
|
if (newState.phaseElapsedMs >= currentPhaseConfig.durationMs) {
|
|
const nextPhaseIndex = newState.currentPhaseIndex + 1;
|
|
|
|
if (nextPhaseIndex >= phases.length) {
|
|
newState = advanceToNextCase(newState);
|
|
} else {
|
|
newState.currentPhaseIndex = nextPhaseIndex;
|
|
newState.currentPhase = phases[nextPhaseIndex].phase;
|
|
newState.phaseElapsedMs = 0;
|
|
if (newState.targetCategory) {
|
|
newState.events = maybeLogPhaseTransition(newState, newState.currentPhase, newState.targetCategory);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (newState.status === 'running' && newState.targetCategory) {
|
|
newState.command = getCommandForPhase(newState.currentPhase, newState.targetCategory);
|
|
}
|
|
|
|
return newState;
|
|
}
|
|
|
|
export function getCasePhases(state: ContinuousPlaybackState): PhaseConfig[] {
|
|
return phasesForCase(state.currentCase);
|
|
}
|
|
|
|
export function getCaseDurationMs(state: ContinuousPlaybackState): number {
|
|
return caseDurationMs(state.currentCase);
|
|
}
|
|
|
|
export function getCaseProgress(state: ContinuousPlaybackState): number {
|
|
return Math.min(state.caseElapsedMs / getCaseDurationMs(state), 1);
|
|
}
|
|
|
|
export function getPhaseProgress(state: ContinuousPlaybackState): number {
|
|
const phases = getCasePhases(state);
|
|
const phaseConfig = phases[state.currentPhaseIndex];
|
|
return Math.min(state.phaseElapsedMs / phaseConfig.durationMs, 1);
|
|
}
|
|
|
|
export function getCurrentPhaseConfig(state: ContinuousPlaybackState): PhaseConfig {
|
|
return getCasePhases(state)[state.currentPhaseIndex];
|
|
}
|
|
|
|
export function isDetectionActive(state: ContinuousPlaybackState): boolean {
|
|
return state.currentPhase === 'detection' || state.currentPhase === 'measurement';
|
|
}
|
|
|
|
export function isRoutingActive(state: ContinuousPlaybackState): boolean {
|
|
return state.currentPhase === 'routing' || state.currentPhase === 'exit';
|
|
}
|
|
|
|
export function isFaultActive(state: ContinuousPlaybackState): boolean {
|
|
return state.currentPhase === 'fault_hold' || state.currentPhase === 'emergency_hold';
|
|
}
|
|
|
|
export function getTotalProgress(state: ContinuousPlaybackState): number {
|
|
const completedCases = state.currentCaseIndex;
|
|
const currentCaseProgress = getCaseProgress(state);
|
|
return (completedCases + currentCaseProgress) / PLAYLIST_LENGTH;
|
|
}
|
|
|
|
/** Assert playlist expectedCategory matches live classifier (for tests). */
|
|
export function assertPlaylistClassifierConsistency(): Array<{ id: string; expected: Category; actual: Category }> {
|
|
const mismatches: Array<{ id: string; expected: Category; actual: Category }> = [];
|
|
for (const c of DEMO_PLAYLIST) {
|
|
if (c.faultType) continue;
|
|
const result = classifyCase(c);
|
|
if (result.category !== c.expectedCategory) {
|
|
mismatches.push({ id: c.id, expected: c.expectedCategory, actual: result.category });
|
|
}
|
|
}
|
|
return mismatches;
|
|
}
|