sa2kit 1.6.91 → 1.6.92

package/dist/mikuContest/index.js

@@ -0,0 +1,1310 @@
+'use strict';
+
+var React4 = require('react');
+var XLSX = require('xlsx');
+var pgCore = require('drizzle-orm/pg-core');
+var drizzleOrm = require('drizzle-orm');
+var server = require('next/server');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React4__default = /*#__PURE__*/_interopDefault(React4);
+var XLSX__namespace = /*#__PURE__*/_interopNamespace(XLSX);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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 text2 = content.textContent || "";
+      if (!text2.trim()) {
+        errors.push("\u6587\u5B57\u7C7B\u4F5C\u54C1\u9700\u586B\u5199\u6B63\u6587");
+      }
+      if (text2.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] = React4.useState(() => createMikuContestService(options));
+  const [version, setVersion] = React4.useState(0);
+  const refresh = () => setVersion((value) => value + 1);
+  const snapshot = React4.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__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h2", null, snapshot.contest.name), /* @__PURE__ */ React4__default.default.createElement("p", null, snapshot.contest.theme), /* @__PURE__ */ React4__default.default.createElement("p", null, "\u6295\u7A3F\u6570\uFF1A", snapshot.submissions.length), /* @__PURE__ */ React4__default.default.createElement("p", null, "\u516C\u544A\u6570\uFF1A", snapshot.announcements.length), /* @__PURE__ */ React4__default.default.createElement("ul", null, snapshot.leaderboard.map((item) => /* @__PURE__ */ React4__default.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 = React4.useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = React4.useState(null);
+  const [loading, setLoading] = React4.useState(false);
+  const [error, setError] = React4.useState(null);
+  const approvedWorks = React4.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);
+    }
+  };
+  React4.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__ */ React4__default.default.createElement("section", null, /* @__PURE__ */ React4__default.default.createElement("h2", null, title), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void loadSnapshot(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React4__default.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, !snapshot ? null : /* @__PURE__ */ React4__default.default.createElement(React4__default.default.Fragment, null, /* @__PURE__ */ React4__default.default.createElement("p", null, "\u8D5B\u4E8B\uFF1A", snapshot.contest.name, "\uFF5C\u4E3B\u9898\uFF1A", snapshot.contest.theme), /* @__PURE__ */ React4__default.default.createElement("p", null, "\u5DF2\u8FC7\u5BA1\u4F5C\u54C1\uFF1A", approvedWorks.length, "\uFF5C\u6BCF\u65E5\u4E0A\u9650\uFF1A", snapshot.contest.votingRules.maxVotesPerDay), /* @__PURE__ */ React4__default.default.createElement("ul", null, approvedWorks.map((work) => /* @__PURE__ */ React4__default.default.createElement("li", { key: work.id }, /* @__PURE__ */ React4__default.default.createElement("strong", null, work.title), "\uFF08", work.authorNickname, "\uFF09- \u5F53\u524D ", work.voteCount, " \u7968", " ", /* @__PURE__ */ React4__default.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 = React4.useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = React4.useState(null);
+  const [mySubmissions, setMySubmissions] = React4.useState([]);
+  const [submitting, setSubmitting] = React4.useState(false);
+  const [loading, setLoading] = React4.useState(false);
+  const [error, setError] = React4.useState(null);
+  const [titleInput, setTitleInput] = React4.useState("");
+  const [descInput, setDescInput] = React4.useState("");
+  const [coverImage, setCoverImage] = React4.useState("");
+  const [workType, setWorkType] = React4.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);
+    }
+  };
+  React4.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__ */ React4__default.default.createElement("section", null, /* @__PURE__ */ React4__default.default.createElement("h2", null, title), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void loadData(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React4__default.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, "\u65B0\u5EFA\u6295\u7A3F"), /* @__PURE__ */ React4__default.default.createElement("input", { value: titleInput, onChange: (e) => setTitleInput(e.target.value), placeholder: "\u4F5C\u54C1\u6807\u9898" }), /* @__PURE__ */ React4__default.default.createElement("br", null), /* @__PURE__ */ React4__default.default.createElement("textarea", { value: descInput, onChange: (e) => setDescInput(e.target.value), placeholder: "\u4F5C\u54C1\u7B80\u4ECB" }), /* @__PURE__ */ React4__default.default.createElement("br", null), /* @__PURE__ */ React4__default.default.createElement("input", { value: coverImage, onChange: (e) => setCoverImage(e.target.value), placeholder: "\u5C01\u9762 URL" }), /* @__PURE__ */ React4__default.default.createElement("br", null), /* @__PURE__ */ React4__default.default.createElement("select", { value: workType, onChange: (e) => setWorkType(e.target.value) }, workTypes.map((item) => /* @__PURE__ */ React4__default.default.createElement("option", { value: item, key: item }, item))), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void submitWork(), disabled: submitting || !snapshot }, submitting ? "\u63D0\u4EA4\u4E2D..." : "\u63D0\u4EA4\u7A3F\u4EF6")), /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, "\u6211\u7684\u6295\u7A3F\uFF08", mySubmissions.length, "\uFF09"), /* @__PURE__ */ React4__default.default.createElement("ul", null, mySubmissions.map((item) => /* @__PURE__ */ React4__default.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 = React4.useMemo(() => client || createMikuContestWebClient(), [client]);
+  const [snapshot, setSnapshot] = React4.useState(null);
+  const [submissions, setSubmissions] = React4.useState([]);
+  const [loading, setLoading] = React4.useState(false);
+  const [error, setError] = React4.useState(null);
+  const [voterId, setVoterId] = React4.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);
+    }
+  };
+  React4.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__ */ React4__default.default.createElement("section", null, /* @__PURE__ */ React4__default.default.createElement("h2", null, title), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void loadData(), disabled: loading }, loading ? "\u5237\u65B0\u4E2D..." : "\u5237\u65B0\u6570\u636E"), error ? /* @__PURE__ */ React4__default.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, "\u8D5B\u4E8B\u5F00\u5173"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void toggleVoting(true), disabled: !snapshot }, "\u5F00\u542F\u6295\u7968"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void toggleVoting(false), disabled: !snapshot }, "\u5173\u95ED\u6295\u7968")), /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, "\u6295\u7A3F\u5BA1\u6838\uFF08", submissions.length, "\uFF09"), /* @__PURE__ */ React4__default.default.createElement("ul", null, submissions.map((item) => /* @__PURE__ */ React4__default.default.createElement("li", { key: item.id }, /* @__PURE__ */ React4__default.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__ */ React4__default.default.createElement(React4__default.default.Fragment, null, " ", /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void review(item, "approve") }, "\u901A\u8FC7"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void review(item, "reject") }, "\u9A73\u56DE")) : null)))), /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, "\u6295\u7968\u98CE\u63A7"), /* @__PURE__ */ React4__default.default.createElement("input", { value: voterId, onChange: (e) => setVoterId(e.target.value), placeholder: "voterId" }), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void setRestriction(true), disabled: !snapshot }, "\u5C01\u7981\u6295\u7968"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void setRestriction(false), disabled: !snapshot }, "\u89E3\u9664\u5C01\u7981"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => void resetVotesByVoter() }, "\u6E05\u96F6\u8BE5\u7528\u6237\u7968\u6570")), /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, "\u5BFC\u51FA"), /* @__PURE__ */ React4__default.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] = React4.useState(defaultView);
+  return /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h1", null, "Miku Contest"), /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => setView("audience") }, "\u89C2\u4F17\u7AEF"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => setView("artist") }, "\u753B\u5E08\u7AEF"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => setView("admin") }, "\u7BA1\u7406\u5458\u7AEF")), view === "audience" ? /* @__PURE__ */ React4__default.default.createElement(MikuContestAudiencePage_default, { voterId: viewerVoterId }) : null, view === "artist" ? /* @__PURE__ */ React4__default.default.createElement(MikuContestArtistPage_default, { authorId: artistId, authorNickname: artistNickname }) : null, view === "admin" ? /* @__PURE__ */ React4__default.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__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, snapshot.contest.name), /* @__PURE__ */ React4__default.default.createElement("p", null, "\u6295\u7A3F\uFF1A", snapshot.submissions.length, " | \u516C\u544A\uFF1A", snapshot.announcements.length), /* @__PURE__ */ React4__default.default.createElement("ol", null, snapshot.leaderboard.slice(0, 3).map((item) => /* @__PURE__ */ React4__default.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] = React4.useState("vote");
+  const [voterId, setVoterId] = React4.useState("miniapp-voter");
+  const [authorId, setAuthorId] = React4.useState("miniapp-author");
+  const [authorNickname, setAuthorNickname] = React4.useState("\u5C0F\u7A0B\u5E8F\u753B\u5E08");
+  const [title, setTitle] = React4.useState("");
+  const [desc, setDesc] = React4.useState("");
+  const [type, setType] = React4.useState("visual");
+  const [error, setError] = React4.useState(null);
+  const approvedWorks = React4.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__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("h3", null, snapshot.contest.name), /* @__PURE__ */ React4__default.default.createElement("p", null, "\u5C0F\u7A0B\u5E8F\u7AEF\u793A\u4F8B\u9875\u9762"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => setTab("vote") }, "\u89C2\u4F17\u6295\u7968"), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => setTab("submit") }, "\u753B\u5E08\u6295\u7A3F"), error ? /* @__PURE__ */ React4__default.default.createElement("p", { style: { color: "crimson" } }, "\u9519\u8BEF\uFF1A", error) : null, tab === "vote" ? /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("input", { value: voterId, onChange: (e) => setVoterId(e.target.value), placeholder: "voterId" }), /* @__PURE__ */ React4__default.default.createElement("ul", null, approvedWorks.map((item) => /* @__PURE__ */ React4__default.default.createElement("li", { key: item.id }, item.title, "\uFF08", item.voteCount, "\u7968\uFF09", /* @__PURE__ */ React4__default.default.createElement("button", { onClick: () => vote(item.id) }, "\u6295\u7968"))))) : null, tab === "submit" ? /* @__PURE__ */ React4__default.default.createElement("div", null, /* @__PURE__ */ React4__default.default.createElement("input", { value: authorId, onChange: (e) => setAuthorId(e.target.value), placeholder: "authorId" }), /* @__PURE__ */ React4__default.default.createElement("input", { value: authorNickname, onChange: (e) => setAuthorNickname(e.target.value), placeholder: "\u4F5C\u8005\u6635\u79F0" }), /* @__PURE__ */ React4__default.default.createElement("input", { value: title, onChange: (e) => setTitle(e.target.value), placeholder: "\u4F5C\u54C1\u6807\u9898" }), /* @__PURE__ */ React4__default.default.createElement("input", { value: desc, onChange: (e) => setDesc(e.target.value), placeholder: "\u4F5C\u54C1\u7B80\u4ECB" }), /* @__PURE__ */ React4__default.default.createElement("select", { value: type, onChange: (e) => setType(e.target.value) }, /* @__PURE__ */ React4__default.default.createElement("option", { value: "visual" }, "visual"), /* @__PURE__ */ React4__default.default.createElement("option", { value: "video" }, "video"), /* @__PURE__ */ React4__default.default.createElement("option", { value: "text" }, "text"), /* @__PURE__ */ React4__default.default.createElement("option", { value: "audio" }, "audio")), /* @__PURE__ */ React4__default.default.createElement("button", { onClick: submit }, "\u63D0\u4EA4")) : null);
+};
+var MikuContestMiniappPage_default = MikuContestMiniappPage;
+
+exports.MikuContestPersistentService = MikuContestPersistentService;
+exports.MikuContestService = MikuContestService;
+exports.MikuContestStateDbService = MikuContestStateDbService;
+exports.checkVoteEligibility = checkVoteEligibility;
+exports.createCreateSubmissionHandler = createCreateSubmissionHandler;
+exports.createDefaultMikuContestConfig = createDefaultMikuContestConfig;
+exports.createExportSubmissionsHandler = createExportSubmissionsHandler;
+exports.createGetContestSnapshotHandler = createGetContestSnapshotHandler;
+exports.createListSubmissionsHandler = createListSubmissionsHandler;
+exports.createMikuContestApiClient = createMikuContestApiClient;
+exports.createMikuContestDrizzlePersistenceAdapter = createMikuContestDrizzlePersistenceAdapter;
+exports.createMikuContestPersistentService = createMikuContestPersistentService;
+exports.createMikuContestService = createMikuContestService;
+exports.createResetVotesHandler = createResetVotesHandler;
+exports.createReviewSubmissionHandler = createReviewSubmissionHandler;
+exports.createSetVoterRestrictionHandler = createSetVoterRestrictionHandler;
+exports.createUpdateContestConfigHandler = createUpdateContestConfigHandler;
+exports.createVoteHandler = createVoteHandler;
+exports.defaultMikuVotingRules = defaultMikuVotingRules;
+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.sortByVotesDesc = sortByVotesDesc;
+exports.toVoteDayKey = toVoteDayKey;
+exports.useMikuContest = useMikuContest;
+exports.validateMikuSubmissionInput = validateMikuSubmissionInput;
+exports.webService = web_exports;
+exports.webUI = web_exports2;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map