sa2kit 1.6.91 → 1.6.92

package/dist/index.mjs

@@ -11,19 +11,26 @@ import Link from 'next/link';
 import { useSensors, useSensor, PointerSensor, TouchSensor, KeyboardSensor, DndContext, closestCenter } from '@dnd-kit/core';
 import { useSortable, sortableKeyboardCoordinates, SortableContext, rectSortingStrategy, arrayMove } from '@dnd-kit/sortable';
 import { CSS } from '@dnd-kit/utilities';
-import { pgEnum, pgTable, boolean, timestamp, jsonb, text, uniqueIndex, foreignKey } from 'drizzle-orm/pg-core';
-import { sql, relations } from 'drizzle-orm';
+import { pgEnum, pgTable, boolean, timestamp, jsonb, text, uniqueIndex, foreignKey, integer } from 'drizzle-orm/pg-core';
+import { sql, relations, eq } from 'drizzle-orm';
 import { randomUUID } from 'crypto';
 import 'bcryptjs';
 import 'jsonwebtoken';
 import * as THREE2 from 'three';
+import * as XLSX from 'xlsx';
+import { NextResponse } from 'next/server';
 
+var __defProp = Object.defineProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/logger/types.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
@@ -51,10 +58,10 @@ var ConsoleLoggerAdapter = class {
     };
   }
   log(entry) {
-    const { level, message, timestamp: timestamp5, data, context, error } = entry;
+    const { level, message, timestamp: timestamp6, data, context, error } = entry;
     let logMessage = "";
-    if (timestamp5) {
-      logMessage += "[" + this.formatTimestamp(timestamp5) + "] ";
+    if (timestamp6) {
+      logMessage += "[" + this.formatTimestamp(timestamp6) + "] ";
     }
     const levelName = this.getLevelName(level);
     logMessage += levelName + ": ";
@@ -547,7 +554,7 @@ var useSentimentAnalysis = (options = {}) => {
     result: null
   });
   const pipelineRef = useRef(null);
-  const analyze = useCallback(async (text5) => {
+  const analyze = useCallback(async (text6) => {
     setState((prev) => ({
       ...prev,
       isProcessing: true,
@@ -594,12 +601,12 @@ var useSentimentAnalysis = (options = {}) => {
         pipelineRef.current = await pipeline("sentiment-analysis", options.model || defaultModel);
       }
       setState((prev) => ({ ...prev, status: "analyzing" }));
-      const output = await pipelineRef.current(text5);
+      const output = await pipelineRef.current(text6);
       const resultData = output[0];
       const label = resultData.label.toLowerCase();
       let sentiment = "neutral";
       const negativeKeywords = ["\u7D2F", "\u60E8", "\u7EDD\u671B", "\u96BE\u53D7", "\u4F24\u5FC3", "\u5DEE", "\u574F", "\u7CDF", "\u4E0D\u884C"];
-      const hasNegativeKeyword = negativeKeywords.some((k) => text5.includes(k));
+      const hasNegativeKeyword = negativeKeywords.some((k) => text6.includes(k));
       if (label.includes("positive") && !hasNegativeKeyword) {
         sentiment = "positive";
       } else if (label.includes("negative") || label.includes("0") || hasNegativeKeyword) {
@@ -631,12 +638,12 @@ var SentimentAnalyzer = ({
   className = "",
   placeholder = "\u8F93\u5165\u4E00\u6BB5\u4E2D\u6587\u6216\u82F1\u6587\uFF0C\u5206\u6790\u5176\u60C5\u611F\u503E\u5411..."
 }) => {
-  const [text5, setText] = useState("");
+  const [text6, setText] = useState("");
   const { analyze, isProcessing, status, result, error } = useSentimentAnalysis();
   const handleAnalyze = async () => {
-    if (!text5.trim() || isProcessing) return;
+    if (!text6.trim() || isProcessing) return;
     try {
-      const res = await analyze(text5);
+      const res = await analyze(text6);
       onResult?.(res);
     } catch (err) {
       console.error("Sentiment Analysis Error:", err);
@@ -667,7 +674,7 @@ var SentimentAnalyzer = ({
   return /* @__PURE__ */ React69__default.createElement("div", { className: clsx("p-6 border rounded-xl bg-white dark:bg-gray-800 shadow-sm", className) }, /* @__PURE__ */ React69__default.createElement("div", { className: "flex items-center gap-2 mb-4 text-gray-700 dark:text-gray-300 font-medium" }, /* @__PURE__ */ React69__default.createElement(MessageSquare, { size: 20 }), /* @__PURE__ */ React69__default.createElement("span", null, "\u6587\u672C\u60C5\u611F\u5206\u6790")), /* @__PURE__ */ React69__default.createElement("div", { className: "relative" }, /* @__PURE__ */ React69__default.createElement(
     "textarea",
     {
-      value: text5,
+      value: text6,
       onChange: (e) => setText(e.target.value),
       placeholder,
       className: "w-full h-32 p-4 bg-gray-50 dark:bg-gray-900 border border-gray-200 dark:border-gray-700 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent transition-all outline-none resize-none text-gray-800 dark:text-gray-200",
@@ -677,7 +684,7 @@ var SentimentAnalyzer = ({
     "button",
     {
       onClick: handleAnalyze,
-      disabled: !text5.trim() || isProcessing,
+      disabled: !text6.trim() || isProcessing,
       className: "absolute bottom-3 right-3 p-2 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-400 text-white rounded-md transition-colors shadow-sm"
     },
     isProcessing ? /* @__PURE__ */ React69__default.createElement(Loader2, { className: "animate-spin", size: 18 }) : /* @__PURE__ */ React69__default.createElement(Send, { size: 18 })
@@ -865,13 +872,13 @@ var requestJson = async (options) => {
       body: body ? JSON.stringify(body) : void 0,
       signal: controller?.signal
     });
-    const text5 = await response.text();
+    const text6 = await response.text();
     let data = null;
-    if (text5) {
+    if (text6) {
       try {
-        data = JSON.parse(text5);
+        data = JSON.parse(text6);
       } catch {
-        data = text5;
+        data = text6;
       }
     }
     if (!response.ok) {
@@ -1332,20 +1339,20 @@ var japaneseUtils = {
   /**
    * 提取文本中的汉字
    */
-  extractKanji(text5) {
-    return text5.match(/[\u4E00-\u9FAF]/g) || [];
+  extractKanji(text6) {
+    return text6.match(/[\u4E00-\u9FAF]/g) || [];
   },
   /**
    * 提取文本中的假名
    */
-  extractKana(text5) {
-    return text5.match(/[\u3040-\u309F\u30A0-\u30FF]/g) || [];
+  extractKana(text6) {
+    return text6.match(/[\u3040-\u309F\u30A0-\u30FF]/g) || [];
   },
   /**
    * 清理文本，移除特殊字符但保留日语字符
    */
-  cleanText(text5) {
-    return text5.replace(/[^\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF\w\s]/g, "");
+  cleanText(text6) {
+    return text6.replace(/[^\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF\w\s]/g, "");
   }
 };
 
@@ -1434,11 +1441,11 @@ var fileUtils = {
    * 生成唯一文件名
    */
   generateUniqueFileName(originalName) {
-    const timestamp5 = Date.now();
+    const timestamp6 = Date.now();
     const random = Math.random().toString(36).substring(2, 15);
     const extension = this.getFileExtension(originalName);
     const baseName = originalName.replace("." + extension, "");
-    return extension ? baseName + "_" + timestamp5 + "_" + random + "." + extension : baseName + "_" + timestamp5 + "_" + random;
+    return extension ? baseName + "_" + timestamp6 + "_" + random + "." + extension : baseName + "_" + timestamp6 + "_" + random;
   },
   /**
    * 验证文件名是否有效
@@ -1508,28 +1515,28 @@ var stringUtils = {
   /**
    * 截断文本
    */
-  truncate(text5, length, suffix = "...") {
-    if (text5.length <= length) return text5;
-    return text5.substring(0, length - suffix.length) + suffix;
+  truncate(text6, length, suffix = "...") {
+    if (text6.length <= length) return text6;
+    return text6.substring(0, length - suffix.length) + suffix;
   },
   /**
    * 首字母大写
    */
-  capitalize(text5) {
-    if (!text5) return "";
-    return text5.charAt(0).toUpperCase() + text5.slice(1).toLowerCase();
+  capitalize(text6) {
+    if (!text6) return "";
+    return text6.charAt(0).toUpperCase() + text6.slice(1).toLowerCase();
   },
   /**
    * 驼峰转下划线
    */
-  camelToSnake(text5) {
-    return text5.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase());
+  camelToSnake(text6) {
+    return text6.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase());
   },
   /**
    * 下划线转驼峰
    */
-  snakeToCamel(text5) {
-    return text5.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  snakeToCamel(text6) {
+    return text6.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
   },
   /**
    * 生成随机字符串
@@ -5648,9 +5655,9 @@ var UserInfoBar = ({ apiClient }) => {
   ))));
 };
 function DanmakuPanel({ onSend }) {
-  const [text5, setText] = useState("");
+  const [text6, setText] = useState("");
   const emit = () => {
-    const value = text5.trim();
+    const value = text6.trim();
     if (!value) {
       return;
     }
@@ -5661,7 +5668,7 @@ function DanmakuPanel({ onSend }) {
     "input",
     {
       type: "text",
-      value: text5,
+      value: text6,
       onChange: (event) => setText(event.target.value),
       onKeyDown: (event) => {
         if (event.key === "Enter") {
@@ -5777,8 +5784,8 @@ function useDanmakuController(options) {
     cursorRef.current += 1;
   }, []);
   const send = useCallback(
-    (text5, color, sendOptions) => {
-      const trimmed = text5.trim();
+    (text6, color, sendOptions) => {
+      const trimmed = text6.trim();
       if (!trimmed) {
         return null;
       }
@@ -5815,26 +5822,26 @@ function useDanmakuController(options) {
     [addIncoming, items, removeItem, send]
   );
 }
-function parseCommand(text5) {
-  if (text5.startsWith("/miku ")) {
-    return { launchKind: "miku", content: text5.replace("/miku ", "").trim() };
+function parseCommand(text6) {
+  if (text6.startsWith("/miku ")) {
+    return { launchKind: "miku", content: text6.replace("/miku ", "").trim() };
   }
-  if (text5 === "/miku") {
+  if (text6 === "/miku") {
     return { launchKind: "miku", content: "MIKU!" };
   }
-  if (text5.startsWith("/avatar ")) {
-    return { launchKind: "avatar", content: text5.replace("/avatar ", "").trim() };
+  if (text6.startsWith("/avatar ")) {
+    return { launchKind: "avatar", content: text6.replace("/avatar ", "").trim() };
   }
-  if (text5 === "/avatar") {
+  if (text6 === "/avatar") {
     return { launchKind: "avatar", content: "Avatar Firework!" };
   }
-  if (text5.startsWith("/normal ")) {
-    return { launchKind: "normal", content: text5.replace("/normal ", "").trim() };
+  if (text6.startsWith("/normal ")) {
+    return { launchKind: "normal", content: text6.replace("/normal ", "").trim() };
   }
-  if (text5 === "/normal") {
+  if (text6 === "/normal") {
     return { launchKind: "normal", content: "Fireworks!" };
   }
-  return { content: text5 };
+  return { content: text6 };
 }
 function createCircularSpriteTexture() {
   const size = 64;
@@ -6516,12 +6523,12 @@ var WebSocketTransport = class {
   }
 };
 function parseServerMessage(raw) {
-  const text5 = decodeMessage(raw);
-  if (!text5) {
+  const text6 = decodeMessage(raw);
+  if (!text6) {
     return null;
   }
   try {
-    return JSON.parse(text5);
+    return JSON.parse(text6);
   } catch {
     return null;
   }
@@ -6788,8 +6795,8 @@ function MikuFireworks3D({
     }
     launch(payload);
   };
-  const handleSendDanmaku = (text5) => {
-    const result = send(text5, void 0, {
+  const handleSendDanmaku = (text6) => {
+    const result = send(text6, void 0, {
       optimistic: !realtimeEnabled
     });
     if (!result) {
@@ -6888,9 +6895,9 @@ function useScreenReceiver(options) {
   const peerRef = useRef({ pendingCandidates: [] });
   const videoRef = useRef(null);
   const appendLog = useCallback(
-    (text5) => {
+    (text6) => {
       logIdRef.current += 1;
-      setLogs((prev) => [...prev, { id: logIdRef.current, text: text5 }].slice(-maxLogs));
+      setLogs((prev) => [...prev, { id: logIdRef.current, text: text6 }].slice(-maxLogs));
     },
     [maxLogs]
   );
@@ -7616,8 +7623,8 @@ var withRoundedClip = (ctx, left, top, width, height, radius, draw) => {
   draw();
   ctx.restore();
 };
-var drawMultilineText = (ctx, text5, left, top, maxWidth, lineHeight) => {
-  const paragraphs = text5.split("\n");
+var drawMultilineText = (ctx, text6, left, top, maxWidth, lineHeight) => {
+  const paragraphs = text6.split("\n");
   let currentY = top;
   paragraphs.forEach((paragraph, index) => {
     const words = paragraph.split("");
@@ -8774,6 +8781,1244 @@ var BoothConfigPage = ({ initialConfig, onSave }) => {
   )), /* @__PURE__ */ React69__default.createElement("div", { className: "flex gap-2" }, /* @__PURE__ */ React69__default.createElement("button", { className: "rounded bg-indigo-600 px-3 py-2 text-white", disabled: saving, onClick: save }, saving ? "\u4FDD\u5B58\u4E2D..." : "\u4FDD\u5B58\u914D\u7F6E"), /* @__PURE__ */ React69__default.createElement("button", { className: "rounded border px-3 py-2", onClick: reset }, "\u6062\u590D\u9ED8\u8BA4")));
 };
 
+// src/mikuContest/logic/shared/defaults.ts
+var defaultMikuVotingRules = {
+  maxVotesPerDay: 3,
+  forbidDuplicateVotePerWork: true,
+  maxVotesPerDevicePerDay: 20,
+  maxVotesPerIpPerDay: 100
+};
+var createDefaultMikuContestConfig = (overrides) => ({
+  id: overrides?.id || "miku-contest-default",
+  name: overrides?.name || "\u521D\u97F3\u672A\u6765\u793E\u56E2\u5F81\u7A3F\u5927\u8D5B",
+  theme: overrides?.theme || "\u521D\u97F3\u672A\u6765\u4E3B\u9898\u521B\u4F5C\u5F81\u7A3F",
+  organizer: overrides?.organizer || "\u521D\u97F3\u672A\u6765\u793E\u56E2",
+  awards: overrides?.awards || ["\u4E00\u7B49\u5956", "\u4E8C\u7B49\u5956", "\u4E09\u7B49\u5956", "\u4EBA\u6C14\u5956"],
+  rules: overrides?.rules || "\u8BF7\u786E\u4FDD\u4F5C\u54C1\u539F\u521B\u4E14\u7B26\u5408\u793E\u56E2\u89C4\u8303\u3002",
+  copyright: overrides?.copyright || "\u6295\u7A3F\u5373\u89C6\u4E3A\u6388\u6743\u8D5B\u4E8B\u5C55\u793A\u4E0E\u516C\u793A\u3002",
+  timeline: overrides?.timeline || {
+    submissionStartAt: (/* @__PURE__ */ new Date()).toISOString(),
+    submissionEndAt: (/* @__PURE__ */ new Date()).toISOString(),
+    votingStartAt: (/* @__PURE__ */ new Date()).toISOString(),
+    votingEndAt: (/* @__PURE__ */ new Date()).toISOString(),
+    publicResultAt: (/* @__PURE__ */ new Date()).toISOString()
+  },
+  votingRules: {
+    ...defaultMikuVotingRules,
+    ...overrides?.votingRules || {}
+  },
+  toggles: {
+    submissionEnabled: overrides?.toggles?.submissionEnabled ?? true,
+    votingEnabled: overrides?.toggles?.votingEnabled ?? true,
+    resultEnabled: overrides?.toggles?.resultEnabled ?? false
+  }
+});
+
+// src/mikuContest/logic/shared/validators.ts
+var DESCRIPTION_LIMIT = 500;
+var MINIAPP_DESCRIPTION_LIMIT = 200;
+var TEXT_CONTENT_LIMIT = 2e3;
+var MAX_TAGS = 3;
+var hasValue = (value) => {
+  return typeof value === "string" ? value.trim().length > 0 : value !== null && value !== void 0;
+};
+var validateByType = (type, input) => {
+  const errors = [];
+  const { content } = input;
+  switch (type) {
+    case "visual": {
+      const imageCount = content.images?.length || 0;
+      if (imageCount < 1 || imageCount > 3) {
+        errors.push("\u89C6\u89C9\u7C7B\u4F5C\u54C1\u9700\u4E0A\u4F20 1-3 \u5F20\u56FE\u7247");
+      }
+      break;
+    }
+    case "video": {
+      if (!hasValue(content.videoLink)) {
+        errors.push("\u89C6\u9891\u7C7B\u4F5C\u54C1\u9700\u63D0\u4F9B\u89C6\u9891\u94FE\u63A5");
+      }
+      if (!hasValue(content.coverImage)) {
+        errors.push("\u89C6\u9891\u7C7B\u4F5C\u54C1\u9700\u63D0\u4F9B\u5C01\u9762\u56FE");
+      }
+      break;
+    }
+    case "text": {
+      const text6 = content.textContent || "";
+      if (!text6.trim()) {
+        errors.push("\u6587\u5B57\u7C7B\u4F5C\u54C1\u9700\u586B\u5199\u6B63\u6587");
+      }
+      if (text6.length > TEXT_CONTENT_LIMIT) {
+        errors.push(`\u6587\u5B57\u6B63\u6587\u4E0D\u80FD\u8D85\u8FC7 ${TEXT_CONTENT_LIMIT} \u5B57`);
+      }
+      break;
+    }
+    case "audio": {
+      if (!hasValue(content.audioLink)) {
+        errors.push("\u97F3\u9891\u7C7B\u4F5C\u54C1\u9700\u63D0\u4F9B\u97F3\u9891\u94FE\u63A5");
+      }
+      break;
+    }
+  }
+  return errors;
+};
+var validateMikuSubmissionInput = (input, mode = "web") => {
+  const errors = [];
+  if (!input.contestId.trim()) errors.push("contestId \u4E0D\u80FD\u4E3A\u7A7A");
+  if (!input.authorId.trim()) errors.push("authorId \u4E0D\u80FD\u4E3A\u7A7A");
+  if (!input.authorNickname.trim()) errors.push("\u4F5C\u8005\u6635\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+  if (!input.title.trim()) errors.push("\u4F5C\u54C1\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+  const descriptionLimit = mode === "miniapp" ? MINIAPP_DESCRIPTION_LIMIT : DESCRIPTION_LIMIT;
+  if (input.description.length > descriptionLimit) {
+    errors.push(`\u4F5C\u54C1\u7B80\u4ECB\u4E0D\u80FD\u8D85\u8FC7 ${descriptionLimit} \u5B57`);
+  }
+  if ((input.tags?.length || 0) > MAX_TAGS) {
+    errors.push(`\u6807\u7B7E\u6700\u591A ${MAX_TAGS} \u4E2A`);
+  }
+  errors.push(...validateByType(input.type, input));
+  return errors;
+};
+
+// src/mikuContest/logic/shared/voting.ts
+var toVoteDayKey = (date = /* @__PURE__ */ new Date()) => {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+};
+var checkVoteEligibility = (context) => {
+  const { existingVotes, submissionId, voterId, dayKey, rules } = context;
+  const userTodayVotes = existingVotes.filter((vote) => vote.voterId === voterId && vote.dayKey === dayKey);
+  if (userTodayVotes.length >= rules.maxVotesPerDay) {
+    return { ok: false, reason: "\u5DF2\u8FBE\u5230\u4ECA\u65E5\u6295\u7968\u4E0A\u9650" };
+  }
+  if (rules.forbidDuplicateVotePerWork) {
+    const duplicated = userTodayVotes.some((vote) => vote.submissionId === submissionId);
+    if (duplicated) return { ok: false, reason: "\u4E0D\u53EF\u91CD\u590D\u6295\u540C\u4E00\u4F5C\u54C1" };
+  }
+  return { ok: true };
+};
+var sortByVotesDesc = (items) => {
+  return [...items].sort((a, b) => {
+    if (b.voteCount === a.voteCount) {
+      return (a.createdAt || "").localeCompare(b.createdAt || "");
+    }
+    return b.voteCount - a.voteCount;
+  });
+};
+var randomId = (prefix) => {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+};
+var serialNo = () => {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const seq = Math.floor(Math.random() * 9e3 + 1e3);
+  return `MIKU-${y}${m}${d}-${seq}`;
+};
+var MikuContestService = class {
+  constructor(options = {}) {
+    this.submissions = /* @__PURE__ */ new Map();
+    this.votes = [];
+    this.announcements = /* @__PURE__ */ new Map();
+    this.voterRestrictions = /* @__PURE__ */ new Map();
+    this.contest = createDefaultMikuContestConfig(options.contestConfig);
+  }
+  getContestConfig() {
+    return this.contest;
+  }
+  updateContestConfig(patch) {
+    this.contest = {
+      ...this.contest,
+      ...patch,
+      votingRules: {
+        ...this.contest.votingRules,
+        ...patch.votingRules || {}
+      },
+      toggles: {
+        ...this.contest.toggles,
+        ...patch.toggles || {}
+      },
+      timeline: {
+        ...this.contest.timeline,
+        ...patch.timeline || {}
+      }
+    };
+    return this.contest;
+  }
+  createSubmission(input, mode = "web") {
+    if (!this.contest.toggles.submissionEnabled) {
+      throw new Error("\u5F53\u524D\u672A\u5F00\u653E\u6295\u7A3F");
+    }
+    const errors = validateMikuSubmissionInput(input, mode);
+    if (errors.length > 0) {
+      throw new Error(errors.join("\uFF1B"));
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = {
+      id: randomId("submission"),
+      serialNo: serialNo(),
+      contestId: input.contestId,
+      authorId: input.authorId,
+      authorNickname: input.authorNickname,
+      title: input.title,
+      type: input.type,
+      description: input.description,
+      tags: input.tags || [],
+      content: input.content,
+      voteCount: 0,
+      status: "pending",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.submissions.set(next.id, next);
+    return next;
+  }
+  listSubmissions(filter) {
+    const authorKeyword = filter?.authorKeyword?.trim().toLowerCase();
+    const titleKeyword = filter?.titleKeyword?.trim().toLowerCase();
+    return [...this.submissions.values()].filter((item) => {
+      if (filter?.status && item.status !== filter.status) return false;
+      if (filter?.type && item.type !== filter.type) return false;
+      if (filter?.authorId && item.authorId !== filter.authorId) return false;
+      if (authorKeyword && !item.authorNickname.toLowerCase().includes(authorKeyword)) return false;
+      if (titleKeyword && !item.title.toLowerCase().includes(titleKeyword)) return false;
+      return true;
+    });
+  }
+  getSubmission(submissionId) {
+    return this.submissions.get(submissionId) || null;
+  }
+  reviewSubmission(input) {
+    const current = this.submissions.get(input.submissionId);
+    if (!current) throw new Error("\u6295\u7A3F\u4E0D\u5B58\u5728");
+    if (input.action === "reject" && !input.rejectReason?.trim()) {
+      throw new Error("\u9A73\u56DE\u9700\u586B\u5199\u539F\u56E0");
+    }
+    const reviewed = {
+      ...current,
+      status: input.action === "approve" ? "approved" : "rejected",
+      rejectReason: input.action === "reject" ? input.rejectReason?.trim() : void 0,
+      reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.submissions.set(reviewed.id, reviewed);
+    return reviewed;
+  }
+  vote(input) {
+    if (!this.contest.toggles.votingEnabled) {
+      throw new Error("\u5F53\u524D\u672A\u5F00\u653E\u6295\u7968");
+    }
+    const restriction = this.voterRestrictions.get(input.voterId);
+    if (restriction?.banned) {
+      throw new Error("\u5F53\u524D\u8D26\u53F7\u5DF2\u88AB\u9650\u5236\u6295\u7968");
+    }
+    const target = this.submissions.get(input.submissionId);
+    if (!target) throw new Error("\u4F5C\u54C1\u4E0D\u5B58\u5728");
+    if (target.status !== "approved") throw new Error("\u4EC5\u53EF\u5BF9\u5DF2\u8FC7\u5BA1\u4F5C\u54C1\u6295\u7968");
+    const dayKey = toVoteDayKey();
+    const eligible = checkVoteEligibility({
+      existingVotes: this.votes,
+      submissionId: input.submissionId,
+      voterId: input.voterId,
+      dayKey,
+      rules: this.contest.votingRules
+    });
+    if (!eligible.ok) {
+      throw new Error(eligible.reason || "\u6295\u7968\u5931\u8D25");
+    }
+    const vote = {
+      id: randomId("vote"),
+      contestId: input.contestId,
+      submissionId: input.submissionId,
+      voterId: input.voterId,
+      votedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      dayKey,
+      deviceId: input.deviceId,
+      ip: input.ip
+    };
+    this.votes.push(vote);
+    const updated = {
+      ...target,
+      voteCount: target.voteCount + 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.submissions.set(updated.id, updated);
+    return updated;
+  }
+  getVoterRestriction(voterId) {
+    return this.voterRestrictions.get(voterId) || null;
+  }
+  setVoterRestriction(input) {
+    const next = {
+      voterId: input.voterId,
+      banned: input.banned,
+      reason: input.reason,
+      operatorId: input.operatorId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.voterRestrictions.set(input.voterId, next);
+    return next;
+  }
+  resetVotes(input) {
+    if (!input.submissionId && !input.voterId) {
+      throw new Error("submissionId \u4E0E voterId \u81F3\u5C11\u63D0\u4F9B\u4E00\u4E2A");
+    }
+    const before = this.votes.length;
+    const affected = /* @__PURE__ */ new Set();
+    const remained = this.votes.filter((vote) => {
+      const matchSubmission = input.submissionId ? vote.submissionId === input.submissionId : true;
+      const matchVoter = input.voterId ? vote.voterId === input.voterId : true;
+      const shouldRemove = matchSubmission && matchVoter;
+      if (shouldRemove) affected.add(vote.submissionId);
+      return !shouldRemove;
+    });
+    this.votes.length = 0;
+    this.votes.push(...remained);
+    this.recalculateVoteCounts();
+    return {
+      removedVotes: before - remained.length,
+      affectedSubmissions: [...affected]
+    };
+  }
+  listAnnouncements(contestId) {
+    const all = [...this.announcements.values()];
+    return contestId ? all.filter((item) => item.contestId === contestId) : all;
+  }
+  publishAnnouncement(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const announcement = {
+      id: randomId("notice"),
+      contestId: input.contestId,
+      title: input.title,
+      content: input.content,
+      type: input.type,
+      createdBy: input.createdBy,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.announcements.set(announcement.id, announcement);
+    return announcement;
+  }
+  getLeaderboard(limit = 10) {
+    const ranked = sortByVotesDesc(this.listSubmissions({ status: "approved" })).slice(0, limit);
+    return ranked.map((item, index) => ({
+      submissionId: item.id,
+      title: item.title,
+      authorNickname: item.authorNickname,
+      voteCount: item.voteCount,
+      rank: index + 1
+    }));
+  }
+  getSnapshot() {
+    return {
+      contest: this.contest,
+      submissions: this.listSubmissions(),
+      announcements: this.listAnnouncements(),
+      leaderboard: this.getLeaderboard()
+    };
+  }
+  getSubmissionExportRows(filter) {
+    return this.listSubmissions(filter).map((item) => ({
+      \u6295\u7A3F\u7F16\u53F7: item.serialNo,
+      \u6295\u7A3FID: item.id,
+      \u8D5B\u4E8BID: item.contestId,
+      \u4F5C\u8005ID: item.authorId,
+      \u4F5C\u8005\u6635\u79F0: item.authorNickname,
+      \u4F5C\u54C1\u540D\u79F0: item.title,
+      \u4F5C\u54C1\u7C7B\u578B: item.type,
+      \u7B80\u4ECB: item.description,
+      \u6807\u7B7E: item.tags.join(","),
+      \u5BA1\u6838\u72B6\u6001: item.status,
+      \u9A73\u56DE\u539F\u56E0: item.rejectReason || "",
+      \u7968\u6570: item.voteCount,
+      \u63D0\u4EA4\u65F6\u95F4: item.createdAt,
+      \u66F4\u65B0\u65F6\u95F4: item.updatedAt
+    }));
+  }
+  exportSubmissionExcel(filter) {
+    const rows = this.getSubmissionExportRows(filter);
+    const workbook = XLSX.utils.book_new();
+    const worksheet = XLSX.utils.json_to_sheet(rows);
+    XLSX.utils.book_append_sheet(workbook, worksheet, "submissions");
+    return XLSX.write(workbook, { bookType: "xlsx", type: "buffer" });
+  }
+  recalculateVoteCounts() {
+    const counts = /* @__PURE__ */ new Map();
+    for (const vote of this.votes) {
+      counts.set(vote.submissionId, (counts.get(vote.submissionId) || 0) + 1);
+    }
+    for (const [id, submission] of this.submissions.entries()) {
+      const nextCount = counts.get(id) || 0;
+      if (submission.voteCount === nextCount) continue;
+      this.submissions.set(id, {
+        ...submission,
+        voteCount: nextCount,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  exportPersistenceState() {
+    return {
+      contest: this.contest,
+      submissions: [...this.submissions.values()],
+      votes: [...this.votes],
+      announcements: [...this.announcements.values()],
+      voterRestrictions: [...this.voterRestrictions.values()],
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  importPersistenceState(state) {
+    this.contest = state.contest;
+    this.submissions.clear();
+    this.announcements.clear();
+    this.voterRestrictions.clear();
+    this.votes.length = 0;
+    for (const item of state.submissions) {
+      this.submissions.set(item.id, item);
+    }
+    for (const item of state.announcements) {
+      this.announcements.set(item.id, item);
+    }
+    for (const item of state.voterRestrictions) {
+      this.voterRestrictions.set(item.voterId, item);
+    }
+    this.votes.push(...state.votes);
+  }
+};
+var createMikuContestService = (options) => {
+  return new MikuContestService(options);
+};
+var mikuContestConfigs = pgTable("miku_contest_configs", {
+  contestId: text("contest_id").primaryKey(),
+  config: jsonb("config").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+});
+var mikuContestSubmissions = pgTable("miku_contest_submissions", {
+  id: text("id").primaryKey(),
+  contestId: text("contest_id").notNull(),
+  serialNo: text("serial_no").notNull(),
+  authorId: text("author_id").notNull(),
+  authorNickname: text("author_nickname").notNull(),
+  title: text("title").notNull(),
+  type: text("type").notNull(),
+  description: text("description").notNull(),
+  tags: jsonb("tags").$type().notNull(),
+  content: jsonb("content").$type().notNull(),
+  voteCount: integer("vote_count").notNull().default(0),
+  status: text("status").notNull(),
+  rejectReason: text("reject_reason"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+  reviewedAt: timestamp("reviewed_at", { withTimezone: true }),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+});
+var mikuContestVotes = pgTable("miku_contest_votes", {
+  id: text("id").primaryKey(),
+  contestId: text("contest_id").notNull(),
+  submissionId: text("submission_id").notNull(),
+  voterId: text("voter_id").notNull(),
+  votedAt: text("voted_at").notNull(),
+  dayKey: text("day_key").notNull(),
+  deviceId: text("device_id"),
+  ip: text("ip")
+});
+var mikuContestNotices = pgTable("miku_contest_notices", {
+  id: text("id").primaryKey(),
+  contestId: text("contest_id").notNull(),
+  title: text("title").notNull(),
+  content: text("content").notNull(),
+  type: text("type").notNull(),
+  createdBy: text("created_by").notNull(),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var mikuContestVoterRestrictions = pgTable("miku_contest_voter_restrictions", {
+  id: text("id").primaryKey(),
+  contestId: text("contest_id").notNull(),
+  data: jsonb("data").$type().notNull()
+});
+var MikuContestStateDbService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async loadState(contestId) {
+    const configRows = await this.db.select({ config: mikuContestConfigs.config }).from(mikuContestConfigs).where(eq(mikuContestConfigs.contestId, contestId)).limit(1);
+    const config = configRows[0]?.config;
+    if (!config) return null;
+    const [submissions, votes, announcements, restrictions] = await Promise.all([
+      this.db.select().from(mikuContestSubmissions).where(eq(mikuContestSubmissions.contestId, contestId)),
+      this.db.select().from(mikuContestVotes).where(eq(mikuContestVotes.contestId, contestId)),
+      this.db.select().from(mikuContestNotices).where(eq(mikuContestNotices.contestId, contestId)),
+      this.db.select({ data: mikuContestVoterRestrictions.data }).from(mikuContestVoterRestrictions).where(eq(mikuContestVoterRestrictions.contestId, contestId))
+    ]);
+    return {
+      contest: config,
+      submissions,
+      votes,
+      announcements,
+      voterRestrictions: restrictions.map((item) => item.data),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async saveState(state) {
+    const contestId = state.contest.id;
+    const exists = await this.db.select({ contestId: mikuContestConfigs.contestId }).from(mikuContestConfigs).where(eq(mikuContestConfigs.contestId, contestId)).limit(1);
+    if (exists[0]) {
+      await this.db.update(mikuContestConfigs).set({
+        config: state.contest,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(eq(mikuContestConfigs.contestId, contestId));
+    } else {
+      await this.db.insert(mikuContestConfigs).values({
+        contestId,
+        config: state.contest
+      });
+    }
+    await this.db.delete(mikuContestSubmissions).where(eq(mikuContestSubmissions.contestId, contestId));
+    await this.db.delete(mikuContestVotes).where(eq(mikuContestVotes.contestId, contestId));
+    await this.db.delete(mikuContestNotices).where(eq(mikuContestNotices.contestId, contestId));
+    await this.db.delete(mikuContestVoterRestrictions).where(eq(mikuContestVoterRestrictions.contestId, contestId));
+    if (state.submissions.length > 0) {
+      await this.db.insert(mikuContestSubmissions).values(
+        state.submissions.map((item) => ({
+          ...item,
+          contestId,
+          createdAt: new Date(item.createdAt),
+          reviewedAt: item.reviewedAt ? new Date(item.reviewedAt) : null,
+          updatedAt: new Date(item.updatedAt)
+        }))
+      );
+    }
+    if (state.votes.length > 0) {
+      await this.db.insert(mikuContestVotes).values(state.votes);
+    }
+    if (state.announcements.length > 0) {
+      await this.db.insert(mikuContestNotices).values(state.announcements);
+    }
+    if (state.voterRestrictions.length > 0) {
+      await this.db.insert(mikuContestVoterRestrictions).values(
+        state.voterRestrictions.map((item) => ({
+          id: `${contestId}:${item.voterId}`,
+          contestId,
+          data: item
+        }))
+      );
+    }
+  }
+};
+
+// src/mikuContest/server/persistence/drizzle-adapter.ts
+var createMikuContestDrizzlePersistenceAdapter = (db) => {
+  const service = new MikuContestStateDbService(db);
+  return {
+    loadState: (contestId) => service.loadState(contestId),
+    saveState: (state) => service.saveState(state)
+  };
+};
+
+// src/mikuContest/server/persistence/service.ts
+var MikuContestPersistentService = class {
+  constructor(options) {
+    this.options = options;
+    this.hydrated = false;
+    this.hydrationPromise = null;
+    this.engine = createMikuContestService(options);
+  }
+  async ensureHydrated() {
+    if (this.hydrated) return;
+    if (this.hydrationPromise) return this.hydrationPromise;
+    this.hydrationPromise = (async () => {
+      const contestId = this.engine.getContestConfig().id;
+      const loaded = await this.options.persistenceAdapter.loadState(contestId);
+      if (loaded) {
+        this.engine.importPersistenceState(loaded);
+      } else {
+        await this.options.persistenceAdapter.saveState(this.engine.exportPersistenceState());
+      }
+      this.hydrated = true;
+    })();
+    await this.hydrationPromise;
+  }
+  async persist() {
+    await this.options.persistenceAdapter.saveState(this.engine.exportPersistenceState());
+  }
+  async getContestConfig() {
+    await this.ensureHydrated();
+    return this.engine.getContestConfig();
+  }
+  async updateContestConfig(patch) {
+    await this.ensureHydrated();
+    const data = this.engine.updateContestConfig(patch);
+    await this.persist();
+    return data;
+  }
+  async createSubmission(input, mode = "web") {
+    await this.ensureHydrated();
+    const data = this.engine.createSubmission(input, mode);
+    await this.persist();
+    return data;
+  }
+  async listSubmissions(filter) {
+    await this.ensureHydrated();
+    return this.engine.listSubmissions(filter);
+  }
+  async getSubmission(submissionId) {
+    await this.ensureHydrated();
+    return this.engine.getSubmission(submissionId);
+  }
+  async reviewSubmission(input) {
+    await this.ensureHydrated();
+    const data = this.engine.reviewSubmission(input);
+    await this.persist();
+    return data;
+  }
+  async vote(input) {
+    await this.ensureHydrated();
+    const data = this.engine.vote(input);
+    await this.persist();
+    return data;
+  }
+  async getVoterRestriction(voterId) {
+    await this.ensureHydrated();
+    return this.engine.getVoterRestriction(voterId);
+  }
+  async setVoterRestriction(input) {
+    await this.ensureHydrated();
+    const data = this.engine.setVoterRestriction(input);
+    await this.persist();
+    return data;
+  }
+  async resetVotes(input) {
+    await this.ensureHydrated();
+    const data = this.engine.resetVotes(input);
+    await this.persist();
+    return data;
+  }
+  async listAnnouncements(contestId) {
+    await this.ensureHydrated();
+    return this.engine.listAnnouncements(contestId);
+  }
+  async publishAnnouncement(input) {
+    await this.ensureHydrated();
+    const data = this.engine.publishAnnouncement(input);
+    await this.persist();
+    return data;
+  }
+  async getLeaderboard(limit = 10) {
+    await this.ensureHydrated();
+    return this.engine.getLeaderboard(limit);
+  }
+  async getSnapshot() {
+    await this.ensureHydrated();
+    return this.engine.getSnapshot();
+  }
+  async getSubmissionExportRows(filter) {
+    await this.ensureHydrated();
+    return this.engine.getSubmissionExportRows(filter);
+  }
+  async exportSubmissionExcel(filter) {
+    await this.ensureHydrated();
+    return this.engine.exportSubmissionExcel(filter);
+  }
+};
+var createMikuContestPersistentService = (options) => {
+  return new MikuContestPersistentService(options);
+};
+
+// src/mikuContest/server/db.ts
+var MikuContestDbService = class {
+  constructor() {
+    this._db = null;
+  }
+  setDb(db) {
+    this._db = db;
+  }
+  isConfigured() {
+    return Boolean(this._db);
+  }
+  get db() {
+    if (!this._db) {
+      throw new Error("MikuContestDbService: Database instance not set. Call setDb(db) first.");
+    }
+    return this._db;
+  }
+};
+var mikuContestDbService = new MikuContestDbService();
+
+// src/mikuContest/logic/hooks/useMikuContest.ts
+var useMikuContest = (options) => {
+  const [service] = useState(() => createMikuContestService(options));
+  const [version, setVersion] = useState(0);
+  const refresh = () => setVersion((value) => value + 1);
+  const snapshot = useMemo(() => {
+    return service.getSnapshot();
+  }, [service, version]);
+  return {
+    service,
+    snapshot,
+    refresh
+  };
+};
+
+// src/mikuContest/service/api/client.ts
+var toQueryString = (filter) => {
+  if (!filter) return "";
+  const params = new URLSearchParams();
+  if (filter.status) params.set("status", filter.status);
+  if (filter.type) params.set("type", filter.type);
+  if (filter.authorId) params.set("authorId", filter.authorId);
+  if (filter.authorKeyword) params.set("authorKeyword", filter.authorKeyword);
+  if (filter.titleKeyword) params.set("titleKeyword", filter.titleKeyword);
+  const query = params.toString();
+  return query ? `?${query}` : "";
+};
+var unwrap = (result) => {
+  if (!result.success || result.data === void 0) {
+    throw new Error(result.error || "\u8BF7\u6C42\u5931\u8D25");
+  }
+  return result.data;
+};
+var createMikuContestApiClient = (basePath, requester) => {
+  return {
+    async getSnapshot() {
+      const result = await requester(`${basePath}/contest`, { method: "GET" });
+      return unwrap(result);
+    },
+    async updateContestConfig(patch) {
+      const result = await requester(`${basePath}/contest`, {
+        method: "PATCH",
+        body: patch
+      });
+      return unwrap(result);
+    },
+    async createSubmission(input, mode = "web") {
+      const result = await requester(`${basePath}/submissions`, {
+        method: "POST",
+        body: { payload: input, mode }
+      });
+      return unwrap(result);
+    },
+    async listSubmissions(filter) {
+      const result = await requester(
+        `${basePath}/submissions${toQueryString(filter)}`,
+        { method: "GET" }
+      );
+      return unwrap(result);
+    },
+    async reviewSubmission(input) {
+      const result = await requester(`${basePath}/submissions/review`, {
+        method: "POST",
+        body: input
+      });
+      return unwrap(result);
+    },
+    async vote(input) {
+      const result = await requester(`${basePath}/votes`, {
+        method: "POST",
+        body: input
+      });
+      return unwrap(result);
+    },
+    async setVoterRestriction(input) {
+      const result = await requester(`${basePath}/admin/voter-restrictions`, {
+        method: "POST",
+        body: input
+      });
+      return unwrap(result);
+    },
+    async resetVotes(input) {
+      const result = await requester(
+        `${basePath}/admin/votes/reset`,
+        {
+          method: "POST",
+          body: input
+        }
+      );
+      return unwrap(result);
+    },
+    async exportSubmissions(filter) {
+      const response = await fetch(`${basePath}/admin/submissions/export${toQueryString(filter)}`);
+      if (!response.ok) {
+        throw new Error(`\u5BFC\u51FA\u5931\u8D25: ${response.status}`);
+      }
+      return response.arrayBuffer();
+    }
+  };
+};
+
+// src/mikuContest/service/web/index.ts
+var web_exports = {};
+__export(web_exports, {
+  createMikuContestWebClient: () => createMikuContestWebClient
+});
+
+// src/mikuContest/service/web/client.ts
+var defaultRequester = (options) => {
+  const baseUrl = options.baseUrl || "";
+  const commonHeaders = options.headers || {};
+  return async (url, requestOptions) => {
+    const response = await fetch(`${baseUrl}${url}`, {
+      method: requestOptions?.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...commonHeaders
+      },
+      body: requestOptions?.body ? JSON.stringify(requestOptions.body) : void 0
+    });
+    const json = await response.json();
+    return json;
+  };
+};
+var createMikuContestWebClient = (options = {}) => {
+  const basePath = options.basePath || "/api/miku-contest";
+  return createMikuContestApiClient(basePath, defaultRequester(options));
+};
+
+// src/mikuContest/service/miniapp/index.ts
+var miniapp_exports = {};
+__export(miniapp_exports, {
+  createMikuContestMiniappClient: () => createMikuContestMiniappClient
+});
+
+// src/mikuContest/service/miniapp/client.ts
+var createMikuContestMiniappClient = (options) => {
+  const basePath = options.basePath || "/api/miku-contest";
+  return createMikuContestApiClient(basePath, options.requester);
+};
+var isDrizzleDb = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.select === "function" && typeof candidate.insert === "function" && typeof candidate.update === "function" && typeof candidate.delete === "function";
+};
+var resolveService = (config) => {
+  if (config?.service) return config.service;
+  const adapter = config?.persistenceAdapter || (isDrizzleDb(config?.db) ? createMikuContestDrizzlePersistenceAdapter(config.db) : null);
+  if (adapter) {
+    return createMikuContestPersistentService({
+      persistenceAdapter: adapter
+    });
+  }
+  return createMikuContestService();
+};
+var createGetContestSnapshotHandler = (config) => {
+  const service = resolveService(config);
+  return async (_request) => {
+    const data = await service.getSnapshot();
+    return NextResponse.json({ success: true, data });
+  };
+};
+var createUpdateContestConfigHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    try {
+      const payload = await request.json();
+      const data = await service.updateContestConfig(payload);
+      return NextResponse.json({ success: true, data });
+    } catch (error) {
+      return NextResponse.json({ success: false, error: error.message }, { status: 400 });
+    }
+  };
+};
+var createCreateSubmissionHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    try {
+      const body = await request.json();
+      const mode = body.mode || "web";
+      const payload = body.payload;
+      if (!payload) {
+        return NextResponse.json({ success: false, error: "payload \u4E0D\u80FD\u4E3A\u7A7A" }, { status: 400 });
+      }
+      const data = await service.createSubmission(payload, mode);
+      return NextResponse.json({ success: true, data });
+    } catch (error) {
+      return NextResponse.json({ success: false, error: error.message }, { status: 400 });
+    }
+  };
+};
+var createVoteHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    try {
+      const payload = await request.json();
+      const data = await service.vote(payload);
+      return NextResponse.json({ success: true, data });
+    } catch (error) {
+      return NextResponse.json({ success: false, error: error.message }, { status: 400 });
+    }
+  };
+};
+var createReviewSubmissionHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    try {
+      const payload = await request.json();
+      const data = await service.reviewSubmission(payload);
+      return NextResponse.json({ success: true, data });
+    } catch (error) {
+      return NextResponse.json({ success: false, error: error.message }, { status: 400 });
+    }
+  };
+};
+var buildSubmissionFilterFromQuery = (request) => {
+  const search = request.nextUrl.searchParams;
+  const status = search.get("status");
+  const type = search.get("type");
+  return {
+    status: status ? status : void 0,
+    type: type ? type : void 0,
+    authorId: search.get("authorId") || void 0,
+    authorKeyword: search.get("authorKeyword") || void 0,
+    titleKeyword: search.get("titleKeyword") || void 0
+  };
+};
+var createListSubmissionsHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    const filter = buildSubmissionFilterFromQuery(request);
+    const data = await service.listSubmissions(filter);
+    return NextResponse.json({ success: true, data });
+  };
+};
+var createSetVoterRestrictionHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    try {
+      const payload = await request.json();
+      const data = await service.setVoterRestriction(payload);
+      return NextResponse.json({ success: true, data });
+    } catch (error) {
+      return NextResponse.json({ success: false, error: error.message }, { status: 400 });
+    }
+  };
+};
+var createResetVotesHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    try {
+      const payload = await request.json();
+      const data = await service.resetVotes(payload);
+      return NextResponse.json({ success: true, data });
+    } catch (error) {
+      return NextResponse.json({ success: false, error: error.message }, { status: 400 });
+    }
+  };
+};
+var createExportSubmissionsHandler = (config) => {
+  const service = resolveService(config);
+  return async (request) => {
+    const filter = buildSubmissionFilterFromQuery(request);
+    const data = await service.exportSubmissionExcel(filter);
+    const body = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    return new NextResponse(body, {
+      status: 200,
+      headers: {
+        "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "Content-Disposition": 'attachment; filename="miku-submissions.xlsx"'
+      }
+    });
+  };
+};
+
+// src/mikuContest/ui/web/index.ts
+var web_exports2 = {};
+__export(web_exports2, {
+  MikuContestAdminPage: () => MikuContestAdminPage_default,
+  MikuContestArtistPage: () => MikuContestArtistPage_default,
+  MikuContestAudiencePage: () => MikuContestAudiencePage_default,
+  MikuContestDashboard: () => MikuContestDashboard_default,
+  MikuContestPage: () => MikuContestPage_default
+});
+var MikuContestDashboard = ({ snapshot }) => {
+  return /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h2", null, snapshot.contest.name), /* @__PURE__ */ React69__default.createElement("p", null, snapshot.contest.theme), /* @__PURE__ */ React69__default.createElement("p", null, "\u6295\u7A3F\u6570\uFF1A", snapshot.submissions.length), /* @__PURE__ */ React69__default.createElement("p", null, "\u516C\u544A\u6570\uFF1A", snapshot.announcements.length), /* @__PURE__ */ React69__default.createElement("ul", null, snapshot.leaderboard.map((item) => /* @__PURE__ */ React69__default.createElement("li", { key: item.submissionId }, "#", item.rank, " ", item.title, " - ", item.voteCount, "\u7968"))));
+};
+var MikuContestDashboard_default = MikuContestDashboard;
+var MikuContestAudiencePage = ({
+  client,
+  voterId,
+  title = "\u89C2\u4F17\u6295\u7968\u533A"
+}) => {
+  const api = useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const approvedWorks = useMemo(() => {
+    if (!snapshot) return [];
+    return snapshot.submissions.filter((item) => item.status === "approved");
+  }, [snapshot]);
+  const loadSnapshot = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await api.getSnapshot();
+      setSnapshot(data);
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+  useEffect(() => {
+    void loadSnapshot();
+  }, []);
+  const handleVote = async (submission) => {
+    if (!snapshot) return;
+    try {
+      await api.vote({
+        contestId: snapshot.contest.id,
+        submissionId: submission.id,
+        voterId
+      });
+      await loadSnapshot();
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  return /* @__PURE__ */ React69__default.createElement("section", null, /* @__PURE__ */ React69__default.createElement("h2", null, title), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void loadSnapshot(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React69__default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, !snapshot ? null : /* @__PURE__ */ React69__default.createElement(React69__default.Fragment, null, /* @__PURE__ */ React69__default.createElement("p", null, "\u8D5B\u4E8B\uFF1A", snapshot.contest.name, "\uFF5C\u4E3B\u9898\uFF1A", snapshot.contest.theme), /* @__PURE__ */ React69__default.createElement("p", null, "\u5DF2\u8FC7\u5BA1\u4F5C\u54C1\uFF1A", approvedWorks.length, "\uFF5C\u6BCF\u65E5\u4E0A\u9650\uFF1A", snapshot.contest.votingRules.maxVotesPerDay), /* @__PURE__ */ React69__default.createElement("ul", null, approvedWorks.map((work) => /* @__PURE__ */ React69__default.createElement("li", { key: work.id }, /* @__PURE__ */ React69__default.createElement("strong", null, work.title), "\uFF08", work.authorNickname, "\uFF09- \u5F53\u524D ", work.voteCount, " \u7968", " ", /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void handleVote(work) }, "\u6295\u7968"))))));
+};
+var MikuContestAudiencePage_default = MikuContestAudiencePage;
+var workTypes = ["visual", "video", "text", "audio"];
+var MikuContestArtistPage = ({
+  client,
+  authorId,
+  authorNickname,
+  title = "\u753B\u5E08\u6295\u7A3F\u533A"
+}) => {
+  const api = useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = useState(null);
+  const [mySubmissions, setMySubmissions] = useState([]);
+  const [submitting, setSubmitting] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [titleInput, setTitleInput] = useState("");
+  const [descInput, setDescInput] = useState("");
+  const [coverImage, setCoverImage] = useState("");
+  const [workType, setWorkType] = useState("visual");
+  const loadData = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const [contest, mine] = await Promise.all([
+        api.getSnapshot(),
+        api.listSubmissions({ authorId })
+      ]);
+      setSnapshot(contest);
+      setMySubmissions(mine);
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+  useEffect(() => {
+    void loadData();
+  }, []);
+  const submitWork = async () => {
+    if (!snapshot) return;
+    const payload = {
+      contestId: snapshot.contest.id,
+      authorId,
+      authorNickname,
+      title: titleInput,
+      description: descInput,
+      type: workType,
+      tags: ["web"],
+      content: {
+        coverImage,
+        images: coverImage ? [coverImage] : void 0
+      }
+    };
+    setSubmitting(true);
+    setError(null);
+    try {
+      await api.createSubmission(payload, "web");
+      setTitleInput("");
+      setDescInput("");
+      setCoverImage("");
+      await loadData();
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setSubmitting(false);
+    }
+  };
+  return /* @__PURE__ */ React69__default.createElement("section", null, /* @__PURE__ */ React69__default.createElement("h2", null, title), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void loadData(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React69__default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, "\u65B0\u5EFA\u6295\u7A3F"), /* @__PURE__ */ React69__default.createElement("input", { value: titleInput, onChange: (e) => setTitleInput(e.target.value), placeholder: "\u4F5C\u54C1\u6807\u9898" }), /* @__PURE__ */ React69__default.createElement("br", null), /* @__PURE__ */ React69__default.createElement("textarea", { value: descInput, onChange: (e) => setDescInput(e.target.value), placeholder: "\u4F5C\u54C1\u7B80\u4ECB" }), /* @__PURE__ */ React69__default.createElement("br", null), /* @__PURE__ */ React69__default.createElement("input", { value: coverImage, onChange: (e) => setCoverImage(e.target.value), placeholder: "\u5C01\u9762 URL" }), /* @__PURE__ */ React69__default.createElement("br", null), /* @__PURE__ */ React69__default.createElement("select", { value: workType, onChange: (e) => setWorkType(e.target.value) }, workTypes.map((item) => /* @__PURE__ */ React69__default.createElement("option", { value: item, key: item }, item))), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void submitWork(), disabled: submitting || !snapshot }, submitting ? "\u63D0\u4EA4\u4E2D..." : "\u63D0\u4EA4\u7A3F\u4EF6")), /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, "\u6211\u7684\u6295\u7A3F\uFF08", mySubmissions.length, "\uFF09"), /* @__PURE__ */ React69__default.createElement("ul", null, mySubmissions.map((item) => /* @__PURE__ */ React69__default.createElement("li", { key: item.id }, item.title, "\uFF5C\u72B6\u6001\uFF1A", item.status, "\uFF5C\u7968\u6570\uFF1A", item.voteCount, item.rejectReason ? `\uFF5C\u9A73\u56DE\uFF1A${item.rejectReason}` : "")))));
+};
+var MikuContestArtistPage_default = MikuContestArtistPage;
+var MikuContestAdminPage = ({
+  client,
+  adminId,
+  title = "\u7BA1\u7406\u5458\u9762\u677F"
+}) => {
+  const api = useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = useState(null);
+  const [submissions, setSubmissions] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [voterId, setVoterId] = useState("");
+  const loadData = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const [contest, list] = await Promise.all([api.getSnapshot(), api.listSubmissions()]);
+      setSnapshot(contest);
+      setSubmissions(list);
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+  useEffect(() => {
+    void loadData();
+  }, []);
+  const review = async (item, action) => {
+    try {
+      await api.reviewSubmission({
+        submissionId: item.id,
+        reviewerId: adminId,
+        action,
+        rejectReason: action === "reject" ? "\u7BA1\u7406\u5458\u9A73\u56DE" : void 0
+      });
+      await loadData();
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  const toggleVoting = async (enabled) => {
+    if (!snapshot) return;
+    try {
+      await api.updateContestConfig({
+        toggles: {
+          ...snapshot.contest.toggles,
+          votingEnabled: enabled
+        }
+      });
+      await loadData();
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  const setRestriction = async (banned) => {
+    if (!snapshot || !voterId.trim()) return;
+    try {
+      await api.setVoterRestriction({
+        voterId: voterId.trim(),
+        banned,
+        reason: banned ? "\u7BA1\u7406\u5458\u624B\u52A8\u5C01\u7981" : "\u7BA1\u7406\u5458\u89E3\u9664\u5C01\u7981",
+        operatorId: adminId
+      });
+      setVoterId("");
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  const resetVotesByVoter = async () => {
+    if (!voterId.trim()) return;
+    try {
+      await api.resetVotes({ voterId: voterId.trim() });
+      setVoterId("");
+      await loadData();
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  const exportExcel = async () => {
+    try {
+      const data = await api.exportSubmissions();
+      const blob = new Blob([data], {
+        type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+      });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "miku-submissions.xlsx";
+      a.click();
+      URL.revokeObjectURL(url);
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  return /* @__PURE__ */ React69__default.createElement("section", null, /* @__PURE__ */ React69__default.createElement("h2", null, title), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void loadData(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React69__default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, "\u8D5B\u4E8B\u5F00\u5173"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void toggleVoting(true), disabled: !snapshot }, "\u5F00\u542F\u6295\u7968"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void toggleVoting(false), disabled: !snapshot }, "\u5173\u95ED\u6295\u7968")), /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, "\u6295\u7A3F\u5BA1\u6838\uFF08", submissions.length, "\uFF09"), /* @__PURE__ */ React69__default.createElement("ul", null, submissions.map((item) => /* @__PURE__ */ React69__default.createElement("li", { key: item.id }, /* @__PURE__ */ React69__default.createElement("strong", null, item.title), "\uFF5C\u4F5C\u8005\uFF1A", item.authorNickname, "\uFF5C\u72B6\u6001\uFF1A", item.status, "\uFF5C\u7968\u6570\uFF1A", item.voteCount, item.status === "pending" ? /* @__PURE__ */ React69__default.createElement(React69__default.Fragment, null, " ", /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void review(item, "approve") }, "\u901A\u8FC7"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void review(item, "reject") }, "\u9A73\u56DE")) : null)))), /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, "\u6295\u7968\u98CE\u63A7"), /* @__PURE__ */ React69__default.createElement("input", { value: voterId, onChange: (e) => setVoterId(e.target.value), placeholder: "voterId" }), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void setRestriction(true), disabled: !snapshot }, "\u5C01\u7981\u6295\u7968"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void setRestriction(false), disabled: !snapshot }, "\u89E3\u9664\u5C01\u7981"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void resetVotesByVoter() }, "\u6E05\u96F6\u8BE5\u7528\u6237\u7968\u6570")), /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, "\u5BFC\u51FA"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => void exportExcel() }, "\u5BFC\u51FA\u6295\u7A3F Excel")));
+};
+var MikuContestAdminPage_default = MikuContestAdminPage;
+
+// src/mikuContest/ui/web/pages/MikuContestPage.tsx
+var MikuContestPage = ({
+  defaultView = "audience",
+  viewerVoterId = "viewer-demo",
+  artistId = "artist-demo",
+  artistNickname = "Demo \u753B\u5E08",
+  adminId = "admin-demo"
+}) => {
+  const [view, setView] = useState(defaultView);
+  return /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h1", null, "Miku Contest"), /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("button", { onClick: () => setView("audience") }, "\u89C2\u4F17\u7AEF"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => setView("artist") }, "\u753B\u5E08\u7AEF"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => setView("admin") }, "\u7BA1\u7406\u5458\u7AEF")), view === "audience" ? /* @__PURE__ */ React69__default.createElement(MikuContestAudiencePage_default, { voterId: viewerVoterId }) : null, view === "artist" ? /* @__PURE__ */ React69__default.createElement(MikuContestArtistPage_default, { authorId: artistId, authorNickname: artistNickname }) : null, view === "admin" ? /* @__PURE__ */ React69__default.createElement(MikuContestAdminPage_default, { adminId }) : null);
+};
+var MikuContestPage_default = MikuContestPage;
+
+// src/mikuContest/ui/miniapp/index.ts
+var miniapp_exports2 = {};
+__export(miniapp_exports2, {
+  MikuContestMiniappHome: () => MikuContestMiniappHome_default,
+  MikuContestMiniappPage: () => MikuContestMiniappPage_default
+});
+var MikuContestMiniappHome = ({ snapshot }) => {
+  return /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, snapshot.contest.name), /* @__PURE__ */ React69__default.createElement("p", null, "\u6295\u7A3F\uFF1A", snapshot.submissions.length, " | \u516C\u544A\uFF1A", snapshot.announcements.length), /* @__PURE__ */ React69__default.createElement("ol", null, snapshot.leaderboard.slice(0, 3).map((item) => /* @__PURE__ */ React69__default.createElement("li", { key: item.submissionId }, item.title, "\uFF08", item.voteCount, "\u7968\uFF09"))));
+};
+var MikuContestMiniappHome_default = MikuContestMiniappHome;
+var MikuContestMiniappPage = () => {
+  const { service, snapshot, refresh } = useMikuContest();
+  const [tab, setTab] = useState("vote");
+  const [voterId, setVoterId] = useState("miniapp-voter");
+  const [authorId, setAuthorId] = useState("miniapp-author");
+  const [authorNickname, setAuthorNickname] = useState("\u5C0F\u7A0B\u5E8F\u753B\u5E08");
+  const [title, setTitle] = useState("");
+  const [desc, setDesc] = useState("");
+  const [type, setType] = useState("visual");
+  const [error, setError] = useState(null);
+  const approvedWorks = useMemo(() => {
+    return snapshot.submissions.filter((item) => item.status === "approved");
+  }, [snapshot.submissions]);
+  const vote = (submissionId) => {
+    try {
+      service.vote({
+        contestId: snapshot.contest.id,
+        submissionId,
+        voterId
+      });
+      refresh();
+      setError(null);
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  const submit = () => {
+    try {
+      service.createSubmission(
+        {
+          contestId: snapshot.contest.id,
+          authorId,
+          authorNickname,
+          title,
+          description: desc,
+          type,
+          content: {}
+        },
+        "miniapp"
+      );
+      setTitle("");
+      setDesc("");
+      refresh();
+      setError(null);
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+  return /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("h3", null, snapshot.contest.name), /* @__PURE__ */ React69__default.createElement("p", null, "\u5C0F\u7A0B\u5E8F\u7AEF\u793A\u4F8B\u9875\u9762"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => setTab("vote") }, "\u89C2\u4F17\u6295\u7968"), /* @__PURE__ */ React69__default.createElement("button", { onClick: () => setTab("submit") }, "\u753B\u5E08\u6295\u7A3F"), error ? /* @__PURE__ */ React69__default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, tab === "vote" ? /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("input", { value: voterId, onChange: (e) => setVoterId(e.target.value), placeholder: "voterId" }), /* @__PURE__ */ React69__default.createElement("ul", null, approvedWorks.map((item) => /* @__PURE__ */ React69__default.createElement("li", { key: item.id }, item.title, "\uFF08", item.voteCount, "\u7968\uFF09", /* @__PURE__ */ React69__default.createElement("button", { onClick: () => vote(item.id) }, "\u6295\u7968"))))) : null, tab === "submit" ? /* @__PURE__ */ React69__default.createElement("div", null, /* @__PURE__ */ React69__default.createElement("input", { value: authorId, onChange: (e) => setAuthorId(e.target.value), placeholder: "authorId" }), /* @__PURE__ */ React69__default.createElement("input", { value: authorNickname, onChange: (e) => setAuthorNickname(e.target.value), placeholder: "\u4F5C\u8005\u6635\u79F0" }), /* @__PURE__ */ React69__default.createElement("input", { value: title, onChange: (e) => setTitle(e.target.value), placeholder: "\u4F5C\u54C1\u6807\u9898" }), /* @__PURE__ */ React69__default.createElement("input", { value: desc, onChange: (e) => setDesc(e.target.value), placeholder: "\u4F5C\u54C1\u7B80\u4ECB" }), /* @__PURE__ */ React69__default.createElement("select", { value: type, onChange: (e) => setType(e.target.value) }, /* @__PURE__ */ React69__default.createElement("option", { value: "visual" }, "visual"), /* @__PURE__ */ React69__default.createElement("option", { value: "video" }, "video"), /* @__PURE__ */ React69__default.createElement("option", { value: "text" }, "text"), /* @__PURE__ */ React69__default.createElement("option", { value: "audio" }, "audio")), /* @__PURE__ */ React69__default.createElement("button", { onClick: submit }, "\u63D0\u4EA4")) : null);
+};
+var MikuContestMiniappPage_default = MikuContestMiniappPage;
+
 // src/storage/adapters/react-native-adapter.ts
 var AsyncStorage = null;
 try {
@@ -9127,6 +10372,6 @@ function useElectronStorage(key, defaultValue) {
   return useStorage(electronStorage, key, defaultValue);
 }
 
-export { About_default as About, Dialog as AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, DialogDescription as AlertDialogDescription, DialogFooter as AlertDialogFooter, DialogHeader as AlertDialogHeader, DialogOverlay as AlertDialogOverlay, DialogPortal as AlertDialogPortal, DialogTitle as AlertDialogTitle, DialogTrigger as AlertDialogTrigger, AutoOpenModal, Avatar, AvatarFallback, AvatarImage, BackButton, BackgroundRemover, Badge, BoothConfigPage, BoothRedeemPanel, BoothSuccessCard, BoothUploadPanel, BoothVaultService, Button, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, CategoryFilter, CollisionBalls, CompletionFilterComponent, ConfirmModal, ConsoleLoggerAdapter, Contact_default as Contact, DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_FESTIVAL_CARD_CONFIG, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DanmakuPanel, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DraggableExperimentGrid, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, EnhancedAvatar, ExperimentCard, ExperimentGrid, ExperimentItemGrid, FIREWORK_KIND_LABELS, FestivalCardBook3D, FestivalCardConfigEditor, FestivalCardConfigPage, FestivalCardManagedPage, FestivalCardPageRenderer, FestivalCardService, FestivalCardStudio, FilterButtonGroup, FireworksCanvas, FireworksControlPanel, FloatingMenu_default as FloatingMenu, FloatingMenuExample_default as FloatingMenuExample, GenericOrderManager, Grid, Home_default as Home, ImageMappingPanel, InMemorySkillRegistry, Input, Label, LocalImageMappingPanel, LogLevel, Logger, MIKU_PALETTE, MikuFireworks3D, Modal, NORMAL_PALETTE, Navigation_default as Navigation, NavigationItem_default as NavigationItem, NavigationToggle_default as NavigationToggle, OCRScanner, PageHeader, PermissionGuard, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, ProfileButton, ProfileModal, Progress, ProjectCarousel, ScreenReceiverPanel, ScrollArea, ScrollBar, SearchBox, SearchResultHint, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SentimentAnalyzer, Separator, Dialog as Sheet, DialogClose as SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, DialogOverlay as SheetOverlay, DialogPortal as SheetPortal, SheetTitle, DialogTrigger as SheetTrigger, SmartAssistant, SortControl, SortModeToggle, SortableExperimentItem, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, Timeline, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, UserInfoBar, WebSocketTransport, applyPromptTemplate, arrayUtils, badgeVariants, buttonVariants, cn, createAiClient, createChatSession, createInMemoryFestivalCardDb, createLogger, createOpenAICompatibleProvider, createSkillRegistry, debugUtils, defaultVocaloidBoothConfig, errorUtils, fileUtils, filterExperiments, formatTime, generateMatchCode, getAllTags, getCategoryColor, getCategoryDisplayName, getCompletionFilterDisplayName, getCompletionStatusColor, getCompletionStatusText, getExperimentCounts, japaneseUtils, logger, normalizeFestivalCardConfig, normalizeMatchCode, normalizePromptVariables, normalizeVocaloidBoothConfig, resizeFestivalCardPages, resolveScreenReceiverSignalUrl, skillToToolDefinition, sortExperiments, stringUtils, useAiChat, useAsyncStorage, useBackgroundRemoval, useDanmakuController, useElectronStorage, useFestivalCardConfig, useFireworksEngine, useFireworksRealtime, useLocalStorage, useOCR, useScreenReceiver, useSentimentAnalysis, useStorage, useTaroStorage, useTextGeneration, validateExperiment, validators };
+export { About_default as About, Dialog as AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, DialogDescription as AlertDialogDescription, DialogFooter as AlertDialogFooter, DialogHeader as AlertDialogHeader, DialogOverlay as AlertDialogOverlay, DialogPortal as AlertDialogPortal, DialogTitle as AlertDialogTitle, DialogTrigger as AlertDialogTrigger, AutoOpenModal, Avatar, AvatarFallback, AvatarImage, BackButton, BackgroundRemover, Badge, BoothConfigPage, BoothRedeemPanel, BoothSuccessCard, BoothUploadPanel, BoothVaultService, Button, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, CategoryFilter, CollisionBalls, CompletionFilterComponent, ConfirmModal, ConsoleLoggerAdapter, Contact_default as Contact, DANMAKU_MAX_LENGTH, DANMAKU_TRACK_COUNT, DEFAULT_FESTIVAL_CARD_CONFIG, DEFAULT_MAX_ACTIVE_FIREWORKS, DEFAULT_MAX_PARTICLES, DEFAULT_OPENAI_BASE_URL, DEFAULT_OPENAI_MODEL, DanmakuPanel, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DraggableExperimentGrid, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EmptyState, EnhancedAvatar, ExperimentCard, ExperimentGrid, ExperimentItemGrid, FIREWORK_KIND_LABELS, FestivalCardBook3D, FestivalCardConfigEditor, FestivalCardConfigPage, FestivalCardManagedPage, FestivalCardPageRenderer, FestivalCardService, FestivalCardStudio, FilterButtonGroup, FireworksCanvas, FireworksControlPanel, FloatingMenu_default as FloatingMenu, FloatingMenuExample_default as FloatingMenuExample, GenericOrderManager, Grid, Home_default as Home, ImageMappingPanel, InMemorySkillRegistry, Input, Label, LocalImageMappingPanel, LogLevel, Logger, MIKU_PALETTE, MikuContestPersistentService, MikuContestService, MikuContestStateDbService, MikuFireworks3D, Modal, NORMAL_PALETTE, Navigation_default as Navigation, NavigationItem_default as NavigationItem, NavigationToggle_default as NavigationToggle, OCRScanner, PageHeader, PermissionGuard, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, ProfileButton, ProfileModal, Progress, ProjectCarousel, ScreenReceiverPanel, ScrollArea, ScrollBar, SearchBox, SearchResultHint, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SentimentAnalyzer, Separator, Dialog as Sheet, DialogClose as SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, DialogOverlay as SheetOverlay, DialogPortal as SheetPortal, SheetTitle, DialogTrigger as SheetTrigger, SmartAssistant, SortControl, SortModeToggle, SortableExperimentItem, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, Timeline, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, UserInfoBar, WebSocketTransport, applyPromptTemplate, arrayUtils, badgeVariants, buttonVariants, checkVoteEligibility, cn, createAiClient, createChatSession, createCreateSubmissionHandler, createDefaultMikuContestConfig, createExportSubmissionsHandler, createGetContestSnapshotHandler, createInMemoryFestivalCardDb, createListSubmissionsHandler, createLogger, createMikuContestApiClient, createMikuContestDrizzlePersistenceAdapter, createMikuContestPersistentService, createMikuContestService, createOpenAICompatibleProvider, createResetVotesHandler, createReviewSubmissionHandler, createSetVoterRestrictionHandler, createSkillRegistry, createUpdateContestConfigHandler, createVoteHandler, debugUtils, defaultMikuVotingRules, defaultVocaloidBoothConfig, errorUtils, fileUtils, filterExperiments, formatTime, generateMatchCode, getAllTags, getCategoryColor, getCategoryDisplayName, getCompletionFilterDisplayName, getCompletionStatusColor, getCompletionStatusText, getExperimentCounts, japaneseUtils, logger, mikuContestConfigs, mikuContestDbService, mikuContestNotices, mikuContestSubmissions, mikuContestVoterRestrictions, mikuContestVotes, miniapp_exports as miniappService, miniapp_exports2 as miniappUI, normalizeFestivalCardConfig, normalizeMatchCode, normalizePromptVariables, normalizeVocaloidBoothConfig, resizeFestivalCardPages, resolveScreenReceiverSignalUrl, skillToToolDefinition, sortByVotesDesc, sortExperiments, stringUtils, toVoteDayKey, useAiChat, useAsyncStorage, useBackgroundRemoval, useDanmakuController, useElectronStorage, useFestivalCardConfig, useFireworksEngine, useFireworksRealtime, useLocalStorage, useMikuContest, useOCR, useScreenReceiver, useSentimentAnalysis, useStorage, useTaroStorage, useTextGeneration, validateExperiment, validateMikuSubmissionInput, validators, web_exports as webService, web_exports2 as webUI };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map