sa2kit 1.6.91 → 1.6.92

package/dist/index.js

@@ -18,6 +18,8 @@ var crypto = require('crypto');
 require('bcryptjs');
 require('jsonwebtoken');
 var THREE2 = require('three');
+var XLSX = require('xlsx');
+var server = require('next/server');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -42,13 +44,19 @@ function _interopNamespace(e) {
 var React69__namespace = /*#__PURE__*/_interopNamespace(React69);
 var Link__default = /*#__PURE__*/_interopDefault(Link);
 var THREE2__namespace = /*#__PURE__*/_interopNamespace(THREE2);
+var XLSX__namespace = /*#__PURE__*/_interopNamespace(XLSX);
 
+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) => {
@@ -76,10 +84,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 + ": ";
@@ -572,7 +580,7 @@ var useSentimentAnalysis = (options = {}) => {
     result: null
   });
   const pipelineRef = React69.useRef(null);
-  const analyze = React69.useCallback(async (text5) => {
+  const analyze = React69.useCallback(async (text6) => {
     setState((prev) => ({
       ...prev,
       isProcessing: true,
@@ -619,12 +627,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) {
@@ -656,12 +664,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] = React69.useState("");
+  const [text6, setText] = React69.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);
@@ -692,7 +700,7 @@ var SentimentAnalyzer = ({
   return /* @__PURE__ */ React69__namespace.default.createElement("div", { className: clsx.clsx("p-6 border rounded-xl bg-white dark:bg-gray-800 shadow-sm", className) }, /* @__PURE__ */ React69__namespace.default.createElement("div", { className: "flex items-center gap-2 mb-4 text-gray-700 dark:text-gray-300 font-medium" }, /* @__PURE__ */ React69__namespace.default.createElement(lucideReact.MessageSquare, { size: 20 }), /* @__PURE__ */ React69__namespace.default.createElement("span", null, "\u6587\u672C\u60C5\u611F\u5206\u6790")), /* @__PURE__ */ React69__namespace.default.createElement("div", { className: "relative" }, /* @__PURE__ */ React69__namespace.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",
@@ -702,7 +710,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__namespace.default.createElement(lucideReact.Loader2, { className: "animate-spin", size: 18 }) : /* @__PURE__ */ React69__namespace.default.createElement(lucideReact.Send, { size: 18 })
@@ -890,13 +898,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) {
@@ -1357,20 +1365,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, "");
   }
 };
 
@@ -1459,11 +1467,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;
   },
   /**
    * 验证文件名是否有效
@@ -1533,28 +1541,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());
   },
   /**
    * 生成随机字符串
@@ -5673,9 +5681,9 @@ var UserInfoBar = ({ apiClient }) => {
   ))));
 };
 function DanmakuPanel({ onSend }) {
-  const [text5, setText] = React69.useState("");
+  const [text6, setText] = React69.useState("");
   const emit = () => {
-    const value = text5.trim();
+    const value = text6.trim();
     if (!value) {
       return;
     }
@@ -5686,7 +5694,7 @@ function DanmakuPanel({ onSend }) {
     "input",
     {
       type: "text",
-      value: text5,
+      value: text6,
       onChange: (event) => setText(event.target.value),
       onKeyDown: (event) => {
         if (event.key === "Enter") {
@@ -5802,8 +5810,8 @@ function useDanmakuController(options) {
     cursorRef.current += 1;
   }, []);
   const send = React69.useCallback(
-    (text5, color, sendOptions) => {
-      const trimmed = text5.trim();
+    (text6, color, sendOptions) => {
+      const trimmed = text6.trim();
       if (!trimmed) {
         return null;
       }
@@ -5840,26 +5848,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;
@@ -6541,12 +6549,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;
   }
@@ -6813,8 +6821,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) {
@@ -6913,9 +6921,9 @@ function useScreenReceiver(options) {
   const peerRef = React69.useRef({ pendingCandidates: [] });
   const videoRef = React69.useRef(null);
   const appendLog = React69.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]
   );
@@ -7641,8 +7649,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("");
@@ -8799,6 +8807,1244 @@ var BoothConfigPage = ({ initialConfig, onSave }) => {
   )), /* @__PURE__ */ React69__namespace.default.createElement("div", { className: "flex gap-2" }, /* @__PURE__ */ React69__namespace.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__namespace.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__namespace.utils.book_new();
+    const worksheet = XLSX__namespace.utils.json_to_sheet(rows);
+    XLSX__namespace.utils.book_append_sheet(workbook, worksheet, "submissions");
+    return XLSX__namespace.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 = pgCore.pgTable("miku_contest_configs", {
+  contestId: pgCore.text("contest_id").primaryKey(),
+  config: pgCore.jsonb("config").$type().notNull(),
+  createdAt: pgCore.timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+});
+var mikuContestSubmissions = pgCore.pgTable("miku_contest_submissions", {
+  id: pgCore.text("id").primaryKey(),
+  contestId: pgCore.text("contest_id").notNull(),
+  serialNo: pgCore.text("serial_no").notNull(),
+  authorId: pgCore.text("author_id").notNull(),
+  authorNickname: pgCore.text("author_nickname").notNull(),
+  title: pgCore.text("title").notNull(),
+  type: pgCore.text("type").notNull(),
+  description: pgCore.text("description").notNull(),
+  tags: pgCore.jsonb("tags").$type().notNull(),
+  content: pgCore.jsonb("content").$type().notNull(),
+  voteCount: pgCore.integer("vote_count").notNull().default(0),
+  status: pgCore.text("status").notNull(),
+  rejectReason: pgCore.text("reject_reason"),
+  createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+  reviewedAt: pgCore.timestamp("reviewed_at", { withTimezone: true }),
+  updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull()
+});
+var mikuContestVotes = pgCore.pgTable("miku_contest_votes", {
+  id: pgCore.text("id").primaryKey(),
+  contestId: pgCore.text("contest_id").notNull(),
+  submissionId: pgCore.text("submission_id").notNull(),
+  voterId: pgCore.text("voter_id").notNull(),
+  votedAt: pgCore.text("voted_at").notNull(),
+  dayKey: pgCore.text("day_key").notNull(),
+  deviceId: pgCore.text("device_id"),
+  ip: pgCore.text("ip")
+});
+var mikuContestNotices = pgCore.pgTable("miku_contest_notices", {
+  id: pgCore.text("id").primaryKey(),
+  contestId: pgCore.text("contest_id").notNull(),
+  title: pgCore.text("title").notNull(),
+  content: pgCore.text("content").notNull(),
+  type: pgCore.text("type").notNull(),
+  createdBy: pgCore.text("created_by").notNull(),
+  createdAt: pgCore.text("created_at").notNull(),
+  updatedAt: pgCore.text("updated_at").notNull()
+});
+var mikuContestVoterRestrictions = pgCore.pgTable("miku_contest_voter_restrictions", {
+  id: pgCore.text("id").primaryKey(),
+  contestId: pgCore.text("contest_id").notNull(),
+  data: pgCore.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(drizzleOrm.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(drizzleOrm.eq(mikuContestSubmissions.contestId, contestId)),
+      this.db.select().from(mikuContestVotes).where(drizzleOrm.eq(mikuContestVotes.contestId, contestId)),
+      this.db.select().from(mikuContestNotices).where(drizzleOrm.eq(mikuContestNotices.contestId, contestId)),
+      this.db.select({ data: mikuContestVoterRestrictions.data }).from(mikuContestVoterRestrictions).where(drizzleOrm.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(drizzleOrm.eq(mikuContestConfigs.contestId, contestId)).limit(1);
+    if (exists[0]) {
+      await this.db.update(mikuContestConfigs).set({
+        config: state.contest,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(drizzleOrm.eq(mikuContestConfigs.contestId, contestId));
+    } else {
+      await this.db.insert(mikuContestConfigs).values({
+        contestId,
+        config: state.contest
+      });
+    }
+    await this.db.delete(mikuContestSubmissions).where(drizzleOrm.eq(mikuContestSubmissions.contestId, contestId));
+    await this.db.delete(mikuContestVotes).where(drizzleOrm.eq(mikuContestVotes.contestId, contestId));
+    await this.db.delete(mikuContestNotices).where(drizzleOrm.eq(mikuContestNotices.contestId, contestId));
+    await this.db.delete(mikuContestVoterRestrictions).where(drizzleOrm.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] = React69.useState(() => createMikuContestService(options));
+  const [version, setVersion] = React69.useState(0);
+  const refresh = () => setVersion((value) => value + 1);
+  const snapshot = React69.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 server.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 server.NextResponse.json({ success: true, data });
+    } catch (error) {
+      return server.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 server.NextResponse.json({ success: false, error: "payload \u4E0D\u80FD\u4E3A\u7A7A" }, { status: 400 });
+      }
+      const data = await service.createSubmission(payload, mode);
+      return server.NextResponse.json({ success: true, data });
+    } catch (error) {
+      return server.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 server.NextResponse.json({ success: true, data });
+    } catch (error) {
+      return server.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 server.NextResponse.json({ success: true, data });
+    } catch (error) {
+      return server.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 server.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 server.NextResponse.json({ success: true, data });
+    } catch (error) {
+      return server.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 server.NextResponse.json({ success: true, data });
+    } catch (error) {
+      return server.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 server.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__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h2", null, snapshot.contest.name), /* @__PURE__ */ React69__namespace.default.createElement("p", null, snapshot.contest.theme), /* @__PURE__ */ React69__namespace.default.createElement("p", null, "\u6295\u7A3F\u6570\uFF1A", snapshot.submissions.length), /* @__PURE__ */ React69__namespace.default.createElement("p", null, "\u516C\u544A\u6570\uFF1A", snapshot.announcements.length), /* @__PURE__ */ React69__namespace.default.createElement("ul", null, snapshot.leaderboard.map((item) => /* @__PURE__ */ React69__namespace.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 = React69.useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = React69.useState(null);
+  const [loading, setLoading] = React69.useState(false);
+  const [error, setError] = React69.useState(null);
+  const approvedWorks = React69.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);
+    }
+  };
+  React69.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__namespace.default.createElement("section", null, /* @__PURE__ */ React69__namespace.default.createElement("h2", null, title), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void loadSnapshot(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React69__namespace.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, !snapshot ? null : /* @__PURE__ */ React69__namespace.default.createElement(React69__namespace.default.Fragment, null, /* @__PURE__ */ React69__namespace.default.createElement("p", null, "\u8D5B\u4E8B\uFF1A", snapshot.contest.name, "\uFF5C\u4E3B\u9898\uFF1A", snapshot.contest.theme), /* @__PURE__ */ React69__namespace.default.createElement("p", null, "\u5DF2\u8FC7\u5BA1\u4F5C\u54C1\uFF1A", approvedWorks.length, "\uFF5C\u6BCF\u65E5\u4E0A\u9650\uFF1A", snapshot.contest.votingRules.maxVotesPerDay), /* @__PURE__ */ React69__namespace.default.createElement("ul", null, approvedWorks.map((work) => /* @__PURE__ */ React69__namespace.default.createElement("li", { key: work.id }, /* @__PURE__ */ React69__namespace.default.createElement("strong", null, work.title), "\uFF08", work.authorNickname, "\uFF09- \u5F53\u524D ", work.voteCount, " \u7968", " ", /* @__PURE__ */ React69__namespace.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 = React69.useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = React69.useState(null);
+  const [mySubmissions, setMySubmissions] = React69.useState([]);
+  const [submitting, setSubmitting] = React69.useState(false);
+  const [loading, setLoading] = React69.useState(false);
+  const [error, setError] = React69.useState(null);
+  const [titleInput, setTitleInput] = React69.useState("");
+  const [descInput, setDescInput] = React69.useState("");
+  const [coverImage, setCoverImage] = React69.useState("");
+  const [workType, setWorkType] = React69.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);
+    }
+  };
+  React69.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__namespace.default.createElement("section", null, /* @__PURE__ */ React69__namespace.default.createElement("h2", null, title), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void loadData(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React69__namespace.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, "\u65B0\u5EFA\u6295\u7A3F"), /* @__PURE__ */ React69__namespace.default.createElement("input", { value: titleInput, onChange: (e) => setTitleInput(e.target.value), placeholder: "\u4F5C\u54C1\u6807\u9898" }), /* @__PURE__ */ React69__namespace.default.createElement("br", null), /* @__PURE__ */ React69__namespace.default.createElement("textarea", { value: descInput, onChange: (e) => setDescInput(e.target.value), placeholder: "\u4F5C\u54C1\u7B80\u4ECB" }), /* @__PURE__ */ React69__namespace.default.createElement("br", null), /* @__PURE__ */ React69__namespace.default.createElement("input", { value: coverImage, onChange: (e) => setCoverImage(e.target.value), placeholder: "\u5C01\u9762 URL" }), /* @__PURE__ */ React69__namespace.default.createElement("br", null), /* @__PURE__ */ React69__namespace.default.createElement("select", { value: workType, onChange: (e) => setWorkType(e.target.value) }, workTypes.map((item) => /* @__PURE__ */ React69__namespace.default.createElement("option", { value: item, key: item }, item))), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void submitWork(), disabled: submitting || !snapshot }, submitting ? "\u63D0\u4EA4\u4E2D..." : "\u63D0\u4EA4\u7A3F\u4EF6")), /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, "\u6211\u7684\u6295\u7A3F\uFF08", mySubmissions.length, "\uFF09"), /* @__PURE__ */ React69__namespace.default.createElement("ul", null, mySubmissions.map((item) => /* @__PURE__ */ React69__namespace.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 = React69.useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = React69.useState(null);
+  const [submissions, setSubmissions] = React69.useState([]);
+  const [loading, setLoading] = React69.useState(false);
+  const [error, setError] = React69.useState(null);
+  const [voterId, setVoterId] = React69.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);
+    }
+  };
+  React69.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__namespace.default.createElement("section", null, /* @__PURE__ */ React69__namespace.default.createElement("h2", null, title), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void loadData(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React69__namespace.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, "\u8D5B\u4E8B\u5F00\u5173"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void toggleVoting(true), disabled: !snapshot }, "\u5F00\u542F\u6295\u7968"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void toggleVoting(false), disabled: !snapshot }, "\u5173\u95ED\u6295\u7968")), /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, "\u6295\u7A3F\u5BA1\u6838\uFF08", submissions.length, "\uFF09"), /* @__PURE__ */ React69__namespace.default.createElement("ul", null, submissions.map((item) => /* @__PURE__ */ React69__namespace.default.createElement("li", { key: item.id }, /* @__PURE__ */ React69__namespace.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__namespace.default.createElement(React69__namespace.default.Fragment, null, " ", /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void review(item, "approve") }, "\u901A\u8FC7"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void review(item, "reject") }, "\u9A73\u56DE")) : null)))), /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, "\u6295\u7968\u98CE\u63A7"), /* @__PURE__ */ React69__namespace.default.createElement("input", { value: voterId, onChange: (e) => setVoterId(e.target.value), placeholder: "voterId" }), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void setRestriction(true), disabled: !snapshot }, "\u5C01\u7981\u6295\u7968"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void setRestriction(false), disabled: !snapshot }, "\u89E3\u9664\u5C01\u7981"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => void resetVotesByVoter() }, "\u6E05\u96F6\u8BE5\u7528\u6237\u7968\u6570")), /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, "\u5BFC\u51FA"), /* @__PURE__ */ React69__namespace.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] = React69.useState(defaultView);
+  return /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h1", null, "Miku Contest"), /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => setView("audience") }, "\u89C2\u4F17\u7AEF"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => setView("artist") }, "\u753B\u5E08\u7AEF"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => setView("admin") }, "\u7BA1\u7406\u5458\u7AEF")), view === "audience" ? /* @__PURE__ */ React69__namespace.default.createElement(MikuContestAudiencePage_default, { voterId: viewerVoterId }) : null, view === "artist" ? /* @__PURE__ */ React69__namespace.default.createElement(MikuContestArtistPage_default, { authorId: artistId, authorNickname: artistNickname }) : null, view === "admin" ? /* @__PURE__ */ React69__namespace.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__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, snapshot.contest.name), /* @__PURE__ */ React69__namespace.default.createElement("p", null, "\u6295\u7A3F\uFF1A", snapshot.submissions.length, " | \u516C\u544A\uFF1A", snapshot.announcements.length), /* @__PURE__ */ React69__namespace.default.createElement("ol", null, snapshot.leaderboard.slice(0, 3).map((item) => /* @__PURE__ */ React69__namespace.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] = React69.useState("vote");
+  const [voterId, setVoterId] = React69.useState("miniapp-voter");
+  const [authorId, setAuthorId] = React69.useState("miniapp-author");
+  const [authorNickname, setAuthorNickname] = React69.useState("\u5C0F\u7A0B\u5E8F\u753B\u5E08");
+  const [title, setTitle] = React69.useState("");
+  const [desc, setDesc] = React69.useState("");
+  const [type, setType] = React69.useState("visual");
+  const [error, setError] = React69.useState(null);
+  const approvedWorks = React69.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__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("h3", null, snapshot.contest.name), /* @__PURE__ */ React69__namespace.default.createElement("p", null, "\u5C0F\u7A0B\u5E8F\u7AEF\u793A\u4F8B\u9875\u9762"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => setTab("vote") }, "\u89C2\u4F17\u6295\u7968"), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => setTab("submit") }, "\u753B\u5E08\u6295\u7A3F"), error ? /* @__PURE__ */ React69__namespace.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, tab === "vote" ? /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("input", { value: voterId, onChange: (e) => setVoterId(e.target.value), placeholder: "voterId" }), /* @__PURE__ */ React69__namespace.default.createElement("ul", null, approvedWorks.map((item) => /* @__PURE__ */ React69__namespace.default.createElement("li", { key: item.id }, item.title, "\uFF08", item.voteCount, "\u7968\uFF09", /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: () => vote(item.id) }, "\u6295\u7968"))))) : null, tab === "submit" ? /* @__PURE__ */ React69__namespace.default.createElement("div", null, /* @__PURE__ */ React69__namespace.default.createElement("input", { value: authorId, onChange: (e) => setAuthorId(e.target.value), placeholder: "authorId" }), /* @__PURE__ */ React69__namespace.default.createElement("input", { value: authorNickname, onChange: (e) => setAuthorNickname(e.target.value), placeholder: "\u4F5C\u8005\u6635\u79F0" }), /* @__PURE__ */ React69__namespace.default.createElement("input", { value: title, onChange: (e) => setTitle(e.target.value), placeholder: "\u4F5C\u54C1\u6807\u9898" }), /* @__PURE__ */ React69__namespace.default.createElement("input", { value: desc, onChange: (e) => setDesc(e.target.value), placeholder: "\u4F5C\u54C1\u7B80\u4ECB" }), /* @__PURE__ */ React69__namespace.default.createElement("select", { value: type, onChange: (e) => setType(e.target.value) }, /* @__PURE__ */ React69__namespace.default.createElement("option", { value: "visual" }, "visual"), /* @__PURE__ */ React69__namespace.default.createElement("option", { value: "video" }, "video"), /* @__PURE__ */ React69__namespace.default.createElement("option", { value: "text" }, "text"), /* @__PURE__ */ React69__namespace.default.createElement("option", { value: "audio" }, "audio")), /* @__PURE__ */ React69__namespace.default.createElement("button", { onClick: submit }, "\u63D0\u4EA4")) : null);
+};
+var MikuContestMiniappPage_default = MikuContestMiniappPage;
+
 // src/storage/adapters/react-native-adapter.ts
 var AsyncStorage = null;
 try {
@@ -9252,6 +10498,9 @@ exports.LocalImageMappingPanel = LocalImageMappingPanel;
 exports.LogLevel = LogLevel;
 exports.Logger = Logger;
 exports.MIKU_PALETTE = MIKU_PALETTE;
+exports.MikuContestPersistentService = MikuContestPersistentService;
+exports.MikuContestService = MikuContestService;
+exports.MikuContestStateDbService = MikuContestStateDbService;
 exports.MikuFireworks3D = MikuFireworks3D;
 exports.Modal = Modal;
 exports.NORMAL_PALETTE = NORMAL_PALETTE;
@@ -9316,14 +10565,30 @@ exports.applyPromptTemplate = applyPromptTemplate;
 exports.arrayUtils = arrayUtils;
 exports.badgeVariants = badgeVariants;
 exports.buttonVariants = buttonVariants;
+exports.checkVoteEligibility = checkVoteEligibility;
 exports.cn = cn;
 exports.createAiClient = createAiClient;
 exports.createChatSession = createChatSession;
+exports.createCreateSubmissionHandler = createCreateSubmissionHandler;
+exports.createDefaultMikuContestConfig = createDefaultMikuContestConfig;
+exports.createExportSubmissionsHandler = createExportSubmissionsHandler;
+exports.createGetContestSnapshotHandler = createGetContestSnapshotHandler;
 exports.createInMemoryFestivalCardDb = createInMemoryFestivalCardDb;
+exports.createListSubmissionsHandler = createListSubmissionsHandler;
 exports.createLogger = createLogger;
+exports.createMikuContestApiClient = createMikuContestApiClient;
+exports.createMikuContestDrizzlePersistenceAdapter = createMikuContestDrizzlePersistenceAdapter;
+exports.createMikuContestPersistentService = createMikuContestPersistentService;
+exports.createMikuContestService = createMikuContestService;
 exports.createOpenAICompatibleProvider = createOpenAICompatibleProvider;
+exports.createResetVotesHandler = createResetVotesHandler;
+exports.createReviewSubmissionHandler = createReviewSubmissionHandler;
+exports.createSetVoterRestrictionHandler = createSetVoterRestrictionHandler;
 exports.createSkillRegistry = createSkillRegistry;
+exports.createUpdateContestConfigHandler = createUpdateContestConfigHandler;
+exports.createVoteHandler = createVoteHandler;
 exports.debugUtils = debugUtils;
+exports.defaultMikuVotingRules = defaultMikuVotingRules;
 exports.defaultVocaloidBoothConfig = defaultVocaloidBoothConfig;
 exports.errorUtils = errorUtils;
 exports.fileUtils = fileUtils;
@@ -9339,6 +10604,14 @@ exports.getCompletionStatusText = getCompletionStatusText;
 exports.getExperimentCounts = getExperimentCounts;
 exports.japaneseUtils = japaneseUtils;
 exports.logger = logger;
+exports.mikuContestConfigs = mikuContestConfigs;
+exports.mikuContestDbService = mikuContestDbService;
+exports.mikuContestNotices = mikuContestNotices;
+exports.mikuContestSubmissions = mikuContestSubmissions;
+exports.mikuContestVoterRestrictions = mikuContestVoterRestrictions;
+exports.mikuContestVotes = mikuContestVotes;
+exports.miniappService = miniapp_exports;
+exports.miniappUI = miniapp_exports2;
 exports.normalizeFestivalCardConfig = normalizeFestivalCardConfig;
 exports.normalizeMatchCode = normalizeMatchCode;
 exports.normalizePromptVariables = normalizePromptVariables;
@@ -9346,8 +10619,10 @@ exports.normalizeVocaloidBoothConfig = normalizeVocaloidBoothConfig;
 exports.resizeFestivalCardPages = resizeFestivalCardPages;
 exports.resolveScreenReceiverSignalUrl = resolveScreenReceiverSignalUrl;
 exports.skillToToolDefinition = skillToToolDefinition;
+exports.sortByVotesDesc = sortByVotesDesc;
 exports.sortExperiments = sortExperiments;
 exports.stringUtils = stringUtils;
+exports.toVoteDayKey = toVoteDayKey;
 exports.useAiChat = useAiChat;
 exports.useAsyncStorage = useAsyncStorage;
 exports.useBackgroundRemoval = useBackgroundRemoval;
@@ -9357,6 +10632,7 @@ exports.useFestivalCardConfig = useFestivalCardConfig;
 exports.useFireworksEngine = useFireworksEngine;
 exports.useFireworksRealtime = useFireworksRealtime;
 exports.useLocalStorage = useLocalStorage;
+exports.useMikuContest = useMikuContest;
 exports.useOCR = useOCR;
 exports.useScreenReceiver = useScreenReceiver;
 exports.useSentimentAnalysis = useSentimentAnalysis;
@@ -9364,6 +10640,9 @@ exports.useStorage = useStorage;
 exports.useTaroStorage = useTaroStorage;
 exports.useTextGeneration = useTextGeneration;
 exports.validateExperiment = validateExperiment;
+exports.validateMikuSubmissionInput = validateMikuSubmissionInput;
 exports.validators = validators;
+exports.webService = web_exports;
+exports.webUI = web_exports2;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map