@fmsim/fmsim 2.0.0-beta.9 → 2.0.0-beta.91

package/dist-server/service/playback/mock-data.js

@@ -0,0 +1,658 @@
+"use strict";
+/**
+ * Playback 목업 데이터 생성기
+ *
+ * 대규모 팩토리 레이아웃 시뮬레이션:
+ * - AGV 20대, OHT 10대 (VEHICLE 시나리오)
+ * - Port 200개 (PORT 시나리오)
+ * - Zone 50개 (ZONE 시나리오)
+ * - Stocker 10기 (STOCKER 시나리오)
+ *
+ * 캐리어 이동 시뮬레이션:
+ *   Vehicle이 Port에서 캐리어를 픽업 → 이동 → 다른 Port에 전달
+ *   상태 전이: IDLE → MOVING → LOADING → MOVING → UNLOADING → IDLE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOCK_ENTITIES = void 0;
+exports.generatePlaybackData = generatePlaybackData;
+exports.generateCarrierLocationHistory = generateCarrierLocationHistory;
+// ── 엔티티 정의 ──
+const AGVS = Array.from({ length: 20 }, (_, i) => `AGV${String(i + 1).padStart(2, '0')}`);
+const OHTS = Array.from({ length: 10 }, (_, i) => `OHT${String(i + 1).padStart(2, '0')}`);
+const VEHICLES = [...AGVS, ...OHTS];
+const PORTS = Array.from({ length: 200 }, (_, i) => {
+    const zone = String(Math.floor(i / 10) + 1).padStart(2, '0');
+    const port = String((i % 10) + 1).padStart(2, '0');
+    return `ZONE${zone}_PORT${port}`;
+});
+const ZONES = Array.from({ length: 50 }, (_, i) => `ZONE${String(i + 1).padStart(2, '0')}`);
+const STOCKERS = Array.from({ length: 10 }, (_, i) => `STK${String(i + 1).padStart(2, '0')}`);
+const EQUIPMENTS = Array.from({ length: 20 }, (_, i) => `EQP${String(i + 1).padStart(2, '0')}`);
+const CONVEYORS = Array.from({ length: 30 }, (_, i) => `CNV${String(i + 1).padStart(2, '0')}`);
+const OHTLINES = ['OHTLINE01', 'OHTLINE02', 'OHTLINE03'];
+const AGVLINES = ['AGVLINE01', 'AGVLINE02', 'AGVLINE03', 'AGVLINE04', 'AGVLINE05', 'AGVLINE06'];
+const LINES = [...OHTLINES, ...AGVLINES];
+// ── 노드 경로 (Vehicle 이동 경로) ──
+const NODE_IDS = Array.from({ length: 100 }, (_, i) => String(i + 1).padStart(4, '0'));
+// 노드별 소속 라인 (보드 모델의 NodeMachine과 정확히 일치해야 함)
+const NODE_MACHINE_MAP = [
+    [0, 6, 'OHTLINE01'], // 0001-0006
+    [6, 12, 'OHTLINE02'], // 0007-0012
+    [12, 18, 'OHTLINE03'], // 0013-0018
+    [18, 30, 'OHTLINE01'], // 0019-0030
+    [30, 36, 'AGVLINE01'], // 0031-0036
+    [36, 42, 'AGVLINE02'], // 0037-0042
+    [42, 48, 'AGVLINE03'], // 0043-0048
+    [48, 60, 'AGVLINE01'], // 0049-0060
+    [60, 66, 'AGVLINE04'], // 0061-0066
+    [66, 72, 'AGVLINE05'], // 0067-0072
+    [72, 78, 'AGVLINE06'], // 0073-0078
+    [78, 100, 'AGVLINE04'], // 0079-0100
+];
+const NODE_MACHINES = {};
+NODE_IDS.forEach((id, i) => {
+    const entry = NODE_MACHINE_MAP.find(([from, to]) => i >= from && i < to);
+    if (entry)
+        NODE_MACHINES[id] = entry[2];
+});
+// 차량별 이동 가능 노드 범위
+const AGV_NODES = NODE_IDS.filter(id => { var _a; return (_a = NODE_MACHINES[id]) === null || _a === void 0 ? void 0 : _a.startsWith('AGVLINE'); });
+const OHT_NODES = NODE_IDS.filter(id => { var _a; return (_a = NODE_MACHINES[id]) === null || _a === void 0 ? void 0 : _a.startsWith('OHTLINE'); });
+// 포트별 연결 노드 — 포트를 차량 유형별 노드 범위에 매핑
+// ZONE01-05(포트 0-49): OHT 영역, ZONE06-20(포트 50-199): AGV 영역
+const PORT_NODES = {};
+PORTS.forEach((port, i) => {
+    if (i < 50) {
+        PORT_NODES[port] = OHT_NODES[i % OHT_NODES.length];
+    }
+    else {
+        PORT_NODES[port] = AGV_NODES[(i - 50) % AGV_NODES.length];
+    }
+});
+// 차량 유형별 포트 범위
+const OHT_PORTS = PORTS.slice(0, 50);
+const AGV_PORTS = PORTS.slice(50);
+// ── 상태 값 ──
+const CARRIER_STATUSES = ['FULL', 'EMPTY', 'EMPTYEMPTY'];
+const PORT_STATUSES = ['2001', '2002', '2005', '2006']; // DOWN, EMPTY, FULL, NOTINSERVICE
+const MACHINE_STATUSES = ['1001', '1002', '1005', '1006', '1007', '1008']; // UP, OUTOFSERVICE, DOWN, NOTAUTO, ALARM, FULL
+const VEHICLE_STATUSES = ['4001', '4006', '4007', '4008']; // ASSIGNED, NOTASSIGNED, INSTALLED, CHARGING
+const UNIT_STATUSES = ['2002', '2003', '2005']; // EMPTY, EMPTY_RESERVED, FULL
+// ── 유틸리티 ──
+function pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+function randInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function formatTime(date) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+// ── 시뮬레이션 엔진 ──
+class FactorySimulator {
+    constructor() {
+        this.vehicles = [];
+        this.ports = [];
+        this.zones = [];
+        this.stockers = [];
+        this.equipments = [];
+        this.conveyors = [];
+        this.lines = [];
+        this.carrierSeq = 1;
+        this.initVehicles();
+        this.initPorts();
+        this.initZones();
+        this.initStockers();
+        this.equipments = EQUIPMENTS.map(name => ({ name, status: pick(MACHINE_STATUSES) }));
+        this.conveyors = CONVEYORS.map(name => ({ name, status: pick(MACHINE_STATUSES) }));
+        this.lines = LINES.map(name => ({ name, status: pick(MACHINE_STATUSES) }));
+    }
+    initVehicles() {
+        this.vehicles = VEHICLES.map(name => {
+            const nodes = name.startsWith('OHT') ? OHT_NODES : AGV_NODES;
+            return {
+                name,
+                phase: 'IDLE',
+                nodeId: pick(nodes),
+                targetNodeId: pick(nodes),
+                carrierName: null,
+                carrierStatus: null,
+                emptyType: 'EMPTY',
+                batteryRate: name.startsWith('AGV') ? randInt(30, 100) : null,
+                phaseTimer: randInt(1, 5),
+                sourcePort: null,
+                destPort: null,
+            };
+        });
+    }
+    initPorts() {
+        this.ports = PORTS.map(name => ({
+            name,
+            status: pick(PORT_STATUSES),
+            carrierName: Math.random() > 0.3 ? this.newCarrierName() : null,
+            carrierStatus: null,
+            emptyType: null,
+        }));
+        // 캐리어가 있는 포트의 상태 설정
+        this.ports.forEach(p => {
+            if (p.carrierName) {
+                p.emptyType = 'FULL';
+                p.carrierStatus = pick(CARRIER_STATUSES);
+            }
+            else {
+                p.emptyType = 'EMPTY';
+            }
+        });
+    }
+    initZones() {
+        this.zones = ZONES.map(name => {
+            const max = randInt(20, 100);
+            return {
+                name,
+                status: pick(MACHINE_STATUSES),
+                currentCapacity: randInt(0, max),
+                maxCapacity: max,
+                highWaterMark: String(Math.round(max * 0.8)),
+                lowWaterMark: String(Math.round(max * 0.6)),
+            };
+        });
+    }
+    initStockers() {
+        this.stockers = STOCKERS.map(name => {
+            const max = randInt(50, 200);
+            const cur = randInt(0, max);
+            return {
+                name,
+                status: pick(MACHINE_STATUSES),
+                currentCapacity: cur,
+                maxCapacity: max,
+                highWaterMark: Math.round(max * 0.8),
+                lowWaterMark: Math.round(max * 0.2),
+            };
+        });
+    }
+    newCarrierName() {
+        return `PLATE-${String(this.carrierSeq++).padStart(4, '0')}`;
+    }
+    // ── 1초 진행 ──
+    tick() {
+        const vehicleChanges = [];
+        const portChanges = [];
+        for (const v of this.vehicles) {
+            const changed = this.tickVehicle(v, portChanges);
+            if (changed)
+                vehicleChanges.push(changed);
+        }
+        // 인접 포트 간 캐리어 이동 (컨베이어 흐름 시뮬레이션)
+        this.tickConveyorFlow(portChanges);
+        const zoneChanges = this.tickZones();
+        const stockerChanges = this.tickStockers();
+        const equipmentChanges = this.tickMachines(this.equipments);
+        const conveyorChanges = this.tickMachines(this.conveyors);
+        const lineChanges = this.tickMachines(this.lines);
+        return { vehicleChanges, portChanges, zoneChanges, stockerChanges, equipmentChanges, conveyorChanges, lineChanges };
+    }
+    tickMachines(machines) {
+        const changes = [];
+        for (const m of machines) {
+            if (Math.random() > 0.05)
+                continue; // 5% 확률로 상태 변경
+            m.status = pick(MACHINE_STATUSES);
+            changes.push({ NAME: m.name, STATUS: m.status });
+        }
+        return changes;
+    }
+    tickVehicle(v, portChanges) {
+        v.phaseTimer--;
+        // AGV 배터리 감소
+        if (v.batteryRate != null && v.phase !== 'IDLE') {
+            v.batteryRate = Math.max(0, v.batteryRate - (Math.random() > 0.8 ? 1 : 0));
+        }
+        if (v.phaseTimer > 0)
+            return null;
+        // Phase 전이
+        switch (v.phase) {
+            case 'IDLE': {
+                // 차량 유형별 포트 범위에서 캐리어가 있는 포트를 찾아 픽업하러 출발
+                const myPorts = v.name.startsWith('OHT') ? OHT_PORTS : AGV_PORTS;
+                const sourcePort = this.ports.find(p => myPorts.includes(p.name) && p.carrierName && (p.status === '2002' || p.status === '2003'));
+                if (!sourcePort) {
+                    v.phaseTimer = randInt(2, 5);
+                    return null;
+                }
+                v.phase = 'MOVING_TO_PICKUP';
+                v.sourcePort = sourcePort.name;
+                v.targetNodeId = PORT_NODES[sourcePort.name] || pick(v.name.startsWith('OHT') ? OHT_NODES : AGV_NODES);
+                v.phaseTimer = randInt(3, 10); // 이동 시간
+                return this.vehicleRecord(v, '4001');
+            }
+            case 'MOVING_TO_PICKUP': {
+                // 이동 중 노드 변경 (경로 시뮬레이션)
+                v.nodeId = v.targetNodeId;
+                v.phase = 'LOADING';
+                v.phaseTimer = randInt(2, 4); // 로딩 시간
+                return this.vehicleRecord(v, '4001');
+            }
+            case 'LOADING': {
+                // 포트에서 캐리어 픽업
+                const port = this.ports.find(p => p.name === v.sourcePort);
+                if (port && port.carrierName) {
+                    v.carrierName = port.carrierName;
+                    v.carrierStatus = port.carrierStatus;
+                    v.emptyType = 'FULL';
+                    // 포트에서 캐리어 제거
+                    port.carrierName = null;
+                    port.carrierStatus = null;
+                    port.emptyType = 'EMPTY';
+                    portChanges.push(this.portRecord(port));
+                }
+                // 차량 유형별 포트 범위에서 드롭할 빈 포트 선택
+                const dropPorts = v.name.startsWith('OHT') ? OHT_PORTS : AGV_PORTS;
+                const destPort = this.ports.find(p => dropPorts.includes(p.name) && !p.carrierName && (p.status === '2002' || p.status === '2003') && p.name !== v.sourcePort);
+                v.destPort = (destPort === null || destPort === void 0 ? void 0 : destPort.name) || pick(dropPorts);
+                v.targetNodeId = PORT_NODES[v.destPort] || pick(v.name.startsWith('OHT') ? OHT_NODES : AGV_NODES);
+                v.phase = 'MOVING_TO_DROP';
+                v.phaseTimer = randInt(3, 12); // 이동 시간
+                return this.vehicleRecord(v, '4001');
+            }
+            case 'MOVING_TO_DROP': {
+                // 이동 중 노드 이동
+                v.nodeId = v.targetNodeId;
+                v.phase = 'UNLOADING';
+                v.phaseTimer = randInt(2, 4); // 언로딩 시간
+                return this.vehicleRecord(v, '4001');
+            }
+            case 'UNLOADING': {
+                // 포트에 캐리어 전달
+                const port = this.ports.find(p => p.name === v.destPort);
+                if (port && !port.carrierName && v.carrierName) {
+                    port.carrierName = v.carrierName;
+                    port.carrierStatus = v.carrierStatus;
+                    port.emptyType = 'FULL';
+                    portChanges.push(this.portRecord(port));
+                }
+                v.carrierName = null;
+                v.carrierStatus = null;
+                v.emptyType = 'EMPTY';
+                v.sourcePort = null;
+                v.destPort = null;
+                v.phase = 'IDLE';
+                v.phaseTimer = randInt(1, 5); // 대기 시간
+                // AGV 충전 (낮은 배터리)
+                if (v.batteryRate != null && v.batteryRate < 20) {
+                    v.phaseTimer = randInt(5, 15);
+                    return this.vehicleRecord(v, '4008');
+                }
+                return this.vehicleRecord(v, '4006');
+            }
+        }
+        return null;
+    }
+    // 이동 중 매 초 노드 이동 시뮬레이션
+    tickVehicleMoving(v) {
+        if (v.phase !== 'MOVING_TO_PICKUP' && v.phase !== 'MOVING_TO_DROP')
+            return null;
+        if (v.phaseTimer <= 0)
+            return null;
+        // 차량 유형별 노드 범위 내에서 순차 이동
+        const nodes = v.name.startsWith('OHT') ? OHT_NODES : AGV_NODES;
+        const currentIdx = nodes.indexOf(v.nodeId);
+        const targetIdx = nodes.indexOf(v.targetNodeId);
+        if (currentIdx >= 0 && targetIdx >= 0 && currentIdx !== targetIdx) {
+            const step = currentIdx < targetIdx ? 1 : -1;
+            v.nodeId = nodes[currentIdx + step] || v.nodeId;
+            return this.vehicleRecord(v, '4001');
+        }
+        return null;
+    }
+    vehicleRecord(v, status) {
+        return Object.assign({ NAME: v.name, STATUS: status, EMPTYTYPE: v.emptyType, NODEMACHINE: NODE_MACHINES[v.nodeId] || v.name, CARRIERNAME: v.carrierName, CARRIERSTATUS: v.carrierStatus, SUBNAME: `V${String(randInt(1, 999)).padStart(3, '0')}`, NODEID: v.nodeId }, (v.batteryRate != null ? { BATTERYRATE: v.batteryRate } : {}));
+    }
+    portRecord(p) {
+        return {
+            NAME: p.name,
+            STATUS: p.status,
+            EMPTYTYPE: p.emptyType,
+            CARRIERNAME: p.carrierName,
+            CARRIERSTATUS: p.carrierStatus,
+        };
+    }
+    /**
+     * 인접 포트 간 캐리어 이동 시뮬레이션 (컨베이어 흐름).
+     * 같은 ZONE 내 포트끼리 한 칸씩 이동 — 매 틱 30% 확률.
+     */
+    tickConveyorFlow(portChanges) {
+        var _a;
+        // ZONE별 10개 포트 그룹
+        for (let z = 0; z < 20; z++) {
+            if (Math.random() > 0.3)
+                continue;
+            const start = z * 10;
+            const zonePorts = this.ports.slice(start, start + 10);
+            // 캐리어가 있는 포트 → 인접 빈 포트로 이동
+            for (let i = 0; i < zonePorts.length; i++) {
+                const src = zonePorts[i];
+                if (!src.carrierName)
+                    continue;
+                // 인접 포트 (i-1 또는 i+1) 중 빈 것
+                const neighbors = [i - 1, i + 1].filter(j => j >= 0 && j < zonePorts.length);
+                const dest = zonePorts[(_a = neighbors.find(j => !zonePorts[j].carrierName)) !== null && _a !== void 0 ? _a : -1];
+                if (!dest)
+                    continue;
+                // 이동
+                dest.carrierName = src.carrierName;
+                dest.carrierStatus = src.carrierStatus;
+                dest.emptyType = 'FULL';
+                src.carrierName = null;
+                src.carrierStatus = null;
+                src.emptyType = 'EMPTY';
+                portChanges.push(this.portRecord(src));
+                portChanges.push(this.portRecord(dest));
+                break; // ZONE당 1회 이동
+            }
+        }
+    }
+    tickZones() {
+        const changes = [];
+        for (const z of this.zones) {
+            if (Math.random() > 0.15)
+                continue;
+            const delta = randInt(-3, 3);
+            const newCap = Math.max(0, Math.min(z.maxCapacity, z.currentCapacity + delta));
+            if (newCap === z.currentCapacity)
+                continue;
+            z.currentCapacity = newCap;
+            changes.push({
+                NAME: z.name,
+                STATUS: z.status,
+                CURRENTCAPACITY: z.currentCapacity,
+                MAXCAPACITY: z.maxCapacity,
+                HIGHWATERMARK: z.highWaterMark,
+                LOWWATERMARK: z.lowWaterMark,
+                FULLUP: z.currentCapacity >= z.maxCapacity ? 'T' : 'F',
+            });
+        }
+        return changes;
+    }
+    tickStockers() {
+        const changes = [];
+        for (const s of this.stockers) {
+            if (Math.random() > 0.4)
+                continue;
+            const delta = randInt(-5, 5);
+            const newCap = Math.max(0, Math.min(s.maxCapacity, s.currentCapacity + delta));
+            const prevStatus = s.status;
+            if (Math.random() < 0.05)
+                s.status = pick(MACHINE_STATUSES);
+            if (newCap === s.currentCapacity && s.status === prevStatus)
+                continue;
+            s.currentCapacity = newCap;
+            changes.push({
+                NAME: s.name,
+                STATUS: s.status,
+                CURRENTCAPACITY: s.currentCapacity,
+                MAXCAPACITY: s.maxCapacity,
+                HIGHWATERMARK: s.highWaterMark,
+                LOWWATERMARK: s.lowWaterMark,
+                FULLUP: s.currentCapacity >= s.maxCapacity ? 'T' : 'F',
+            });
+        }
+        return changes;
+    }
+    // ── Snapshot 생성 ──
+    getVehicleSnapshot() {
+        return this.vehicles.map(v => {
+            const status = v.phase === 'IDLE' ? '4006' // NOTASSIGNED
+                : v.phase === 'LOADING' ? '4001' // ASSIGNED
+                    : v.phase === 'UNLOADING' ? '4001' // ASSIGNED
+                        : '4001'; // ASSIGNED (moving)
+            return this.vehicleRecord(v, status);
+        });
+    }
+    getPortSnapshot() {
+        return this.ports.map(p => this.portRecord(p));
+    }
+    getZoneSnapshot() {
+        return this.zones.map(z => ({
+            NAME: z.name,
+            STATUS: z.status,
+            CURRENTCAPACITY: z.currentCapacity,
+            MAXCAPACITY: z.maxCapacity,
+            HIGHWATERMARK: z.highWaterMark,
+            LOWWATERMARK: z.lowWaterMark,
+            FULLUP: z.currentCapacity >= z.maxCapacity ? 'T' : 'F',
+        }));
+    }
+    getStockerSnapshot() {
+        return this.stockers.map(s => ({
+            NAME: s.name,
+            STATUS: s.status,
+            CURRENTCAPACITY: s.currentCapacity,
+            MAXCAPACITY: s.maxCapacity,
+            HIGHWATERMARK: s.highWaterMark,
+            LOWWATERMARK: s.lowWaterMark,
+            FULLUP: s.currentCapacity >= s.maxCapacity ? 'T' : 'F',
+        }));
+    }
+}
+/**
+ * Mock playback 데이터 생성.
+ * - `endTime` 제공: 범위 기반 (startTime → endTime 까지 1초 간격 diff)
+ * - `count` 제공: 프레임 수 기반 (snapshot 포함 총 count 개 프레임)
+ * - 둘 다 없으면 빈 배열
+ * - 둘 다 있으면 `endTime` 우선
+ */
+function generatePlaybackData(startTime, opts) {
+    const start = new Date(startTime.replace(' ', 'T'));
+    // 총 생성할 프레임 수 결정 (첫 프레임은 snapshot, 나머지는 diff)
+    let totalFrames;
+    if (opts.endTime) {
+        const end = new Date(opts.endTime.replace(' ', 'T'));
+        const totalSeconds = Math.floor((end.getTime() - start.getTime()) / 1000);
+        if (totalSeconds < 0 || totalSeconds > 7200)
+            return [];
+        totalFrames = totalSeconds + 1;
+    }
+    else if (opts.count && opts.count > 0) {
+        totalFrames = Math.min(opts.count, 7201);
+    }
+    else {
+        return [];
+    }
+    const sim = new FactorySimulator();
+    const t0 = formatTime(start);
+    const vehicleFrames = [
+        { type: 'snapshot', time: t0, data: sim.getVehicleSnapshot() }
+    ];
+    const portFrames = [
+        { type: 'snapshot', time: t0, data: sim.getPortSnapshot() }
+    ];
+    const zoneFrames = [
+        { type: 'snapshot', time: t0, data: sim.getZoneSnapshot() }
+    ];
+    const stockerFrames = [
+        { type: 'snapshot', time: t0, data: sim.getStockerSnapshot() }
+    ];
+    const equipmentFrames = [
+        { type: 'snapshot', time: t0, data: sim.equipments.map(m => ({ NAME: m.name, STATUS: m.status })) }
+    ];
+    const conveyorFrames = [
+        { type: 'snapshot', time: t0, data: sim.conveyors.map(m => ({ NAME: m.name, STATUS: m.status })) }
+    ];
+    const lineFrames = [
+        { type: 'snapshot', time: t0, data: sim.lines.map(m => ({ NAME: m.name, STATUS: m.status })) }
+    ];
+    // diff 프레임 (snapshot 외 추가 프레임이 있으면)
+    for (let s = 1; s < totalFrames; s++) {
+        const t = formatTime(new Date(start.getTime() + s * 1000));
+        // 이동 중인 차량의 노드 변경 (매 초)
+        const movingChanges = [];
+        for (const v of sim.vehicles) {
+            const mc = sim.tickVehicleMoving(v);
+            if (mc)
+                movingChanges.push(mc);
+        }
+        // 상태 전이 처리
+        const { vehicleChanges, portChanges, zoneChanges, stockerChanges, equipmentChanges, conveyorChanges, lineChanges } = sim.tick();
+        // 이동 변경 + 상태 전이 병합 (같은 vehicle은 상태 전이가 우선)
+        const vehicleChangeMap = new Map();
+        for (const c of movingChanges)
+            vehicleChangeMap.set(c.NAME, c);
+        for (const c of vehicleChanges)
+            vehicleChangeMap.set(c.NAME, c);
+        vehicleFrames.push({ type: 'diff', time: t, data: [...vehicleChangeMap.values()] });
+        portFrames.push({ type: 'diff', time: t, data: portChanges });
+        zoneFrames.push({ type: 'diff', time: t, data: zoneChanges });
+        stockerFrames.push({ type: 'diff', time: t, data: stockerChanges });
+        equipmentFrames.push({ type: 'diff', time: t, data: equipmentChanges });
+        conveyorFrames.push({ type: 'diff', time: t, data: conveyorChanges });
+        lineFrames.push({ type: 'diff', time: t, data: lineChanges });
+    }
+    return [
+        { scenarioName: 'MCS_LV_VEHICLE', snapshots: vehicleFrames },
+        { scenarioName: 'MCS_LV_PORT', snapshots: portFrames },
+        { scenarioName: 'MCS_LV_ZONE', snapshots: zoneFrames },
+        { scenarioName: 'MCS_LV_STOCKER', snapshots: stockerFrames },
+        { scenarioName: 'MCS_LV_EQUIPMENT', snapshots: equipmentFrames },
+        { scenarioName: 'MCS_LV_CONVEYOR', snapshots: conveyorFrames },
+        { scenarioName: 'MCS_LV_LINE', snapshots: lineFrames },
+    ];
+}
+// ── 엔티티 목록 (보드 작화용) ──
+exports.MOCK_ENTITIES = {
+    vehicles: { agvs: AGVS, ohts: OHTS },
+    ports: PORTS,
+    zones: ZONES,
+    stockers: STOCKERS,
+    equipments: EQUIPMENTS,
+    conveyors: CONVEYORS,
+    lines: LINES,
+};
+/** 문자열 해시 (carrierName → seed). djb2 변형. */
+function hashString(s) {
+    let h = 5381;
+    for (let i = 0; i < s.length; i++)
+        h = ((h << 5) + h + s.charCodeAt(i)) | 0;
+    return Math.abs(h) || 1;
+}
+/** Mulberry32 PRNG — 가벼운 deterministic 난수. */
+function seededRng(seed) {
+    let s = seed >>> 0;
+    return () => {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = s;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** "YYYY-MM-DDTHH:mm:ss" — 정확히 초 단위 (ms 없음, T 구분자). */
+function formatTimeSec(date) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+ * 위치 풀 — playback mock 이 사용하는 동일 식별자만 사용.
+ * 영구추적 fallback resolver 가 scene.findFirst 로 매칭하므로 보드 컴포넌트
+ * id 와 정확히 일치해야 함.
+ *
+ * 머신/유닛 매핑:
+ *   PORT (예: ZONE01_PORT01) — machine = "ZONE01", unit = "ZONE01_PORT01"
+ *     PORT 는 ZONE 의 sub-unit. fallback 은 unit 우선 lookup, miss 면 machine.
+ *   STOCKER / EQUIPMENT / CONVEYOR — machine == unit (자체가 단일 단위)
+ */
+const CARRIER_LOCATION_POOL = (() => {
+    const pool = [];
+    for (const port of PORTS) {
+        const zone = port.split('_')[0];
+        pool.push({ machine: zone, unit: port });
+    }
+    for (const m of STOCKERS)
+        pool.push({ machine: m, unit: m });
+    for (const m of EQUIPMENTS)
+        pool.push({ machine: m, unit: m });
+    for (const m of CONVEYORS)
+        pool.push({ machine: m, unit: m });
+    return pool;
+})();
+/**
+ * 단일 carrier 의 시간 구간 내 위치 이력 mock.
+ *
+ * 동작:
+ * - **매 초마다 한 record** 제공 (1시간 = 3601개, 2시간 = 7201개).
+ * - carrierName 기반 deterministic — 같은 인자엔 같은 결과 (재현성).
+ * - 위치는 playback mock 의 PORTS / STOCKERS / EQUIPMENTS / CONVEYORS 에서만 선택
+ *   → 보드 컴포넌트 id 와 항상 일치.
+ * - carrier 가 한 위치에 5–30초 머문 후 다음 위치로 전환.
+ * - 위치 전환 시 15% 확률로 NA (Not Available) 진입. NA 도 동일하게 5–30초 지속.
+ * - 시간 포맷: "YYYY-MM-DDTHH:mm:ss" — 정확히 초 단위, T 구분자.
+ *
+ * 호출자가 max 2시간 범위 (== /playback 과 동일) 안에서 사용한다고 가정.
+ */
+/**
+ * 테스트 모드 — machineName / unitName 을 각각 독립적으로 풀에서 random 선택.
+ * 풀: STK01~STK10 (총 10개 값).
+ * 정상 시뮬레이션으로 복원하려면 false 로 토글.
+ */
+const TEST_FIXED_LOCATION = true;
+/** 테스트 모드 값 풀 — STK01~STK10 (10개). */
+const TEST_VALUE_POOL = Array.from({ length: 10 }, (_, i) => `STK${String(i + 1).padStart(2, '0')}`);
+function generateCarrierLocationHistory(startTime, endTime, carrierName) {
+    const start = new Date(startTime.replace(' ', 'T'));
+    const end = new Date(endTime.replace(' ', 'T'));
+    const durationMs = end.getTime() - start.getTime();
+    if (durationMs <= 0 || durationMs > 7200000)
+        return [];
+    const startSec = Math.floor(start.getTime() / 1000) * 1000;
+    const totalSec = Math.floor(durationMs / 1000);
+    const result = [];
+    if (TEST_FIXED_LOCATION) {
+        // 테스트 모드 — machineName / unitName 을 풀에서 각각 독립적으로 random 선택,
+        // 5-30초마다 동시에 갱신. carrierName 기반 deterministic. NA 없음.
+        const rng = seededRng(hashString(carrierName));
+        const rngInt = (min, max) => Math.floor(rng() * (max - min + 1)) + min;
+        const pickValue = () => TEST_VALUE_POOL[Math.floor(rng() * TEST_VALUE_POOL.length)];
+        let machineName = pickValue();
+        let unitName = pickValue();
+        let nextChangeAt = rngInt(5, 30);
+        for (let s = 0; s <= totalSec; s++) {
+            if (s === nextChangeAt) {
+                machineName = pickValue();
+                unitName = pickValue();
+                nextChangeAt = s + rngInt(5, 30);
+            }
+            result.push({
+                time: formatTimeSec(new Date(startSec + s * 1000)),
+                machineName,
+                unitName
+            });
+        }
+        return result;
+    }
+    // ── 정상 시뮬레이션 (carrier 가 시간에 따라 여러 위치를 옮겨다님) ──
+    const rng = seededRng(hashString(carrierName));
+    const rngInt = (min, max) => Math.floor(rng() * (max - min + 1)) + min;
+    const NA_LOC = { machine: 'NA', unit: 'NA' };
+    const pickLocation = () => {
+        // 15% 확률로 NA 구간 진입, 나머지는 풀에서 random
+        if (rng() < 0.15)
+            return NA_LOC;
+        return CARRIER_LOCATION_POOL[Math.floor(rng() * CARRIER_LOCATION_POOL.length)];
+    };
+    let cur = pickLocation();
+    let nextChangeAt = rngInt(5, 30); // 다음 위치 전환 시점 (초)
+    for (let s = 0; s <= totalSec; s++) {
+        if (s === nextChangeAt) {
+            cur = pickLocation();
+            nextChangeAt = s + rngInt(5, 30);
+        }
+        result.push({
+            time: formatTimeSec(new Date(startSec + s * 1000)),
+            machineName: cur.machine,
+            unitName: cur.unit
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=mock-data.js.map