@cartanova/qgrid-cli 2.6.9 → 2.6.11

package/bundle/dist/application/qgrid/qgrid-run-lifecycle.js

@@ -1,6 +1,9 @@
+import { SD } from "../../i18n/sd.generated.js";
+import { isRestartPending } from "../../utils/server-restart.js";
 import { estimateImageGenerationCostMicroUsd, imageGenerationCostMethod } from "./qgrid-image-generation.js";
 import { buildImageGenerationToolSteps, formatResponseForLog, getImageParts } from "./qgrid-response-format.js";
 import { RequestLogModel } from "../request-log/request-log.model.js";
+import { ServiceUnavailableException } from "sonamu";
 import { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/qgrid-run-lifecycle.ts
 const logger = getLogger(["qgrid", "run-lifecycle"]);
@@ -8,6 +11,35 @@ const STALE_RUN_THRESHOLD_MS = 1800 * 1e3;
 const STALE_CLEANUP_INTERVAL_MS = 60 * 1e3;
 let staleCleanupInFlight;
 let lastStaleCleanupStartedAt = 0;
+const activeNativeRunRefs = /* @__PURE__ */ new Map();
+const interruptedNativeRunIds = /* @__PURE__ */ new Set();
+const activeNativeFinalizers = /* @__PURE__ */ new Map();
+function restartUnavailable() {
+	return new ServiceUnavailableException(SD("qgrid.restartPending")());
+}
+function registerNativeRun(requestLogId) {
+	activeNativeRunRefs.set(requestLogId, (activeNativeRunRefs.get(requestLogId) ?? 0) + 1);
+}
+function releaseNativeRun(requestLogId) {
+	const refs = activeNativeRunRefs.get(requestLogId);
+	if (refs === void 0 || refs <= 1) activeNativeRunRefs.delete(requestLogId);
+	else activeNativeRunRefs.set(requestLogId, refs - 1);
+}
+function trackNativeFinalizer(requestLogId, finalize) {
+	const operation = finalize();
+	const settled = operation.then(() => void 0, () => void 0);
+	const finalizers = activeNativeFinalizers.get(requestLogId) ?? /* @__PURE__ */ new Set();
+	finalizers.add(settled);
+	activeNativeFinalizers.set(requestLogId, finalizers);
+	settled.then(() => {
+		finalizers.delete(settled);
+		if (finalizers.size === 0) activeNativeFinalizers.delete(requestLogId);
+	});
+	return operation;
+}
+function assertNativeRunAdmission() {
+	if (isRestartPending()) throw restartUnavailable();
+}
 function withProviderPrefix(routeModel, model) {
 	if (!model) return void 0;
 	if (model.includes("/")) return model;
@@ -38,6 +70,7 @@ function filterHistoryForStorage(rawHistory) {
 * 2) afterQuery: generate step + tool-call step + finish/keep-open
 */
 async function beforeQuery(args) {
+	assertNativeRunAdmission();
 	let requestLogId;
 	let stepIndex = 0;
 	if (args.runContext?.requestLogId !== void 0) {
@@ -57,79 +90,123 @@ async function beforeQuery(args) {
 			is_image_generation: args.imageGeneration
 		});
 	}
+	if (isRestartPending()) {
+		await finishTerminalRun(requestLogId, "error", "server restarted");
+		throw restartUnavailable();
+	}
+	registerNativeRun(requestLogId);
 	return {
 		requestLogId,
 		stepIndex
 	};
 }
 async function afterQuery(requestLogId, stepIndex, args, result) {
-	const requestedModelName = withProviderPrefix(args.model, args.model ?? result.requestedModel ?? result.model);
-	const servedModelName = withProviderPrefix(args.model, result.model);
-	await RequestLogModel.appendStep(requestLogId, {
-		step_index: stepIndex,
-		type: "generate",
-		model_name: servedModelName,
-		requested_model_name: requestedModelName,
-		fallback_count: result.modelFallbacks?.length ?? 0,
-		input_tokens: result.usage.input_tokens,
-		output_tokens: result.usage.output_tokens,
-		cache_read_tokens: result.usage.cache_read_input_tokens,
-		cache_creation_tokens: result.usage.cache_creation_input_tokens,
-		cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,
-		cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,
-		cost_usd: Math.round(result.costUsd * 1e6),
-		cost_source: result.costSource,
-		duration_ms: result.durationMs,
-		ttft_ms: result.ttftMs,
-		finish_reason: result.finishReason
-	});
-	const imageParts = getImageParts(result);
-	const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(result, args.imageGenerationOptions);
-	for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) await RequestLogModel.appendStep(requestLogId, step);
-	if (result.finishReason === "tool-calls") {
-		const toolCalls = result.content.filter((c) => c.type === "tool-call");
-		for (let i = 0; i < toolCalls.length; i++) {
-			const tc = toolCalls[i];
-			if (tc.type !== "tool-call") continue;
+	if (interruptedNativeRunIds.has(requestLogId)) return {};
+	return trackNativeFinalizer(requestLogId, async () => {
+		try {
+			const requestedModelName = withProviderPrefix(args.model, args.model ?? result.requestedModel ?? result.model);
+			const servedModelName = withProviderPrefix(args.model, result.model);
 			await RequestLogModel.appendStep(requestLogId, {
 				step_index: stepIndex,
-				type: "tool_call",
-				tool_call_index: imageParts.length + i,
-				tool_call_id: tc.toolCallId,
-				tool_name: tc.toolName,
-				tool_args: tc.input
+				type: "generate",
+				model_name: servedModelName,
+				requested_model_name: requestedModelName,
+				fallback_count: result.modelFallbacks?.length ?? 0,
+				input_tokens: result.usage.input_tokens,
+				output_tokens: result.usage.output_tokens,
+				cache_read_tokens: result.usage.cache_read_input_tokens,
+				cache_creation_tokens: result.usage.cache_creation_input_tokens,
+				cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,
+				cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,
+				cost_usd: Math.round(result.costUsd * 1e6),
+				cost_source: result.costSource,
+				duration_ms: result.durationMs,
+				ttft_ms: result.ttftMs,
+				finish_reason: result.finishReason
+			});
+			const imageParts = getImageParts(result);
+			const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(result, args.imageGenerationOptions);
+			for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) await RequestLogModel.appendStep(requestLogId, step);
+			if (result.finishReason === "tool-calls") {
+				const toolCalls = result.content.filter((c) => c.type === "tool-call");
+				for (let i = 0; i < toolCalls.length; i++) {
+					const tc = toolCalls[i];
+					if (tc.type !== "tool-call") continue;
+					await RequestLogModel.appendStep(requestLogId, {
+						step_index: stepIndex,
+						type: "tool_call",
+						tool_call_index: imageParts.length + i,
+						tool_call_id: tc.toolCallId,
+						tool_name: tc.toolName,
+						tool_args: tc.input
+					});
+				}
+				return { runContext: { requestLogId } };
+			}
+			const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
+			await RequestLogModel.finishRun(requestLogId, {
+				status: "succeeded",
+				response: formatResponseForLog(result),
+				token_name: result.tokenName,
+				input_tokens: agg.input_tokens,
+				output_tokens: agg.output_tokens,
+				cache_read_tokens: agg.cache_read_tokens,
+				cache_creation_tokens: agg.cache_creation_tokens,
+				cache_creation_5m_tokens: agg.cache_creation_5m_tokens,
+				cache_creation_1h_tokens: agg.cache_creation_1h_tokens,
+				duration_ms: agg.duration_ms,
+				requested_model_name: requestedModelName,
+				model_name: servedModelName,
+				fallback_count: agg.fallback_count,
+				cost_usd: agg.cost_usd,
+				cost_source: agg.cost_source,
+				image_cost_usd: imageCostMicroUsd,
+				image_cost_method: imageCostMicroUsd !== null ? imageGenerationCostMethod(args.imageGenerationOptions) : null,
+				history: filterHistoryForStorage(args.history)
 			});
+			return {};
+		} finally {
+			releaseNativeRun(requestLogId);
 		}
-		return { runContext: { requestLogId } };
-	}
-	const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
-	await RequestLogModel.finishRun(requestLogId, {
-		status: "succeeded",
-		response: formatResponseForLog(result),
-		token_name: result.tokenName,
-		input_tokens: agg.input_tokens,
-		output_tokens: agg.output_tokens,
-		cache_read_tokens: agg.cache_read_tokens,
-		cache_creation_tokens: agg.cache_creation_tokens,
-		cache_creation_5m_tokens: agg.cache_creation_5m_tokens,
-		cache_creation_1h_tokens: agg.cache_creation_1h_tokens,
-		duration_ms: agg.duration_ms,
-		requested_model_name: requestedModelName,
-		model_name: servedModelName,
-		fallback_count: agg.fallback_count,
-		cost_usd: agg.cost_usd,
-		cost_source: agg.cost_source,
-		image_cost_usd: imageCostMicroUsd,
-		image_cost_method: imageCostMicroUsd !== null ? imageGenerationCostMethod(args.imageGenerationOptions) : null,
-		history: filterHistoryForStorage(args.history)
 	});
-	return {};
 }
 async function finishRunWithError(requestLogId, errorMessage, args) {
-	await finishTerminalRun(requestLogId, "error", errorMessage, args);
+	if (interruptedNativeRunIds.has(requestLogId)) return;
+	return trackNativeFinalizer(requestLogId, async () => {
+		try {
+			await finishTerminalRun(requestLogId, "error", errorMessage, args);
+		} finally {
+			releaseNativeRun(requestLogId);
+		}
+	});
 }
 async function finishRunAborted(requestLogId, args) {
-	await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
+	if (interruptedNativeRunIds.has(requestLogId)) return;
+	return trackNativeFinalizer(requestLogId, async () => {
+		try {
+			await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
+		} finally {
+			releaseNativeRun(requestLogId);
+		}
+	});
+}
+/** 현재 이 프로세스가 provider를 실행 중인 native run만 재시작 오류로 마감한다. */
+async function finishActiveNativeRunsForRestart() {
+	const requestLogIds = [...activeNativeRunRefs.keys()];
+	for (const requestLogId of requestLogIds) {
+		interruptedNativeRunIds.add(requestLogId);
+		activeNativeRunRefs.delete(requestLogId);
+	}
+	await Promise.all(requestLogIds.map(async (requestLogId) => {
+		await Promise.all(activeNativeFinalizers.get(requestLogId) ?? []);
+		await finishTerminalRun(requestLogId, "error", "server restarted");
+	}));
+}
+/** 프로세스 전역 registry를 격리해야 하는 단위 테스트 전용. */
+function resetNativeRunRegistryForTests() {
+	activeNativeRunRefs.clear();
+	interruptedNativeRunIds.clear();
+	activeNativeFinalizers.clear();
 }
 async function finishTerminalRun(requestLogId, status, errorMessage, args) {
 	try {
@@ -185,6 +262,6 @@ async function performStaleRunCleanup() {
 	}
 }
 //#endregion
-export { afterQuery, beforeQuery, finishRunAborted, finishRunWithError };
+export { afterQuery, assertNativeRunAdmission, beforeQuery, finishActiveNativeRunsForRestart, finishRunAborted, finishRunWithError, resetNativeRunRegistryForTests };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid-run-lifecycle.js","names":[],"sources":["../../../src/application/qgrid/qgrid-run-lifecycle.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\n\nimport { RequestLogModel } from \"../request-log/request-log.model\";\nimport {\n  estimateImageGenerationCostMicroUsd,\n  imageGenerationCostMethod,\n} from \"./qgrid-image-generation\";\nimport {\n  buildImageGenerationToolSteps,\n  formatResponseForLog,\n  getImageParts,\n} from \"./qgrid-response-format\";\nimport { type QgridRunContext, type QueryInput, type QueryOutput } from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"run-lifecycle\"]);\nconst STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;\nconst STALE_CLEANUP_INTERVAL_MS = 60 * 1000;\nlet staleCleanupInFlight: Promise<void> | undefined;\nlet lastStaleCleanupStartedAt = 0;\n\nfunction withProviderPrefix(\n  routeModel: string | undefined,\n  model: string | undefined,\n): string | undefined {\n  if (!model) return undefined;\n  if (model.includes(\"/\")) return model;\n  const slash = routeModel?.indexOf(\"/\") ?? -1;\n  const provider = slash > 0 ? routeModel?.slice(0, slash) : undefined;\n  return provider ? `${provider}/${model}` : model;\n}\n\n/**\n * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장\n */\nfunction filterHistoryForStorage(rawHistory: string | undefined): unknown {\n  if (!rawHistory) return undefined;\n  try {\n    const items = JSON.parse(rawHistory) as unknown[];\n    const filtered = items.filter((item) => {\n      if (!item || typeof item !== \"object\") return false;\n      const record = item as Record<string, unknown>;\n      return record.type === \"message\" && (record.role === \"user\" || record.role === \"assistant\");\n    });\n    return filtered.length > 0 ? filtered : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport type RunLifecycleResult = {\n  runContext?: QgridRunContext;\n};\n\n/**\n * logger-enabled query/stream 응답 전후에 호출.\n *\n * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale tool-wait cleanup\n * 2) afterQuery: generate step + tool-call step + finish/keep-open\n */\nexport async function beforeQuery(args: QueryInput): Promise<{\n  requestLogId: number;\n  stepIndex: number;\n}> {\n  let requestLogId: number;\n  let stepIndex = 0;\n\n  // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.\n  // continuation 은 createRun 을 건너뛰므로 run 의 tools 는 첫 스텝 장착분으로 고정된다 —\n  // AI SDK prepareStep/activeTools 로 스텝마다 툴셋이 바뀌어도 로그에는 반영되지 않는다.\n  if (args.runContext?.requestLogId !== undefined) {\n    requestLogId = args.runContext.requestLogId;\n    // cleanup과 같은 DB advisory lock을 잡고 tool 결과 반영 + 다음 step 예약을 한\n    // transaction에서 처리한다. 여러 qgrid 프로세스 사이에서도 stale expiry가\n    // 도착 중인 follow-up을 error로 덮어쓰지 못한다.\n    stepIndex = await RequestLogModel.continueToolRun(requestLogId, args.toolResults ?? []);\n    await cleanupStaleRuns();\n  } else {\n    await cleanupStaleRuns();\n    requestLogId = await RequestLogModel.createRun({\n      user_prompt: args.prompt,\n      system_prompt: args.system,\n      requested_model_name: args.model,\n      effort: args.effort,\n      project_name: args.projectName,\n      history: filterHistoryForStorage(args.history),\n      tools: args.tools?.length ? args.tools : undefined,\n      is_image_generation: args.imageGeneration,\n    });\n  }\n\n  return { requestLogId, stepIndex };\n}\n\nexport async function afterQuery(\n  requestLogId: number,\n  stepIndex: number,\n  args: QueryInput,\n  result: QueryOutput,\n): Promise<RunLifecycleResult> {\n  // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.\n  const requestedModelName = withProviderPrefix(\n    args.model,\n    args.model ?? result.requestedModel ?? result.model,\n  );\n  const servedModelName = withProviderPrefix(args.model, result.model);\n\n  // generate step 기록\n  await RequestLogModel.appendStep(requestLogId, {\n    step_index: stepIndex,\n    type: \"generate\",\n    model_name: servedModelName,\n    requested_model_name: requestedModelName,\n    fallback_count: result.modelFallbacks?.length ?? 0,\n    input_tokens: result.usage.input_tokens,\n    output_tokens: result.usage.output_tokens,\n    cache_read_tokens: result.usage.cache_read_input_tokens,\n    cache_creation_tokens: result.usage.cache_creation_input_tokens,\n    cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,\n    cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,\n    cost_usd: Math.round(result.costUsd * 1_000_000),\n    cost_source: result.costSource,\n    duration_ms: result.durationMs,\n    ttft_ms: result.ttftMs,\n    finish_reason: result.finishReason,\n  });\n\n  const imageParts = getImageParts(result);\n  const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(\n    result,\n    args.imageGenerationOptions,\n  );\n  for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {\n    await RequestLogModel.appendStep(requestLogId, step);\n  }\n\n  if (result.finishReason === \"tool-calls\") {\n    // tool-call step을 즉시 기록하고, 다음 follow-up이 같은 row에 결과를 채운다.\n    const toolCalls = result.content.filter((c) => c.type === \"tool-call\");\n    for (let i = 0; i < toolCalls.length; i++) {\n      const tc = toolCalls[i]!;\n      if (tc.type !== \"tool-call\") continue;\n      await RequestLogModel.appendStep(requestLogId, {\n        step_index: stepIndex,\n        type: \"tool_call\",\n        tool_call_index: imageParts.length + i,\n        tool_call_id: tc.toolCallId,\n        tool_name: tc.toolName,\n        tool_args: tc.input,\n      });\n    }\n\n    return { runContext: { requestLogId } };\n  }\n\n  // finishReason === \"stop\" → run 종료 (전체 step usage 합산)\n  const agg = await RequestLogModel.aggregateStepUsage(requestLogId);\n  await RequestLogModel.finishRun(requestLogId, {\n    status: \"succeeded\",\n    response: formatResponseForLog(result),\n    token_name: result.tokenName,\n    input_tokens: agg.input_tokens,\n    output_tokens: agg.output_tokens,\n    cache_read_tokens: agg.cache_read_tokens,\n    cache_creation_tokens: agg.cache_creation_tokens,\n    cache_creation_5m_tokens: agg.cache_creation_5m_tokens,\n    cache_creation_1h_tokens: agg.cache_creation_1h_tokens,\n    duration_ms: agg.duration_ms,\n    // multi-step run 부모의 모델은 최종 turn을 서빙한 모델이다.\n    requested_model_name: requestedModelName,\n    model_name: servedModelName,\n    fallback_count: agg.fallback_count,\n    cost_usd: agg.cost_usd,\n    cost_source: agg.cost_source,\n    image_cost_usd: imageCostMicroUsd,\n    image_cost_method:\n      imageCostMicroUsd !== null ? imageGenerationCostMethod(args.imageGenerationOptions) : null,\n    history: filterHistoryForStorage(args.history),\n  });\n\n  return {};\n}\n\nexport async function finishRunWithError(\n  requestLogId: number,\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  await finishTerminalRun(requestLogId, \"error\", errorMessage, args);\n}\n\nexport async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {\n  await finishTerminalRun(requestLogId, \"aborted\", \"client disconnected\", args);\n}\n\nasync function finishTerminalRun(\n  requestLogId: number,\n  status: \"error\" | \"aborted\",\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  try {\n    let aggregate: Awaited<ReturnType<typeof RequestLogModel.aggregateStepUsage>> | undefined;\n    try {\n      aggregate = await RequestLogModel.aggregateStepUsage(requestLogId);\n    } catch (e) {\n      logger.error(`aggregateStepUsage failed while finishing ${status}: ${(e as Error).message}`);\n    }\n\n    await RequestLogModel.finishRun(requestLogId, {\n      status,\n      error_message: errorMessage,\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n      ...(aggregate\n        ? {\n            input_tokens: aggregate.input_tokens,\n            output_tokens: aggregate.output_tokens,\n            cache_read_tokens: aggregate.cache_read_tokens,\n            cache_creation_tokens: aggregate.cache_creation_tokens,\n            cache_creation_5m_tokens: aggregate.cache_creation_5m_tokens,\n            cache_creation_1h_tokens: aggregate.cache_creation_1h_tokens,\n            duration_ms: aggregate.duration_ms,\n            fallback_count: aggregate.fallback_count,\n            cost_usd: aggregate.cost_usd,\n            cost_source: aggregate.cost_source,\n          }\n        : {}),\n    });\n  } catch (e) {\n    logger.error(`finishTerminalRun(${status}) failed: ${(e as Error).message}`);\n  }\n}\n\nasync function cleanupStaleRuns(): Promise<void> {\n  if (staleCleanupInFlight) {\n    await staleCleanupInFlight;\n    return;\n  }\n\n  const now = Date.now();\n  if (now - lastStaleCleanupStartedAt < STALE_CLEANUP_INTERVAL_MS) return;\n  lastStaleCleanupStartedAt = now;\n\n  const cleanup = performStaleRunCleanup();\n  staleCleanupInFlight = cleanup;\n  try {\n    await cleanup;\n  } finally {\n    if (staleCleanupInFlight === cleanup) staleCleanupInFlight = undefined;\n  }\n}\n\nasync function performStaleRunCleanup(): Promise<void> {\n  try {\n    const errorMessage = \"tool-call run: no follow-up within 30 minutes\";\n    const staleIds = await RequestLogModel.expireStaleToolWaitingRuns(\n      STALE_RUN_THRESHOLD_MS,\n      errorMessage,\n    );\n    const cleanedCount = staleIds.length;\n    if (cleanedCount > 0) {\n      logger.info(`cleaned up ${cleanedCount} stale running request logs`);\n    }\n  } catch (e) {\n    logger.error(`stale cleanup failed: ${(e as Error).message}`);\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid-run-lifecycle.js","names":[],"sources":["../../../src/application/qgrid/qgrid-run-lifecycle.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport { ServiceUnavailableException } from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { isRestartPending } from \"../../utils/server-restart\";\nimport { RequestLogModel } from \"../request-log/request-log.model\";\nimport {\n  estimateImageGenerationCostMicroUsd,\n  imageGenerationCostMethod,\n} from \"./qgrid-image-generation\";\nimport {\n  buildImageGenerationToolSteps,\n  formatResponseForLog,\n  getImageParts,\n} from \"./qgrid-response-format\";\nimport { type QgridRunContext, type QueryInput, type QueryOutput } from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"run-lifecycle\"]);\nconst STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;\nconst STALE_CLEANUP_INTERVAL_MS = 60 * 1000;\nlet staleCleanupInFlight: Promise<void> | undefined;\nlet lastStaleCleanupStartedAt = 0;\nconst activeNativeRunRefs = new Map<number, number>();\nconst interruptedNativeRunIds = new Set<number>();\nconst activeNativeFinalizers = new Map<number, Set<Promise<void>>>();\n\nfunction restartUnavailable(): ServiceUnavailableException {\n  return new ServiceUnavailableException(SD(\"qgrid.restartPending\")());\n}\n\nfunction registerNativeRun(requestLogId: number): void {\n  activeNativeRunRefs.set(requestLogId, (activeNativeRunRefs.get(requestLogId) ?? 0) + 1);\n}\n\nfunction releaseNativeRun(requestLogId: number): void {\n  const refs = activeNativeRunRefs.get(requestLogId);\n  if (refs === undefined || refs <= 1) activeNativeRunRefs.delete(requestLogId);\n  else activeNativeRunRefs.set(requestLogId, refs - 1);\n}\n\nfunction trackNativeFinalizer<T>(requestLogId: number, finalize: () => Promise<T>): Promise<T> {\n  const operation = finalize();\n  const settled = operation.then(\n    () => undefined,\n    () => undefined,\n  );\n  const finalizers = activeNativeFinalizers.get(requestLogId) ?? new Set<Promise<void>>();\n  finalizers.add(settled);\n  activeNativeFinalizers.set(requestLogId, finalizers);\n  void settled.then(() => {\n    finalizers.delete(settled);\n    if (finalizers.size === 0) activeNativeFinalizers.delete(requestLogId);\n  });\n  return operation;\n}\n\nexport function assertNativeRunAdmission(): void {\n  if (isRestartPending()) throw restartUnavailable();\n}\n\nfunction withProviderPrefix(\n  routeModel: string | undefined,\n  model: string | undefined,\n): string | undefined {\n  if (!model) return undefined;\n  if (model.includes(\"/\")) return model;\n  const slash = routeModel?.indexOf(\"/\") ?? -1;\n  const provider = slash > 0 ? routeModel?.slice(0, slash) : undefined;\n  return provider ? `${provider}/${model}` : model;\n}\n\n/**\n * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장\n */\nfunction filterHistoryForStorage(rawHistory: string | undefined): unknown {\n  if (!rawHistory) return undefined;\n  try {\n    const items = JSON.parse(rawHistory) as unknown[];\n    const filtered = items.filter((item) => {\n      if (!item || typeof item !== \"object\") return false;\n      const record = item as Record<string, unknown>;\n      return record.type === \"message\" && (record.role === \"user\" || record.role === \"assistant\");\n    });\n    return filtered.length > 0 ? filtered : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport type RunLifecycleResult = {\n  runContext?: QgridRunContext;\n};\n\n/**\n * logger-enabled query/stream 응답 전후에 호출.\n *\n * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale tool-wait cleanup\n * 2) afterQuery: generate step + tool-call step + finish/keep-open\n */\nexport async function beforeQuery(args: QueryInput): Promise<{\n  requestLogId: number;\n  stepIndex: number;\n}> {\n  assertNativeRunAdmission();\n\n  let requestLogId: number;\n  let stepIndex = 0;\n\n  // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.\n  // continuation 은 createRun 을 건너뛰므로 run 의 tools 는 첫 스텝 장착분으로 고정된다 —\n  // AI SDK prepareStep/activeTools 로 스텝마다 툴셋이 바뀌어도 로그에는 반영되지 않는다.\n  if (args.runContext?.requestLogId !== undefined) {\n    requestLogId = args.runContext.requestLogId;\n    // cleanup과 같은 DB advisory lock을 잡고 tool 결과 반영 + 다음 step 예약을 한\n    // transaction에서 처리한다. 여러 qgrid 프로세스 사이에서도 stale expiry가\n    // 도착 중인 follow-up을 error로 덮어쓰지 못한다.\n    stepIndex = await RequestLogModel.continueToolRun(requestLogId, args.toolResults ?? []);\n    await cleanupStaleRuns();\n  } else {\n    await cleanupStaleRuns();\n    requestLogId = await RequestLogModel.createRun({\n      user_prompt: args.prompt,\n      system_prompt: args.system,\n      requested_model_name: args.model,\n      effort: args.effort,\n      project_name: args.projectName,\n      history: filterHistoryForStorage(args.history),\n      tools: args.tools?.length ? args.tools : undefined,\n      is_image_generation: args.imageGeneration,\n    });\n  }\n\n  // DB 준비 중에 재시작이 시작됐다면 provider 실행으로 넘어가지 않는다.\n  // 이 요청은 재시작 snapshot에 없었으므로 방금 준비한 run을 직접 마감한다.\n  if (isRestartPending()) {\n    await finishTerminalRun(requestLogId, \"error\", \"server restarted\");\n    throw restartUnavailable();\n  }\n\n  registerNativeRun(requestLogId);\n  return { requestLogId, stepIndex };\n}\n\nexport async function afterQuery(\n  requestLogId: number,\n  stepIndex: number,\n  args: QueryInput,\n  result: QueryOutput,\n): Promise<RunLifecycleResult> {\n  if (interruptedNativeRunIds.has(requestLogId)) return {};\n\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.\n      const requestedModelName = withProviderPrefix(\n        args.model,\n        args.model ?? result.requestedModel ?? result.model,\n      );\n      const servedModelName = withProviderPrefix(args.model, result.model);\n\n      // generate step 기록\n      await RequestLogModel.appendStep(requestLogId, {\n        step_index: stepIndex,\n        type: \"generate\",\n        model_name: servedModelName,\n        requested_model_name: requestedModelName,\n        fallback_count: result.modelFallbacks?.length ?? 0,\n        input_tokens: result.usage.input_tokens,\n        output_tokens: result.usage.output_tokens,\n        cache_read_tokens: result.usage.cache_read_input_tokens,\n        cache_creation_tokens: result.usage.cache_creation_input_tokens,\n        cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,\n        cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,\n        cost_usd: Math.round(result.costUsd * 1_000_000),\n        cost_source: result.costSource,\n        duration_ms: result.durationMs,\n        ttft_ms: result.ttftMs,\n        finish_reason: result.finishReason,\n      });\n\n      const imageParts = getImageParts(result);\n      const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(\n        result,\n        args.imageGenerationOptions,\n      );\n      for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {\n        await RequestLogModel.appendStep(requestLogId, step);\n      }\n\n      if (result.finishReason === \"tool-calls\") {\n        // tool-call step을 즉시 기록하고, 다음 follow-up이 같은 row에 결과를 채운다.\n        const toolCalls = result.content.filter((c) => c.type === \"tool-call\");\n        for (let i = 0; i < toolCalls.length; i++) {\n          const tc = toolCalls[i]!;\n          if (tc.type !== \"tool-call\") continue;\n          await RequestLogModel.appendStep(requestLogId, {\n            step_index: stepIndex,\n            type: \"tool_call\",\n            tool_call_index: imageParts.length + i,\n            tool_call_id: tc.toolCallId,\n            tool_name: tc.toolName,\n            tool_args: tc.input,\n          });\n        }\n\n        return { runContext: { requestLogId } };\n      }\n\n      // finishReason === \"stop\" → run 종료 (전체 step usage 합산)\n      const agg = await RequestLogModel.aggregateStepUsage(requestLogId);\n      await RequestLogModel.finishRun(requestLogId, {\n        status: \"succeeded\",\n        response: formatResponseForLog(result),\n        token_name: result.tokenName,\n        input_tokens: agg.input_tokens,\n        output_tokens: agg.output_tokens,\n        cache_read_tokens: agg.cache_read_tokens,\n        cache_creation_tokens: agg.cache_creation_tokens,\n        cache_creation_5m_tokens: agg.cache_creation_5m_tokens,\n        cache_creation_1h_tokens: agg.cache_creation_1h_tokens,\n        duration_ms: agg.duration_ms,\n        // multi-step run 부모의 모델은 최종 turn을 서빙한 모델이다.\n        requested_model_name: requestedModelName,\n        model_name: servedModelName,\n        fallback_count: agg.fallback_count,\n        cost_usd: agg.cost_usd,\n        cost_source: agg.cost_source,\n        image_cost_usd: imageCostMicroUsd,\n        image_cost_method:\n          imageCostMicroUsd !== null\n            ? imageGenerationCostMethod(args.imageGenerationOptions)\n            : null,\n        history: filterHistoryForStorage(args.history),\n      });\n\n      return {};\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\nexport async function finishRunWithError(\n  requestLogId: number,\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  if (interruptedNativeRunIds.has(requestLogId)) return;\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      await finishTerminalRun(requestLogId, \"error\", errorMessage, args);\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\nexport async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {\n  if (interruptedNativeRunIds.has(requestLogId)) return;\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      await finishTerminalRun(requestLogId, \"aborted\", \"client disconnected\", args);\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\n/** 현재 이 프로세스가 provider를 실행 중인 native run만 재시작 오류로 마감한다. */\nexport async function finishActiveNativeRunsForRestart(): Promise<void> {\n  const requestLogIds = [...activeNativeRunRefs.keys()];\n  for (const requestLogId of requestLogIds) {\n    interruptedNativeRunIds.add(requestLogId);\n    activeNativeRunRefs.delete(requestLogId);\n  }\n\n  await Promise.all(\n    requestLogIds.map(async (requestLogId) => {\n      await Promise.all(activeNativeFinalizers.get(requestLogId) ?? []);\n      await finishTerminalRun(requestLogId, \"error\", \"server restarted\");\n    }),\n  );\n}\n\n/** 프로세스 전역 registry를 격리해야 하는 단위 테스트 전용. */\nexport function resetNativeRunRegistryForTests(): void {\n  activeNativeRunRefs.clear();\n  interruptedNativeRunIds.clear();\n  activeNativeFinalizers.clear();\n}\n\nasync function finishTerminalRun(\n  requestLogId: number,\n  status: \"error\" | \"aborted\",\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  try {\n    let aggregate: Awaited<ReturnType<typeof RequestLogModel.aggregateStepUsage>> | undefined;\n    try {\n      aggregate = await RequestLogModel.aggregateStepUsage(requestLogId);\n    } catch (e) {\n      logger.error(`aggregateStepUsage failed while finishing ${status}: ${(e as Error).message}`);\n    }\n\n    await RequestLogModel.finishRun(requestLogId, {\n      status,\n      error_message: errorMessage,\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n      ...(aggregate\n        ? {\n            input_tokens: aggregate.input_tokens,\n            output_tokens: aggregate.output_tokens,\n            cache_read_tokens: aggregate.cache_read_tokens,\n            cache_creation_tokens: aggregate.cache_creation_tokens,\n            cache_creation_5m_tokens: aggregate.cache_creation_5m_tokens,\n            cache_creation_1h_tokens: aggregate.cache_creation_1h_tokens,\n            duration_ms: aggregate.duration_ms,\n            fallback_count: aggregate.fallback_count,\n            cost_usd: aggregate.cost_usd,\n            cost_source: aggregate.cost_source,\n          }\n        : {}),\n    });\n  } catch (e) {\n    logger.error(`finishTerminalRun(${status}) failed: ${(e as Error).message}`);\n  }\n}\n\nasync function cleanupStaleRuns(): Promise<void> {\n  if (staleCleanupInFlight) {\n    await staleCleanupInFlight;\n    return;\n  }\n\n  const now = Date.now();\n  if (now - lastStaleCleanupStartedAt < STALE_CLEANUP_INTERVAL_MS) return;\n  lastStaleCleanupStartedAt = now;\n\n  const cleanup = performStaleRunCleanup();\n  staleCleanupInFlight = cleanup;\n  try {\n    await cleanup;\n  } finally {\n    if (staleCleanupInFlight === cleanup) staleCleanupInFlight = undefined;\n  }\n}\n\nasync function performStaleRunCleanup(): Promise<void> {\n  try {\n    const errorMessage = \"tool-call run: no follow-up within 30 minutes\";\n    const staleIds = await RequestLogModel.expireStaleToolWaitingRuns(\n      STALE_RUN_THRESHOLD_MS,\n      errorMessage,\n    );\n    const cleanedCount = staleIds.length;\n    if (cleanedCount > 0) {\n      logger.info(`cleaned up ${cleanedCount} stale running request logs`);\n    }\n  } catch (e) {\n    logger.error(`stale cleanup failed: ${(e as Error).message}`);\n  }\n}\n"],"mappings":";;;;;;;;AAiBA,MAAM,SAAS,UAAU,CAAC,SAAS,eAAe,CAAC;AACnD,MAAM,yBAAyB,OAAU;AACzC,MAAM,4BAA4B,KAAK;AACvC,IAAI;AACJ,IAAI,4BAA4B;AAChC,MAAM,sCAAsB,IAAI,IAAoB;AACpD,MAAM,0CAA0B,IAAI,IAAY;AAChD,MAAM,yCAAyB,IAAI,IAAgC;AAEnE,SAAS,qBAAkD;CACzD,OAAO,IAAI,4BAA4B,GAAG,sBAAsB,CAAC,CAAC,CAAC;AACrE;AAEA,SAAS,kBAAkB,cAA4B;CACrD,oBAAoB,IAAI,eAAe,oBAAoB,IAAI,YAAY,KAAK,KAAK,CAAC;AACxF;AAEA,SAAS,iBAAiB,cAA4B;CACpD,MAAM,OAAO,oBAAoB,IAAI,YAAY;CACjD,IAAI,SAAS,UAAa,QAAQ,GAAG,oBAAoB,OAAO,YAAY;MACvE,oBAAoB,IAAI,cAAc,OAAO,CAAC;AACrD;AAEA,SAAS,qBAAwB,cAAsB,UAAwC;CAC7F,MAAM,YAAY,SAAS;CAC3B,MAAM,UAAU,UAAU,WAClB,cACA,MACR;CACA,MAAM,aAAa,uBAAuB,IAAI,YAAY,qBAAK,IAAI,IAAmB;CACtF,WAAW,IAAI,OAAO;CACtB,uBAAuB,IAAI,cAAc,UAAU;CACnD,AAAK,QAAQ,WAAW;EACtB,WAAW,OAAO,OAAO;EACzB,IAAI,WAAW,SAAS,GAAG,uBAAuB,OAAO,YAAY;CACvE,CAAC;CACD,OAAO;AACT;AAEA,SAAgB,2BAAiC;CAC/C,IAAI,iBAAiB,GAAG,MAAM,mBAAmB;AACnD;AAEA,SAAS,mBACP,YACA,OACoB;CACpB,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI,MAAM,SAAS,GAAG,GAAG,OAAO;CAChC,MAAM,QAAQ,YAAY,QAAQ,GAAG,KAAK;CAC1C,MAAM,WAAW,QAAQ,IAAI,YAAY,MAAM,GAAG,KAAK,IAAI;CAC3D,OAAO,WAAW,GAAG,SAAS,GAAG,UAAU;AAC7C;;;;AAKA,SAAS,wBAAwB,YAAyC;CACxE,IAAI,CAAC,YAAY,OAAO;CACxB,IAAI;EAEF,MAAM,WADQ,KAAK,MAAM,UACR,CAAA,CAAM,QAAQ,SAAS;GACtC,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO;GAC9C,MAAM,SAAS;GACf,OAAO,OAAO,SAAS,cAAc,OAAO,SAAS,UAAU,OAAO,SAAS;EACjF,CAAC;EACD,OAAO,SAAS,SAAS,IAAI,WAAW;CAC1C,QAAQ;EACN;CACF;AACF;;;;;;;AAYA,eAAsB,YAAY,MAG/B;CACD,yBAAyB;CAEzB,IAAI;CACJ,IAAI,YAAY;CAKhB,IAAI,KAAK,YAAY,iBAAiB,QAAW;EAC/C,eAAe,KAAK,WAAW;EAI/B,YAAY,MAAM,gBAAgB,gBAAgB,cAAc,KAAK,eAAe,CAAC,CAAC;EACtF,MAAM,iBAAiB;CACzB,OAAO;EACL,MAAM,iBAAiB;EACvB,eAAe,MAAM,gBAAgB,UAAU;GAC7C,aAAa,KAAK;GAClB,eAAe,KAAK;GACpB,sBAAsB,KAAK;GAC3B,QAAQ,KAAK;GACb,cAAc,KAAK;GACnB,SAAS,wBAAwB,KAAK,OAAO;GAC7C,OAAO,KAAK,OAAO,SAAS,KAAK,QAAQ;GACzC,qBAAqB,KAAK;EAC5B,CAAC;CACH;CAIA,IAAI,iBAAiB,GAAG;EACtB,MAAM,kBAAkB,cAAc,SAAS,kBAAkB;EACjE,MAAM,mBAAmB;CAC3B;CAEA,kBAAkB,YAAY;CAC9B,OAAO;EAAE;EAAc;CAAU;AACnC;AAEA,eAAsB,WACpB,cACA,WACA,MACA,QAC6B;CAC7B,IAAI,wBAAwB,IAAI,YAAY,GAAG,OAAO,CAAC;CAEvD,OAAO,qBAAqB,cAAc,YAAY;EACpD,IAAI;GAEF,MAAM,qBAAqB,mBACzB,KAAK,OACL,KAAK,SAAS,OAAO,kBAAkB,OAAO,KAChD;GACA,MAAM,kBAAkB,mBAAmB,KAAK,OAAO,OAAO,KAAK;GAGnE,MAAM,gBAAgB,WAAW,cAAc;IAC7C,YAAY;IACZ,MAAM;IACN,YAAY;IACZ,sBAAsB;IACtB,gBAAgB,OAAO,gBAAgB,UAAU;IACjD,cAAc,OAAO,MAAM;IAC3B,eAAe,OAAO,MAAM;IAC5B,mBAAmB,OAAO,MAAM;IAChC,uBAAuB,OAAO,MAAM;IACpC,0BAA0B,OAAO,MAAM;IACvC,0BAA0B,OAAO,MAAM;IACvC,UAAU,KAAK,MAAM,OAAO,UAAU,GAAS;IAC/C,aAAa,OAAO;IACpB,aAAa,OAAO;IACpB,SAAS,OAAO;IAChB,eAAe,OAAO;GACxB,CAAC;GAED,MAAM,aAAa,cAAc,MAAM;GACvC,MAAM,oBAAoB,oCACxB,QACA,KAAK,sBACP;GACA,KAAK,MAAM,QAAQ,8BAA8B,MAAM,YAAY,SAAS,GAC1E,MAAM,gBAAgB,WAAW,cAAc,IAAI;GAGrD,IAAI,OAAO,iBAAiB,cAAc;IAExC,MAAM,YAAY,OAAO,QAAQ,QAAQ,MAAM,EAAE,SAAS,WAAW;IACrE,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;KACzC,MAAM,KAAK,UAAU;KACrB,IAAI,GAAG,SAAS,aAAa;KAC7B,MAAM,gBAAgB,WAAW,cAAc;MAC7C,YAAY;MACZ,MAAM;MACN,iBAAiB,WAAW,SAAS;MACrC,cAAc,GAAG;MACjB,WAAW,GAAG;MACd,WAAW,GAAG;KAChB,CAAC;IACH;IAEA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE;GACxC;GAGA,MAAM,MAAM,MAAM,gBAAgB,mBAAmB,YAAY;GACjE,MAAM,gBAAgB,UAAU,cAAc;IAC5C,QAAQ;IACR,UAAU,qBAAqB,MAAM;IACrC,YAAY,OAAO;IACnB,cAAc,IAAI;IAClB,eAAe,IAAI;IACnB,mBAAmB,IAAI;IACvB,uBAAuB,IAAI;IAC3B,0BAA0B,IAAI;IAC9B,0BAA0B,IAAI;IAC9B,aAAa,IAAI;IAEjB,sBAAsB;IACtB,YAAY;IACZ,gBAAgB,IAAI;IACpB,UAAU,IAAI;IACd,aAAa,IAAI;IACjB,gBAAgB;IAChB,mBACE,sBAAsB,OAClB,0BAA0B,KAAK,sBAAsB,IACrD;IACN,SAAS,wBAAwB,KAAK,OAAO;GAC/C,CAAC;GAED,OAAO,CAAC;EACV,UAAU;GACR,iBAAiB,YAAY;EAC/B;CACF,CAAC;AACH;AAEA,eAAsB,mBACpB,cACA,cACA,MACe;CACf,IAAI,wBAAwB,IAAI,YAAY,GAAG;CAC/C,OAAO,qBAAqB,cAAc,YAAY;EACpD,IAAI;GACF,MAAM,kBAAkB,cAAc,SAAS,cAAc,IAAI;EACnE,UAAU;GACR,iBAAiB,YAAY;EAC/B;CACF,CAAC;AACH;AAEA,eAAsB,iBAAiB,cAAsB,MAAkC;CAC7F,IAAI,wBAAwB,IAAI,YAAY,GAAG;CAC/C,OAAO,qBAAqB,cAAc,YAAY;EACpD,IAAI;GACF,MAAM,kBAAkB,cAAc,WAAW,uBAAuB,IAAI;EAC9E,UAAU;GACR,iBAAiB,YAAY;EAC/B;CACF,CAAC;AACH;;AAGA,eAAsB,mCAAkD;CACtE,MAAM,gBAAgB,CAAC,GAAG,oBAAoB,KAAK,CAAC;CACpD,KAAK,MAAM,gBAAgB,eAAe;EACxC,wBAAwB,IAAI,YAAY;EACxC,oBAAoB,OAAO,YAAY;CACzC;CAEA,MAAM,QAAQ,IACZ,cAAc,IAAI,OAAO,iBAAiB;EACxC,MAAM,QAAQ,IAAI,uBAAuB,IAAI,YAAY,KAAK,CAAC,CAAC;EAChE,MAAM,kBAAkB,cAAc,SAAS,kBAAkB;CACnE,CAAC,CACH;AACF;;AAGA,SAAgB,iCAAuC;CACrD,oBAAoB,MAAM;CAC1B,wBAAwB,MAAM;CAC9B,uBAAuB,MAAM;AAC/B;AAEA,eAAe,kBACb,cACA,QACA,cACA,MACe;CACf,IAAI;EACF,IAAI;EACJ,IAAI;GACF,YAAY,MAAM,gBAAgB,mBAAmB,YAAY;EACnE,SAAS,GAAG;GACV,OAAO,MAAM,6CAA6C,OAAO,IAAK,EAAY,SAAS;EAC7F;EAEA,MAAM,gBAAgB,UAAU,cAAc;GAC5C;GACA,eAAe;GACf,SAAS,OAAO,wBAAwB,KAAK,OAAO,IAAI;GACxD,GAAI,YACA;IACE,cAAc,UAAU;IACxB,eAAe,UAAU;IACzB,mBAAmB,UAAU;IAC7B,uBAAuB,UAAU;IACjC,0BAA0B,UAAU;IACpC,0BAA0B,UAAU;IACpC,aAAa,UAAU;IACvB,gBAAgB,UAAU;IAC1B,UAAU,UAAU;IACpB,aAAa,UAAU;GACzB,IACA,CAAC;EACP,CAAC;CACH,SAAS,GAAG;EACV,OAAO,MAAM,qBAAqB,OAAO,YAAa,EAAY,SAAS;CAC7E;AACF;AAEA,eAAe,mBAAkC;CAC/C,IAAI,sBAAsB;EACxB,MAAM;EACN;CACF;CAEA,MAAM,MAAM,KAAK,IAAI;CACrB,IAAI,MAAM,4BAA4B,2BAA2B;CACjE,4BAA4B;CAE5B,MAAM,UAAU,uBAAuB;CACvC,uBAAuB;CACvB,IAAI;EACF,MAAM;CACR,UAAU;EACR,IAAI,yBAAyB,SAAS,uBAAuB;CAC/D;AACF;AAEA,eAAe,yBAAwC;CACrD,IAAI;EAMF,MAAM,gBAAe,MAJE,gBAAgB,2BACrC,wBACA,+CACF,EACqB,CAAS;EAC9B,IAAI,eAAe,GACjB,OAAO,KAAK,cAAc,aAAa,4BAA4B;CAEvE,SAAS,GAAG;EACV,OAAO,MAAM,yBAA0B,EAAY,SAAS;CAC9D;AACF"}