poi-plugin-gimmick-tracker 0.1.0

package/index.js

@@ -0,0 +1,1405 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let views_create_store = require("views/create-store");
+let views_env = require("views/env");
+let fs = require("fs");
+let path = require("path");
+let __blueprintjs_core = require("@blueprintjs/core");
+let react = require("react");
+react = __toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/core/guide-parser.ts
+const AIR_TEXT_TO_STATE = {
+	空确: 1,
+	空優: 2,
+	空优: 2,
+	空均: 3,
+	空劣: 4
+};
+const TOKEN_PATTERN = /([A-Za-z]\d*)\s*点\s*(到达|到達)\s*(\d+)\s*次|([A-Za-z]\d*)\s*点\s*(SS|S|A|B|C|D|E)\s*胜\s*(\d+)\s*次|([A-Za-z]\d*)\s*点\s*(空确|空優|空优|空均|空劣)\s*(\d+)\s*次|(守家|基地防空)\s*(空确|空優|空优|空均|空劣)\s*(\d+)\s*次/gi;
+function normalizeNodeLabel(value) {
+	return value.trim().toUpperCase();
+}
+function parseGuideText(text) {
+	const normalized = text.replace(/[，；]/g, (value) => value === "，" ? "," : ";");
+	const parsed = [];
+	let match;
+	TOKEN_PATTERN.lastIndex = 0;
+	while ((match = TOKEN_PATTERN.exec(normalized)) !== null) {
+		const rawText = match[0].replace(/\s+/g, "");
+		if (match[1] != null) {
+			parsed.push({
+				kind: "node-arrival",
+				nodeLabel: normalizeNodeLabel(match[1]),
+				requiredCount: Number(match[3]),
+				rawText
+			});
+			continue;
+		}
+		if (match[4] != null) {
+			parsed.push({
+				kind: "victory-rank",
+				nodeLabel: normalizeNodeLabel(match[4]),
+				requiredRank: match[5].toUpperCase(),
+				requiredCount: Number(match[6]),
+				rawText
+			});
+			continue;
+		}
+		if (match[7] != null) {
+			parsed.push({
+				kind: "node-air-state",
+				nodeLabel: normalizeNodeLabel(match[7]),
+				requiredAirState: AIR_TEXT_TO_STATE[match[8]],
+				requiredCount: Number(match[9]),
+				rawText
+			});
+			continue;
+		}
+		parsed.push({
+			kind: "base-air-defense",
+			requiredAirState: AIR_TEXT_TO_STATE[match[11]],
+			requiredCount: Number(match[12]),
+			rawText
+		});
+	}
+	return parsed.filter((item) => Number.isInteger(item.requiredCount) && item.requiredCount > 0);
+}
+
+//#endregion
+//#region src/core/conditions.ts
+const RANK_SCORE = {
+	E: 0,
+	D: 1,
+	C: 2,
+	B: 3,
+	A: 4,
+	S: 5,
+	SS: 6
+};
+const AIR_LABEL = {
+	1: "空确",
+	2: "空优",
+	3: "空均",
+	4: "空劣"
+};
+function airStateLabel(state) {
+	return AIR_LABEL[state];
+}
+function meetsRank(actual, required) {
+	return RANK_SCORE[actual] >= RANK_SCORE[required];
+}
+function meetsAirState(actual, required) {
+	return actual <= required;
+}
+function conditionSignature(map, item) {
+	return [
+		map.mapId,
+		item.kind,
+		item.nodeLabel == null ? "" : normalizeNodeLabel(item.nodeLabel),
+		item.requiredRank ?? "",
+		item.requiredAirState ?? ""
+	].join(":");
+}
+function observationMatches(condition, observation) {
+	if (condition.mapId !== observation.mapId || condition.kind !== observation.kind) return false;
+	if (condition.nodeLabel != null && normalizeNodeLabel(condition.nodeLabel) !== normalizeNodeLabel(observation.nodeLabel ?? "")) return false;
+	if (condition.kind === "victory-rank") return observation.kind === "victory-rank" && condition.requiredRank != null && meetsRank(observation.rank, condition.requiredRank);
+	if (condition.kind === "node-air-state" || condition.kind === "base-air-defense") return (observation.kind === "node-air-state" || observation.kind === "base-air-defense") && condition.requiredAirState != null && meetsAirState(observation.airState, condition.requiredAirState);
+	return observation.kind === "node-arrival";
+}
+function guideConditionLabel(condition) {
+	const node = condition.nodeLabel == null ? "" : `${condition.nodeLabel}点`;
+	switch (condition.kind) {
+		case "node-arrival": return `${node}到达 ${condition.requiredCount}次`;
+		case "victory-rank": return `${node}${condition.requiredRank}胜 ${condition.requiredCount}次`;
+		case "node-air-state": return `${node}${airStateLabel(condition.requiredAirState)} ${condition.requiredCount}次`;
+		case "base-air-defense": return `守家${airStateLabel(condition.requiredAirState)} ${condition.requiredCount}次`;
+	}
+}
+function observationLabel(observation) {
+	switch (observation.kind) {
+		case "node-arrival": return `${observation.nodeLabel}点到达`;
+		case "victory-rank": return `${observation.nodeLabel}点${observation.rank}胜`;
+		case "node-air-state": return `${observation.nodeLabel}点${airStateLabel(observation.airState)}`;
+		case "base-air-defense": return `守家${airStateLabel(observation.airState)}`;
+	}
+}
+function buildReviewCandidates(state, mapId, observationIds) {
+	const evidence = state.observations.filter((item) => observationIds.includes(item.id));
+	const guides = state.guideConditions.filter((condition) => condition.mapId === mapId && !condition.confirmed);
+	if (guides.length > 0) return guides.map((condition) => ({
+		id: `guide:${condition.id}`,
+		mode: "guide",
+		kind: condition.kind,
+		label: guideConditionLabel(condition),
+		conditionId: condition.id,
+		matchedInSortie: evidence.some((item) => observationMatches(condition, item)),
+		observedCount: condition.observedCount,
+		requiredCount: condition.requiredCount
+	})).sort((left, right) => Number(right.matchedInSortie) - Number(left.matchedInSortie));
+	return evidence.map((observation) => ({
+		id: `free:${observation.id}`,
+		mode: "free",
+		kind: observation.kind,
+		label: observationLabel(observation),
+		observationId: observation.id,
+		matchedInSortie: true
+	}));
+}
+
+//#endregion
+//#region src/core/events.ts
+const MAP_PATHS = new Set([
+	"/kcsapi/api_req_map/start",
+	"/kcsapi/api_req_map/next",
+	"/kcsapi/api_req_map/air_raid"
+]);
+const BATTLE_SUFFIXES = new Set([
+	"battle",
+	"airbattle",
+	"ld_airbattle",
+	"night_to_day",
+	"sp_midnight",
+	"midnight",
+	"midnight_battle",
+	"battle_water",
+	"each_battle",
+	"each_battle_water",
+	"ec_battle",
+	"ec_midnight_battle",
+	"ec_night_to_day"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+	if (isRecord(value)) return value;
+	if (typeof value !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function asNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+function isRelevantPath(path$1) {
+	return path$1 === "/kcsapi/api_port/port" || MAP_PATHS.has(path$1) || isBattlePath(path$1) || isBattleResultPath(path$1);
+}
+function isBattleResultPath(path$1) {
+	return path$1.startsWith("/kcsapi/") && path$1.endsWith("/battleresult");
+}
+function isBattlePath(path$1) {
+	if (!/^\/kcsapi\/api_req_(sortie|combined_battle|battle_midnight)\//.test(path$1)) return false;
+	return BATTLE_SUFFIXES.has(path$1.slice(path$1.lastIndexOf("/") + 1));
+}
+function eventKey(detail) {
+	return `${detail.path}|${detail.time}`;
+}
+function extractMapRef(detail, fallback) {
+	const mapArea = asNumber(detail.body.api_maparea_id) ?? asNumber(detail.postBody?.api_maparea_id) ?? fallback?.mapArea ?? 0;
+	const mapNo = asNumber(detail.body.api_mapinfo_no) ?? asNumber(detail.postBody?.api_mapinfo_no) ?? fallback?.mapNo ?? 0;
+	return {
+		mapArea,
+		mapNo,
+		mapId: mapArea * 10 + mapNo
+	};
+}
+function extractNodeNo(body) {
+	return asNumber(body.api_no);
+}
+function extractBattleAirState(body) {
+	const value = asNumber(asRecord(asRecord(body.api_kouku)?.api_stage1)?.api_disp_seiku);
+	return value != null && value >= 1 && value <= 4 ? value : void 0;
+}
+function extractVictoryRank(body) {
+	const value = typeof body.api_win_rank === "string" ? body.api_win_rank.toUpperCase() : "";
+	return [
+		"SS",
+		"S",
+		"A",
+		"B",
+		"C",
+		"D",
+		"E"
+	].includes(value) ? value : void 0;
+}
+function extractDestructionBattles(body) {
+	const raw = body.api_destruction_battle;
+	return (Array.isArray(raw) ? raw : raw == null ? [] : [raw]).map(asRecord).filter((item) => item != null);
+}
+function extractDefenseAirState(entry) {
+	const value = asNumber(asRecord(asRecord(entry.api_air_base_attack)?.api_stage1)?.api_disp_seiku);
+	return value != null && value >= 1 && value <= 4 ? value : void 0;
+}
+function hasPortSignal(detail) {
+	const eventObject = asRecord(detail.body.api_event_object);
+	return detail.path === "/kcsapi/api_port/port" && asNumber(eventObject?.api_m_flag2) === 1;
+}
+function hasBattleResultSignal(detail) {
+	return isBattleResultPath(detail.path) && asNumber(detail.body.api_m2) === 1;
+}
+function hasDefenseSignal(entry) {
+	return asNumber(entry.api_m2) === 1;
+}
+function extractPortMemberId(detail) {
+	if (detail.path !== "/kcsapi/api_port/port") return void 0;
+	return asRecord(detail.body.api_basic)?.api_member_id;
+}
+
+//#endregion
+//#region src/core/types.ts
+const PLUGIN_ID = "poi-plugin-gimmick-tracker";
+const SCHEMA_VERSION = 1;
+function createInitialState(now = 0) {
+	return {
+		schemaVersion: SCHEMA_VERSION,
+		observations: [],
+		guideConditions: [],
+		reviews: [],
+		freeCompletions: [],
+		processedEventKeys: [],
+		updatedAt: now
+	};
+}
+function cloneState(state) {
+	return JSON.parse(JSON.stringify(state));
+}
+function mapLabel(map) {
+	return map.mapArea > 0 && map.mapNo > 0 ? `${map.mapArea}-${map.mapNo}` : `地图 #${map.mapId}`;
+}
+
+//#endregion
+//#region src/core/state-machine.ts
+const MAX_PROCESSED_EVENT_KEYS = 2048;
+function safeNodeLabel(resolver, map, apiNo) {
+	try {
+		const value = resolver({
+			mapArea: map.mapArea,
+			mapNo: map.mapNo,
+			apiNo
+		}).trim();
+		return value === "" ? `#${apiNo}` : value;
+	} catch {
+		return `#${apiNo}`;
+	}
+}
+function createSortie(detail, map, captureComplete) {
+	return {
+		...map,
+		id: `${captureComplete ? "sortie" : "partial"}:${map.mapId}:${detail.time}`,
+		startedAt: detail.time,
+		captureComplete,
+		route: [],
+		timeline: [],
+		observationIds: []
+	};
+}
+function appendObservation(state, sortie, observation) {
+	if (state.observations.some((item) => item.id === observation.id)) return false;
+	state.observations.push(observation);
+	sortie.observationIds.push(observation.id);
+	for (const condition of state.guideConditions) if (observationMatches(condition, observation)) condition.observedCount += 1;
+	return true;
+}
+function currentNode(sortie) {
+	return sortie.route.at(-1);
+}
+function addNodeVisit(state, sortie, detail, nodeResolver) {
+	const nodeNo = extractNodeNo(detail.body);
+	if (nodeNo == null) return;
+	const id = `${eventKey(detail)}:node`;
+	if (sortie.route.some((visit$1) => visit$1.id === id)) return;
+	const nodeLabel = safeNodeLabel(nodeResolver, sortie, nodeNo);
+	const visit = {
+		id,
+		mapArea: sortie.mapArea,
+		mapNo: sortie.mapNo,
+		mapId: sortie.mapId,
+		nodeNo,
+		nodeLabel,
+		arrivedAt: detail.time,
+		sourcePath: detail.path
+	};
+	sortie.route.push(visit);
+	sortie.timeline.push({
+		id: `${id}:timeline`,
+		kind: "node",
+		occurredAt: detail.time,
+		sourcePath: detail.path,
+		nodeVisitId: id,
+		nodeNo,
+		nodeLabel
+	});
+	appendObservation(state, sortie, {
+		id: `${id}:arrival`,
+		kind: "node-arrival",
+		mapArea: sortie.mapArea,
+		mapNo: sortie.mapNo,
+		mapId: sortie.mapId,
+		nodeNo,
+		nodeLabel,
+		observedAt: detail.time,
+		sourcePath: detail.path,
+		sortieId: sortie.id
+	});
+}
+function addBattle(state, sortie, detail) {
+	const battle = {
+		timestamp: detail.time,
+		path: detail.path,
+		kind: detail.path.endsWith("/ld_airbattle") ? "fleet-air-raid" : "battle"
+	};
+	sortie.lastBattle = battle;
+	const node = currentNode(sortie);
+	if (node != null) {
+		node.battle = battle;
+		(node.battleEvents ??= []).push(battle);
+	}
+	const airState = extractBattleAirState(detail.body);
+	if (battle.kind === "fleet-air-raid") sortie.timeline.push({
+		id: `${eventKey(detail)}:fleet-air-raid`,
+		kind: "fleet-air-raid",
+		occurredAt: detail.time,
+		sourcePath: detail.path,
+		nodeVisitId: node?.id,
+		nodeNo: node?.nodeNo,
+		nodeLabel: node?.nodeLabel,
+		airState
+	});
+	if (node == null || airState == null) return;
+	node.airState = airState;
+	appendObservation(state, sortie, {
+		id: `${eventKey(detail)}:node-air`,
+		kind: "node-air-state",
+		mapArea: sortie.mapArea,
+		mapNo: sortie.mapNo,
+		mapId: sortie.mapId,
+		nodeNo: node.nodeNo,
+		nodeLabel: node.nodeLabel,
+		airState,
+		observedAt: detail.time,
+		sourcePath: detail.path,
+		sortieId: sortie.id,
+		battle
+	});
+}
+function addBattleResult(state, sortie, detail) {
+	const rank = extractVictoryRank(detail.body);
+	const node = currentNode(sortie);
+	if (rank == null || node == null) return;
+	node.rank = rank;
+	appendObservation(state, sortie, {
+		id: `${eventKey(detail)}:victory`,
+		kind: "victory-rank",
+		mapArea: sortie.mapArea,
+		mapNo: sortie.mapNo,
+		mapId: sortie.mapId,
+		nodeNo: node.nodeNo,
+		nodeLabel: node.nodeLabel,
+		rank,
+		observedAt: detail.time,
+		sourcePath: detail.path,
+		sortieId: sortie.id,
+		battle: sortie.lastBattle
+	});
+}
+function addDefenseBattles(state, sortie, detail) {
+	const entries = extractDestructionBattles(detail.body);
+	let signal = false;
+	entries.forEach((entry, index) => {
+		signal ||= hasDefenseSignal(entry);
+		const airState = extractDefenseAirState(entry);
+		const node = currentNode(sortie);
+		sortie.timeline.push({
+			id: `${eventKey(detail)}:defense:${index}:timeline`,
+			kind: "base-air-defense",
+			occurredAt: detail.time,
+			sourcePath: detail.path,
+			nodeVisitId: node?.id,
+			nodeNo: node?.nodeNo,
+			nodeLabel: node?.nodeLabel,
+			airState
+		});
+		if (node != null) (node.baseDefenseEvents ??= []).push({
+			timestamp: detail.time,
+			path: detail.path,
+			airState
+		});
+		if (airState == null) return;
+		appendObservation(state, sortie, {
+			id: `${eventKey(detail)}:defense:${index}`,
+			kind: "base-air-defense",
+			mapArea: sortie.mapArea,
+			mapNo: sortie.mapNo,
+			mapId: sortie.mapId,
+			airState,
+			observedAt: detail.time,
+			sourcePath: detail.path,
+			sortieId: sortie.id,
+			battle: {
+				timestamp: detail.time,
+				path: detail.path,
+				kind: "base-air-defense"
+			}
+		});
+	});
+	return { signal };
+}
+function reviewFromSortie(state, sortie, source, detectedAt, sealed) {
+	return {
+		id: `review:${sortie.id}`,
+		sortieId: sortie.id,
+		startedAt: sortie.startedAt,
+		mapArea: sortie.mapArea,
+		mapNo: sortie.mapNo,
+		mapId: sortie.mapId,
+		detectedAt,
+		triggerSources: [source],
+		sealed,
+		routeComplete: sortie.captureComplete,
+		route: cloneState({
+			schemaVersion: 1,
+			observations: [],
+			guideConditions: [],
+			reviews: [],
+			freeCompletions: [],
+			processedEventKeys: [],
+			updatedAt: 0,
+			activeSortie: sortie
+		}).activeSortie.route,
+		timeline: JSON.parse(JSON.stringify(sortie.timeline)),
+		observationIds: [...sortie.observationIds],
+		candidates: buildReviewCandidates(state, sortie.mapId, sortie.observationIds),
+		status: "pending"
+	};
+}
+function orphanReview(state, source, detectedAt) {
+	const sortieId = `orphan:${detectedAt}`;
+	return {
+		id: `review:${sortieId}`,
+		sortieId,
+		startedAt: detectedAt,
+		mapArea: 0,
+		mapNo: 0,
+		mapId: 0,
+		detectedAt,
+		triggerSources: [source],
+		sealed: source === "port",
+		routeComplete: false,
+		route: [],
+		timeline: [],
+		observationIds: [],
+		candidates: buildReviewCandidates(state, 0, []),
+		status: "pending"
+	};
+}
+function triggerReview(state, sortie, source, detectedAt, sealed) {
+	if (sortie == null && source === "port") {
+		const recentOrphan = [...state.reviews].reverse().find((item) => item.status === "pending" && item.sortieId.startsWith("orphan:") && !item.sealed && item.triggerSources.includes("battleresult") && !item.triggerSources.includes("port") && detectedAt - item.detectedAt <= 600 * 1e3);
+		if (recentOrphan != null) {
+			if (!recentOrphan.triggerSources.includes(source)) recentOrphan.triggerSources.push(source);
+			recentOrphan.sealed ||= sealed || source === "port";
+			return false;
+		}
+	}
+	const candidate = sortie == null ? orphanReview(state, source, detectedAt) : reviewFromSortie(state, sortie, source, detectedAt, sealed);
+	const existing = state.reviews.find((item) => item.id === candidate.id);
+	if (existing == null) {
+		state.reviews.push(candidate);
+		return true;
+	}
+	if (!existing.triggerSources.includes(source)) existing.triggerSources.push(source);
+	existing.sealed ||= sealed;
+	if (sortie != null) {
+		existing.routeComplete = sortie.captureComplete;
+		existing.route = candidate.route;
+		existing.timeline = candidate.timeline;
+		existing.observationIds = candidate.observationIds;
+		if (existing.status === "pending") existing.candidates = candidate.candidates;
+	}
+	return false;
+}
+function syncReviewForActiveSortie(state, sealed = false) {
+	const sortie = state.activeSortie;
+	if (sortie == null) return;
+	const review = state.reviews.find((item) => item.sortieId === sortie.id);
+	if (review == null) return;
+	review.sealed ||= sealed;
+	review.routeComplete = sortie.captureComplete;
+	review.route = JSON.parse(JSON.stringify(sortie.route));
+	review.timeline = JSON.parse(JSON.stringify(sortie.timeline));
+	review.observationIds = [...sortie.observationIds];
+	if (review.status === "pending") review.candidates = buildReviewCandidates(state, sortie.mapId, sortie.observationIds);
+}
+function handleMapEvent(state, detail, nodeResolver) {
+	if (detail.path === "/kcsapi/api_req_map/start") state.activeSortie = createSortie(detail, extractMapRef(detail), true);
+	else if (state.activeSortie == null) state.activeSortie = createSortie(detail, extractMapRef(detail), false);
+	else {
+		const map = extractMapRef(detail, state.activeSortie);
+		Object.assign(state.activeSortie, map);
+	}
+	const sortie = state.activeSortie;
+	if (detail.path !== "/kcsapi/api_req_map/air_raid") addNodeVisit(state, sortie, detail, nodeResolver);
+	const defense = addDefenseBattles(state, sortie, detail);
+	let shouldFocus = false;
+	if (defense.signal) shouldFocus = triggerReview(state, sortie, "air-defense", detail.time, false);
+	syncReviewForActiveSortie(state);
+	return shouldFocus;
+}
+function applyGameResponse(previous, detail, nodeResolver) {
+	if (!isRelevantPath(detail.path)) return {
+		state: previous,
+		changed: false,
+		shouldFocus: false
+	};
+	const key = eventKey(detail);
+	if (previous.processedEventKeys.includes(key)) return {
+		state: previous,
+		changed: false,
+		shouldFocus: false
+	};
+	const state = cloneState(previous);
+	state.processedEventKeys.push(key);
+	if (state.processedEventKeys.length > MAX_PROCESSED_EVENT_KEYS) state.processedEventKeys.splice(0, state.processedEventKeys.length - MAX_PROCESSED_EVENT_KEYS);
+	let shouldFocus = false;
+	if (MAP_PATHS.has(detail.path)) shouldFocus = handleMapEvent(state, detail, nodeResolver);
+	else if (isBattleResultPath(detail.path)) {
+		if (state.activeSortie != null) addBattleResult(state, state.activeSortie, detail);
+		if (hasBattleResultSignal(detail)) shouldFocus = triggerReview(state, state.activeSortie, "battleresult", detail.time, false);
+		syncReviewForActiveSortie(state);
+	} else if (isBattlePath(detail.path)) {
+		if (state.activeSortie != null) {
+			addBattle(state, state.activeSortie, detail);
+			syncReviewForActiveSortie(state);
+		}
+	} else if (detail.path === "/kcsapi/api_port/port") {
+		if (hasPortSignal(detail)) shouldFocus = triggerReview(state, state.activeSortie, "port", detail.time, true);
+		syncReviewForActiveSortie(state, true);
+		state.activeSortie = void 0;
+	}
+	state.updatedAt = detail.time;
+	return {
+		state,
+		changed: true,
+		shouldFocus
+	};
+}
+function refreshPendingCandidates(state) {
+	for (const review of state.reviews) {
+		if (review.status !== "pending") continue;
+		review.candidates = buildReviewCandidates(state, review.mapId, review.observationIds);
+	}
+}
+function importGuideConditions(previous, text, map, now) {
+	const parsed = parseGuideText(text);
+	if (parsed.length === 0) return {
+		state: previous,
+		importedCount: 0
+	};
+	const state = cloneState(previous);
+	const unique = /* @__PURE__ */ new Map();
+	for (const item of parsed) unique.set(conditionSignature(map, item), item);
+	for (const [signature, item] of unique) {
+		const id = `guide:${signature}`;
+		const existing = state.guideConditions.find((condition$1) => condition$1.id === id);
+		if (existing != null) {
+			existing.rawText = item.rawText;
+			existing.requiredCount = item.requiredCount;
+			existing.observedCount = state.observations.filter((observation) => observationMatches(existing, observation)).length;
+			continue;
+		}
+		const condition = {
+			...map,
+			id,
+			kind: item.kind,
+			rawText: item.rawText,
+			nodeLabel: item.nodeLabel,
+			requiredRank: item.requiredRank,
+			requiredAirState: item.requiredAirState,
+			requiredCount: item.requiredCount,
+			observedCount: 0,
+			confirmed: false,
+			createdAt: now
+		};
+		condition.observedCount = state.observations.filter((observation) => observationMatches(condition, observation)).length;
+		state.guideConditions.push(condition);
+	}
+	refreshPendingCandidates(state);
+	state.updatedAt = now;
+	return {
+		state,
+		importedCount: unique.size
+	};
+}
+function confirmReview(previous, reviewId, candidateIds, now) {
+	if (candidateIds.length === 0) return previous;
+	const state = cloneState(previous);
+	const review = state.reviews.find((item) => item.id === reviewId);
+	if (review == null || review.status !== "pending") return previous;
+	const selected = review.candidates.filter((candidate) => candidateIds.includes(candidate.id));
+	if (selected.length === 0) return previous;
+	const mapHasGuide = state.guideConditions.some((condition) => condition.mapId === review.mapId);
+	for (const candidate of selected) {
+		if (candidate.mode === "guide" && candidate.conditionId != null) {
+			const condition = state.guideConditions.find((item) => item.id === candidate.conditionId);
+			if (condition != null && !condition.confirmed) {
+				condition.confirmed = true;
+				condition.confirmedAt = now;
+				condition.confirmedByReviewId = review.id;
+			}
+			continue;
+		}
+		if (mapHasGuide || candidate.observationId == null) continue;
+		if (state.observations.find((item) => item.id === candidate.observationId) == null) continue;
+		const completion = {
+			mapArea: review.mapArea,
+			mapNo: review.mapNo,
+			mapId: review.mapId,
+			id: `free-completion:${review.id}:${candidate.observationId}`,
+			kind: candidate.kind,
+			label: candidate.label,
+			reviewId: review.id,
+			observationId: candidate.observationId,
+			confirmedAt: now
+		};
+		if (!state.freeCompletions.some((item) => item.id === completion.id)) state.freeCompletions.push(completion);
+	}
+	review.status = "confirmed";
+	review.selectedCandidateIds = selected.map((candidate) => candidate.id);
+	review.resolvedAt = now;
+	refreshPendingCandidates(state);
+	state.updatedAt = now;
+	return state;
+}
+function ignoreReview(previous, reviewId, now) {
+	const state = cloneState(previous);
+	const review = state.reviews.find((item) => item.id === reviewId);
+	if (review == null || review.status !== "pending") return previous;
+	review.status = "ignored";
+	review.resolvedAt = now;
+	state.updatedAt = now;
+	return state;
+}
+
+//#endregion
+//#region src/storage/index.ts
+function normalizeMemberId(value) {
+	if (value == null) return void 0;
+	const normalized = typeof value === "number" ? String(value) : typeof value === "string" ? value : "";
+	return /^\d+$/.test(normalized) ? normalized : void 0;
+}
+function hydrateState(value) {
+	if (typeof value !== "object" || value == null) return createInitialState();
+	const raw = value;
+	if (raw.schemaVersion !== SCHEMA_VERSION) return createInitialState();
+	const reviews = Array.isArray(raw.reviews) ? raw.reviews.map((review) => ({
+		...review,
+		startedAt: typeof review.startedAt === "number" ? review.startedAt : review.route?.[0]?.arrivedAt ?? review.detectedAt,
+		timeline: Array.isArray(review.timeline) ? review.timeline : []
+	})) : [];
+	const activeSortie = raw.activeSortie != null ? {
+		...raw.activeSortie,
+		timeline: Array.isArray(raw.activeSortie.timeline) ? raw.activeSortie.timeline : []
+	} : void 0;
+	return {
+		...createInitialState(typeof raw.updatedAt === "number" ? raw.updatedAt : 0),
+		...raw,
+		schemaVersion: SCHEMA_VERSION,
+		observations: Array.isArray(raw.observations) ? raw.observations : [],
+		guideConditions: Array.isArray(raw.guideConditions) ? raw.guideConditions : [],
+		reviews,
+		freeCompletions: Array.isArray(raw.freeCompletions) ? raw.freeCompletions : [],
+		processedEventKeys: Array.isArray(raw.processedEventKeys) ? raw.processedEventKeys : [],
+		activeSortie
+	};
+}
+var FileTrackerStorage = class {
+	constructor(appDataPath) {
+		this.appDataPath = appDataPath;
+	}
+	statePath(memberId) {
+		const safe = normalizeMemberId(memberId);
+		if (safe == null) throw new Error("Invalid memberId");
+		return (0, path.join)(this.appDataPath, "gimmick-tracker", safe, "state-v1.json");
+	}
+	load(memberId) {
+		const path$1 = this.statePath(memberId);
+		if (!(0, fs.existsSync)(path$1)) return createInitialState();
+		try {
+			return hydrateState(JSON.parse((0, fs.readFileSync)(path$1, "utf8")));
+		} catch {
+			return createInitialState();
+		}
+	}
+	save(memberId, state) {
+		const path$1 = this.statePath(memberId);
+		(0, fs.mkdirSync)((0, path.join)(path$1, ".."), { recursive: true });
+		const temporary = `${path$1}.${process.pid}.${Date.now()}.tmp`;
+		try {
+			(0, fs.writeFileSync)(temporary, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+			(0, fs.renameSync)(temporary, path$1);
+		} catch (error) {
+			try {
+				if ((0, fs.existsSync)(temporary)) (0, fs.unlinkSync)(temporary);
+			} catch {}
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/controller.ts
+function parseEvent(event) {
+	if (typeof event !== "object" || event == null) return void 0;
+	const detail = event.detail;
+	if (typeof detail !== "object" || detail == null) return void 0;
+	const value = detail;
+	if (typeof value.path !== "string" || typeof value.time !== "number") return void 0;
+	return {
+		method: typeof value.method === "string" ? value.method : void 0,
+		path: value.path,
+		body: asRecord(value.body) ?? {},
+		postBody: asRecord(value.postBody),
+		time: value.time
+	};
+}
+function mergeById(stored, transient) {
+	const merged = new Map(stored.map((item) => [item.id, item]));
+	for (const item of transient) merged.set(item.id, item);
+	return [...merged.values()];
+}
+var TrackerController = class {
+	state = createInitialState();
+	subscribers = /* @__PURE__ */ new Set();
+	eventTarget;
+	memberId;
+	started = false;
+	handleResponse = (event) => {
+		const detail = parseEvent(event);
+		if (detail == null) return;
+		try {
+			const preferred = this.readPreferredMemberId();
+			const portMember = normalizeMemberId(extractPortMemberId(detail));
+			this.switchMember(portMember ?? preferred);
+			const result = applyGameResponse(this.state, detail, this.dependencies.nodeResolver);
+			if (!result.changed) return;
+			this.state = result.state;
+			this.persist();
+			this.emit();
+			if (result.shouldFocus) try {
+				this.dependencies.focus.focusPlugin(this.dependencies.pluginId);
+			} catch (error) {
+				this.report(error);
+			}
+		} catch (error) {
+			this.report(error);
+		}
+	};
+	constructor(dependencies) {
+		this.dependencies = dependencies;
+	}
+	start(target) {
+		if (this.started) return;
+		this.started = true;
+		this.eventTarget = target;
+		this.switchMember(this.readPreferredMemberId());
+		target.addEventListener("game.response", this.handleResponse);
+		this.emit();
+	}
+	stop() {
+		if (!this.started) return;
+		this.eventTarget?.removeEventListener("game.response", this.handleResponse);
+		this.eventTarget = void 0;
+		this.started = false;
+	}
+	getSnapshot = () => this.state;
+	subscribe = (subscriber) => {
+		this.subscribers.add(subscriber);
+		return () => this.subscribers.delete(subscriber);
+	};
+	currentMap() {
+		if (this.state.activeSortie != null && this.state.activeSortie.mapId > 0) return {
+			mapArea: this.state.activeSortie.mapArea,
+			mapNo: this.state.activeSortie.mapNo,
+			mapId: this.state.activeSortie.mapId
+		};
+		const review = [...this.state.reviews].reverse().find((item) => item.mapId > 0);
+		if (review != null) return {
+			mapArea: review.mapArea,
+			mapNo: review.mapNo,
+			mapId: review.mapId
+		};
+		const observation = this.state.observations.at(-1);
+		return observation == null ? void 0 : {
+			mapArea: observation.mapArea,
+			mapNo: observation.mapNo,
+			mapId: observation.mapId
+		};
+	}
+	importGuide(text, map = this.currentMap()) {
+		if (map == null) return 0;
+		const result = importGuideConditions(this.state, text, map, this.now());
+		if (result.state === this.state) return result.importedCount;
+		this.state = result.state;
+		this.persist();
+		this.emit();
+		return result.importedCount;
+	}
+	confirm(reviewId, candidateIds) {
+		const next = confirmReview(this.state, reviewId, candidateIds, this.now());
+		if (next === this.state) return;
+		this.state = next;
+		this.persist();
+		this.emit();
+	}
+	ignore(reviewId) {
+		const next = ignoreReview(this.state, reviewId, this.now());
+		if (next === this.state) return;
+		this.state = next;
+		this.persist();
+		this.emit();
+	}
+	now() {
+		return this.dependencies.now?.() ?? Date.now();
+	}
+	readPreferredMemberId() {
+		try {
+			return normalizeMemberId(this.dependencies.getMemberId?.());
+		} catch (error) {
+			this.report(error);
+			return;
+		}
+	}
+	switchMember(next) {
+		if (next == null || next === this.memberId) return;
+		if (this.memberId != null) this.persist();
+		const transient = this.memberId == null ? this.state : void 0;
+		this.memberId = next;
+		try {
+			const stored = this.dependencies.storage.load(next);
+			if (transient == null || transient.updatedAt === 0 && transient.activeSortie == null) {
+				this.state = stored;
+				return;
+			}
+			this.state = {
+				...stored,
+				activeSortie: transient.activeSortie ?? stored.activeSortie,
+				observations: mergeById(stored.observations, transient.observations),
+				guideConditions: mergeById(stored.guideConditions, transient.guideConditions),
+				reviews: mergeById(stored.reviews, transient.reviews),
+				freeCompletions: mergeById(stored.freeCompletions, transient.freeCompletions),
+				processedEventKeys: [...new Set([...stored.processedEventKeys, ...transient.processedEventKeys])].slice(-2048),
+				updatedAt: Math.max(stored.updatedAt, transient.updatedAt)
+			};
+		} catch (error) {
+			this.state = transient ?? createInitialState();
+			this.report(error);
+		}
+	}
+	persist() {
+		if (this.memberId == null) return;
+		try {
+			this.dependencies.storage.save(this.memberId, this.state);
+		} catch (error) {
+			this.report(error);
+		}
+	}
+	emit() {
+		for (const subscriber of this.subscribers) subscriber();
+	}
+	report(error) {
+		this.dependencies.onError?.(error);
+	}
+};
+
+//#endregion
+//#region src/host/focus.ts
+function tryIpc(ipc$1, id) {
+	try {
+		const focus = ipc$1?.access("MainWindow")?.ipcFocusPlugin;
+		if (typeof focus !== "function") return false;
+		focus(id);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function createFocusAdapter(dependencies) {
+	return { focusPlugin(id) {
+		if (tryIpc(dependencies.primaryIpc, id)) return "ipc";
+		if (tryIpc(dependencies.legacyIpc, id)) return "legacy-ipc";
+		try {
+			if (typeof dependencies.dispatch === "function") {
+				const tabInfo = Boolean(dependencies.getStore?.("config.poi.tabarea.double")) ? { activePluginName: id } : {
+					activeMainTab: id,
+					activePluginName: id
+				};
+				dependencies.dispatch({
+					type: "@@TabSwitch",
+					payload: {
+						tabInfo,
+						autoSwitch: false
+					}
+				});
+				return "dispatch";
+			}
+		} catch {}
+		try {
+			if (typeof dependencies.success === "function") {
+				dependencies.success("检测到机关变化，请打开机关条件追踪器确认。");
+				return "notice";
+			}
+		} catch {}
+		return "none";
+	} };
+}
+
+//#endregion
+//#region src/host/node-resolver.ts
+function createFcdNodeResolver(getStore$1) {
+	return ({ mapArea, mapNo, apiNo }) => {
+		const fallback = `#${apiNo}`;
+		try {
+			const fcdMap = getStore$1("fcd.map");
+			if (typeof fcdMap !== "object" || fcdMap == null) return fallback;
+			const map = fcdMap[`${mapArea}-${mapNo}`];
+			if (typeof map !== "object" || map == null) return fallback;
+			const route$1 = map.route;
+			if (typeof route$1 !== "object" || route$1 == null) return fallback;
+			const edge = route$1[String(apiNo)];
+			if (!Array.isArray(edge) || typeof edge[1] !== "string" || edge[1].trim() === "") return fallback;
+			return edge[1];
+		} catch {
+			return fallback;
+		}
+	};
+}
+
+//#endregion
+//#region i18n/zh-CN.json
+var zh_CN_default = {
+	机关条件追踪器: "机关条件追踪器",
+	记录出击路线并在机关触发后请用户确认完成条件: "记录出击路线并在机关触发后请用户确认完成条件",
+	title: "机关条件追踪器",
+	subtitle: "平时安静记录；检测到机关变化后才请你确认。数据只保存在本机。",
+	activeMap: "当前海域",
+	pendingReviews: "待确认触发",
+	pending: "待确认",
+	noPending: "暂无待确认触发。普通出击不会自动切换到本页。",
+	unknownMap: "未知海域",
+	route: "本次路线",
+	incompleteRoute: "未捕获到完整出击：插件可能在出击中途加载，或仅收到了回港信号。",
+	emptyRoute: "没有可显示的节点路线。",
+	candidates: "这次完成了哪一项？",
+	chooseCandidate: "请选择本次完成条件（● 表示本次有直接证据）",
+	noCandidates: "没有足够事实生成候选；可忽略本次，或先导入攻略条件后再观察下一次出击。",
+	matchedThisSortie: "本次有证据",
+	confirm: "确认完成",
+	ignore: "忽略本次",
+	ignored: "已忽略",
+	guide: "导入攻略条件",
+	guidePlaceholder: "例如：D点S胜2次；C2点到达2次 A2点空优1次，守家空优2次",
+	"import": "导入到当前海域",
+	importNeedMap: "尚未识别当前海域，请先捕获一次地图出击。",
+	importSuccess: "已识别 {count} 条条件。",
+	noMatch: "未识别到受支持的条件格式。",
+	completed: "按海域的上次触发与完成清单",
+	lastTriggeredSortie: "上一次触发出击",
+	triggerHistory: "每次机关触发出击",
+	noCompleted: "尚未导入攻略条件，也没有自由完成记录。",
+	observed: "观测",
+	confirmed: "已确认",
+	unconfirmed: "未确认",
+	freeRecord: "无攻略时的自由记录"
+};
+
+//#endregion
+//#region src/ui/index.tsx
+const styles = {
+	root: {
+		padding: 16,
+		height: "100%",
+		overflow: "auto",
+		boxSizing: "border-box"
+	},
+	header: {
+		display: "flex",
+		justifyContent: "space-between",
+		gap: 16,
+		alignItems: "center"
+	},
+	section: { marginTop: 16 },
+	review: { marginTop: 12 },
+	reviewGrid: {
+		display: "grid",
+		gridTemplateColumns: "minmax(260px, 1.2fr) minmax(280px, .8fr)",
+		gap: 18
+	},
+	route: {
+		display: "flex",
+		flexWrap: "wrap",
+		gap: 6,
+		marginTop: 8
+	},
+	historyRow: {
+		display: "grid",
+		gridTemplateColumns: "minmax(280px, 1fr) auto",
+		gap: 16,
+		padding: "10px 0",
+		borderBottom: "1px solid rgba(128,128,128,.18)"
+	},
+	candidate: {
+		padding: "6px 0",
+		borderBottom: "1px solid rgba(128,128,128,.18)"
+	},
+	actions: {
+		display: "flex",
+		gap: 8,
+		marginTop: 12
+	},
+	guideRow: {
+		display: "grid",
+		gridTemplateColumns: "1fr auto auto",
+		gap: 12,
+		alignItems: "center"
+	},
+	muted: { color: "#738091" }
+};
+const t = (key) => zh_CN_default[key];
+function routeBadge(review, index) {
+	const visit = review.route[index];
+	const details = [visit.rank == null ? void 0 : `${visit.rank}胜`];
+	if (visit.airState != null) details.push(airStateLabel(visit.airState));
+	if (visit.battleEvents?.some((event) => event.kind === "fleet-air-raid")) details.push("舰队空袭");
+	for (const defense of visit.baseDefenseEvents ?? []) details.push(`基地防空${defense.airState == null ? "" : ` · ${airStateLabel(defense.airState)}`}`);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__blueprintjs_core.Tag, {
+		minimal: index !== review.route.length - 1,
+		title: new Date(visit.arrivedAt).toLocaleString(),
+		children: [visit.nodeLabel, details.filter(Boolean).length > 0 ? ` · ${details.filter(Boolean).join(" · ")}` : ""]
+	}, visit.id);
+}
+function formatSortieTime(review) {
+	const startedAt = review.startedAt ?? review.route[0]?.arrivedAt ?? review.detectedAt;
+	return `${new Date(startedAt).toLocaleString()} ～ ${new Date(review.detectedAt).toLocaleString()}`;
+}
+function timelineBadge(review, event) {
+	if (event.kind === "node") {
+		const index = review.route.findIndex((visit) => visit.id === event.nodeVisitId);
+		if (index >= 0) return routeBadge(review, index);
+	}
+	const label = event.kind === "fleet-air-raid" ? "舰队空袭" : "基地防空";
+	const parts = [event.nodeLabel == null ? void 0 : `${event.nodeLabel}点`, label];
+	if (event.airState != null) parts.push(airStateLabel(event.airState));
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Tag, {
+		intent: event.kind === "base-air-defense" ? "warning" : "primary",
+		title: new Date(event.occurredAt).toLocaleString(),
+		children: parts.filter(Boolean).join(" · ")
+	}, event.id);
+}
+function sortieTimeline(review) {
+	const timeline = review.timeline ?? [];
+	if (timeline.length > 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		style: styles.route,
+		children: timeline.map((event) => timelineBadge(review, event))
+	});
+	if (review.route.length > 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		style: styles.route,
+		children: review.route.map((_, index) => routeBadge(review, index))
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+		style: styles.muted,
+		children: t("emptyRoute")
+	});
+}
+function PendingCard({ review, selected, setSelected, controller: controller$1 }) {
+	const selectedCandidate = review.candidates.find((candidate) => candidate.id === selected);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__blueprintjs_core.Card, {
+		style: styles.review,
+		elevation: __blueprintjs_core.Elevation.ONE,
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			style: styles.header,
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: review.mapId > 0 ? mapLabel(review) : t("unknownMap") }),
+				" ",
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Tag, {
+					intent: "warning",
+					children: t("pending")
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					style: styles.muted,
+					children: formatSortieTime(review)
+				})
+			] }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: styles.route,
+				children: review.triggerSources.map((source) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Tag, {
+					minimal: true,
+					children: source
+				}, source))
+			})]
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			style: styles.reviewGrid,
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h4", { children: t("route") }),
+				!review.routeComplete && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Callout, {
+					intent: "warning",
+					children: t("incompleteRoute")
+				}),
+				sortieTimeline(review)
+			] }), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h4", { children: t("candidates") }),
+				review.candidates.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Callout, { children: t("noCandidates") }) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__blueprintjs_core.HTMLSelect, {
+					fill: true,
+					value: selected,
+					onChange: (event) => setSelected(event.currentTarget.value),
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+						value: "",
+						children: t("chooseCandidate")
+					}), review.candidates.map((candidate) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("option", {
+						value: candidate.id,
+						children: [
+							candidate.matchedInSortie ? "● " : "",
+							candidate.label,
+							candidate.observedCount == null ? "" : ` · ${t("observed")} ${candidate.observedCount}/${candidate.requiredCount}`
+						]
+					}, candidate.id))]
+				}), selectedCandidate?.matchedInSortie && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Callout, {
+					style: { marginTop: 8 },
+					intent: "success",
+					children: t("matchedThisSortie")
+				})] }),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: styles.actions,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Button, {
+						intent: "primary",
+						disabled: selected === "",
+						onClick: () => controller$1.confirm(review.id, [selected]),
+						children: t("confirm")
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Button, {
+						onClick: () => controller$1.ignore(review.id),
+						children: t("ignore")
+					})]
+				})
+			] })]
+		})]
+	});
+}
+function createTrackerView(controller$1) {
+	return function GimmickTrackerView() {
+		const state = (0, react.useSyncExternalStore)(controller$1.subscribe, controller$1.getSnapshot, controller$1.getSnapshot);
+		const [guideText, setGuideText] = (0, react.useState)("");
+		const [message, setMessage] = (0, react.useState)("");
+		const [selected, setSelected] = (0, react.useState)({});
+		const pending$1 = state.reviews.filter((review) => review.status === "pending");
+		const currentMap = controller$1.currentMap();
+		const mapIds = (0, react.useMemo)(() => [...new Set([
+			...state.guideConditions.map((item) => item.mapId),
+			...state.freeCompletions.map((item) => item.mapId),
+			...state.reviews.filter((item) => item.mapId > 0).map((item) => item.mapId)
+		])].sort((left, right) => left - right), [
+			state.guideConditions,
+			state.freeCompletions,
+			state.reviews
+		]);
+		const importGuide = () => {
+			if (currentMap == null) {
+				setMessage(t("importNeedMap"));
+				return;
+			}
+			const count = controller$1.importGuide(guideText, currentMap);
+			setMessage(count > 0 ? t("importSuccess").replace("{count}", String(count)) : t("noMatch"));
+		};
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("main", {
+			style: styles.root,
+			children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("header", {
+					style: styles.header,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+						style: { margin: 0 },
+						children: t("title")
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: {
+							...styles.muted,
+							marginBottom: 0
+						},
+						children: t("subtitle")
+					})] }), currentMap != null && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__blueprintjs_core.Tag, {
+						large: true,
+						children: [
+							t("activeMap"),
+							": ",
+							mapLabel(currentMap)
+						]
+					})]
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+					style: styles.section,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: t("pendingReviews") }), pending$1.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Callout, { children: t("noPending") }) : pending$1.map((review) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PendingCard, {
+						review,
+						controller: controller$1,
+						selected: selected[review.id] ?? "",
+						setSelected: (id) => setSelected((value) => ({
+							...value,
+							[review.id]: id
+						}))
+					}, review.id))]
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+					style: styles.section,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: t("guide") }),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.TextArea, {
+							fill: true,
+							rows: 4,
+							value: guideText,
+							placeholder: t("guidePlaceholder"),
+							onChange: (event) => setGuideText(event.currentTarget.value)
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: styles.actions,
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Button, {
+								intent: "primary",
+								onClick: importGuide,
+								children: t("import")
+							}), message !== "" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: styles.muted,
+								children: message
+							})]
+						})
+					]
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+					style: styles.section,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h3", { children: t("completed") }), mapIds.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Callout, { children: t("noCompleted") }) : mapIds.map((mapId) => {
+						const guides = state.guideConditions.filter((item) => item.mapId === mapId);
+						const free = state.freeCompletions.filter((item) => item.mapId === mapId);
+						const reviews = state.reviews.filter((item) => item.mapId === mapId);
+						const lastReview = reviews.at(-1);
+						const map = guides[0] ?? free[0] ?? lastReview;
+						return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(__blueprintjs_core.Card, {
+							style: styles.review,
+							elevation: __blueprintjs_core.Elevation.ZERO,
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h4", { children: map == null ? `#${mapId}` : mapLabel(map) }),
+								reviews.length > 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									style: { marginBottom: 16 },
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: t("triggerHistory") }), [...reviews].reverse().map((review) => {
+										const selectedLabels = review.candidates.filter((candidate) => review.selectedCandidateIds?.includes(candidate.id)).map((candidate) => candidate.label);
+										return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+											style: styles.historyRow,
+											children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: sortieTimeline(review) }), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+												style: { textAlign: "right" },
+												children: [
+													/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+														style: styles.muted,
+														children: formatSortieTime(review)
+													}),
+													/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Tag, {
+														intent: review.status === "confirmed" ? "success" : review.status === "pending" ? "warning" : "none",
+														children: review.status === "confirmed" ? t("confirmed") : review.status === "pending" ? t("pending") : t("ignored")
+													}),
+													selectedLabels.length > 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: selectedLabels.join("、") })
+												]
+											})]
+										}, review.id);
+									})]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.HTMLTable, {
+									compact: true,
+									striped: true,
+									style: { width: "100%" },
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("tbody", { children: [guides.map((condition) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("tr", { children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", { children: guideConditionLabel(condition) }),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("td", { children: [
+											t("observed"),
+											" ",
+											condition.observedCount,
+											"/",
+											condition.requiredCount
+										] }),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Tag, {
+											intent: condition.confirmed ? "success" : "none",
+											children: condition.confirmed ? t("confirmed") : t("unconfirmed")
+										}) })
+									] }, condition.id)), free.map((completion) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("tr", { children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", { children: completion.label }),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", { children: t("freeRecord") }),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__blueprintjs_core.Tag, {
+											intent: "success",
+											children: t("confirmed")
+										}) })
+									] }, completion.id))] })
+								})
+							]
+						}, mapId);
+					})]
+				})
+			]
+		});
+	};
+}
+
+//#endregion
+//#region index-src.ts
+const controller = new TrackerController({
+	storage: new FileTrackerStorage(window.APPDATA_PATH ?? views_env.APPDATA_PATH),
+	focus: createFocusAdapter({
+		primaryIpc: views_env.ipc,
+		legacyIpc: window.ipc,
+		dispatch: views_create_store.dispatch,
+		getStore: (path$1) => (0, views_create_store.getStore)(path$1),
+		success: window.success
+	}),
+	pluginId: PLUGIN_ID,
+	nodeResolver: createFcdNodeResolver((path$1) => (0, views_create_store.getStore)(path$1)),
+	getMemberId: () => (0, views_create_store.getStore)("info.basic.api_member_id"),
+	onError: (error) => console.error(`[${PLUGIN_ID}]`, error)
+});
+const reactClass = createTrackerView(controller);
+const windowMode = false;
+function pluginDidLoad() {
+	controller.start(window);
+}
+function pluginWillUnload() {
+	controller.stop();
+}
+
+//#endregion
+exports.pluginDidLoad = pluginDidLoad;
+exports.pluginWillUnload = pluginWillUnload;
+exports.reactClass = reactClass;
+exports.windowMode = windowMode;
+//# sourceMappingURL=index.js.map