diff --git a/apps/admin-web/src/api/adminApiClient.test.ts b/apps/admin-web/src/api/adminApiClient.test.ts
index aee62a5ff..e4009c408 100644
--- a/apps/admin-web/src/api/adminApiClient.test.ts
+++ b/apps/admin-web/src/api/adminApiClient.test.ts
@@ -10,6 +10,7 @@ import {
   reconcileAdminUserConsumption,
   resolveAdminRechargeRefundManualReview,
   reviewAdminGameDistributionVersion,
+  suspendAdminGameDistributionGame,
   updateAdminAccount,
   uploadAdminEditorShowcaseCampaignImage,
   upsertAdminFeatureGateConfig,
@@ -411,6 +412,53 @@ test('游戏审核列表与审核动作使用约定的 URL、方法和幂等键'
   );
 });
 
+test('安全下架请求携带公开修订号、原因与幂等键', async () => {
+  const fetchMock = vi.fn().mockImplementation(() =>
+    Promise.resolve(
+      new Response(JSON.stringify({ game: {}, replayed: false }), {
+        status: 200,
+      }),
+    ),
+  );
+  vi.stubGlobal('fetch', fetchMock);
+
+  await suspendAdminGameDistributionGame(
+    'admin-token',
+    'game/1',
+    'game-suspend-key-1',
+    { expectedPublicationRevision: 7, reason: '版权投诉' },
+  );
+
+  expect(fetchMock.mock.calls[0]?.[0]).toBe(
+    '/admin/api/game-distribution/games/game%2F1/suspend',
+  );
+  expect(fetchMock.mock.calls[0]?.[1]).toEqual(
+    expect.objectContaining({
+      method: 'POST',
+      headers: expect.objectContaining({
+        Authorization: 'Bearer admin-token',
+        'Idempotency-Key': 'game-suspend-key-1',
+      }),
+      body: JSON.stringify({
+        expectedPublicationRevision: 7,
+        reason: '版权投诉',
+      }),
+    }),
+  );
+
+  expect(() =>
+    suspendAdminGameDistributionGame('admin-token', '  ', 'key', {
+      expectedPublicationRevision: 1,
+    }),
+  ).toThrow('缺少游戏 ID');
+  expect(() =>
+    suspendAdminGameDistributionGame('admin-token', 'game-1', '  ', {
+      expectedPublicationRevision: 1,
+    }),
+  ).toThrow('下架幂等键必须是 1 到 128 个字符');
+  expect(fetchMock).toHaveBeenCalledTimes(1);
+});
+
 test('游戏审核拒绝请求携带理由，空幂等键在本地失败关闭', async () => {
   const fetchMock = vi.fn().mockImplementation(() =>
     Promise.resolve(
diff --git a/apps/admin-web/src/api/adminApiClient.ts b/apps/admin-web/src/api/adminApiClient.ts
index d9da6b382..fe6da3890 100644
--- a/apps/admin-web/src/api/adminApiClient.ts
+++ b/apps/admin-web/src/api/adminApiClient.ts
@@ -1194,6 +1194,36 @@ export function listAdminGameDistributionReviews(token: string, limit = 48) {
  * 审核游戏发行版本。幂等键由调用方生成并在同一次提交内复用，避免重复点击产生
  * 两条审核结论。
  */
+/**
+ * 安全下架整个游戏。管理员下架同样要求 CAS 修订号与幂等键，避免并发审核互相覆盖。
+ */
+export function suspendAdminGameDistributionGame(
+  token: string,
+  gameId: string,
+  idempotencyKey: string,
+  payload: import('./adminApiTypes').AdminGameDistributionSuspendRequest,
+) {
+  const normalizedGameId = gameId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedGameId) {
+    throw new Error('缺少游戏 ID');
+  }
+  if (!normalizedKey || normalizedKey.length > 128) {
+    throw new Error('下架幂等键必须是 1 到 128 个字符');
+  }
+  return request<
+    import('./adminApiTypes').AdminGameDistributionSuspendResponse
+  >(
+    `/admin/api/game-distribution/games/${encodeURIComponent(normalizedGameId)}/suspend`,
+    {
+      method: 'POST',
+      token,
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: payload,
+    },
+  );
+}
+
 export function reviewAdminGameDistributionVersion(
   token: string,
   versionId: string,
diff --git a/apps/admin-web/src/api/adminApiTypes.ts b/apps/admin-web/src/api/adminApiTypes.ts
index 48cfc470e..1da9cc709 100644
--- a/apps/admin-web/src/api/adminApiTypes.ts
+++ b/apps/admin-web/src/api/adminApiTypes.ts
@@ -1061,3 +1061,18 @@ export interface AdminGameDistributionReviewResponse {
   version: AdminGameDistributionReviewEntry;
   replayed: boolean;
 }
+
+export interface AdminGameDistributionSuspendRequest {
+  expectedPublicationRevision: number;
+  reason?: string;
+}
+
+export interface AdminGameDistributionSuspendResponse {
+  game: {
+    id: string;
+    title: string;
+    status: string;
+    publicationRevision: number;
+  };
+  replayed: boolean;
+}
diff --git a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
new file mode 100644
index 000000000..ae00212d9
--- /dev/null
+++ b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx
@@ -0,0 +1,186 @@
+/* @vitest-environment jsdom */
+
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, expect, test, vi } from 'vitest';
+
+import {
+  listAdminGameDistributionReviews,
+  reviewAdminGameDistributionVersion,
+  suspendAdminGameDistributionGame,
+} from '../api/adminApiClient';
+import type { AdminGameDistributionReviewEntry } from '../api/adminApiTypes';
+import {
+  AdminGameDistributionReviewPage,
+  resolveGameReleaseEntryUrlError,
+} from './AdminGameDistributionReviewPage';
+
+vi.mock('../api/adminApiClient', () => ({
+  isAdminApiError: vi.fn(
+    (error: unknown) =>
+      typeof error === 'object' &&
+      error !== null &&
+      'status' in error &&
+      typeof error.status === 'number',
+  ),
+  formatAdminApiError: vi.fn((error: unknown) =>
+    error instanceof Error ? error.message : '请求失败',
+  ),
+  listAdminGameDistributionReviews: vi.fn(),
+  reviewAdminGameDistributionVersion: vi.fn(),
+  suspendAdminGameDistributionGame: vi.fn(),
+}));
+
+const entry: AdminGameDistributionReviewEntry = {
+  versionId: 'version-1',
+  gameId: 'game_1',
+  versionNumber: 2,
+  packageSha256: 'a'.repeat(64),
+  packageBytes: 2048,
+  status: 'pending_review',
+  publicationRevision: 4,
+  reviewReason: null,
+  createdAt: '2026-09-20T08:00:00Z',
+  updatedAt: '2026-09-20T08:00:00Z',
+};
+
+beforeEach(() => {
+  vi.mocked(listAdminGameDistributionReviews).mockReset();
+  vi.mocked(reviewAdminGameDistributionVersion).mockReset();
+  vi.mocked(suspendAdminGameDistributionGame).mockReset();
+  vi.mocked(listAdminGameDistributionReviews).mockResolvedValue({
+    entries: [entry],
+    nextCursor: null,
+  });
+});
+
+test('发行入口必须是带完整来源的 HTTPS 地址', () => {
+  expect(resolveGameReleaseEntryUrlError('')).toBe('请填写发行入口');
+  expect(
+    resolveGameReleaseEntryUrlError('http://games.test/a/index.html'),
+  ).toBe('发行入口必须以 https:// 开头');
+  expect(
+    resolveGameReleaseEntryUrlError('https://games.test/a/index.html?token=1'),
+  ).toBe('发行入口不能包含 query 或 fragment');
+  expect(
+    resolveGameReleaseEntryUrlError('https://u:p@games.test/a/index.html'),
+  ).toBe('发行入口不能包含凭据');
+  expect(
+    resolveGameReleaseEntryUrlError('https://games.test/a/index.html'),
+  ).toBe('');
+});
+
+test('通过审核时提交当前 publicationRevision 与发行入口并刷新列表', async () => {
+  vi.mocked(reviewAdminGameDistributionVersion).mockResolvedValue({
+    version: { ...entry, status: 'published' },
+    replayed: false,
+  });
+
+  render(
+    <AdminGameDistributionReviewPage
+      token="admin-token"
+      onUnauthorized={vi.fn()}
+    />,
+  );
+  await screen.findByText('game_1');
+
+  fireEvent.change(screen.getByLabelText('发行入口'), {
+    target: { value: 'https://games.test/releases/game_1/index.html' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: '通过' }));
+
+  await waitFor(() =>
+    expect(reviewAdminGameDistributionVersion).toHaveBeenCalledTimes(1),
+  );
+  const [token, versionId, idempotencyKey, payload] =
+    vi.mocked(reviewAdminGameDistributionVersion).mock.calls[0] ?? [];
+  expect(token).toBe('admin-token');
+  expect(versionId).toBe('version-1');
+  expect(String(idempotencyKey)).toContain('version-1');
+  expect(payload).toEqual({
+    decision: 'approve',
+    expectedPublicationRevision: 4,
+    entryUrl: 'https://games.test/releases/game_1/index.html',
+  });
+  await waitFor(() =>
+    expect(vi.mocked(listAdminGameDistributionReviews)).toHaveBeenCalledTimes(
+      2,
+    ),
+  );
+});
+
+test('缺少拒绝理由时不调用审核接口', async () => {
+  render(
+    <AdminGameDistributionReviewPage
+      token="admin-token"
+      onUnauthorized={vi.fn()}
+    />,
+  );
+  await screen.findByText('game_1');
+
+  fireEvent.click(screen.getByRole('button', { name: '拒绝' }));
+
+  expect(await screen.findByText('拒绝审核必须填写理由')).toBeTruthy();
+  expect(reviewAdminGameDistributionVersion).not.toHaveBeenCalled();
+});
+
+test('安全下架需要二次确认，并携带公开修订号与原因', async () => {
+  vi.mocked(suspendAdminGameDistributionGame).mockResolvedValue({
+    game: {
+      id: 'game_1',
+      title: '测试游戏',
+      status: 'suspended',
+      publicationRevision: 5,
+    },
+    replayed: false,
+  });
+
+  render(
+    <AdminGameDistributionReviewPage
+      token="admin-token"
+      onUnauthorized={vi.fn()}
+    />,
+  );
+  await screen.findByText('game_1');
+
+  fireEvent.change(screen.getByLabelText('下架原因'), {
+    target: { value: '盗用素材' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: '安全下架' }));
+
+  // 第一次点击只弹出确认面板，不直接调用后端。
+  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
+  expect(await screen.findByRole('dialog')).toBeTruthy();
+
+  fireEvent.click(screen.getByRole('button', { name: '确认' }));
+
+  await waitFor(() =>
+    expect(suspendAdminGameDistributionGame).toHaveBeenCalledTimes(1),
+  );
+  const [token, gameId, idempotencyKey, payload] =
+    vi.mocked(suspendAdminGameDistributionGame).mock.calls[0] ?? [];
+  expect(token).toBe('admin-token');
+  expect(gameId).toBe('game_1');
+  expect(String(idempotencyKey)).toContain('game_1');
+  expect(payload).toEqual({
+    expectedPublicationRevision: 4,
+    reason: '盗用素材',
+  });
+  expect(await screen.findByText(/已安全下架/u)).toBeTruthy();
+});
+
+test('取消确认时不下架', async () => {
+  render(
+    <AdminGameDistributionReviewPage
+      token="admin-token"
+      onUnauthorized={vi.fn()}
+    />,
+  );
+  await screen.findByText('game_1');
+
+  fireEvent.click(screen.getByRole('button', { name: '安全下架' }));
+  await screen.findByRole('dialog');
+  fireEvent.click(screen.getByRole('button', { name: '取消' }));
+
+  await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());
+  expect(suspendAdminGameDistributionGame).not.toHaveBeenCalled();
+});
diff --git a/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
new file mode 100644
index 000000000..b1e993ed7
--- /dev/null
+++ b/apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx
@@ -0,0 +1,365 @@
+import { RefreshCcw } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+
+import {
+  listAdminGameDistributionReviews,
+  reviewAdminGameDistributionVersion,
+  suspendAdminGameDistributionGame,
+} from '../api/adminApiClient';
+import type { AdminGameDistributionReviewEntry } from '../api/adminApiTypes';
+import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
+import { handlePageError } from './pageUtils';
+
+interface AdminGameDistributionReviewPageProps {
+  token: string;
+  onUnauthorized: (message?: string) => void;
+}
+
+function formatBytes(value: number) {
+  if (value >= 1024 * 1024) {
+    return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
+  }
+  if (value >= 1024) {
+    return `${(value / 1024).toFixed(1)} KiB`;
+  }
+  return `${value} B`;
+}
+
+function formatTime(value: string) {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return value;
+  return parsed.toLocaleString('zh-CN', { hour12: false });
+}
+
+function createSuspendIdempotencyKey(gameId: string) {
+  const random =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return `game-suspend-${gameId}-${random}`.slice(0, 128);
+}
+
+function createReviewIdempotencyKey(versionId: string) {
+  const random =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return `game-review-${versionId}-${random}`.slice(0, 128);
+}
+
+export function resolveGameReleaseEntryUrlError(value: string) {
+  const normalized = value.trim();
+  if (!normalized) return '请填写发行入口';
+  if (!normalized.startsWith('https://')) {
+    return '发行入口必须以 https:// 开头';
+  }
+  if (normalized.includes('?') || normalized.includes('#')) {
+    return '发行入口不能包含 query 或 fragment';
+  }
+  try {
+    const parsed = new URL(normalized);
+    if (parsed.username || parsed.password) {
+      return '发行入口不能包含凭据';
+    }
+  } catch {
+    return '发行入口不是合法 URL';
+  }
+  return '';
+}
+
+export function AdminGameDistributionReviewPage({
+  token,
+  onUnauthorized,
+}: AdminGameDistributionReviewPageProps) {
+  const [entries, setEntries] = useState<AdminGameDistributionReviewEntry[]>(
+    [],
+  );
+  const [isLoading, setIsLoading] = useState(false);
+  const [busyVersionId, setBusyVersionId] = useState('');
+  const [errorMessage, setErrorMessage] = useState('');
+  const [statusMessage, setStatusMessage] = useState('');
+  const [entryUrlByVersion, setEntryUrlByVersion] = useState<
+    Record<string, string>
+  >({});
+  const [reasonByVersion, setReasonByVersion] = useState<
+    Record<string, string>
+  >({});
+  const [suspendReasonByGame, setSuspendReasonByGame] = useState<
+    Record<string, string>
+  >({});
+  const [busyGameId, setBusyGameId] = useState('');
+  const writeConfirm = useAdminWriteConfirm();
+
+  const loadReviews = useCallback(async () => {
+    setIsLoading(true);
+    setErrorMessage('');
+    try {
+      const response = await listAdminGameDistributionReviews(token);
+      setEntries(response.entries);
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setErrorMessage);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [token, onUnauthorized]);
+
+  useEffect(() => {
+    void loadReviews();
+  }, [loadReviews]);
+
+  async function submitReview(
+    entry: AdminGameDistributionReviewEntry,
+    decision: 'approve' | 'reject',
+  ) {
+    const entryUrl = (entryUrlByVersion[entry.versionId] ?? '').trim();
+    const reason = (reasonByVersion[entry.versionId] ?? '').trim();
+    if (decision === 'approve') {
+      const invalid = resolveGameReleaseEntryUrlError(entryUrl);
+      if (invalid) {
+        setErrorMessage(invalid);
+        return;
+      }
+    } else if (!reason) {
+      setErrorMessage('拒绝审核必须填写理由');
+      return;
+    }
+    setBusyVersionId(entry.versionId);
+    setErrorMessage('');
+    setStatusMessage('');
+    try {
+      await reviewAdminGameDistributionVersion(
+        token,
+        entry.versionId,
+        createReviewIdempotencyKey(entry.versionId),
+        decision === 'approve'
+          ? {
+              decision,
+              expectedPublicationRevision: entry.publicationRevision,
+              entryUrl,
+            }
+          : {
+              decision,
+              expectedPublicationRevision: entry.publicationRevision,
+              reviewReason: reason,
+            },
+      );
+      setStatusMessage(
+        decision === 'approve'
+          ? `版本 v${entry.versionNumber} 已通过审核`
+          : `版本 v${entry.versionNumber} 已拒绝`,
+      );
+      await loadReviews();
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setErrorMessage);
+    } finally {
+      setBusyVersionId('');
+    }
+  }
+
+  /**
+   * 管理员安全下架：先二次确认，再带当前公开修订号调用后端；并发审核导致修订号变化时
+   * 由服务端返回冲突，前端只提示刷新，不静默重试。
+   */
+  async function suspendGame(entry: AdminGameDistributionReviewEntry) {
+    const reason = (suspendReasonByGame[entry.gameId] ?? '').trim();
+    const confirmed = await writeConfirm.confirmWrite({
+      action: '安全下架游戏',
+      target: `${entry.gameId}（版本 v${entry.versionNumber}）`,
+    });
+    if (!confirmed) return;
+    setBusyGameId(entry.gameId);
+    setErrorMessage('');
+    setStatusMessage('');
+    try {
+      await suspendAdminGameDistributionGame(
+        token,
+        entry.gameId,
+        createSuspendIdempotencyKey(entry.gameId),
+        {
+          expectedPublicationRevision: entry.publicationRevision,
+          ...(reason ? { reason } : {}),
+        },
+      );
+      setStatusMessage(`游戏 ${entry.gameId} 已安全下架，发行入口已关闭`);
+      setSuspendReasonByGame((current) => ({ ...current, [entry.gameId]: '' }));
+      await loadReviews();
+    } catch (error) {
+      handlePageError(error, onUnauthorized, setErrorMessage);
+    } finally {
+      setBusyGameId('');
+    }
+  }
+
+  return (
+    <section className="admin-page admin-page-wide">
+      <div className="admin-page-heading">
+        <h1>游戏审核</h1>
+        <button
+          type="button"
+          className="admin-secondary-button"
+          onClick={() => void loadReviews()}
+          disabled={isLoading}
+        >
+          <RefreshCcw aria-hidden="true" />
+          刷新
+        </button>
+      </div>
+
+      {errorMessage ? (
+        <div className="admin-alert admin-alert-warning" role="alert">
+          {errorMessage}
+        </div>
+      ) : null}
+      {statusMessage ? (
+        <div className="admin-alert admin-alert-success" role="status">
+          {statusMessage}
+        </div>
+      ) : null}
+
+      <div className="admin-panel">
+        <div className="admin-panel-heading">
+          <h2>待审版本</h2>
+          <span className="admin-muted-text">共 {entries.length} 条</span>
+        </div>
+
+        {isLoading ? (
+          <p className="admin-muted-text">正在加载待审版本…</p>
+        ) : null}
+
+        {!isLoading && entries.length === 0 ? (
+          <p className="admin-muted-text">当前没有待审核的游戏版本。</p>
+        ) : null}
+
+        {!isLoading && entries.length > 0 ? (
+          <div className="admin-table-wrap">
+            <table className="admin-table admin-table-wide">
+              <thead>
+                <tr>
+                  <th>游戏</th>
+                  <th>版本</th>
+                  <th>发行包</th>
+                  <th>提交时间</th>
+                  <th>审核</th>
+                </tr>
+              </thead>
+              <tbody>
+                {entries.map((entry) => {
+                  const busy = busyVersionId === entry.versionId;
+                  return (
+                    <tr key={entry.versionId}>
+                      <td>
+                        <code>{entry.gameId}</code>
+                      </td>
+                      <td>
+                        v{entry.versionNumber}
+                        <div className="admin-muted-text">{entry.status}</div>
+                        {entry.reviewReason ? (
+                          <div className="admin-muted-text">
+                            {entry.reviewReason}
+                          </div>
+                        ) : null}
+                      </td>
+                      <td>
+                        {formatBytes(entry.packageBytes)}
+                        <div className="admin-muted-text">
+                          <code>{entry.packageSha256.slice(0, 12)}</code>
+                        </div>
+                      </td>
+                      <td>{formatTime(entry.createdAt)}</td>
+                      <td>
+                        <div className="admin-action-row">
+                          <div className="admin-field">
+                            <label
+                              htmlFor={`game-release-url-${entry.versionId}`}
+                            >
+                              发行入口
+                            </label>
+                            <input
+                              id={`game-release-url-${entry.versionId}`}
+                              value={entryUrlByVersion[entry.versionId] ?? ''}
+                              placeholder="https://"
+                              onChange={(event) =>
+                                setEntryUrlByVersion((current) => ({
+                                  ...current,
+                                  [entry.versionId]: event.target.value,
+                                }))
+                              }
+                              disabled={busy}
+                            />
+                          </div>
+                          <button
+                            type="button"
+                            className="admin-primary-button"
+                            disabled={busy}
+                            onClick={() => void submitReview(entry, 'approve')}
+                          >
+                            通过
+                          </button>
+                          <div className="admin-field">
+                            <label
+                              htmlFor={`game-reject-reason-${entry.versionId}`}
+                            >
+                              拒绝理由
+                            </label>
+                            <input
+                              id={`game-reject-reason-${entry.versionId}`}
+                              value={reasonByVersion[entry.versionId] ?? ''}
+                              onChange={(event) =>
+                                setReasonByVersion((current) => ({
+                                  ...current,
+                                  [entry.versionId]: event.target.value,
+                                }))
+                              }
+                              disabled={busy}
+                            />
+                          </div>
+                          <button
+                            type="button"
+                            className="admin-ghost-button"
+                            disabled={busy}
+                            onClick={() => void submitReview(entry, 'reject')}
+                          >
+                            拒绝
+                          </button>
+                          <div className="admin-field">
+                            <label
+                              htmlFor={`game-suspend-reason-${entry.versionId}`}
+                            >
+                              下架原因
+                            </label>
+                            <input
+                              id={`game-suspend-reason-${entry.versionId}`}
+                              value={suspendReasonByGame[entry.gameId] ?? ''}
+                              onChange={(event) =>
+                                setSuspendReasonByGame((current) => ({
+                                  ...current,
+                                  [entry.gameId]: event.target.value,
+                                }))
+                              }
+                              disabled={busy}
+                            />
+                          </div>
+                          <button
+                            type="button"
+                            className="admin-danger-button"
+                            disabled={busy || busyGameId === entry.gameId}
+                            onClick={() => void suspendGame(entry)}
+                          >
+                            {busyGameId === entry.gameId
+                              ? '正在下架…'
+                              : '安全下架'}
+                          </button>
+                        </div>
+                      </td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+          </div>
+        ) : null}
+      </div>
+      {writeConfirm.confirmDialog}
+    </section>
+  );
+}
diff --git a/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx b/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx
new file mode 100644
index 000000000..c23887955
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx
@@ -0,0 +1,216 @@
+import { useEffect, useRef, useState } from 'react';
+
+import type { GameCreationAppManifest } from '../../../../../packages/shared/src/contracts/gameCreationApp';
+import { resolveTauriInvoke } from '../../app/tauri';
+import type { LocalProjectExportPackageResult } from '../../app/types';
+import {
+  createGameDistributionPublishKey,
+  type GameDistributionPublishMetadata,
+  type GameDistributionPublishResult,
+  publishLocalProjectGame,
+} from '../../services/gameDistributionPublish';
+import { ThemedModal } from '../modal/ThemedModal';
+
+const CATEGORIES = [
+  '休闲',
+  '益智',
+  '动作',
+  '冒险',
+  '模拟',
+  '策略',
+  '其他',
+] as const;
+
+export function GameDistributionPublishPanel({
+  open,
+  projectPath,
+  manifest,
+  packageResult,
+  onClose,
+  onPublished,
+}: {
+  open: boolean;
+  projectPath: string;
+  manifest: GameCreationAppManifest;
+  packageResult: LocalProjectExportPackageResult | null;
+  onClose: () => void;
+  onPublished?: (result: GameDistributionPublishResult) => void;
+}) {
+  const [title, setTitle] = useState('');
+  const [summary, setSummary] = useState('');
+  const [category, setCategory] =
+    useState<GameDistributionPublishMetadata['category']>('其他');
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState('');
+  const [result, setResult] = useState<GameDistributionPublishResult | null>(
+    null,
+  );
+  const publishIdempotencyKeyRef = useRef('');
+
+  useEffect(() => {
+    if (!open) return;
+    setTitle(manifest.name.trim());
+    setSummary(
+      (manifest.goal ?? '由陶泥儿创作的可在线游玩游戏').trim().slice(0, 120),
+    );
+    setCategory('其他');
+    setBusy(false);
+    setError('');
+    setResult(null);
+  }, [manifest.goal, manifest.name, open, packageResult?.packageRelativePath]);
+
+  useEffect(() => {
+    if (open) {
+      publishIdempotencyKeyRef.current = createGameDistributionPublishKey();
+    }
+  }, [open, packageResult?.packageRelativePath]);
+
+  async function handleSubmit() {
+    if (!packageResult || !projectPath.trim()) {
+      setError('请先导出有效的试玩包');
+      return;
+    }
+    const invoke = resolveTauriInvoke();
+    if (!invoke) {
+      setError('需要在 Tauri App 内发布');
+      return;
+    }
+    setBusy(true);
+    setError('');
+    try {
+      const next = await publishLocalProjectGame({
+        invoke,
+        projectPath,
+        packageRelativePath: packageResult.packageRelativePath,
+        manifest,
+        metadata: { title, summary, category },
+        idempotencyKey: publishIdempotencyKeyRef.current,
+      });
+      setResult(next);
+      onPublished?.(next);
+    } catch (nextError) {
+      setError(
+        nextError instanceof Error ? nextError.message : String(nextError),
+      );
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <ThemedModal
+      open={open}
+      ariaLabel="发布到游戏广场"
+      onClose={busy ? () => undefined : onClose}
+      panelClassName="game-distribution-publish-panel"
+      closeOnBackdrop={!busy}
+      closeOnEscape={!busy}
+    >
+      <header className="game-distribution-publish-panel__header">
+        <div>
+          <span className="game-distribution-publish-panel__eyebrow">
+            发布到游戏广场
+          </span>
+          <h2>让玩家现在就能试玩</h2>
+        </div>
+        <button
+          type="button"
+          onClick={onClose}
+          disabled={busy}
+          aria-label="关闭发布面板"
+        >
+          ×
+        </button>
+      </header>
+      {result ? (
+        <div className="game-distribution-publish-panel__success" role="status">
+          <strong>已提交审核</strong>
+          <p>版本已进入审核队列，审核通过后才会在游戏广场公开展示。</p>
+          <p className="game-distribution-publish-panel__mono">
+            版本 {result.versionNumber} ·{' '}
+            {result.packageSizeBytes.toLocaleString()} B ·{' '}
+            {result.packageSha256.slice(0, 16)}…
+          </p>
+          <div className="game-distribution-publish-panel__actions">
+            <button type="button" onClick={onClose}>
+              完成
+            </button>
+          </div>
+        </div>
+      ) : (
+        <>
+          <p className="game-distribution-publish-panel__intro">
+            仅上传已导出的 ZIP 字节和摘要信息；不会上传本地路径或项目源码快照。
+          </p>
+          <div
+            className="game-distribution-publish-panel__package"
+            aria-label="发行包摘要"
+          >
+            <span>{packageResult?.packageRelativePath ?? '未找到试玩包'}</span>
+            <span>
+              {packageResult
+                ? `${packageResult.fileCount} 个文件 · ${packageResult.totalBytes.toLocaleString()} B`
+                : '请先导出'}
+            </span>
+          </div>
+          <div className="game-distribution-publish-panel__fields">
+            <label>
+              游戏名称
+              <input
+                value={title}
+                maxLength={40}
+                onChange={(event) => setTitle(event.target.value)}
+              />
+            </label>
+            <label>
+              一句话简介
+              <textarea
+                value={summary}
+                maxLength={120}
+                rows={2}
+                onChange={(event) => setSummary(event.target.value)}
+              />
+            </label>
+            <label>
+              分类
+              <select
+                value={category}
+                onChange={(event) =>
+                  setCategory(
+                    event.target
+                      .value as GameDistributionPublishMetadata['category'],
+                  )
+                }
+              >
+                {CATEGORIES.map((item) => (
+                  <option key={item} value={item}>
+                    {item}
+                  </option>
+                ))}
+              </select>
+            </label>
+          </div>
+          {error ? (
+            <p className="game-distribution-publish-panel__error" role="alert">
+              {error}
+            </p>
+          ) : null}
+          <div className="game-distribution-publish-panel__actions">
+            <button type="button" onClick={onClose} disabled={busy}>
+              稍后再说
+            </button>
+            <button
+              type="button"
+              onClick={() => void handleSubmit()}
+              disabled={
+                busy || !title.trim() || !summary.trim() || !packageResult
+              }
+            >
+              {busy ? '上传中…' : '发布游戏'}
+            </button>
+          </div>
+        </>
+      )}
+    </ThemedModal>
+  );
+}
diff --git a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
new file mode 100644
index 000000000..ea6ff5887
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
@@ -0,0 +1,225 @@
+import type { GameCreationAppManifest } from '../../../../packages/shared/src/contracts/gameCreationApp';
+import type {
+  GameDistributionCategory,
+  GameDistributionCreateGameRequest,
+  GameDistributionCreateVersionRequest,
+  GameDistributionInputMode,
+  GameDistributionOrientation,
+} from '../../../../packages/shared/src/contracts/gameDistribution';
+import type {
+  LocalProjectExportPackagePayload,
+  TauriInvoke,
+} from '../app/types';
+import { requestClientApi } from './clientApi';
+
+export type GameDistributionPublishMetadata = {
+  title: string;
+  summary: string;
+  description: string;
+  category: GameDistributionCategory;
+  tags: string[];
+  deviceSupport: {
+    desktop: boolean;
+    mobile: boolean;
+    touch: boolean;
+  };
+  inputModes: GameDistributionInputMode[];
+  orientation: GameDistributionOrientation;
+};
+
+export type GameDistributionPublishResult = {
+  gameId: string;
+  versionId: string;
+  versionNumber: number;
+  status: string;
+  packageSha256: string;
+  packageSizeBytes: number;
+  fileCount: number;
+};
+
+type CreatedGame = { id: string; publicationRevision?: number };
+type CreatedVersion = {
+  gameId: string;
+  versionId: string;
+  versionNumber: number;
+  status: string;
+};
+
+export function createGameDistributionPublishKey() {
+  const randomUuid =
+    typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+      ? crypto.randomUUID()
+      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return `agc-publish-${randomUuid}`;
+}
+
+function normalizeMetadata(
+  manifest: GameCreationAppManifest,
+  metadata?: Partial<GameDistributionPublishMetadata>,
+): GameDistributionPublishMetadata {
+  const title = (metadata?.title ?? manifest.name).trim();
+  const summary = (
+    metadata?.summary ??
+    manifest.goal ??
+    '由陶泥儿创作的可在线游玩游戏'
+  ).trim();
+  if (!title || title.length > 40) {
+    throw new Error('游戏标题必须为 1 到 40 个字符');
+  }
+  if (!summary || summary.length > 120) {
+    throw new Error('游戏简介必须为 1 到 120 个字符');
+  }
+  return {
+    title,
+    summary,
+    description: (metadata?.description ?? summary).trim().slice(0, 2_000),
+    category: metadata?.category ?? '其他',
+    tags: metadata?.tags ?? [],
+    deviceSupport: metadata?.deviceSupport ?? {
+      desktop: true,
+      mobile: true,
+      touch: true,
+    },
+    inputModes: metadata?.inputModes ?? ['keyboard', 'mouse', 'touch'],
+    orientation: metadata?.orientation ?? 'responsive',
+  };
+}
+
+function toCreateGameRequest(
+  metadata: GameDistributionPublishMetadata,
+  localProjectId: string,
+): GameDistributionCreateGameRequest {
+  return {
+    localProjectId,
+    title: metadata.title,
+    summary: metadata.summary,
+    description: metadata.description,
+    category: metadata.category,
+    tags: metadata.tags,
+    deviceSupport: metadata.deviceSupport,
+    inputModes: metadata.inputModes,
+    orientation: metadata.orientation,
+  };
+}
+
+export async function publishLocalProjectGame(args: {
+  invoke: TauriInvoke;
+  projectPath: string;
+  packageRelativePath: string;
+  manifest: GameCreationAppManifest;
+  metadata?: Partial<GameDistributionPublishMetadata>;
+  idempotencyKey?: string;
+}): Promise<GameDistributionPublishResult> {
+  const projectPath = args.projectPath.trim();
+  const packageRelativePath = args.packageRelativePath.trim();
+  if (!projectPath || !packageRelativePath) {
+    throw new Error('发布需要绑定本地项目和试玩包');
+  }
+  const payload = await args.invoke<LocalProjectExportPackagePayload>(
+    'read_local_project_export_package',
+    { projectPath, packageRelativePath },
+  );
+  if (
+    !payload.packageBytes.length ||
+    payload.packageSizeBytes !== payload.packageBytes.length ||
+    payload.files.length === 0
+  ) {
+    throw new Error('本地发行包摘要无效，请重新导出试玩包');
+  }
+  if (payload.packageRelativePath !== packageRelativePath) {
+    throw new Error('本地发行包路径已变化，请重新导出试玩包');
+  }
+
+  const metadata = normalizeMetadata(args.manifest, args.metadata);
+  const localProjectId = args.manifest.projectId.trim();
+  if (!localProjectId) {
+    throw new Error('发布需要本地项目标识，请重新打开项目后再试');
+  }
+  const gameMetadata = toCreateGameRequest(metadata, localProjectId);
+  const rootKey =
+    args.idempotencyKey?.trim() || createGameDistributionPublishKey();
+  const game = await requestClientApi<CreatedGame>(
+    '/api/game-distribution/games',
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Idempotency-Key': `${rootKey}:game`,
+      },
+      body: JSON.stringify(gameMetadata),
+    },
+    '创建平台游戏失败',
+  );
+  if (!game?.id?.trim()) {
+    throw new Error('创建平台游戏未返回游戏 ID');
+  }
+
+  const versionRequest: GameDistributionCreateVersionRequest = {
+    localProjectId,
+    packageSha256: payload.packageSha256,
+    packageBytes: payload.packageSizeBytes,
+    packageFileCount: payload.files.length,
+    packageEntryPath: 'index.html',
+    gameMetadata,
+  };
+  const version = await requestClientApi<CreatedVersion>(
+    `/api/game-distribution/games/${encodeURIComponent(game.id)}/versions`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Idempotency-Key': `${rootKey}:version`,
+      },
+      body: JSON.stringify(versionRequest),
+    },
+    '创建游戏发行版本失败',
+  );
+  if (!version?.versionId?.trim()) {
+    throw new Error('创建发行版本未返回版本 ID');
+  }
+
+  const packageBody = new Blob([new Uint8Array(payload.packageBytes)], {
+    type: 'application/zip',
+  });
+  const uploaded = await requestClientApi<{
+    versionId: string;
+    status: string;
+  }>(
+    `/api/game-distribution/versions/${encodeURIComponent(version.versionId)}/package`,
+    {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/zip',
+        'Idempotency-Key': `${rootKey}:upload`,
+      },
+      body: packageBody,
+    },
+    '上传游戏发行包失败',
+  );
+  const submitted = await requestClientApi<{
+    game?: { publicationRevision?: number };
+    version?: { status?: string };
+  }>(
+    `/api/game-distribution/versions/${encodeURIComponent(version.versionId)}/submit`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Idempotency-Key': `${rootKey}:submit`,
+      },
+      body: JSON.stringify({
+        expectedPublicationRevision: game.publicationRevision ?? 0,
+      }),
+    },
+    '提交审核失败',
+  );
+  return {
+    gameId: game.id,
+    versionId: version.versionId,
+    versionNumber: version.versionNumber,
+    status: submitted?.version?.status ?? uploaded?.status ?? 'pending_review',
+    packageSha256: payload.packageSha256,
+    packageSizeBytes: payload.packageSizeBytes,
+    fileCount: payload.files.length,
+  };
+}
diff --git a/apps/ai-game-creator-shell/tests/appSurface/project-preview/preview-shortcuts/assert-project-tools-and-preview.ts b/apps/ai-game-creator-shell/tests/appSurface/project-preview/preview-shortcuts/assert-project-tools-and-preview.ts
index 22fe7f8e6..497398d22 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/project-preview/preview-shortcuts/assert-project-tools-and-preview.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/project-preview/preview-shortcuts/assert-project-tools-and-preview.ts
@@ -849,6 +849,14 @@ export function registerProjectToolsAndPreviewTests() {
         /已导出本地试玩包：exports\/playtest-package-unit\.zip/,
       ),
     ).not.toBeNull();
+    // 导出成功后会直接打开发布到游戏广场的面板；它是模态，先确认出现再关闭，
+    // 然后回到预览快捷操作的会话流。
+    const publishPanel = await screen.findByRole('dialog', {
+      name: '发布到游戏广场',
+    });
+    expect(publishPanel).not.toBeNull();
+    fireEvent.click(screen.getByRole('button', { name: '关闭发布面板' }));
+
     const exportRevealButtons = screen.getAllByRole('button', {
       name: '显示目录',
     });
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
new file mode 100644
index 000000000..93d69d847
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
@@ -0,0 +1,118 @@
+// @vitest-environment jsdom
+import { beforeEach, expect, test, vi } from 'vitest';
+
+const fetchClientHttp = vi.fn();
+
+vi.mock('../src/services/clientHttp', () => ({
+  AGC_DEVELOPMENT_API_BASE_URL: 'https://dev.genarrative.world',
+  fetchClientHttp: (...args: unknown[]) => fetchClientHttp(...args),
+  getClientServerBaseUrl: () => 'https://dev.genarrative.world',
+  readClientHttpResponseText: (response: Response) => response.text(),
+}));
+
+vi.mock('../src/services/errorReporting', () => ({
+  captureClientError: vi.fn(),
+}));
+
+import type { GameCreationAppManifest } from '../../../packages/shared/src/contracts/gameCreationApp';
+import { publishLocalProjectGame } from '../src/services/gameDistributionPublish';
+
+const MANIFEST = {
+  projectId: 'local-proj-1',
+  name: '星轨防线',
+  goal: '守住轨道城',
+} as unknown as GameCreationAppManifest;
+
+function jsonResponse(payload: unknown) {
+  return new Response(
+    JSON.stringify({
+      ok: true,
+      data: payload,
+      error: null,
+      meta: { apiVersion: 'v1' },
+    }),
+    {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    },
+  );
+}
+
+beforeEach(() => {
+  fetchClientHttp.mockReset();
+  window.localStorage.clear();
+});
+
+test('发布时携带本地项目标识，让重复发布复用同一个平台游戏', async () => {
+  fetchClientHttp
+    .mockResolvedValueOnce(
+      jsonResponse({ id: 'game_1', publicationRevision: 0 }),
+    )
+    .mockResolvedValueOnce(
+      jsonResponse({
+        gameId: 'game_1',
+        versionId: 'gamever_1',
+        versionNumber: 1,
+        status: 'awaiting_upload',
+      }),
+    )
+    .mockResolvedValueOnce(
+      jsonResponse({ versionId: 'gamever_1', status: 'uploaded' }),
+    )
+    .mockResolvedValueOnce(
+      jsonResponse({ version: { status: 'pending_review' } }),
+    );
+
+  const result = await publishLocalProjectGame({
+    invoke: (async (command: string) => {
+      expect(command).toBe('read_local_project_export_package');
+      return {
+        packageRelativePath: 'exports/playtest-package-1.zip',
+        packageBytes: [1, 2, 3],
+        packageSha256: 'a'.repeat(64),
+        packageSizeBytes: 3,
+        files: [{ path: 'index.html', sizeBytes: 3, sha256: 'a'.repeat(64) }],
+      };
+    }) as never,
+    projectPath: '/tmp/project',
+    packageRelativePath: 'exports/playtest-package-1.zip',
+    manifest: MANIFEST,
+  });
+
+  const createGameCall = fetchClientHttp.mock.calls[0];
+  expect(createGameCall?.[0]).toBe('/api/game-distribution/games');
+  const createGameBody = JSON.parse(
+    String((createGameCall?.[1] as RequestInit).body),
+  );
+  expect(createGameBody.localProjectId).toBe('local-proj-1');
+
+  const createVersionCall = fetchClientHttp.mock.calls[1];
+  expect(createVersionCall?.[0]).toBe(
+    '/api/game-distribution/games/game_1/versions',
+  );
+  expect(
+    JSON.parse(String((createVersionCall?.[1] as RequestInit).body))
+      .localProjectId,
+  ).toBe('local-proj-1');
+
+  expect(result.gameId).toBe('game_1');
+  expect(result.versionId).toBe('gamever_1');
+});
+
+test('缺少本地项目标识时在发起请求前失败关闭', async () => {
+  await expect(
+    publishLocalProjectGame({
+      invoke: (async () => ({
+        packageRelativePath: 'exports/playtest-package-1.zip',
+        packageBytes: [1],
+        packageSha256: 'a'.repeat(64),
+        packageSizeBytes: 1,
+        files: [{ path: 'index.html', sizeBytes: 1, sha256: 'a'.repeat(64) }],
+      })) as never,
+      projectPath: '/tmp/project',
+      packageRelativePath: 'exports/playtest-package-1.zip',
+      manifest: { ...MANIFEST, projectId: '   ' } as GameCreationAppManifest,
+    }),
+  ).rejects.toThrow('发布需要本地项目标识');
+  expect(fetchClientHttp).not.toHaveBeenCalled();
+});
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
new file mode 100644
index 000000000..4b22e58a6
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
@@ -0,0 +1,222 @@
+// @vitest-environment jsdom
+/**
+ * AGC「一键发布」的真实链路验证（默认跳过，按需开启）。
+ *
+ * 运行方式：
+ *   GENARRATIVE_AGC_PUBLISH_E2E_BASE_URL=http://127.0.0.1:10001 \
+ *     npx vitest run apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts
+ *
+ * 开启后测试会注册一个临时作者，并通过真实的 `clientApi` / `clientHttp`（而不是
+ * mock 请求层）调用 AGC 的发布函数，覆盖：本地导出包读取、创建游戏、同
+ * `localProjectId` 复用游戏身份、真实 ZIP 上传、送审与版本回读。
+ */
+import { createHash } from 'node:crypto';
+
+import JSZip from 'jszip';
+import { expect, test, vi } from 'vitest';
+
+import type { GameCreationAppManifest } from '../../../packages/shared/src/contracts/gameCreationApp';
+import type { LocalProjectExportPackagePayload } from '../src/app/types';
+import { setStoredAuthAccessToken } from '../src/services/clientAuth';
+import { publishLocalProjectGame } from '../src/services/gameDistributionPublish';
+
+const liveBaseUrl = (process.env.GENARRATIVE_AGC_PUBLISH_E2E_BASE_URL ?? '')
+  .trim()
+  .replace(/\/+$/u, '');
+const liveTest = liveBaseUrl ? test : test.skip;
+
+const realFetch = globalThis.fetch.bind(globalThis);
+const ENVELOPE_HEADERS = { 'x-genarrative-response-envelope': 'v1' };
+
+function apiUrl(path: string) {
+  return new URL(path, `${liveBaseUrl}/`).toString();
+}
+
+/** 把 AGC 的相对请求改写到本地栈；其余语义（头部、超时包装）保持真实实现。 */
+function installFetchBridge() {
+  vi.stubGlobal(
+    'fetch',
+    async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url =
+        typeof input === 'string'
+          ? apiUrl(input)
+          : input instanceof URL
+            ? input.toString()
+            : input;
+      const body = init?.body;
+      if (typeof Blob !== 'undefined' && body instanceof Blob) {
+        // jsdom 的 Blob/ArrayBuffer 属于另一个 realm，且旧版 jsdom 没有
+        // Blob.arrayBuffer；统一读成字节后复制为 Node 侧 Buffer 再转发。
+        const bytes = await readBlobBytes(body);
+        return realFetch(url as string, {
+          ...init,
+          body: Buffer.from(bytes),
+        });
+      }
+      return realFetch(url as string, init);
+    },
+  );
+}
+
+async function readBlobBytes(blob: Blob): Promise<Uint8Array> {
+  const maybeArrayBuffer = (
+    blob as Blob & { arrayBuffer?: () => Promise<ArrayBuffer> }
+  ).arrayBuffer;
+  if (typeof maybeArrayBuffer === 'function') {
+    return new Uint8Array(await maybeArrayBuffer.call(blob));
+  }
+  return await new Promise<Uint8Array>((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result;
+      resolve(
+        result instanceof ArrayBuffer
+          ? new Uint8Array(result)
+          : new Uint8Array(0),
+      );
+    };
+    reader.onerror = () =>
+      reject(reader.error ?? new Error('读取发行包字节失败'));
+    reader.readAsArrayBuffer(blob);
+  });
+}
+
+async function unwrap<T>(response: Response): Promise<T> {
+  const text = await response.text();
+  const parsed: unknown = JSON.parse(text);
+  if (
+    !parsed ||
+    typeof parsed !== 'object' ||
+    (parsed as { ok?: boolean }).ok !== true
+  ) {
+    throw new Error(`后端返回失败：${text.slice(0, 400)}`);
+  }
+  return (parsed as { data: T }).data;
+}
+
+async function registerAuthor(): Promise<string> {
+  const phone = `136${String(Date.now()).slice(-8)}`;
+  const response = await realFetch(apiUrl('/api/auth/entry'), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...ENVELOPE_HEADERS },
+    body: JSON.stringify({
+      purePhoneNumber: phone,
+      password: 'GenTest123!',
+    }),
+  });
+  const data = await unwrap<{ token: string }>(response);
+  return data.token;
+}
+
+async function buildExportPayload(): Promise<LocalProjectExportPackagePayload> {
+  const zip = new JSZip();
+  const indexHtml =
+    '<!doctype html><html><head><meta charset="utf-8"><title>AGC Live</title>' +
+    '<script src="assets/app.js"></script></head><body><h1>AGC-LIVE</h1></body></html>';
+  const appJs =
+    'window.__agcLive=1;document.documentElement.dataset.booted="agc";';
+  zip.file('index.html', indexHtml);
+  zip.file('assets/app.js', appJs);
+  const bytes = await zip.generateAsync({ type: 'uint8array' });
+  const sha256 = createHash('sha256').update(bytes).digest('hex');
+  return {
+    packageRelativePath: 'dist/game.zip',
+    packageBytes: Array.from(bytes),
+    packageSha256: sha256,
+    packageSizeBytes: bytes.length,
+    files: [
+      {
+        path: 'index.html',
+        sizeBytes: Buffer.byteLength(indexHtml),
+        sha256: createHash('sha256').update(indexHtml).digest('hex'),
+      },
+      {
+        path: 'assets/app.js',
+        sizeBytes: Buffer.byteLength(appJs),
+        sha256: createHash('sha256').update(appJs).digest('hex'),
+      },
+    ],
+  };
+}
+
+liveTest(
+  'AGC 发布函数在真实后端完成创建、上传、送审并在重复发布时复用游戏身份',
+  async () => {
+    installFetchBridge();
+    const token = await registerAuthor();
+    setStoredAccessToken(token);
+
+    const payload = await buildExportPayload();
+    const stamp = String(Date.now());
+    const manifest = {
+      projectId: `agc-live-${stamp}`,
+      name: `AGC 真实发布${stamp.slice(-4)}`,
+      goal: '验证 AGC 一键发布链路',
+    } as unknown as GameCreationAppManifest;
+    const invoke = vi.fn(async () => payload);
+    const metadata = {
+      summary: '由 AGC 发布函数真实提交',
+      description:
+        '集成验证：AGC 发布函数 → 本地 api-server → SpacetimeDB / 私有 OSS',
+      category: '益智' as const,
+      tags: ['集成验证'],
+      deviceSupport: { desktop: true, mobile: false, touch: false },
+      inputModes: ['keyboard', 'mouse'] as const,
+      orientation: 'landscape' as const,
+    };
+
+    const first = await publishLocalProjectGame({
+      invoke,
+      projectPath: '/data/dsk/Genarrative/tmp-agc-live-project',
+      packageRelativePath: 'dist/game.zip',
+      manifest,
+      metadata: { ...metadata, inputModes: [...metadata.inputModes] },
+    });
+    expect(first.status).toBe('pending_review');
+    expect(first.versionNumber).toBe(1);
+    expect(first.packageSha256).toBe(payload.packageSha256);
+
+    const readResult = await unwrap<{
+      version: { versionId: string; status: string; recoveryAction: string };
+      game: { id: string };
+    }>(
+      await realFetch(
+        apiUrl(`/api/game-distribution/versions/${first.versionId}`),
+        { headers: { Authorization: `Bearer ${token}`, ...ENVELOPE_HEADERS } },
+      ),
+    );
+    expect(readResult.version.status).toBe('pending_review');
+    expect(readResult.version.recoveryAction).toBe('wait');
+    expect(readResult.game.id).toBe(first.gameId);
+
+    // 第二次发布不带旧幂等键：同 localProjectId 必须复用同一 gameId 并新增版本。
+    const second = await publishLocalProjectGame({
+      invoke,
+      projectPath: '/data/dsk/Genarrative/tmp-agc-live-project',
+      packageRelativePath: 'dist/game.zip',
+      manifest,
+      metadata: { ...metadata, inputModes: [...metadata.inputModes] },
+    });
+    expect(second.gameId).toBe(first.gameId);
+    expect(second.versionNumber).toBe(first.versionNumber + 1);
+
+    const myGames = await unwrap<{
+      games: Array<{
+        id: string;
+        latestVersion: { versionId: string; status: string } | null;
+      }>;
+    }>(
+      await realFetch(apiUrl('/api/game-distribution/my-games'), {
+        headers: { Authorization: `Bearer ${token}`, ...ENVELOPE_HEADERS },
+      }),
+    );
+    const published = myGames.games.find((game) => game.id === first.gameId);
+    expect(published?.latestVersion?.versionId).toBe(second.versionId);
+    expect(published?.latestVersion?.status).toBe('pending_review');
+  },
+  120_000,
+);
+
+function setStoredAccessToken(token: string) {
+  setStoredAuthAccessToken(token);
+}
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx b/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
new file mode 100644
index 000000000..fb9f41fe3
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx
@@ -0,0 +1,213 @@
+// @vitest-environment jsdom
+/**
+ * AGC「发布到游戏广场」面板的行为边界。
+ *
+ * 这里只覆盖面板自身（预填资料、必填门禁、防重复点击、成功/失败态与无 Tauri 宿主），
+ * 真实的 HTTP 链路由 `gameDistributionPublishLive.test.ts` 覆盖。
+ */
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from '@testing-library/react';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+
+import type { GameCreationAppManifest } from '../../../packages/shared/src/contracts/gameCreationApp';
+import type { LocalProjectExportPackageResult } from '../src/app/types';
+import { GameDistributionPublishPanel } from '../src/components/game-distribution/GameDistributionPublishPanel';
+import { publishLocalProjectGame } from '../src/services/gameDistributionPublish';
+
+vi.mock('../src/services/gameDistributionPublish', async (importOriginal) => {
+  const actual =
+    await importOriginal<
+      typeof import('../src/services/gameDistributionPublish')
+    >();
+  return { ...actual, publishLocalProjectGame: vi.fn() };
+});
+
+type TauriInvoke = (
+  command: string,
+  args?: Record<string, unknown>,
+) => Promise<unknown>;
+
+function installTauriInvoke(invoke: TauriInvoke) {
+  const mock = vi.fn(invoke);
+  (
+    window as unknown as {
+      __TAURI__?: { core?: { invoke?: typeof mock } };
+    }
+  ).__TAURI__ = { core: { invoke: mock } };
+  return mock;
+}
+
+const MANIFEST = {
+  projectId: 'local-proj-1',
+  name: '星轨防线',
+  goal: '守住轨道城',
+} as unknown as GameCreationAppManifest;
+
+const PACKAGE_RESULT = {
+  packageRelativePath: 'exports/playtest-package-unit.zip',
+  packageBytes: [1, 2, 3],
+  packageSha256: 'a'.repeat(64),
+  packageSizeBytes: 3,
+  fileCount: 2,
+  totalBytes: 3,
+} as unknown as LocalProjectExportPackageResult;
+
+function renderPanel(
+  overrides: Partial<Parameters<typeof GameDistributionPublishPanel>[0]> = {},
+) {
+  const onClose = vi.fn();
+  const onPublished = vi.fn();
+  render(
+    <GameDistributionPublishPanel
+      open
+      projectPath="/tmp/authorized-game"
+      manifest={MANIFEST}
+      packageResult={PACKAGE_RESULT}
+      onClose={onClose}
+      onPublished={onPublished}
+      {...overrides}
+    />,
+  );
+  return { onClose, onPublished };
+}
+
+afterEach(() => {
+  cleanup();
+  vi.mocked(publishLocalProjectGame).mockReset();
+  delete (window as unknown as { __TAURI__?: unknown }).__TAURI__;
+  window.localStorage.clear();
+});
+
+describe('GameDistributionPublishPanel', () => {
+  test('打开时预填游戏资料并展示发行包摘要', () => {
+    installTauriInvoke(async () => undefined);
+    renderPanel();
+
+    expect(screen.getByLabelText('游戏名称')).toHaveProperty(
+      'value',
+      '星轨防线',
+    );
+    expect(screen.getByLabelText('一句话简介')).toHaveProperty(
+      'value',
+      '守住轨道城',
+    );
+    expect(screen.getByLabelText('发行包摘要').textContent).toContain(
+      'exports/playtest-package-unit.zip',
+    );
+    expect(screen.getByLabelText('发行包摘要').textContent).toContain(
+      '2 个文件',
+    );
+  });
+
+  test('提交时带上项目路径、发行包与资料，成功后展示审核状态', async () => {
+    const invoke = installTauriInvoke(async () => undefined);
+    vi.mocked(publishLocalProjectGame).mockResolvedValue({
+      gameId: 'game_1',
+      versionId: 'gamever_1',
+      versionNumber: 1,
+      status: 'pending_review',
+      packageSha256: 'a'.repeat(64),
+      packageSizeBytes: 3,
+      fileCount: 2,
+    });
+    const { onPublished } = renderPanel();
+
+    fireEvent.change(screen.getByLabelText('游戏名称'), {
+      target: { value: '星轨防线二' },
+    });
+    fireEvent.change(screen.getByLabelText('分类'), {
+      target: { value: '动作' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: '发布游戏' }));
+
+    await waitFor(() =>
+      expect(publishLocalProjectGame).toHaveBeenCalledTimes(1),
+    );
+    const args = vi.mocked(publishLocalProjectGame).mock.calls[0]?.[0];
+    expect(args?.invoke).toBeDefined();
+    expect(args?.projectPath).toBe('/tmp/authorized-game');
+    expect(args?.packageRelativePath).toBe('exports/playtest-package-unit.zip');
+    expect(args?.manifest).toBe(MANIFEST);
+    expect(args?.metadata).toEqual({
+      title: '星轨防线二',
+      summary: '守住轨道城',
+      category: '动作',
+    });
+    expect(String(args?.idempotencyKey)).toMatch(/^agc-publish-/u);
+    expect(invoke).toBeDefined();
+
+    expect(await screen.findByText('已提交审核')).not.toBeNull();
+    expect(screen.getByText(/版本 1/u)).not.toBeNull();
+    expect(onPublished).toHaveBeenCalledTimes(1);
+  });
+
+  test('连续点击只提交一次，上传中禁用动作按钮', async () => {
+    installTauriInvoke(async () => undefined);
+    let resolvePublish: (value: unknown) => void = () => undefined;
+    vi.mocked(publishLocalProjectGame).mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          resolvePublish = resolve as (value: unknown) => void;
+        }) as never,
+    );
+    renderPanel();
+
+    const submit = screen.getByRole('button', { name: '发布游戏' });
+    fireEvent.click(submit);
+    fireEvent.click(submit);
+
+    expect(await screen.findByText('上传中…')).not.toBeNull();
+    expect(publishLocalProjectGame).toHaveBeenCalledTimes(1);
+
+    resolvePublish({
+      gameId: 'game_1',
+      versionId: 'gamever_1',
+      versionNumber: 1,
+      status: 'pending_review',
+      packageSha256: 'a'.repeat(64),
+      packageSizeBytes: 3,
+      fileCount: 2,
+    });
+    expect(await screen.findByText('已提交审核')).not.toBeNull();
+  });
+
+  test('服务端失败时保留面板并展示可读错误', async () => {
+    installTauriInvoke(async () => undefined);
+    vi.mocked(publishLocalProjectGame).mockRejectedValue(
+      new Error('上传游戏发行包失败：游戏分发服务暂不可用（503）'),
+    );
+    renderPanel();
+
+    fireEvent.click(screen.getByRole('button', { name: '发布游戏' }));
+
+    expect(
+      await screen.findByText(
+        '上传游戏发行包失败：游戏分发服务暂不可用（503）',
+      ),
+    ).not.toBeNull();
+    expect(screen.queryByText('已提交审核')).toBeNull();
+  });
+
+  test('不在 Tauri 宿主或缺少试玩包时失败关闭且不调用发布接口', async () => {
+    renderPanel();
+    fireEvent.click(screen.getByRole('button', { name: '发布游戏' }));
+    expect(await screen.findByText('需要在 Tauri App 内发布')).not.toBeNull();
+    expect(publishLocalProjectGame).not.toHaveBeenCalled();
+
+    cleanup();
+    installTauriInvoke(async () => undefined);
+    renderPanel({ packageResult: null });
+    expect(screen.getByRole('button', { name: '发布游戏' })).toHaveProperty(
+      'disabled',
+      true,
+    );
+    expect(screen.getByLabelText('发行包摘要').textContent).toContain(
+      '未找到试玩包',
+    );
+  });
+});
diff --git a/deploy/nginx/README.md b/deploy/nginx/README.md
index e6fe4ca99..c3c4bff34 100644
--- a/deploy/nginx/README.md
+++ b/deploy/nginx/README.md
@@ -99,3 +99,11 @@ curl -sSI -H 'Accept-Encoding: br' \
 - gzip 可用时返回 `Content-Encoding: gzip`。
 - br 可用时返回 `Content-Encoding: br`。
 - 响应头应包含 `Vary: Accept-Encoding`。
+
+## 游戏发行来源（每游戏独立 origin）
+
+- `deploy/nginx/genarrative-release-origin.conf` 为已公开游戏提供每游戏独立来源：`https://<gameId>.games.example.com/`。部署前替换域名、通配证书路径与 upstream 端口，并为 `*.games.example.com` 配置通配 DNS 与通配 TLS。
+- 该来源只把子域根路径映射到 `…/releases/<gameId>/index.html`、其余路径映射到 `…/releases/<gameId>/<原路径>`；平台 API、后台、SPA 与上传接口都不在这个来源上暴露，命中即 404。
+- 发行来源不使用 Cookie：带 `Cookie` 的请求在边缘直接 403，转发前也会 `proxy_set_header Cookie ""`。响应头（`X-Content-Type-Options`、CORP、无凭据 CORS、HTML CSP、内容类型白名单与 `Cache-Control: public, max-age=60, must-revalidate`）由 `api-server` 发行网关设置，边缘不覆盖。
+- 审核通过时填写的 `entryUrl` 就是该子域根地址 `https://<gameId>.games.example.com/`；换版本或下架只改变后端公开投影，边缘不需要改配置。
+- 门禁：`npm run check:release-origin-config` 会逐条校验模板约束、交叉检查发行网关仍在设置上述响应头，并在本机存在 `nginx` 与 `openssl` 时用自签通配证书渲染一份临时配置执行 `nginx -t`。
diff --git a/deploy/nginx/genarrative-release-origin.conf b/deploy/nginx/genarrative-release-origin.conf
new file mode 100644
index 000000000..5e120726d
--- /dev/null
+++ b/deploy/nginx/genarrative-release-origin.conf
@@ -0,0 +1,80 @@
+# 游戏发行来源（每游戏独立 origin）
+#
+# 部署前替换：
+#   1) `games.example.com` 为真实发行域，并为 `*.games.example.com` 配置通配 DNS
+#      与通配 TLS 证书；
+#   2) `ssl_certificate` / `ssl_certificate_key` 指向该通配证书；
+#   3) upstream 端口与 api-server 实际监听一致。
+#
+# 设计约定：
+#   - 每个已公开游戏使用自己的子域：`https://<gameId>.games.example.com/`；
+#   - 该来源只把请求映射到发行网关
+#     `/api/game-distribution/releases/<gameId>/…`，平台 API、后台、SPA 与上传
+#     接口都不在这个来源上暴露；
+#   - 发行来源从不使用 Cookie：带 Cookie 的请求直接 403，转发前也会清空 Cookie；
+#   - `X-Content-Type-Options` / CORP / 无凭据 CORS / HTML CSP / 内容类型白名单由
+#     api-server 发行网关设置，这里不覆盖，避免两层策略漂移；
+#   - 公开版本切换与下架由后端 `publication_revision` CAS 决定，边缘只做按主机映射。
+
+upstream genarrative_release_api {
+    server 127.0.0.1:8082;
+    keepalive 32;
+}
+
+server {
+    listen 80;
+    server_name ~^(?<game_id>[a-z0-9_]+)\.games\.example\.com$;
+
+    location /.well-known/acme-challenge/ {
+        root /var/www/html;
+    }
+
+    location / {
+        return 301 https://$host$request_uri;
+    }
+}
+
+server {
+    listen 443 ssl http2;
+    server_name ~^(?<game_id>[a-z0-9_]+)\.games\.example\.com$;
+
+    ssl_certificate /etc/letsencrypt/live/games.example.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/games.example.com/privkey.pem;
+
+    access_log /var/log/nginx/genarrative-release.access.log;
+    error_log /var/log/nginx/genarrative-release.error.log warn;
+
+    # 发行文件是公开静态资源，从不携带平台 Cookie。带上 Cookie 的请求说明它落在
+    # 平台会话来源上，直接拒绝，避免发行内容被主站同源脚本读取。
+    if ($http_cookie) {
+        return 403;
+    }
+
+    # 子域根路径直接服务该游戏的 index.html，游戏内其余资源按相对路径原样交给
+    # 发行网关；这样审核通过时填写的 entryUrl 就是 https://<gameId>.games.example.com/。
+    location = / {
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Request-Id $request_id;
+        proxy_set_header Cookie "";
+        proxy_pass http://genarrative_release_api/api/game-distribution/releases/$game_id/index.html;
+        proxy_read_timeout 60s;
+        proxy_send_timeout 60s;
+    }
+
+    location / {
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Request-Id $request_id;
+        proxy_set_header Cookie "";
+        proxy_pass http://genarrative_release_api/api/game-distribution/releases/$game_id$request_uri;
+        proxy_read_timeout 60s;
+        proxy_send_timeout 60s;
+    }
+}
diff --git a/docs/project-memory/plans/【实施计划】游戏分发阶段A领域合同-2026-09-19.md b/docs/project-memory/plans/【实施计划】游戏分发阶段A领域合同-2026-09-19.md
new file mode 100644
index 000000000..37b419c8e
--- /dev/null
+++ b/docs/project-memory/plans/【实施计划】游戏分发阶段A领域合同-2026-09-19.md
@@ -0,0 +1,91 @@
+# 【实施计划】游戏分发阶段A领域合同
+
+| 字段 | 值 |
+| --- | --- |
+| Milestone | `docs/project-memory/plans/【里程碑】游戏分发目录详情与在线游玩-2026-09-18.md` 阶段 A |
+| Status | in_progress |
+| Owner | Codex |
+
+## 修改边界
+
+- 允许修改：`module-game-distribution` 新领域 crate、workspace 声明、Rust shared-contracts DTO、领域单测及文档证据。
+- 明确不修改：发行域名与 CDN、旧 public work/runtime、AGC native 上传命令、网页发布表单。
+
+## 行为范围
+
+- 定义游戏身份、版本状态、包摘要、owner 权限、幂等 key 冲突和 publication revision CAS。
+- 领域服务先以纯内存仓储验证状态合同，再接入已冻结的 SpacetimeDB 游戏/版本/幂等收据表；不把内存仓储作为生产事实源。
+- 阶段 A 只提供身份、版本、真实包确认和状态回读基础，不提供“发布成功”或公开可玩状态，不绕过人工审核。
+
+## 验证命令
+
+1. `cargo test -p module-game-distribution --manifest-path server-rs/Cargo.toml`
+2. `cargo fmt --all --manifest-path server-rs/Cargo.toml -- --check`
+3. `npm run check:encoding`
+4. `git diff --check`
+
+## 风险与回滚点
+
+- API 接入前端前必须完成 SpacetimeDB facade 和 schema 门禁；任何失败都保留旧版本数据，不覆盖已有业务表。
+- 内存仓储只用于行为合同测试，不得被前端当作正式数据源。
+
+## 已完成证据（当前切片）
+
+- `module-game-distribution` 已落地游戏/版本状态机、owner 校验、幂等摘要冲突、上传确认、验证失败重试、审核 CAS、撤回和管理员暂停的纯领域服务与内存测试仓储。
+- 同一 crate 已加入不执行上传代码的 ZIP 包校验：根 `index.html`、路径穿越/大小写冲突、符号链接、加密文件、敏感文件、嵌套压缩包、单文件/总展开量/压缩比上限和逐文件 SHA-256 清单；并新增按白名单内容类型取单个发行资源的读取层。
+- Rust/TypeScript 跨端 DTO、SpacetimeDB 三张持久表、migration 白名单、生成 bindings、typed facade 和游戏分发 HTTP 路由已接入，覆盖创建、上传、送审、审核、下架、公开目录与详情。
+- `api-server` 新增发行网关 `GET /api/game-distribution/releases/{gameId}/{assetPath}`：只服务当前已公开版本，未知扩展名 404，附带 nosniff / CORP / HTML CSP，拒绝带 Cookie 请求，并按对象键做有界包缓存。
+- 重复发布复用游戏身份：游戏表末尾新增可空 `local_project_id`，`create_game_distribution_game` 在 owner + local_project_id 命中时复用既有 `gameId` 并只新增版本；`localProjectId` 经 shared-contracts（Rust/TS）透传，AGC 发布链路写入并在缺失时于发请求前失败关闭，api-server 对短标识做路径分隔符与控制字符校验。
+- 后台新增 `#game-distribution` 游戏审核页：待审列表、通过（要求 HTTPS 发行入口）、拒绝（要求理由）、幂等键与列表刷新；对应 `editor-showcase` Tab 权限映射、API client 与页面测试已加入。
+- 路由级测试证明发行网关、公开目录与登录发布路由确实挂载：带 Cookie 的发行请求 403、未知扩展名 404 且不触达对象存储、无 Bearer 的发布请求 401、目录在无数据库时返回 502 而不是 404。
+- 自动化证据：`cargo test -p module-game-distribution`（11 passed）、`cargo test -p api-server` 游戏分发模块（9 passed）与全量 `cargo test -p api-server`（1069 passed / 6 ignored）、`cargo test -p shared-contracts`、admin-web Vitest（149 passed，含新增游戏审核页与 client 用例）、前端游戏定向 Vitest（15 passed）、AGC `typecheck` 与 `local_project_export` Rust 测试（7 passed）、Vite build。
+- 版本回读、撤回与管理员安全下架闭环：新增 SpacetimeDB `get_game_distribution_version_and_return` / `cancel_game_distribution_version_and_return`（幂等收据 + 公开修订号 CAS）、`spacetime-client` façade、`GET /api/game-distribution/versions/{versionId}`（作者，未知与非 owner 一律 404）、`GET /admin/api/game-distribution/versions/{versionId}`（管理员）与 `POST /api/game-distribution/versions/{versionId}/cancel`（作者，`Idempotency-Key` + `expectedPublicationRevision`）；版本私有投影新增服务端派生的 `recoveryAction`（upload/submit/wait/none/reupload/fix_package/fix_metadata）。后台游戏审核页补齐「安全下架」入口（原因输入 + 二次确认弹窗 + 幂等键）。
+- 幂等响应语义修正：写操作 procedure 现在把「命中既有幂等收据」如实回传为 `replayed: true`（此前所有写操作都固定返回 false），覆盖创建游戏/版本、确认包、上传失败、送审、审核、撤回、下架与暂停。
+- 网页端恢复与撤回：`/games/publish` 在创建版本后写入带 owner 的发布草稿，窗口关闭或上传中断后同一账号可见「继续上传／继续送审」并复用原 `versionId`，换账号只忽略不读取；`/games/mine` 对可撤回状态提供二次确认的「撤回审核」，成功后刷新状态。
+- AGC 发布真实链路回归测试：新增 `apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts`（默认跳过，设置 `GENARRATIVE_AGC_PUBLISH_E2E_BASE_URL` 指向运行中的 api-server 才执行）。它不 mock 请求层，而是走真实的 `clientApi`/`clientHttp` 调用 `publishLocalProjectGame`，覆盖本地导出包读取、创建游戏、同 `localProjectId` 复用游戏身份、真实 ZIP 上传、送审、版本回读与 `my-games` 聚合，把「AGC 一键发布」从请求组装单测提升到真实后端链路证据。
+- AGC 客户端回归修复：导出试玩包后自动打开的发布面板是焦点陷阱模态，会让既有 `appSurface` 导出快捷操作用例静默失效；用例改为先断言面板出现、关闭后再继续，`appSurface.test.ts` 552 项（535 passed / 17 skipped）恢复全绿，并顺手补上该面板此前缺失的行为断言。同一轮修掉 `gameDistributionPublish.test.ts` 的模块 mock 缺少 `getClientServerBaseUrl` 导出的既有失败。
+- 发行来源（每游戏独立 origin）部署工件：新增 `deploy/nginx/genarrative-release-origin.conf` 与 `scripts/check-release-origin-config.mjs`（`npm run check:release-origin-config`）。模板按命名捕获 `game_id` 把 `https://<gameId>.games.<域>/` 映射到该游戏的 `index.html`、其余路径映射到发行网关前缀，边缘拒绝并清空 Cookie，不代理平台 API/后台/SPA；门禁逐条校验模板约束、交叉检查发行网关仍在设置 `nosniff`/CORP/CORS/CSP 与 Cookie 403，并在本机渲染临时配置跑 `nginx -t`。
+- AGC 发布面板组件测试：新增 `apps/ai-game-creator-shell/tests/gameDistributionPublishPanel.test.tsx`，覆盖打开时预填资料、发行包摘要、提交入参（项目路径/发行包/资料/幂等键）、连续点击只提交一次、服务端失败保留面板与无 Tauri 宿主/缺包时失败关闭。
+- 视觉与交互巡检修复：真实栈 + headless Chromium 逐页巡检 `/games`、`/games/detail`、`/games/play`、`/games/mine`、`/games/publish`（桌面 1440×900 与移动 390×844）。修掉两处：① 详情页「游玩方式」只读公开投影里恒为空的 `version.controls`，作者声明的 `inputModes` 被忽略，现在优先展示「键盘 · 鼠标 · 触屏」再退回自由文本；② 桌面端 hero 过高导致首屏看不到任何游戏卡片，改为仅桌面压缩 hero 高度，首排卡片进入 900px 视口。
+- 容量与限额边界（阶段 D 证据）：新增真实栈脚本覆盖 5 类包——① 99.0 MiB（两个 50/49 MiB 文件 + `index.html`，均在单文件/展开量/压缩比限制内）上传 200、耗时 11.8s、api-server RSS 81.6→378.0 MB（峰值 +296 MB）后回落 83.2 MB，随后送审 202 进入 `pending_review`；② 声明的 `packageBytes` 为 101 MiB 时在创建版本即被拒 413 `PAYLOAD_TOO_LARGE`（"发行包大小超出限制"，不落版本）；③ 声明合法但请求体 101 MiB 时被请求体限制拒绝 413（0.03s、内存零增长、版本保持 `awaiting_upload`/`upload`，可原版本重传）；④ 60 MiB 全零文件压到 61 KB（压缩比约 1000）拒绝 422 `PACKAGE_VALIDATION_FAILED`（0.01s，`upload_failed`/`reupload`）；⑤ 单文件 65 MiB 与 10,001 个文件同样 422（0.05s / 0.02s）。失败包都不出现在公开目录。
+- 发行包 PUT 受控重试：`platform-oss` 新增 `put_internal_object_with_retry`（复用既有 `oss_error_is_retryable` 分类：传输/超时/connect、408、429、5xx 与 400+RequestTimeout 可重试，确定性 4xx 不重试；body 只转一次 `Bytes` 供各 attempt 复用），发行包上传接入 3 次尝试 + 250/500ms 退避。触发原因：本机实测 99 MiB 单次 PUT 三次里出现过一次 `UPSTREAM_ERROR`（`请求 OSS 失败：error sending request`），客户端需要白传整包。
+- 网页端「为既有游戏发布新版本」：发布页新增 `updateGameId` 更新模式（按作者中心的最近版本回读冻结资料与公开修订号预填，提交时跳过创建游戏、直接在既有 `gameId` 下创建不可变新版本），作者中心新增「发布新版本」入口，壳层支持 `/games/publish?game=<gameId>`。浏览器真实链路：从 `/games/mine` 点「发布新版本」→ `/games/publish?game=…` 预填并显示「为《…》发布新版本 v2」→ 选包提交 → 该 `gameId` 下出现 `versions [(2, pending_review), (1, published)]`，公开入口仍指向并返回 v1 内容。此前网页端只能新建游戏，更新无法沿用 `gameId`，与里程碑「更新沿用相同 gameId」不符。
+- 全生命周期回归（真实栈，11 步）：待审公开不可见（目录不返回 + 详情 404）→ 管理员通过 v1 后目录/详情/网关可玩 V1 → v2 待审期间网关仍是 V1 → v2 被拒后仍是 V1 → 重复批准 `rejected` 版本返回 409（`rejected` 是终态，必须新建版本，与主规范一致）→ 新建 v3 通过后公开入口切换为 V3 → 作者回读被拒版本为 `rejected`/`fix_metadata` → 作者下架后目录/详情/网关全部关闭。同一轮修掉 5 条既有的壳层导航用例失败（游戏分发新增「游戏」页签与移动底栏后，测试仍断言旧导航集合）。
+- 边界、越权与隔离运行时证据（真实栈）：① 跨作者越权——作者 B 对作者 A 的版本上传 403、送审 403、撤回 404、回读 404，且 A 的版本状态未被改变；② 过期 CAS——管理员用错误 `publicationRevision` 批准返回 409，正确修订号才通过；③ 包边界——符号链接条目、`.env` 凭据文件、嵌套 ZIP 分别返回 422 `PACKAGE_VALIDATION_FAILED`，版本落到 `upload_failed`/`reupload`；④ 私有对象直取——按对象键直接 GET 私有 OSS 地址返回 **403**，发行文件只能经网关读取。
+- 浏览器沙箱隔离实测：发布一个自检探测包（内联脚本主动探测并 `postMessage` 回传结果），在 `/games/play` 里点「开始游戏」后收到 `{ origin: "http://127.0.0.1:10001", cookie: "throw:SecurityError", storage: "throw:SecurityError", parentDom: "throw:SecurityError", externalFetch: "throw:TypeError" }`——主站 Cookie、localStorage、父页面 DOM 全部不可访问，外站 fetch 被 CSP `connect-src 'self'` 阻断。键盘可达抽查：桌面端 Tab 顺序覆盖导航 → 搜索 → 下载客户端 → 账户，游戏分发自己的控件（发布游戏/我的游戏/分类页签/游戏卡片）聚焦时都有可见的浏览器默认焦点环。同一探测包还验证了音频链路：沙箱内 `fetch('assets/beep.wav')` 返回 `status:200 type:audio/wav`，WebAudio `decodeAudioData` 成功解出 `0.40s / 48000Hz`（`AudioContext.state = suspended`，与浏览器“首次播放需帧内用户手势”的策略一致，玩家进入游戏后的第一次交互即提供该手势）。尚未在无头环境验证的是游戏内的真实触屏输入（移动视口渲染与触控声明已验证）。
+- 上传中断与进程重启恢复（真实栈，两次独立实验）：60 MiB 包 PUT 进行到 ~2.5s 时 `SIGKILL` api-server，客户端拿到 `RemoteDisconnected`（等价于响应丢失）；重启后该版本仍是 `awaiting_upload`/`upload`，没有半确认状态。① 用不同字节重传返回 422 `PACKAGE_VALIDATION_FAILED`（`InvalidArchive`）并转 `upload_failed`/`reupload`；② 用固定时间戳构造的确定性 60 MiB 包重传**相同字节**返回 200（7.64s），版本转 `uploaded`/`submit`，随后送审 202 进入 `pending_review`。两次实验中游戏都未出现在公开目录。
+- 发布开关（回滚/事故能力）：新增 `game-distribution:publish` 灰度 gate（复用现役灰度配置机制与后台入口）。默认开放；`enabled=true` 时按白名单/用户标签/灰度百分比放行，`rolloutPercent=0` 且无白名单即全部关闭。关闭时作者写入与管理员批准返回 `503 GAME_DISTRIBUTION_PUBLISH_DISABLED`，而目录、详情、版本回读、发行网关、`/my-games`、审核队列读取、拒绝审核与安全下架继续可用；开关读取失败按关闭处理。路由级测试覆盖「默认放行 / 全关拦截 / 读取不受影响 / 白名单放行」，真实栈验证同口径：关闭后作者写入 503、目录/详情/网关/my-games 全 200、管理员批准 503 而拒绝 200、白名单用户可发布、重新开放后恢复。
+- 工程门禁：`npm run check:spacetime-schema`（147 tables）、`npm run check:server-rs-ddd`、`cargo fmt --all -- --check`、`npm run check:encoding`、`npm run check:doc-index`、`git diff --check`。
+
+## 运行时证据（2026-09-20，真实本地栈）
+
+`npm run dev` 在无冲突端口段启动（spacetime `127.0.0.1:10004`、api-server `127.0.0.1:10001`、真实 OSS bucket `xushi-dev`），用 HTTP 全链路脚本验证：
+
+- 管理员登录 + 用户口令注册/登录均走真实路由。
+- 创建游戏后，用相同 `localProjectId` 再次创建返回**同一个 `gameId`**（去重在真实数据库上生效）。
+- 真实 ZIP（根 `index.html` + `assets/app.js`）上传私有 OSS，服务端重算 SHA-256 / 字节数 / 文件数并确认 `uploaded`。
+- 送审返回 `202` 与 `pending_review`；此时公开目录、公开详情都不返回该游戏。
+- 管理员用 HTTPS `entryUrl` 审核通过后，目录与详情出现该游戏并带当前版本 `entryUrl`。
+- 发行网关返回 `text/html` 与 `text/javascript`；带 `Cookie` 的发行请求 403，未知扩展名 404。
+- 作者下架后公开详情回到 404。
+- 更新链路：v2 送审期间与 v2 被拒后，公开入口始终停留在 v1 且 v1 内容仍可读取；v3 通过审核后才替换公开版本。
+- 真实浏览器（headless Chromium）加载发行网关的 `index.html`：文档渲染、同源 `assets/app.js` 在现役 CSP 下执行成功（`booted=1`、`window.__gd=1`），控制台只剩 favicon 404。
+- 浏览器打开 `http://127.0.0.1:10000/games` 能看到已发布游戏卡片，`/games/detail?id=<id>` 渲染标题与「立即玩」。
+- 平台页面内嵌游玩：浏览器打开 `/games/play?id=<id>`，点「开始游戏」后 iframe 以 `sandbox="allow-scripts"` 挂载发行网关地址，`game-player-frame--ready` 置位，控制台无 CSP/CORP 拦截，api-server 访问日志显示该版本 `assets/app.js` 返回 200。
+- 非生产环境允许 http 回环 `entryUrl`（与前端 `normalizeGameEntryUrl` 同口径），生产仍只接受 HTTPS；这样本地无需 TLS 即可验证内嵌游玩。
+- 作者中心 `/games/mine`：SpacetimeDB 新增 `list_owner_game_distribution_games_and_return`（owner 只从认证主体派生，每游戏最多回 10 个最近版本），`api-server` 暴露 `GET /api/game-distribution/my-games`；浏览器里用真实作者 token 打开该页，能看到「已公开」状态与「下架」按钮，点击后状态变为「未公开」、按钮消失，公开目录同步不再返回该游戏。
+- 网页端发布入口 `/games/publish`：浏览器里用真实文件选择框上传 ZIP（根 `index.html` + `assets/app.js`），api-server 访问日志记录 `POST /api/game-distribution/games` 200 → `POST /api/game-distribution/games/{gameId}/versions` 200 → `PUT /api/game-distribution/versions/{versionId}/package` 200 → `POST /api/game-distribution/versions/{versionId}/submit` 202；随后同一账号在 `/games/mine` 看到该游戏为「未公开 / 版本 v1 · 审核中」，公开目录不返回它。
+
+- 版本回读/撤回真实链路（`npm run dev`，api-server `127.0.0.1:10001`、SpacetimeDB `127.0.0.1:10004`）：作者送审后 `GET /versions/{id}` 返回 `pending_review` + `recoveryAction=wait`；其他账号与未知版本都是 404；过期修订号撤回 409；正常撤回 200 且状态变 `cancelled`、`recoveryAction=none`；同 key 同请求重放返回 `replayed=true`，同 key 不同摘要 409；撤回后公开目录不返回该游戏。
+- 主链路回归（同一真实栈）：正式发布 `replayed=false`、重复送审 `replayed=true`；待审期间目录不可见；管理员读版本 200、审核通过后状态 `published` 且目录与详情返回 `currentVersion.entryUrl`；发行网关 `index.html` 200、带 Cookie 403、未知扩展名 404。
+- AGC 发布真实链路（同一真实栈）：`GENARRATIVE_AGC_PUBLISH_E2E_BASE_URL=http://127.0.0.1:10001 npx vitest run apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts` 通过——AGC 发布函数依次完成创建游戏、创建版本、上传 ZIP、送审，返回 `pending_review`；版本回读为 `pending_review`/`wait`；不带旧幂等键的第二次发布复用同一 `gameId` 并生成 v2；`/my/games` 的 `latestVersion` 指向 v2。
+- 非法包真实链路（同一真实栈）：缺根 `index.html` 且含 `../` 条目的 ZIP 上传返回 422（包校验错误），版本进入 `upload_failed` 且 `recoveryAction=reupload`，此时送审被拒（409）、公开目录不返回该游戏，作者仍可撤回该版本重新出包。
+- 发行来源真实边缘验证（同一真实栈 + 本机 nginx 1.28.3，模板渲染到 `~/data/tmp` 后监听高位端口）：`Host: <gameId>.games.example.com` 时根路径 200 `text/html`（游戏 `index.html`）、`/assets/app.js` 200 `text/javascript`；带 `Cookie` 403；`/api/auth/me` 404（平台命名空间未暴露）；未知 gameId 404；http 301 到 https；响应头经边缘透传后仍是 `nosniff` + CORP `cross-origin` + 无凭据 CORS + HTML CSP + `Cache-Control: public, max-age=60, must-revalidate`。
+- 移动视口真实游玩：headless Chromium 以 `390x844` 打开已发布游戏 `/games/play?id=<id>`，页面显示「横屏设计，旋转设备」提示与移动端底部导航，点击「开始游戏」后 iframe 以 `sandbox="allow-scripts"` + `allow="fullscreen"` 挂载发行网关地址并 `ready`，`index.html` 与 `assets/app.js` 均返回 200，控制台无 CSP/CORP 报错；截图存于本轮验证记录（不入库）。
+本轮同时修掉三个真实缺陷：Vite dev 代理缺少 `/api/game-distribution` 前缀（本地全部 404）；详情页在「已发布但没有 controls」时误显示「暂未发布可玩版本」；发行网关的 `Cross-Origin-Resource-Policy: same-origin` 会让 opaque origin 沙箱内的游戏加载不了自己的脚本（改为 `cross-origin` + 无凭据 CORS，详见 `pitfalls.md`）。
+
+## 尚未完成
+
+- 真实独立发行域名、通配 TLS 与 CDN 仍属部署侧：边缘模板与门禁已就绪，本地已用真实 nginx 验证按主机映射、Cookie 403 与命名空间隔离，但仍需在真实域名/证书下跑一次“审核通过 → 游玩 → 换版 → 下架”并确认 CDN TTL 不超过 60 秒窗口。
+- 版本回读、撤回与管理员安全下架已实现；主规范 HTTP 表中不再有待落地路由。容量与限额边界、发行包 PUT 重试已有真实栈证据；仍未做的是 CDN purge 失败行为、回滚演练与清理策略（不删除仍被公开版本引用的对象）的上线验收。
+- 生产调用依赖已初始化的 editor generation runtime service identity；未初始化时 procedure 拒绝写入，不会退回 API 进程内存状态。
diff --git a/docs/project-memory/plans/【里程碑】游戏分发目录详情与在线游玩-2026-09-18.md b/docs/project-memory/plans/【里程碑】游戏分发目录详情与在线游玩-2026-09-18.md
new file mode 100644
index 000000000..4024b8e92
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】游戏分发目录详情与在线游玩-2026-09-18.md
@@ -0,0 +1,135 @@
+# 【里程碑】游戏分发、发布与在线游玩
+
+| 字段 | 值 |
+| --- | --- |
+| Version | 0.2 |
+| Status | accepted（用户“继续”确认按既定假设进入阶段 A；A 未验收） |
+| Date | 2026-09-18 |
+| Parent Spec | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md` |
+
+## 交付与评审边界
+
+本文件拆分主规范“AGC 游戏分发与在线游玩合同”的完整业务：真实上传、持久化发行、审核、隔离托管、AGC 发布、网页上传与游玩、上线运维。当前只授权阶段 A 实现，阶段 B/C/D 仍为 `proposed`，没有已上线/已验收结论。
+
+先完成主规范与本文件评审，再为一个获准阶段创建单独实施计划；未经该阶段验收，不进入依赖它的阶段。里程碑只规定行为与证据，不预先写代码步骤。
+
+| 阶段 | 行为切片 | 依赖 | 状态 |
+| --- | --- | --- | --- |
+| A | 真实包、游戏身份与可恢复发行 | 主规范评审及持久化合同冻结 | accepted（实现中） |
+| B | 人工审核、公开投影与隔离托管 | A 验收；发行站点/私有存储/审核策略确认 | proposed |
+| C | AGC 与网页发布、现代游戏目录和跨端游玩 | B 验收；导航与交互稿评审 | proposed |
+| D | 端到端验收、容量与撤销、上线准备 | C 验收；实际部署资源可用 | proposed |
+
+## 实现进度（2026-09-20，未验收）
+
+以下是已落地的实现与本地运行时证据，**不等于阶段验收**：B/C 的隔离托管、域名与生产验收仍缺少真实发行域名、TLS/CDN 与生产账号。
+
+- 阶段 A：真实 ZIP 上传、游戏身份、owner/幂等/CAS、状态机、DTO 与 schema 门禁已完成；真实 SpacetimeDB + 私有 OSS 的创建/上传/确认/重启恢复已有证据。
+- 阶段 B：人工审核（后台列表、通过需 HTTPS 入口、拒绝需理由）、公开投影、发行网关（按公开版本服务、扩展名白名单、`nosniff`/CORP/CSP、带 Cookie 403）与作者下架已实现；每游戏独立来源已有可执行工件 `deploy/nginx/genarrative-release-origin.conf` 与门禁 `npm run check:release-origin-config`，并已在本机用真实 nginx + 真实网关验证按主机映射、Cookie 403 与平台命名空间 404；生产域名、通配证书与 CDN TTL 仍需上线环境确认。
+- 阶段 C：AGC 客户端「发布到平台」面板与发布链路（dist 归一化根 `index.html`、摘要/字节数声明、幂等键、`localProjectId` 复用）已实现并有请求组装与 Rust 导出测试；网页 `/games/publish` 走同一服务端管道，本地已用真实文件选择验证；AGC GUI 自身的端到端发布仍待客户端环境验收。目录（关键词/分类/设备筛选、滚动与筛选恢复）、详情、游玩页（主动作后加载、超时重试、旋转提示、全屏、移动端门槛）与作者中心（状态、驳回理由、撤回、下架）已实现；本地已在桌面与 `390x844` 移动视口真实游玩。
+- 阶段 D：容量/额度、重启恢复、CDN 撤销与回滚演练尚未开始，依赖生产资源。
+
+细节与命令级证据见[实施计划【游戏分发阶段A领域合同】](【实施计划】游戏分发阶段A领域合同-2026-09-19.md)的「已完成证据」「运行时证据」「尚未完成」。
+
+## 共通范围与不做项
+
+- 正式状态来自后端，素材仍复用平台上传与归属能力；前端和 AGC 不另建公开游戏状态、owner 事实或审核结果。
+- 真实发行包具有不可变版本和 SHA-256，AGC dist 归一化为发行根 `index.html`；网页 ZIP 与 AGC 共用一条服务管道。
+- 不恢复退役玩法 API、公开作品表或专属 runtime；不把私有项目源码镜像公开。
+- 首版不包含原生/Wasm 游戏、任意外网依赖、服务端进程、多人联机、云存档、评论/评分/关注、排行榜、推荐算法和收益结算。
+- 本文件只协调本业务；不顺带改造图片编辑器、Agent Runtime 执行模型或无关项目数据。
+
+## 阶段 A：真实包、身份与可恢复发行
+
+### 前置条件
+
+- 主规范的包类型、限额、身份/幂等/CAS、状态机和内部 API 已评审。
+- 游戏、版本、审核与操作账本的完整字段、索引、唯一约束、受信服务身份及清理策略已经冻结；若涉及已有表破坏性变更，另有已确认迁移计划。
+
+### 行为与验收
+
+- [ ] 登录用户创建服务端分配的游戏，owner 不能由请求伪造；其他账号不能读取私有版本、上传、提交或撤销。
+- [ ] 服务端接收真实 ZIP 字节，重算摘要/字节数并建立展开清单；只有 metadata 的请求不能获得已上传或已发布状态。
+- [ ] 缺入口、越界/重复/大小写冲突路径、符号链接、压缩炸弹、敏感内容和额度超限均失败关闭，原私有对象和公开状态保持一致。
+- [ ] 一份版本只接受一份已确认内容；同 key 同请求重放无重复游戏/版本，不同请求冲突；同版本并发上传不混写。
+- [ ] 校验可异步恢复，响应丢失、服务进程退出和客户端重试均回到原版本；确定失败和未知结果在响应中可区分。
+- [ ] 正常及失败状态、私有查询和错误 envelope 在 Rust 与 TypeScript DTO 中一致；新增 schema、迁移、表目录与绑定一致。
+
+### 证据要求
+
+- 自动化：领域状态机、owner、幂等/CAS、包读取与错误路径、DTO 和 schema 定向测试。
+- 运行时：真实 SpacetimeDB 与私有对象存储完成上传/回读/重启恢复；`/healthz` 正常。
+- 边界：服务端记录的 ZIP 摘要与测试上传字节一致；未审核目录不能匿名读取；无凭据或本地路径泄漏。
+
+## 阶段 B：审核、公开投影与隔离托管
+
+### 前置条件
+
+- A 已验收；人工审核角色、资料检查标准与拒绝/封禁行为已确认。
+- 已确定不同可注册站点的发行域名、每游戏独立 origin、私有存储和网关能力；同源临时路径不能作为验收替代。
+
+### 行为与验收
+
+- [ ] 自动校验通过只进入待审，管理员可查看真实待审游戏并批准/拒绝；审核记录可追溯且普通作者不能提交审核动作。
+- [ ] 新游戏审核通过并核验发行文件可读后才公开；更新待审或失败不改变旧版资料、URL 与可玩性。
+- [ ] 审核激活与下架使用 `publicationRevision` CAS；过期审核、重复批准、并发更新和下架不会恢复本应关闭的游戏。
+- [ ] 游客目录、详情和启动接口只返回已公开投影；未公开和已下架状态均不可见，不返回私有快照地址。
+- [ ] 每游戏在独立 HTTPS origin 上，iframe sandbox、网关 CSP/CORS/MIME/禁止 Worker 等策略与主规范一致。
+- [ ] 实际 npm/Vite 模块和同包资源在 opaque sandbox 下可载入；外站 fetch/WebSocket、平台 Cookie/storage/DOM、顶层跳转、弹窗和敏感权限被阻断。
+- [ ] 作者下架及管理员安全下架会关闭新启动和发行读取；不能绕过网关直取公开 OSS 对象；撤销传播符合最大缓存窗口。
+
+### 证据要求
+
+- 自动化：审核权限、版本切换事务、公开投影与入口 allowlist、响应头和缓存策略测试。
+- 运行时：真实独立域名内运行至少一个代表性游戏；真实审核、更新失败、并发下架和旧 URL 回读证据。
+- 边界：外部请求阻断、匿名私有对象拒绝、跨游戏 origin 隔离及 60 秒以内缓存撤销（以获批值为准）。
+
+## 阶段 C：双端发布与现代游戏体验
+
+### 前置条件
+
+- B 已验收；网页根入口、桌面/移动导航、暖色主题交互稿及首版设备范围已评审。
+- AGC 现有 npm 构建/导出能提供完整 dist，不需要把源码同步管道改作发行管道。
+
+### 行为与验收
+
+- [ ] AGC 从已构建 dist 生成根入口为 `index.html` 的真实包，一次提交动作完成检查、资料确认、上传和送审；状态及失败原因与服务端回读一致。
+- [ ] 网页可选 ZIP、提交封面和必需资料，进入相同上传/校验/审核流程；任一客户端可以查看同账号游戏状态，更新沿用相同 `gameId`。
+- [ ] 上传中断、双击、登录失效、窗口关闭后恢复原操作；换账号不能恢复前账号私有状态；待审不能显示为已发布。
+- [ ] 目录支持真实数据、关键词/分类/设备筛选、空/错/加载态；详情提供明确主动作，搜索与返回恢复上下文。
+- [ ] 游客从目录/分享链接进入详情再启动真实已发布游戏；开始操作后才加载 iframe，加载失败可重试，退出不会自动重启游戏。
+- [ ] 桌面与移动导航、详情、上传/发布面板、旋转提示、全屏、安全区和焦点可达符合主规范；不适配移动端的游戏有明确门槛。
+- [ ] 视觉沿用现有 warm token，通用交互复用共享组件；没有固定假统计、本地演示兜底或同源 iframe 放宽。
+
+### 证据要求
+
+- 自动化：AGC 打包与操作恢复定向 Rust 测试、两端客户端/组件/路由/状态测试及类型检查。
+- 运行时：AGC 一次真实发布、网页一次真实 ZIP 上传，分别审核后从桌面和手机游玩；浏览器覆盖游戏模块、素材、音频、触屏及横竖屏。
+- 边界：未构建/失效 dist、资料缺失、换账号、迟到响应、审核拒绝、非移动游戏及真实空态。
+
+## 阶段 D：端到端、运维与上线准备
+
+### 前置条件
+
+- C 已验收；生产域名/TLS、CDN、私有存储、审核账号及保留/清理周期可用且已确认。
+
+### 行为与验收
+
+- [ ] 真实环境中完整跑通“首次上传 → 校验 → 审核 → 公开 → 游客游玩 → 更新待审旧版在线 → 新版切换 → 下架撤销”。
+- [ ] 100 MiB 包与获批文件数/展开量边界有可复核耗时、内存和失败证据；校验不会执行上传代码，服务资源有界。
+- [ ] 校验执行器重启可恢复，审核积压与失败可观测，清理不删除仍被公开版本引用的文件。
+- [ ] CDN purge 失败时仍在获批缓存 TTL 内拒绝新资源；明确已下载脚本无法远程抹除的边界。
+- [ ] 发布/回滚步骤保留当前公开版本，能关闭新提交和新版本激活；部署路由、缓存、响应头、日志脱敏和告警完成检查。
+- [ ] 主规范逐条证据矩阵齐全，未验证项明确列出；有任何核心路径未验证时不标记上线完成。
+
+### 证据要求
+
+- 自动化：范围匹配前后端、schema/契约、编码与文档索引门禁，部署配置检查。
+- 运行时：真实发行域名、真实存储、真实账号和两类客户端的完整链路证据，桌面及移动视口记录。
+- 边界：压力/额度、重启恢复、缓存撤销、误删防护和回滚演练。
+
+## 当前待审项与下一门禁
+
+主规范仍待确认人工审核策略、导航、首版能力/额度、对象保留、发行域名及运营责任；当前没有主规范与里程碑通过评审的记录，也没有任何阶段验收证据。先评审这些决策，再冻结 A 的持久化与 DTO 明细并创建仅覆盖 A 的实施计划。不得把该文档状态改为 accepted 以代替评审。
+
+所有阶段完成并验收后，稳定事实回写主规范，删除本临时里程碑与各阶段实施计划；过程记录不进入产品代码、用户文案或长期共享记忆。
diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index eb0a2da65..6289ce9ce 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -55,6 +55,35 @@ Godot 编辑器操控复用既有 AGC 插件宿主、EditorAdapter、Runner 和
 - 验证方式：`provider_transient_retry_` 7 项中重写后的档位用例与 upstream-400 用例通过（断言 `maxRetries` 直取设置值、400 与其它瞬态共用同一预算），`provider_retry_` 其余 26/28 通过；该组 2 项（`provider_transient_retry_transport_failure_closes_then_stable_retry_succeeds`、`provider_transient_retry_backoff_is_exponential_and_capped_at_thirty_seconds`）与 `provider_retry_waiting_final_reply_*` 2 项在本机改动前后同为失败（`stash` 基线复跑确认，现象是等待自动重试唤醒超时）。本机串行全量套件另有既有环境失败（`tempfile::tempdir()` 归属校验、缺少 npm 构建产物、Windows 启动失败 MessageBox 阻塞 `startup_log_slot_fail_without_path...`）；抽查其中 5 项在 `stash` 基线上同样失败，与本次改动无关。仓库 `cargo fmt --check`、`npm run check:encoding`、`git diff --check` 通过。
 - 关联文档：[AI游戏创作智能体App实施计划](../../technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md)、[踩坑记录](pitfalls.md)。
 
+## 2026-09-20 游戏分发用灰度开关承载「关闭投稿、保在线」的回滚口径
+
+- 背景：主规范要求回滚部署时“关闭新提交和新版本激活，保留当前可玩版本与状态读取”。此前只能靠改配置或停服实现。
+- 决策：复用现役灰度配置（`game-distribution:publish`，后台「灰度发布配置」可改），没有 gate 行或 `enabled=false` 时默认开放；`enabled=true` 时只有白名单/标签/灰度命中的作者能发布，`rolloutPercent=0` 且无白名单等于紧急关闭投稿。拦截范围是作者写入（创建游戏/版本、上传、送审、撤回、下架）与管理员批准；读取、发行网关、审核队列读取、拒绝审核与安全下架始终可用，避免把“关投稿”变成“停服务”或“无法处理事故”。
+- 失败姿态：开关读取失败按关闭处理（写入口 503），读取路径不受影响。
+- 关联：`server-rs/crates/module-runtime/src/application.rs`、`server-rs/crates/api-server/src/state.rs`、`server-rs/crates/api-server/src/modules/game_distribution.rs`、[开发运维文档](../../【开发运维】本地开发验证与生产运维-2026-05-15.md)。
+
+## 2026-09-20 游戏发行包 PUT 采用受控重试与容量边界口径
+
+- 背景：阶段 D 容量验证时实测 99.0 MiB 发行包单次 PUT 成功耗时 11.8s、api-server 峰值内存 378 MB（基线 82 MB），但三次尝试里出现过一次 `请求 OSS 失败：error sending request`。当时版本停在 `awaiting_upload`（可原版本重传），代价是作者白传一次整包。
+- 决策：`platform-oss` 新增 `put_internal_object_with_retry`，复用既有 `oss_error_is_retryable` 分类（传输/超时/connect、408、429、5xx、400+RequestTimeout 可重试；确定性 4xx 不重试），body 只转一次引用计数的 `Bytes`，各 attempt 复用同一份字节；发行包上传配置为 3 次尝试、250/500ms 退避，参数不合法（次数为 0 或缺退避）时按配置错误失败关闭。
+- 容量口径（真实栈实测，作为阶段 D 证据基线）：99.0 MiB 包 11.8s / 峰值 +296 MB；声明 101 MiB 在创建版本即 413；请求体 101 MiB 被请求体限制 413 且版本保持可重传；压缩比 1000 与单文件 65 MiB、10,001 文件都是 422 `PACKAGE_VALIDATION_FAILED` 并落到 `upload_failed`/`reupload`；失败包不进公开目录。
+- 关联：`server-rs/crates/platform-oss/src/lib.rs`、`server-rs/crates/api-server/src/modules/game_distribution.rs`、[实施计划](../plans/【实施计划】游戏分发阶段A领域合同-2026-09-19.md)。
+
+## 2026-09-20 游戏详情的“游玩方式”以版本声明的 inputModes 为准
+
+- 背景：公开投影里 `currentVersion.controls` 一直是空数组（首版没有自由文本操作说明的录入），详情页却只读它，于是所有已发布游戏都显示「未标注操作方式」，而作者其实在发布时声明过 `inputModes`。
+- 决策：展示层优先用公开投影里已有的结构化 `inputModes`（键盘 / 鼠标 / 触屏，去重后按声明顺序拼接），再退回 `controls` 自由文本，两者都为空才显示「未标注操作方式」。不改 HTTP 契约、不新增后端字段。
+- 关联：`src/components/game-distribution/GameDetailPage.tsx`、`src/components/game-distribution/GameDistributionPages.test.tsx`、[主规范](../../【玩法创作】平台入口与玩法链路-2026-05-15.md)。
+
+## 2026-09-20 游戏分发的版本回读、撤回与安全下架以服务端 recoveryAction 为准
+
+- 决策：游戏发行版本的「下一步做什么」不从客户端状态推断。`GET /api/game-distribution/versions/{versionId}`（作者）与 `/admin/api/game-distribution/versions/{versionId}`（管理员）返回版本私有投影 + 服务端派生的 `recoveryAction`（`upload` / `submit` / `wait` / `none` / `reupload` / `fix_package` / `fix_metadata`），网页发布页与作者中心只按它渲染主行动作。
+- 撤回语义：`POST /api/game-distribution/versions/{versionId}/cancel` 只能撤回未参与当前公开投影的版本，要求 `Idempotency-Key` 与 `expectedPublicationRevision` CAS；已公开版本必须走作者下架或管理员 `suspend`，不能借撤回关闭线上入口。
+- 可见性：未知版本与非 owner 的版本一律 404，不用 403 区分「别人的版本」和「不存在的版本」。
+- 幂等响应：命中既有幂等收据的写操作统一回传 `replayed: true`（此前所有写操作固定 false），客户端据此区分「本次生效」与「复用既有结果」。
+- 网页恢复：`/games/publish` 只把 `{ownerUserId, gameId, versionId, versionNumber, title}` 写入 localStorage 作为恢复标识；换账号只忽略草稿、不回读也不清除，禁止展示上一账号的私有状态。
+- 关联文档：[游戏分发实现计划](../plans/【实施计划】游戏分发阶段A领域合同-2026-09-19.md)、[主规范](../../【玩法创作】平台入口与玩法链路-2026-05-15.md)。
+
 ## 2026-09-18 AGC backend 采用共享 Runtime、本地宿主与云端控制面分层
 
 - 决策：AGC backend 统一按“`agent-runtime-core`/`agent-runtime-orchestration` 共享内核 + Tauri 本地执行宿主 + `server-rs` 云端控制面 + `module-*`/`platform-*` 领域与外部适配器”整理；先建立 application facade、能力合同和跨边界状态映射，不新建第二套 Agent Runtime、会话库或业务真相。
diff --git a/docs/project-memory/shared-memory/pitfalls.md b/docs/project-memory/shared-memory/pitfalls.md
index 8a2942429..38870dabb 100644
--- a/docs/project-memory/shared-memory/pitfalls.md
+++ b/docs/project-memory/shared-memory/pitfalls.md
@@ -5784,3 +5784,17 @@ Cocos Creator 根目录由 `package.json.creator.version` 与普通 `assets/` 
 - **处理（现行口径）**：发行网关的公开静态响应使用 `Cross-Origin-Resource-Policy: cross-origin` 与不带 credentials 的 `Access-Control-Allow-Origin: *`，继续保留 `X-Content-Type-Options: nosniff`、内容类型白名单、HTML 最小权限 CSP 和「带 Cookie 一律 403」。这些都是公开静态文件，放宽 CORP/CORS 不暴露凭据；容器隔离靠沙箱、CSP 与独立来源，不靠 CORP。
 - **验证方式**：不要只用 `onLoad` 判断可玩。要在真实浏览器里点「开始游戏」，确认控制台没有 `ERR_BLOCKED_BY_RESPONSE`/CSP 报错，并核对 api-server 访问日志里该版本资源的 `http.response.status_code=200`。
 - **关联**：`server-rs/crates/api-server/src/modules/game_distribution.rs`（`release_asset_response`）、`src/components/game-distribution/GamePlayPage.tsx`、[`docs/【玩法创作】平台入口与玩法链路-2026-05-15.md`](../../【玩法创作】平台入口与玩法链路-2026-05-15.md)。
+
+## 2026-09-20 在 jsdom 里把 AGC 发布接到真实后端：Blob 没有 arrayBuffer，且跨 realm BodyInit 会被 undici 拒绝
+
+- **现象**：给 AGC 的 `publishLocalProjectGame` 写“默认跳过”的真实后端集成测试时，创建游戏、创建版本都成功，只有上传 ZIP 报“无法连接登录服务”（`networkError: true`），服务端访问日志里也没有这次上传。
+- **原因**：测试跑在 jsdom 环境，`fetch` 是 Node(undici)，但请求体是 jsdom 的 `Blob`：① 该 jsdom 版本的 `Blob` 没有 `arrayBuffer()`（`typeof blob.arrayBuffer === 'undefined'`），直接调用会抛异常；② 即便拿到字节，jsdom realm 的 `ArrayBuffer`/`Uint8Array` 也不是 undici 认得的 `BodyInit`。
+- **处理（现行口径）**：桥接层用 `FileReader.readAsArrayBuffer` 读 jsdom Blob（有 `arrayBuffer` 时才走它），再用 `Buffer.from(new Uint8Array(...))` 复制成 Node 侧 Buffer 交给 undici。参考 `apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts`。
+- **关联**：`apps/ai-game-creator-shell/tests/gameDistributionPublishLive.test.ts`、`apps/ai-game-creator-shell/src/services/clientHttp.ts`。
+
+## 2026-09-20 AGC 导出后自动弹发布面板：焦点陷阱会吞掉模态之外的点击，既有导出快捷操作用例变红
+
+- **现象**：给 AGC 加「导出试玩包后自动打开发布到游戏广场面板」后，`appSurface.test.ts` 的「预览快捷操作：导出确认、取消与包列表」变红——期望点消息上的「显示目录」把 `/open-project` 填进输入框，实际输入框仍是空。把发布面板的自动打开去掉，或用例先关掉面板，就恢复绿色。
+- **原因**：同目录的 `ThemedModal` 用 `createPortal` + `focus-trap-react` 渲染模态。焦点陷阱存在时，模态之外的 `click` 不会触达 React 的处理器（实测：临时把 `FocusTrap` 换成普通 `div`、其余不动，同一个被模态遮住的按钮点击立刻恢复生效），所以自动化里“点模态背后的按钮”不会报错，只是静默无效。
+- **处理（现行口径）**：① 产品行为保留“导出成功后自动打开面板”（一键发布入口），但受影响的用例必须先用 `findByRole('dialog', { name: '发布到游戏广场' })` 断言面板出现、点「关闭发布面板」再继续后续会话操作；② 给这类“新增自动弹窗”改流程时，先跑一遍相关 `appSurface` 用例，避免只跑新增用例；③ 排查同类“点了没反应”时，先看当前是否有焦点陷阱模态打开，而不是先怀疑事件绑定或状态。
+- **关联**：`apps/ai-game-creator-shell/src/App.tsx`（`setPublishPanelOpen(true)`）、`apps/ai-game-creator-shell/src/components/modal/ThemedModal.tsx`、`apps/ai-game-creator-shell/src/components/game-distribution/GameDistributionPublishPanel.tsx`、`apps/ai-game-creator-shell/tests/appSurface/project-preview/preview-shortcuts/assert-project-tools-and-preview.ts`。
diff --git a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
index ce9af7d98..1d6d0c7d5 100644
--- a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
+++ b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
@@ -672,6 +672,7 @@ Responses 的终态载荷既是工具调用的恢复源，也是正文的恢复
 - 源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`
 - 用途：不可变发行版本与真实包确认事实。创建后冻结 `package_sha256`、字节数、文件数、根入口和版本号；后续只推进上传、校验、审核、公开、撤回状态，并记录私有对象键、文件清单、入口 URL、审核者和阶段时间。
 - 索引：`by_game_distribution_version_game_id`、`by_game_distribution_version_owner_user_id`。真实 ZIP 由 `api-server` 校验并写入私有 OSS 后，才通过 facade 确认 `uploaded`；表不保存 ZIP 正文。
+- 撤回与回读：`cancel_game_distribution_version_and_return` 只允许把未参与当前公开投影的版本推进到 `cancelled`，并要求 `expected_publication_revision` 与游戏公开修订号一致；`get_game_distribution_version_and_return` 供管理员按版本 ID 直读。客户端看到的 `recoveryAction` 由 `api-server` 按 `status` 派生，不落表。
 
 ### `game_distribution_idempotency_receipt`
 
@@ -679,6 +680,7 @@ Responses 的终态载荷既是工具调用的恢复源，也是正文的恢复
 - 源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`
 - 用途：创建、上传、提交、审核、撤回和下架操作的幂等收据。`owner_user_id + action + idempotency_key` 组合唯一，保存请求摘要、结果 ID、有限结果 JSON、创建/过期时间和完成时间；同 key 不同摘要必须返回冲突，收据不保存凭据或包正文。
 - 索引：owner、game、version 和 `by_game_distribution_receipt_scope` 组合索引；默认保留窗口由服务端清理策略控制。
+- 重放语义：写操作命中既有收据时，procedure 回传 `replayed = true` 并复用收据里的结果 ID，不重复创建游戏、版本或审核结论；同 key 不同请求摘要必须返回冲突。
 
 ### `llm_router_account`
 
diff --git a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
index 34ce87c6d..208fa3c55 100644
--- a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
+++ b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
@@ -606,6 +606,37 @@ Nginx 负责站点和反向代理
 Jenkins 按 web / api / Spacetime module / build / deploy / publish 拆分
 ```
 
+### 游戏发行来源（发行域名、每游戏 origin 与缓存窗口）
+
+已公开游戏运行在**独立来源**上，与主站来源隔离；这是发行网关（`api-server`）之外唯一需要的边缘配置。
+
+- 配置工件：`deploy/nginx/genarrative-release-origin.conf`。上线前替换域名、通配证书路径与 upstream 端口，并把文件安装到 Nginx 站点目录。
+- 前置资源：`*.games.<域名>` 通配 DNS 指向同一入口，以及覆盖该通配名的 TLS 证书（certbot DNS-01 或等价流程）。
+- 路由约定：`https://<gameId>.games.<域名>/` 是该游戏的入口（子域根路径映射到该游戏的 `index.html`），其余路径按原样映射到 `/api/game-distribution/releases/<gameId>/…`；平台 API、后台、SPA 与上传接口在这个来源上一律 404，命中即证明边缘多代理了命名空间。
+- 会话隔离：发行来源从不使用 Cookie。带 `Cookie` 的请求在边缘直接 403，转发前也会 `proxy_set_header Cookie ""`；发行网关自身同样对带 Cookie 的请求返回 403。
+- 响应头与缓存：`X-Content-Type-Options`、CORP（`cross-origin`）、无凭据 CORS、HTML CSP、内容类型白名单与 `Cache-Control: public, max-age=60, must-revalidate` 都由发行网关设置，边缘不覆盖。换版与下架只改变后端公开投影，因此**最迟 60 秒**内新请求不再拿到旧版本；已经下载到浏览器的脚本无法远程抹除，撤销能力以“停止继续分发”为准。
+- 审核动作：管理员审核通过时填写的 `entryUrl` 必须是该游戏的子域根地址 `https://<gameId>.games.<域名>/`（HTTPS、无凭据、无 query/fragment）；非生产环境仍按现有口径允许 http 回环地址用于本地联调。
+- 门禁与本地联调：
+
+```bash
+# 模板约束 + 发行网关响应头策略交叉检查；本机有 nginx/openssl 时还会渲染一份临时配置跑 nginx -t
+npm run check:release-origin-config
+```
+
+本地想在真实边缘语义下复验时，可以把模板渲染到 `~/data/tmp`（替换 upstream 为本地 api-server 端口、证书换成自签通配证书、监听端口换成高位端口），用 `nginx -c <渲染文件>` 起一个临时实例，再用 `curl -H 'Host: <gameId>.games.example.com'` 验证：根路径 200 `text/html`、`/assets/*` 200、带 Cookie 403、平台 API 路径 404、未知 gameId 404、http 301 到 https。
+
+#### 发布开关（关闭投稿、保在线）
+
+发布事故或回滚窗口里用 `game-distribution:publish` 灰度开关控制写入，不需要改代码或重启：
+
+- 开关位置：后台「灰度发布配置」（`GET/PUT /admin/api/feature-gates`），`gateKey = game-distribution:publish`。
+- 语义：没有该 gate 行或 `enabled=false` 表示**默认开放**；`enabled=true` 时只有 `allowUserIds` / `allowUserTags` / `rolloutPercent` 命中的作者能发布，`rolloutPercent=0` 且无白名单即**全部关闭**（等价紧急关闭投稿）。
+- 关闭范围：创建游戏、创建版本、上传包、送审、撤回、作者下架，以及管理员**批准**（新版本激活）都返回 `503 GAME_DISTRIBUTION_PUBLISH_DISABLED`。
+- 始终可用：目录、详情、版本回读、发行网关（已公开游戏继续游玩）、`/my-games`、审核队列读取、**拒绝审核**与管理员**安全下架**。
+- 失败姿态：开关状态读取失败时按关闭处理，避免绕过运营刚下的收紧动作；本地排障时确认 SpacetimeDB 正常后再判断业务是否被误伤。
+
+上线前仍需确认的外部状态：通配 DNS 与证书已生效、upstream 端口与 `genarrative-api.service` 一致、若前面还有 CDN 需把 TTL 收敛到不超过上述 60 秒窗口，并跑一次真实域名下的“审核通过 → 游玩 → 换版 → 下架”链路。
+
 ### 生产健康巡检
 
 `Genarrative-Server-Provision` 会安装并启用 `genarrative-health-patrol.timer`，默认每 5 分钟运行一次 `genarrative-health-patrol.service`。巡检脚本随 API release 归档到 `/opt/genarrative/current/scripts/ops/production-health-patrol.mjs`，只读检查：
diff --git a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
index d39290968..58d11d20a 100644
--- a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
+++ b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
@@ -113,7 +113,7 @@
 
 ### HTTP 与持久化边界（拟定）
 
-现役内部命名空间使用 `/api/game-distribution`；除标注为完整后台路径的行外，下表路径都带该前缀。标注「已实现」的路由已在 `api-server` 挂载并有定向测试，标注「待评审」的仍未落地。公开目录只消费后端投影；所有变更经过现有鉴权、限流和埋点中间件。账号内部 API 不扩展 `/api/external/v1`，后续若对外开放再同步 External OpenAPI。
+现役内部命名空间使用 `/api/game-distribution`；除标注为完整后台路径的行外，下表路径都带该前缀。标注「已实现」的路由已在 `api-server` 挂载并有定向测试；本表当前没有待落地路由。公开目录只消费后端投影；所有变更经过现有鉴权、限流和埋点中间件。账号内部 API 不扩展 `/api/external/v1`，后续若对外开放再同步 External OpenAPI。
 
 | 方法与路径 | 身份 | 行为 |
 | --- | --- | --- |
@@ -124,13 +124,13 @@
 | `POST /games` | 登录作者 | **已实现**：幂等创建游戏身份，尚不公开；带 `localProjectId` 时同一作者复用既有 `gameId` |
 | `POST /games/{gameId}/versions` | owner | **已实现**：创建不可变待上传版本，冻结包摘要/字节数/文件数与资料 |
 | `PUT /versions/{versionId}/package` | owner | **已实现**：接收真实 ZIP、重算摘要与文件清单并写入私有对象；不执行游戏代码 |
-| `GET /versions/{versionId}` | owner/管理员 | 回读状态、错误代码、恢复动作及审核结论，普通游客不可读 |
+| `GET /versions/{versionId}` | owner/管理员 | **已实现**：回读状态、错误代码、审核结论与服务端 `recoveryAction`；管理员走 `/admin/api/game-distribution/versions/{versionId}`；未知版本与别人的版本都按不可见返回 404 |
 | `POST /versions/{versionId}/submit` | owner | **已实现**：只有已确认完整包可提交，返回 202 并进入 `pending_review` |
-| `POST /versions/{versionId}/cancel` | owner | 撤回尚未公开版本，保留幂等结果 |
+| `POST /versions/{versionId}/cancel` | owner | **已实现**：带 `expectedPublicationRevision` CAS 与 `Idempotency-Key`，只能撤回未参与公开投影的版本；同 key 同请求重放返回 `replayed: true`，摘要不同返回 409 |
 | `POST /games/{gameId}/unpublish` | owner | **已实现**：CAS 关闭公开游戏及其版本入口，不删除审核记录 |
 | `GET /admin/api/game-distribution/reviews` | 管理员 | **已实现**：分页获取待审版本；此行是完整后台路径 |
 | `POST /admin/api/game-distribution/versions/{versionId}/review` | 管理员 | **已实现**：批准需 HTTPS 发行入口并执行公开版本 CAS；拒绝需理由；此行是完整后台路径 |
-| `POST /admin/api/game-distribution/games/{gameId}/suspend` | 管理员 | 安全下架整个游戏并撤销发行访问；此行是完整后台路径 |
+| `POST /admin/api/game-distribution/games/{gameId}/suspend` | 管理员 | **已实现**：安全下架整个游戏并撤销发行访问，要求 `expectedPublicationRevision` CAS 与幂等键；后台游戏审核页提供带原因输入与二次确认的入口；此行是完整后台路径 |
 
 除显式 `/admin/api/...` 外，表内路径均相对 `/api/game-distribution`。错误采用现有平台 envelope，覆盖 400 格式错误、401 未登录、403 owner/审核权限错误、404 不可见、409 幂等/状态/并发冲突、413 大小上限、422 包或资料校验失败、429 限流和明确的可重试 5xx；服务端响应不包含存储凭据和本地绝对路径。
 
@@ -151,7 +151,7 @@
 - 建议 HTML、公开状态与启动 API 使用 `no-store`；发行静态资源的浏览器与 CDN 有效期均不超过 60 秒，禁止 `stale-while-revalidate`、`stale-if-error` 和发行 Service Worker。下架主动 purge 相关 CDN 键，60 秒作为最大缓存撤销窗口，不把 purge 成功当唯一保障。旧版本被更新替代后，新启动只用当前版；旧游戏已经载入的脚本/资源不承诺远程抹除，用户退出或刷新后按当前授权重新判断。
 - 发布所需部署依赖包括独立站点域名及通配 TLS、每游戏 host 路由、私有存储、网关 CSP/CORS/MIME、CDN TTL/purge、管理员审核运营入口和可恢复校验执行器；缺少任一项不能宣布公开上线。
 - 观察上传失败、校验耗时、审核积压、发行 4xx/5xx、撤销传播时间与容量，日志按游戏/版本/操作 ID 关联，不记录 Token、完整用户文件内容或 signed URL。原始失败/撤回包建议保留 7 天后清理，公开版本和审核记录的保留周期在上线前确定；清理必须先检查引用，不能删除仍在服务的版本。
-- 回滚部署时关闭新提交和新版本激活，保留当前可玩版本与状态读取；数据库迁移不以删表回滚。安全事件通过服务端关闭游戏发行权限，不依赖前端隐藏按钮。
+- 回滚部署时关闭新提交和新版本激活，保留当前可玩版本与状态读取；数据库迁移不以删表回滚。安全事件通过服务端关闭游戏发行权限，不依赖前端隐藏按钮。现役实现：`game-distribution:publish` 灰度开关（后台「灰度发布配置」）控制作者写入与新版本激活——没有 gate 行或 `enabled=false` 时默认开放；`enabled=true` 时只有白名单/灰度命中的用户能发布（`rolloutPercent=0` 且无白名单即全部关闭）。关闭期间目录、详情、版本回读、发行网关、审核队列读取、拒绝审核与安全下架都不受影响；开关读取失败按关闭处理。
 
 ### 验收标准与证据
 
diff --git a/package.json b/package.json
index 7436a415f..0873d9483 100644
--- a/package.json
+++ b/package.json
@@ -82,6 +82,7 @@
     "check:pingora-gateway-smoke": "node scripts/check-pingora-gateway-smoke.mjs",
     "check:nginx-pingora-canary": "node scripts/check-nginx-pingora-canary.mjs",
     "check:nginx-spa-routes": "node scripts/check-nginx-spa-routes.mjs",
+    "check:release-origin-config": "node scripts/check-release-origin-config.mjs",
     "check:pingora-route-parity": "node scripts/check-pingora-route-parity.mjs",
     "check:pingora-canary-live": "node scripts/check-pingora-canary-live.mjs",
     "check:pingora-canary-live-guard": "node scripts/check-pingora-canary-live-guard.mjs",
diff --git a/packages/shared/src/contracts/gameDistribution.ts b/packages/shared/src/contracts/gameDistribution.ts
new file mode 100644
index 000000000..80ea20340
--- /dev/null
+++ b/packages/shared/src/contracts/gameDistribution.ts
@@ -0,0 +1,149 @@
+export const GAME_DISTRIBUTION_CATEGORIES = [
+  '休闲',
+  '益智',
+  '动作',
+  '冒险',
+  '模拟',
+  '策略',
+  '其他',
+] as const;
+
+export type GameDistributionCategory =
+  (typeof GAME_DISTRIBUTION_CATEGORIES)[number];
+
+export type GameDistributionDeviceSupport = {
+  desktop: boolean;
+  mobile: boolean;
+  touch: boolean;
+};
+
+export type GameDistributionInputMode = 'keyboard' | 'mouse' | 'touch';
+export type GameDistributionOrientation =
+  | 'landscape'
+  | 'portrait'
+  | 'responsive';
+
+export type GameDistributionAuthor = {
+  id: string;
+  name: string;
+  avatarUrl?: string | null;
+};
+
+export type GameDistributionVersionStatus =
+  | 'awaiting_upload'
+  | 'uploaded'
+  | 'validating'
+  | 'pending_review'
+  | 'published'
+  | 'upload_failed'
+  | 'validation_failed'
+  | 'rejected'
+  | 'cancelled'
+  | 'revoked';
+
+export type GameDistributionGameVisibility =
+  | 'unpublished'
+  | 'published'
+  | 'suspended';
+
+export type GameDistributionVersionSummary = {
+  id: string;
+  version: string;
+  entryUrl: string;
+  sha256: string;
+  publishedAt: string;
+  controls: string[];
+};
+
+export type GameDistributionGame = {
+  id: string;
+  title: string;
+  summary: string;
+  description: string;
+  category: GameDistributionCategory;
+  tags: string[];
+  coverColor: string;
+  icon: string;
+  author: GameDistributionAuthor;
+  deviceSupport: GameDistributionDeviceSupport;
+  inputModes?: GameDistributionInputMode[];
+  orientation?: GameDistributionOrientation;
+  status: Extract<GameDistributionGameVisibility, 'published' | 'unpublished'>;
+  /** 公开切换 CAS 版本号；作者下架与管理员审核都必须回传当前值。 */
+  publicationRevision: number;
+  currentVersion: GameDistributionVersionSummary | null;
+  playCount: number;
+  createdAt: string;
+};
+
+export type GameDistributionListResponse = {
+  games: GameDistributionGame[];
+  nextCursor?: string | null;
+};
+
+export type GameDistributionCreateGameRequest = {
+  /** 发布方本地项目标识；同一作者重复发布会复用既有 gameId。 */
+  localProjectId?: string | null;
+  title: string;
+  summary: string;
+  description?: string;
+  category: GameDistributionCategory;
+  tags?: string[];
+  coverAssetId?: string;
+  deviceSupport: GameDistributionDeviceSupport;
+  inputModes: GameDistributionInputMode[];
+  orientation: GameDistributionOrientation;
+};
+
+export type GameDistributionCreateVersionRequest = {
+  localProjectId?: string | null;
+  packageSha256: string;
+  packageBytes: number;
+  packageFileCount: number;
+  packageEntryPath: 'index.html';
+  gameMetadata: GameDistributionCreateGameRequest;
+};
+
+export type GameDistributionPrivateVersion = {
+  versionId: string;
+  gameId: string;
+  versionNumber: number;
+  packageSha256: string;
+  packageBytes: number;
+  status: GameDistributionVersionStatus;
+  /** 游戏公开修订号；撤回与审核动作都必须回传当前值做 CAS。 */
+  publicationRevision: number;
+  reviewReason?: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+/**
+ * 版本状态的下一步动作，由服务端派生；客户端只按它渲染主行动作，不自行推断状态。
+ */
+export type GameDistributionRecoveryAction =
+  | 'upload'
+  | 'submit'
+  | 'wait'
+  | 'none'
+  | 'reupload'
+  | 'fix_package'
+  | 'fix_metadata';
+
+export type GameDistributionVersionDetail = {
+  game: GameDistributionGame;
+  version: GameDistributionPrivateVersion & {
+    recoveryAction: GameDistributionRecoveryAction;
+  };
+};
+
+export type GameDistributionCancelVersionRequest = {
+  expectedPublicationRevision: number;
+  reason?: string;
+};
+
+export type GameDistributionCancelVersionResponse = {
+  game: GameDistributionGame;
+  version: GameDistributionPrivateVersion;
+  replayed: boolean;
+};
diff --git a/scripts/check-release-origin-config.mjs b/scripts/check-release-origin-config.mjs
new file mode 100644
index 000000000..7a3164ae6
--- /dev/null
+++ b/scripts/check-release-origin-config.mjs
@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * 游戏发行来源配置门禁。
+ *
+ * 逐条校验 `deploy/nginx/genarrative-release-origin.conf`：
+ *   1) 每游戏独立 origin 的按主机映射（命名捕获 `game_id` + 发行网关前缀）；
+ *   2) 只暴露发行网关，不代理平台 API / 后台 / SPA；
+ *   3) 发行来源不使用 Cookie（边缘 403 + 转发前清空）；
+ *   4) 响应头策略仍由 api-server 发行网关负责（源码级交叉检查）。
+ * 只要本机存在 nginx 与 openssl，还会用自签通配证书渲染一份临时配置执行
+ * `nginx -t`，把语法与指令上下文一起验证掉。
+ */
+import { execFileSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(scriptDir, '..');
+const templatePath = join(
+  repoRoot,
+  'deploy/nginx/genarrative-release-origin.conf',
+);
+const gatewayPath = join(
+  repoRoot,
+  'server-rs/crates/api-server/src/modules/game_distribution.rs',
+);
+
+const failures = [];
+const notes = [];
+
+function fail(message) {
+  failures.push(message);
+}
+
+function normalize(source) {
+  return source.replace(/\s+/gu, ' ');
+}
+
+function requireSnippet(source, snippet, message) {
+  if (!normalize(source).includes(normalize(snippet))) {
+    fail(message);
+  }
+}
+
+function main() {
+  if (!existsSync(templatePath)) {
+    fail(`缺少发行来源模板：${templatePath}`);
+    return;
+  }
+  const template = readFileSync(templatePath, 'utf8');
+
+  requireSnippet(
+    template,
+    'server_name ~^(?<game_id>[a-z0-9_]+)\\.games\\.example\\.com$;',
+    '发行来源必须用命名捕获 game_id 的子域匹配（每游戏独立 origin）',
+  );
+  requireSnippet(
+    template,
+    'ssl_certificate /etc/letsencrypt/live/games.example.com/fullchain.pem;',
+    '发行来源必须使用通配 TLS 证书',
+  );
+  requireSnippet(
+    template,
+    'if ($http_cookie) { return 403; }',
+    '发行来源必须拒绝携带平台 Cookie 的请求',
+  );
+  requireSnippet(
+    template,
+    'proxy_set_header Cookie "";',
+    '发行来源转发前必须清空 Cookie',
+  );
+  requireSnippet(
+    template,
+    'proxy_pass http://genarrative_release_api/api/game-distribution/releases/$game_id$request_uri;',
+    '发行来源必须按 game_id 映射到发行网关前缀',
+  );
+  requireSnippet(
+    template,
+    'location /.well-known/acme-challenge/',
+    '发行来源必须保留 ACME challenge 路径',
+  );
+
+  requireSnippet(
+    template,
+    'location = / {',
+    '发行来源必须显式把子域根路径映射为该游戏的 index.html',
+  );
+  requireSnippet(
+    template,
+    'proxy_pass http://genarrative_release_api/api/game-distribution/releases/$game_id/index.html;',
+    '子域根路径必须映射到该游戏的 index.html',
+  );
+  const proxyPassCount = (template.match(/proxy_pass\s/gu) ?? []).length;
+  if (proxyPassCount !== 2) {
+    fail(
+      `发行来源只应存在两条 proxy_pass（子域根路径与发行网关前缀），实际 ${proxyPassCount} 条`,
+    );
+  }
+  const cookieStripCount = (
+    template.match(/proxy_set_header Cookie "";/gu) ?? []
+  ).length;
+  if (cookieStripCount !== 2) {
+    fail(`每条发行来源代理都必须清空 Cookie，实际 ${cookieStripCount} 处`);
+  }
+  const gatewayPrefixCount = (
+    template.match(/api\/game-distribution\/releases\/\$game_id/gu) ?? []
+  ).length;
+  if (gatewayPrefixCount !== 2) {
+    fail(`发行来源代理必须都映射到发行网关前缀，实际 ${gatewayPrefixCount} 处`);
+  }
+  for (const forbidden of [
+    '/api/auth',
+    '/api/profile',
+    '/admin/api',
+    '/api/game-distribution/games',
+    '/api/game-distribution/versions',
+  ]) {
+    if (template.includes(forbidden)) {
+      fail(`发行来源不得代理平台命名空间：${forbidden}`);
+    }
+  }
+
+  if (!existsSync(gatewayPath)) {
+    fail(`缺少发行网关源码：${gatewayPath}`);
+  } else {
+    const gateway = readFileSync(gatewayPath, 'utf8');
+    for (const [snippet, message] of [
+      [
+        'header::X_CONTENT_TYPE_OPTIONS',
+        '发行网关必须继续设置 X-Content-Type-Options',
+      ],
+      [
+        'HeaderName::from_static("cross-origin-resource-policy")',
+        '发行网关必须继续设置 CORP',
+      ],
+      [
+        'HeaderValue::from_static("cross-origin")',
+        'CORP 必须是 cross-origin（opaque sandbox 才能加载自有脚本）',
+      ],
+      [
+        'header::ACCESS_CONTROL_ALLOW_ORIGIN',
+        '发行网关必须继续设置无凭据 CORS',
+      ],
+      ['header::CONTENT_SECURITY_POLICY', '发行网关必须继续为 HTML 设置 CSP'],
+      ['StatusCode::FORBIDDEN', '发行网关必须继续拒绝携带 Cookie 的请求'],
+    ]) {
+      if (!gateway.includes(snippet)) {
+        fail(message);
+      }
+    }
+  }
+
+  validateWithNginx(template);
+
+  if (failures.length > 0) {
+    console.error('[check:release-origin-config] FAILED');
+    for (const message of failures) {
+      console.error(`- ${message}`);
+    }
+    process.exit(1);
+  }
+  for (const note of notes) {
+    console.log(`[check:release-origin-config] ${note}`);
+  }
+  console.log(
+    '[check:release-origin-config] OK（发行来源模板、网关响应头策略与 nginx 语法一致）',
+  );
+}
+
+function binaryExists(binary) {
+  try {
+    execFileSync('sh', ['-c', `command -v ${binary}`], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function validateWithNginx(template) {
+  if (!binaryExists('nginx')) {
+    notes.push('未找到 nginx，跳过渲染后的 nginx -t');
+    return;
+  }
+  const workDir = mkdtempSync(join(tmpdir(), 'genarrative-release-origin-'));
+  try {
+    const certPath = join(workDir, 'wildcard.crt');
+    const keyPath = join(workDir, 'wildcard.key');
+    if (binaryExists('openssl')) {
+      execFileSync(
+        'openssl',
+        [
+          'req',
+          '-x509',
+          '-newkey',
+          'rsa:2048',
+          '-nodes',
+          '-days',
+          '1',
+          '-subj',
+          '/CN=games.example.com',
+          '-addext',
+          'subjectAltName=DNS:*.games.example.com,DNS:games.example.com',
+          '-keyout',
+          keyPath,
+          '-out',
+          certPath,
+        ],
+        { stdio: 'ignore' },
+      );
+    } else {
+      notes.push('未找到 openssl，跳过渲染后的 nginx -t');
+      return;
+    }
+    const rendered = template
+      .replace(
+        '/etc/letsencrypt/live/games.example.com/fullchain.pem',
+        certPath,
+      )
+      .replace('/etc/letsencrypt/live/games.example.com/privkey.pem', keyPath)
+      .replace(
+        /\/var\/log\/nginx\/(genarrative-release\.[a-z]+\.log)/gu,
+        join(workDir, '$1'),
+      )
+      // 非 root 环境无法绑定 80/443；语法检查用高位端口，不改生产模板本身。
+      .replace('listen 80;', 'listen 18080;')
+      .replace('listen 443 ssl http2;', 'listen 18443 ssl http2;');
+    const renderedPath = join(workDir, 'release-origin.conf');
+    writeFileSync(renderedPath, rendered);
+    const wrapperPath = join(workDir, 'nginx.conf');
+    writeFileSync(
+      wrapperPath,
+      [
+        `pid ${join(workDir, 'nginx.pid')};`,
+        `error_log ${join(workDir, 'error.log')} warn;`,
+        'events { worker_connections 64; }',
+        'http {',
+        '    access_log off;',
+        '    client_body_temp_path ' + join(workDir, 'client-body') + ';',
+        '    proxy_temp_path ' + join(workDir, 'proxy') + ';',
+        '    fastcgi_temp_path ' + join(workDir, 'fastcgi') + ';',
+        '    uwsgi_temp_path ' + join(workDir, 'uwsgi') + ';',
+        '    scgi_temp_path ' + join(workDir, 'scgi') + ';',
+        `    include ${renderedPath};`,
+        '}',
+        '',
+      ].join('\n'),
+    );
+    try {
+      execFileSync('nginx', ['-t', '-c', wrapperPath], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      notes.push('渲染后的发行来源配置通过 nginx -t');
+    } catch (error) {
+      const stderr = error.stderr ? String(error.stderr) : '';
+      fail(
+        `渲染后的发行来源配置未通过 nginx -t：${stderr.trim() || error.message}`,
+      );
+    }
+  } finally {
+    rmSync(workDir, { recursive: true, force: true });
+  }
+}
+
+main();
diff --git a/server-rs/crates/api-server/src/app.rs b/server-rs/crates/api-server/src/app.rs
index 21253fc06..cde0da26f 100644
--- a/server-rs/crates/api-server/src/app.rs
+++ b/server-rs/crates/api-server/src/app.rs
@@ -1312,6 +1312,91 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn game_distribution_publish_switch_blocks_writes_but_keeps_reads_and_allowlist() {
+        let state = AppState::new(AppConfig::default()).expect("state should build");
+        let user = seed_phone_user_with_password(&state, "13800138112", TEST_PASSWORD).await;
+        let token = sign_test_user_token(&state, &user, "sess_game_publish_switch");
+        let payload = serde_json::json!({
+            "title": "开关验证",
+            "summary": "发布开关验证",
+            "description": "发布开关验证",
+            "category": "其他",
+            "tags": ["验证"],
+            "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+            "inputModes": ["keyboard"],
+            "orientation": "responsive",
+            "localProjectId": "publish-switch-test"
+        })
+        .to_string();
+        let app = build_router(state.clone());
+        let publish_request = || {
+            Request::builder()
+                .method("POST")
+                .uri("/api/game-distribution/games")
+                .header("authorization", format!("Bearer {token}"))
+                .header("content-type", "application/json")
+                .header("idempotency-key", "publish-switch-test-1")
+                .body(Body::from(payload.clone()))
+                .expect("request should build")
+        };
+
+        // 默认没有 gate 行：写入进入业务，不能被发布开关拦下。
+        let open = app
+            .clone()
+            .oneshot(publish_request())
+            .await
+            .expect("request should succeed");
+        assert_ne!(
+            open.status(),
+            StatusCode::SERVICE_UNAVAILABLE,
+            "默认状态不应拦截发布"
+        );
+
+        // 运营收紧到 rollout 0 且无白名单：作者写入 503 + 专用错误码。
+        state.set_test_feature_gate_config(vec![test_feature_gate(
+            module_runtime::GAME_DISTRIBUTION_PUBLISH_GATE_KEY,
+        )]);
+        let blocked = app
+            .clone()
+            .oneshot(publish_request())
+            .await
+            .expect("request should succeed");
+        assert_eq!(blocked.status(), StatusCode::SERVICE_UNAVAILABLE);
+        let blocked_payload = read_json_response(blocked).await;
+        assert_eq!(
+            blocked_payload["error"]["code"],
+            "GAME_DISTRIBUTION_PUBLISH_DISABLED"
+        );
+
+        // 读取不受影响：公开目录仍走业务路径，不是发布关闭。
+        let catalog = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/api/game-distribution/games")
+                    .body(Body::empty())
+                    .expect("request should build"),
+            )
+            .await
+            .expect("request should succeed");
+        assert_ne!(catalog.status(), StatusCode::SERVICE_UNAVAILABLE);
+
+        // 白名单内用户仍可发布（灰度放行）。
+        let mut gate = test_feature_gate(module_runtime::GAME_DISTRIBUTION_PUBLISH_GATE_KEY);
+        gate.allow_user_ids = vec![user.id.clone()];
+        state.set_test_feature_gate_config(vec![gate]);
+        let allowed = app
+            .oneshot(publish_request())
+            .await
+            .expect("request should succeed");
+        assert_ne!(
+            allowed.status(),
+            StatusCode::SERVICE_UNAVAILABLE,
+            "白名单用户不应被发布开关拦截"
+        );
+    }
+
     fn test_feature_gate(gate_key: &str) -> module_runtime::FeatureGateConfigSnapshot {
         module_runtime::FeatureGateConfigSnapshot {
             gate_key: gate_key.to_string(),
diff --git a/server-rs/crates/api-server/src/modules/game_distribution.rs b/server-rs/crates/api-server/src/modules/game_distribution.rs
new file mode 100644
index 000000000..660459817
--- /dev/null
+++ b/server-rs/crates/api-server/src/modules/game_distribution.rs
@@ -0,0 +1,1736 @@
+use std::{
+    collections::{BTreeMap, HashMap, VecDeque},
+    sync::{Arc, Mutex, OnceLock},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use axum::{
+    Json, Router,
+    body::{Body, Bytes},
+    extract::{DefaultBodyLimit, Extension, Path, Query, State},
+    http::{HeaderMap, HeaderValue, StatusCode, header},
+    middleware,
+    response::Response,
+    routing::{get, post, put},
+};
+use module_game_distribution::{
+    MAX_PACKAGE_BYTES, ReleaseAssetError, ReleasePackageError, ReleasePackageManifest,
+    compute_request_digest, extract_release_asset, release_asset_content_type,
+    validate_release_zip,
+};
+use platform_oss::{OssGetObjectRequest, OssInternalPutObjectRequest, OssObjectAccess};
+use serde::Deserialize;
+use serde_json::{Value, json};
+use shared_contracts::game_distribution::{
+    GAME_DISTRIBUTION_CATEGORIES, GameDistributionCreateGameRequest,
+    GameDistributionCreateVersionRequest, GameDistributionInputMode,
+};
+use spacetime_client::{
+    GameDistributionApproveRecordInput, GameDistributionCancelVersionRecordInput,
+    GameDistributionGameRecord, GameDistributionGetGameRecordInput,
+    GameDistributionPublicGameListRecordInput, GameDistributionPublicGameRecord,
+    GameDistributionRejectRecordInput, GameDistributionSubmitReviewRecordInput,
+    GameDistributionSuspendRecordInput, GameDistributionUnpublishRecordInput,
+    GameDistributionVersionRecord, SpacetimeClientError,
+};
+use uuid::Uuid;
+
+use crate::{
+    admin::{AuthenticatedAdmin, require_admin_auth},
+    api_response::json_success_body,
+    auth::{AuthenticatedAccessToken, require_bearer_auth},
+    http_error::AppError,
+    platform_errors::map_oss_error,
+    request_context::RequestContext,
+    state::AppState,
+};
+
+pub(crate) const MAX_PACKAGE_REQUEST_BODY_BYTES: usize = MAX_PACKAGE_BYTES as usize + 1024;
+const MAX_LIST_LIMIT: u32 = 48;
+const MAX_IDEMPOTENCY_KEY_CHARS: usize = 128;
+const MAX_PACKAGE_MANIFEST_JSON_BYTES: usize = 2 * 1024 * 1024;
+const GAME_DISTRIBUTION_OBJECT_PREFIX: &str = "agc/project-snapshots/v1/game-distribution/";
+const GAME_DISTRIBUTION_PUBLISHED_STATUS: &str = "published";
+/// 发行包 PUT 的尝试次数与退避，口径与 `platform-oss` 的可重试分类一致。
+const GAME_DISTRIBUTION_OSS_PUT_MAX_ATTEMPTS: usize = 3;
+const GAME_DISTRIBUTION_OSS_PUT_RETRY_DELAYS_MS: [u64; 2] = [250, 500];
+const RELEASE_PACKAGE_CACHE_MAX_ENTRIES: usize = 4;
+const RELEASE_PACKAGE_CACHE_MAX_BYTES: usize = 200 * 1024 * 1024;
+
+/// 发行静态资源的进程内缓存。
+///
+/// 单个资源取自整个 ZIP，若每个请求都重新下载整包会拖垮发行网关；缓存只保存已通过
+/// 校验的私有包字节，键是对象键，超出条目或字节预算时按插入顺序淘汰。
+static RELEASE_PACKAGE_CACHE: OnceLock<Mutex<ReleasePackageCache>> = OnceLock::new();
+
+#[derive(Default)]
+struct ReleasePackageCache {
+    packages: HashMap<String, Arc<Vec<u8>>>,
+    order: VecDeque<String>,
+    total_bytes: usize,
+}
+
+impl ReleasePackageCache {
+    fn get(&self, object_key: &str) -> Option<Arc<Vec<u8>>> {
+        self.packages.get(object_key).cloned()
+    }
+
+    fn insert(&mut self, object_key: String, bytes: Arc<Vec<u8>>) {
+        self.insert_with_limits(
+            object_key,
+            bytes,
+            RELEASE_PACKAGE_CACHE_MAX_ENTRIES,
+            RELEASE_PACKAGE_CACHE_MAX_BYTES,
+        );
+    }
+
+    fn insert_with_limits(
+        &mut self,
+        object_key: String,
+        bytes: Arc<Vec<u8>>,
+        max_entries: usize,
+        max_bytes: usize,
+    ) {
+        if self.packages.contains_key(&object_key) {
+            return;
+        }
+        // 单个包超过缓存预算时直接不缓存，避免一次插入把整个进程内存顶满。
+        if bytes.len() > max_bytes {
+            return;
+        }
+        while self.order.len() >= max_entries
+            || self.total_bytes.saturating_add(bytes.len()) > max_bytes
+        {
+            let Some(evicted) = self.order.pop_front() else {
+                break;
+            };
+            if let Some(previous) = self.packages.remove(&evicted) {
+                self.total_bytes = self.total_bytes.saturating_sub(previous.len());
+            }
+        }
+        self.total_bytes = self.total_bytes.saturating_add(bytes.len());
+        self.order.push_back(object_key.clone());
+        self.packages.insert(object_key, bytes);
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct GameListQuery {
+    #[serde(alias = "keyword")]
+    search: Option<String>,
+    category: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct AdminReviewListQuery {
+    limit: Option<u32>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PublicationRevisionRequest {
+    expected_publication_revision: u64,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AdminReviewRequest {
+    decision: String,
+    expected_publication_revision: u64,
+    #[serde(default)]
+    review_reason: Option<String>,
+    #[serde(default)]
+    entry_url: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct CancelVersionRequest {
+    expected_publication_revision: u64,
+    #[serde(default)]
+    reason: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AdminSuspendRequest {
+    expected_publication_revision: u64,
+    #[serde(default)]
+    reason: Option<String>,
+}
+
+pub fn router(state: AppState) -> Router<AppState> {
+    let protected = Router::new()
+        .route("/api/game-distribution/games", post(create_game))
+        .route(
+            "/api/game-distribution/games/{game_id}/versions",
+            post(create_version),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}/package",
+            put(upload_package).layer(DefaultBodyLimit::max(MAX_PACKAGE_REQUEST_BODY_BYTES)),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}/submit",
+            post(submit_version),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}",
+            get(get_owner_version),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}/cancel",
+            post(cancel_version),
+        )
+        .route("/api/game-distribution/my-games", get(list_my_games))
+        .route(
+            "/api/game-distribution/games/{game_id}/unpublish",
+            post(unpublish_game),
+        )
+        .route_layer(middleware::from_fn_with_state(
+            state.clone(),
+            require_bearer_auth,
+        ));
+
+    let admin = Router::new()
+        .route(
+            "/admin/api/game-distribution/reviews",
+            get(admin_list_reviews),
+        )
+        .route(
+            "/admin/api/game-distribution/versions/{version_id}/review",
+            post(admin_review_version),
+        )
+        .route(
+            "/admin/api/game-distribution/versions/{version_id}",
+            get(admin_get_version),
+        )
+        .route(
+            "/admin/api/game-distribution/games/{game_id}/suspend",
+            post(admin_suspend_game),
+        )
+        .route_layer(middleware::from_fn_with_state(
+            state.clone(),
+            require_admin_auth,
+        ));
+
+    Router::new()
+        .route("/api/game-distribution/games", get(list_games))
+        .route("/api/game-distribution/games/{game_id}", get(get_game))
+        .route(
+            "/api/game-distribution/releases/{game_id}/{*asset_path}",
+            get(serve_release_asset),
+        )
+        .merge(protected)
+        .merge(admin)
+}
+
+/// 公开发行网关。
+///
+/// 只服务当前已公开版本的游戏文件，路径必须在白名单内容类型内；私有 ZIP 对象和
+/// 未公开版本不会因为知道 ID 而可读。
+async fn serve_release_asset(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Path((game_id, asset_path)): Path<(String, String)>,
+) -> Result<Response, AppError> {
+    // 发行文件必须由独立来源提供。带上平台 Cookie 的请求说明它正落在主站来源上，
+    // 此时同源脚本可以读到平台会话，必须直接关闭而不是降级服务。
+    if headers.contains_key(header::COOKIE) {
+        return Err(AppError::from_status(StatusCode::FORBIDDEN)
+            .with_message("发行资源必须在独立来源上请求"));
+    }
+    let asset_path = asset_path.trim_start_matches('/').to_string();
+    let content_type = release_asset_content_type(&asset_path)
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let public_game = state
+        .spacetime_client()
+        .get_public_game_distribution_game(game_id.clone())
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let version = public_game
+        .current_version
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    if version.status != GAME_DISTRIBUTION_PUBLISHED_STATUS {
+        return Err(AppError::from_status(StatusCode::NOT_FOUND));
+    }
+    let package = release_package_bytes(&state, &game_id, &version.version_id).await?;
+    let content = match extract_release_asset(&package, &asset_path) {
+        Ok(content) => content,
+        Err(ReleaseAssetError::FileTooLarge) => {
+            return Err(AppError::from_status(StatusCode::PAYLOAD_TOO_LARGE)
+                .with_message("发行资源超过响应上限"));
+        }
+        Err(_) => return Err(AppError::from_status(StatusCode::NOT_FOUND)),
+    };
+    Ok(release_asset_response(content, content_type))
+}
+
+/// 读取（并按对象键缓存）已确认的私有发行包。
+async fn release_package_bytes(
+    state: &AppState,
+    game_id: &str,
+    version_id: &str,
+) -> Result<Arc<Vec<u8>>, AppError> {
+    let object_key = format!("{GAME_DISTRIBUTION_OBJECT_PREFIX}{game_id}/{version_id}.zip");
+    let cache = RELEASE_PACKAGE_CACHE.get_or_init(|| Mutex::new(ReleasePackageCache::default()));
+    if let Some(cached) = cache.lock().ok().and_then(|guard| guard.get(&object_key)) {
+        return Ok(cached);
+    }
+    let oss = state.project_snapshot_oss_client().ok_or_else(|| {
+        AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_message("游戏发行包 OSS 未配置")
+    })?;
+    let bytes = oss
+        .get_object(
+            state.editor_oss_http_client(),
+            OssGetObjectRequest {
+                object_key: object_key.clone(),
+                max_bytes: MAX_PACKAGE_BYTES as usize,
+            },
+        )
+        .await
+        .map_err(|error| {
+            if matches!(error, platform_oss::OssError::ObjectNotFound(_)) {
+                AppError::from_status(StatusCode::NOT_FOUND)
+            } else {
+                map_oss_error(error, "aliyun-oss")
+            }
+        })?;
+    let bytes = Arc::new(bytes);
+    if let Ok(mut guard) = cache.lock() {
+        guard.insert(object_key, bytes.clone());
+    }
+    Ok(bytes)
+}
+
+fn release_asset_response(content: Vec<u8>, content_type: &'static str) -> Response {
+    let mut response = Response::new(Body::from(content));
+    let headers = response.headers_mut();
+    headers.insert(header::CONTENT_TYPE, HeaderValue::from_static(content_type));
+    headers.insert(
+        header::X_CONTENT_TYPE_OPTIONS,
+        HeaderValue::from_static("nosniff"),
+    );
+    headers.insert(
+        header::REFERRER_POLICY,
+        HeaderValue::from_static("no-referrer"),
+    );
+    headers.insert(
+        header::CACHE_CONTROL,
+        HeaderValue::from_static("public, max-age=60, must-revalidate"),
+    );
+    // 发行文档运行在 allow-scripts 的 opaque origin 沙箱里，其同包资源请求不再与
+    // 网关同源；CORP 必须允许跨来源，ES modules 还需要不带 credentials 的 CORS，
+    // 否则游戏自己的脚本会被浏览器拦下（实测 net::ERR_BLOCKED_BY_RESPONSE）。
+    // 这些是公开静态文件，放宽 CORP 不涉及凭据。
+    headers.insert(
+        header::HeaderName::from_static("cross-origin-resource-policy"),
+        HeaderValue::from_static("cross-origin"),
+    );
+    headers.insert(
+        header::ACCESS_CONTROL_ALLOW_ORIGIN,
+        HeaderValue::from_static("*"),
+    );
+    if content_type.starts_with("text/html") {
+        // 发行 HTML 走与主站不同的来源并强制最小权限策略；包内 meta 不能放宽。
+        headers.insert(
+            header::CONTENT_SECURITY_POLICY,
+            HeaderValue::from_static(
+                "default-src 'none'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';                  img-src 'self' data: blob:; media-src 'self' data: blob:; font-src 'self' data:;                  connect-src 'self'; worker-src 'none'; object-src 'none'; frame-src 'none';                  form-action 'none'; base-uri 'none'",
+            ),
+        );
+    }
+    response
+}
+
+async fn list_games(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Query(query): Query<GameListQuery>,
+) -> Result<Json<Value>, AppError> {
+    let games = state
+        .spacetime_client()
+        .list_game_distribution_games(GameDistributionPublicGameListRecordInput {
+            search: normalize_optional(query.search),
+            category: normalize_optional(query.category),
+            limit: MAX_LIST_LIMIT,
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    let games = games
+        .into_iter()
+        .map(public_game_payload)
+        .collect::<Vec<_>>();
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "games": games, "nextCursor": Value::Null }),
+    ))
+}
+
+async fn get_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let game = state
+        .spacetime_client()
+        .get_public_game_distribution_game(game_id)
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    Ok(json_success_body(Some(&ctx), public_game_payload(game)))
+}
+
+/// 作者自有游戏列表：只返回当前认证主体名下的游戏与最近版本状态。
+async fn list_my_games(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+) -> Result<Json<Value>, AppError> {
+    let games = state
+        .spacetime_client()
+        .list_owner_game_distribution_games(
+            spacetime_client::GameDistributionOwnerGameListRecordInput {
+                owner_user_id: auth.claims().user_id().to_string(),
+                limit: MAX_LIST_LIMIT,
+            },
+        )
+        .await
+        .map_err(map_spacetime_error)?;
+    let payload = games
+        .into_iter()
+        .map(|entry| {
+            let mut value = game_payload(&entry.game);
+            let versions = entry
+                .versions
+                .iter()
+                .map(private_version_payload)
+                .collect::<Vec<_>>();
+            if let Value::Object(ref mut object) = value {
+                object.insert(
+                    "latestVersion".to_string(),
+                    versions.first().cloned().unwrap_or(Value::Null),
+                );
+                object.insert("versions".to_string(), Value::Array(versions));
+            }
+            value
+        })
+        .collect::<Vec<_>>();
+    Ok(json_success_body(Some(&ctx), json!({ "games": payload })))
+}
+
+async fn create_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Json(payload): Json<GameDistributionCreateGameRequest>,
+) -> Result<Json<Value>, AppError> {
+    ensure_publish_enabled(&state, Some(auth.claims().user_id())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    validate_game_metadata(&payload)?;
+    let now = now_micros();
+    let game_id = format!("game_{}", Uuid::new_v4().simple());
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&payload).map_err(|error| internal(error.to_string()))?,
+    );
+    let game = state
+        .spacetime_client()
+        .create_game_distribution_game(spacetime_client::GameDistributionCreateGameRecordInput {
+            game_id,
+            owner_user_id: auth.claims().user_id().to_string(),
+            title: payload.title,
+            summary: payload.summary,
+            description: payload.description,
+            category: payload.category,
+            tags_json: serde_json::to_string(&payload.tags)
+                .map_err(|error| internal(error.to_string()))?,
+            cover_asset_id: payload.cover_asset_id,
+            author_name: None,
+            author_avatar_url: None,
+            device_support_desktop: payload.device_support.desktop,
+            device_support_mobile: payload.device_support.mobile,
+            device_support_touch: payload.device_support.touch,
+            input_modes_json: serde_json::to_string(&payload.input_modes)
+                .map_err(|error| internal(error.to_string()))?,
+            orientation: serde_json::to_string(&payload.orientation)
+                .map_err(|error| internal(error.to_string()))?
+                .trim_matches('"')
+                .to_string(),
+            idempotency_key,
+            request_digest,
+            now_micros: now,
+            local_project_id: normalize_local_project_id(payload.local_project_id.as_deref())?,
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(json_success_body(Some(&ctx), game_payload(&game.0)))
+}
+
+async fn create_version(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(game_id): Path<String>,
+    Json(payload): Json<GameDistributionCreateVersionRequest>,
+) -> Result<Json<Value>, AppError> {
+    ensure_publish_enabled(&state, Some(auth.claims().user_id())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    validate_version_declaration(&payload)?;
+    let now = now_micros();
+    let version_id = format!("gamever_{}", Uuid::new_v4().simple());
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(game_id.as_str(), &payload))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let version = state
+        .spacetime_client()
+        .create_game_distribution_version(
+            spacetime_client::GameDistributionCreateVersionRecordInput {
+                game_id,
+                owner_user_id: auth.claims().user_id().to_string(),
+                version_id,
+                package_sha256: payload.package_sha256,
+                package_bytes: payload.package_bytes,
+                package_file_count: payload.package_file_count,
+                package_entry_path: payload.package_entry_path,
+                local_project_id: normalize_local_project_id(payload.local_project_id.as_deref())?,
+                idempotency_key,
+                request_digest,
+                now_micros: now,
+            },
+        )
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(json_success_body(
+        Some(&ctx),
+        private_version_payload(&version.0),
+    ))
+}
+
+async fn upload_package(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(version_id): Path<String>,
+    body: Bytes,
+) -> Result<Json<Value>, AppError> {
+    require_zip_content_type(&headers)?;
+    let owner_user_id = auth.claims().user_id().to_string();
+    ensure_publish_enabled(&state, Some(owner_user_id.as_str())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let expected = state
+        .spacetime_client()
+        .get_owner_game_distribution_version(owner_user_id.clone(), version_id.clone())
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let manifest = match validate_release_zip(&body) {
+        Ok(manifest) => manifest,
+        Err(error) => {
+            let mapped = map_package_error(error.clone());
+            record_upload_failure(
+                &state,
+                &owner_user_id,
+                &version_id,
+                &idempotency_key,
+                "PACKAGE_VALIDATION_FAILED",
+                format!("{error:?}"),
+            )
+            .await;
+            return Err(mapped);
+        }
+    };
+    if manifest.package_sha256 != expected.package_sha256
+        || manifest.package_bytes != expected.package_bytes
+        || u32::try_from(manifest.files.len()).unwrap_or(u32::MAX) != expected.package_file_count
+        || expected.package_entry_path != "index.html"
+    {
+        let error = AppError::from_status(StatusCode::CONFLICT)
+            .with_code("PACKAGE_MISMATCH")
+            .with_details(json!({
+                "provider": "game-distribution",
+                "message": "发行包摘要、体积、文件数或入口与版本声明不一致",
+            }));
+        record_upload_failure(
+            &state,
+            &owner_user_id,
+            &version_id,
+            &idempotency_key,
+            "PACKAGE_MISMATCH",
+            "发行包摘要、体积、文件数或入口与版本声明不一致".to_string(),
+        )
+        .await;
+        return Err(error);
+    }
+    let package_object_key = format!(
+        "{GAME_DISTRIBUTION_OBJECT_PREFIX}{}/{version_id}.zip",
+        expected.game_id
+    );
+    let package_manifest_json = package_manifest_json(&manifest)?;
+    let oss = state.project_snapshot_oss_client().ok_or_else(|| {
+        AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_message("游戏发行包 OSS 未配置")
+    })?;
+    let existing = oss
+        .head_internal_object(state.editor_oss_http_client(), &package_object_key)
+        .await
+        .map_err(|error| map_oss_error(error, "aliyun-oss"))?;
+    let skipped = match existing {
+        Some(existing) if existing.content_length == manifest.package_bytes => true,
+        Some(_) => {
+            let error = AppError::from_status(StatusCode::CONFLICT)
+                .with_code("PACKAGE_OBJECT_MISMATCH")
+                .with_message("发行包对象已存在但体积不一致");
+            record_upload_failure(
+                &state,
+                &owner_user_id,
+                &version_id,
+                &idempotency_key,
+                "PACKAGE_OBJECT_MISMATCH",
+                "发行包对象已存在但体积不一致".to_string(),
+            )
+            .await;
+            return Err(error);
+        }
+        None => false,
+    };
+    if !skipped {
+        // 单次 100 MiB PUT 在本机实测 12 秒上下，偶发传输失败会让作者白传一次；
+        // 这里按 platform-oss 既有的可重试分类做受控重试（只重试传输/超时/408/429/5xx）。
+        oss.put_internal_object_with_retry(
+            state.editor_oss_http_client(),
+            OssInternalPutObjectRequest {
+                object_key: package_object_key.clone(),
+                content_type: Some("application/zip".to_string()),
+                access: OssObjectAccess::Private,
+                metadata: BTreeMap::new(),
+                body: body.to_vec(),
+            },
+            GAME_DISTRIBUTION_OSS_PUT_MAX_ATTEMPTS,
+            &GAME_DISTRIBUTION_OSS_PUT_RETRY_DELAYS_MS,
+        )
+        .await
+        .map_err(|error| map_oss_error(error, "aliyun-oss"))?;
+    }
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(version_id.as_str(), manifest.package_sha256.as_str()))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let confirmed = state
+        .spacetime_client()
+        .confirm_game_distribution_package(
+            spacetime_client::GameDistributionConfirmPackageRecordInput {
+                version_id,
+                owner_user_id,
+                package_sha256: manifest.package_sha256,
+                package_bytes: manifest.package_bytes,
+                package_file_count: u32::try_from(manifest.files.len()).unwrap_or(u32::MAX),
+                package_entry_path: "index.html".to_string(),
+                package_object_key,
+                package_manifest_json,
+                idempotency_key,
+                request_digest,
+                updated_at_micros: now_micros(),
+            },
+        )
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "versionId": confirmed.0.version_id, "status": confirmed.0.status }),
+    ))
+}
+
+async fn submit_version(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(version_id): Path<String>,
+    Json(payload): Json<PublicationRevisionRequest>,
+) -> Result<(StatusCode, Json<Value>), AppError> {
+    let owner_user_id = auth.claims().user_id().to_string();
+    ensure_publish_enabled(&state, Some(owner_user_id.as_str())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let version = state
+        .spacetime_client()
+        .get_owner_game_distribution_version(owner_user_id.clone(), version_id.clone())
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let game = state
+        .spacetime_client()
+        .get_game_distribution_game(GameDistributionGetGameRecordInput {
+            game_id: version.game_id.clone(),
+            owner_user_id: Some(owner_user_id.clone()),
+        })
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(version_id.as_str(), payload.expected_publication_revision))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let submitted = state
+        .spacetime_client()
+        .submit_game_distribution_version_for_review(GameDistributionSubmitReviewRecordInput {
+            version_id,
+            owner_user_id,
+            expected_publication_revision: payload.expected_publication_revision,
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok((
+        StatusCode::ACCEPTED,
+        json_success_body(
+            Some(&ctx),
+            json!({
+                "game": game_payload(&game),
+                "version": private_version_payload(&submitted.0),
+                "replayed": submitted.1,
+            }),
+        ),
+    ))
+}
+
+/// 作者回读单个版本的私有状态与恢复动作。
+///
+/// 版本不存在或不属于当前主体都返回 404，避免用错误码区分“别人的版本”和“不存在的版本”。
+async fn get_owner_version(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    Path(version_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let owner_user_id = auth.claims().user_id().to_string();
+    let version = load_owner_version_or_404(&state, owner_user_id.clone(), version_id).await?;
+    let game = state
+        .spacetime_client()
+        .get_game_distribution_game(GameDistributionGetGameRecordInput {
+            game_id: version.game_id.clone(),
+            owner_user_id: Some(owner_user_id),
+        })
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    Ok(json_success_body(
+        Some(&ctx),
+        version_detail_payload(&version, &game),
+    ))
+}
+
+/// 作者撤回尚未公开的版本。
+///
+/// 只能撤回自己名下、且未参与当前公开投影的版本；`expectedPublicationRevision` 以
+/// 游戏公开修订号做 CAS，过期请求返回 409，已公开版本改用下架。
+async fn cancel_version(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(version_id): Path<String>,
+    Json(payload): Json<CancelVersionRequest>,
+) -> Result<Json<Value>, AppError> {
+    let owner_user_id = auth.claims().user_id().to_string();
+    ensure_publish_enabled(&state, Some(owner_user_id.as_str())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let version =
+        load_owner_version_or_404(&state, owner_user_id.clone(), version_id.clone()).await?;
+    if version.publication_revision != payload.expected_publication_revision {
+        return Err(
+            AppError::from_status(StatusCode::CONFLICT).with_details(json!({
+                "provider": "game-distribution",
+                "code": "PUBLICATION_CONFLICT",
+                "message": "游戏的公开修订号已变化，请刷新后重试",
+            })),
+        );
+    }
+    let game = state
+        .spacetime_client()
+        .get_game_distribution_game(GameDistributionGetGameRecordInput {
+            game_id: version.game_id.clone(),
+            owner_user_id: Some(owner_user_id.clone()),
+        })
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let reason = payload
+        .reason
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty());
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(
+            version_id.as_str(),
+            payload.expected_publication_revision,
+            reason,
+        ))
+        .map_err(|error| internal(error.to_string()))?,
+    );
+    let (version, replayed) = state
+        .spacetime_client()
+        .cancel_game_distribution_version(GameDistributionCancelVersionRecordInput {
+            version_id,
+            owner_user_id,
+            expected_publication_revision: payload.expected_publication_revision,
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({
+            "game": game_payload(&game),
+            "version": private_version_payload(&version),
+            "replayed": replayed,
+        }),
+    ))
+}
+
+async fn unpublish_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(game_id): Path<String>,
+    Json(payload): Json<PublicationRevisionRequest>,
+) -> Result<Json<Value>, AppError> {
+    let owner_user_id = auth.claims().user_id().to_string();
+    ensure_publish_enabled(&state, Some(owner_user_id.as_str())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(game_id.as_str(), payload.expected_publication_revision))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let game = state
+        .spacetime_client()
+        .unpublish_game_distribution_game(GameDistributionUnpublishRecordInput {
+            game_id,
+            owner_user_id,
+            expected_publication_revision: payload.expected_publication_revision,
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "game": game_payload(&game.0), "replayed": game.1 }),
+    ))
+}
+
+async fn admin_list_reviews(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(_admin): Extension<AuthenticatedAdmin>,
+    Query(query): Query<AdminReviewListQuery>,
+) -> Result<Json<Value>, AppError> {
+    let limit = query.limit.unwrap_or(MAX_LIST_LIMIT).min(MAX_LIST_LIMIT);
+    let reviews = state
+        .spacetime_client()
+        .list_game_distribution_reviews(limit)
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({
+            "entries": reviews.iter().map(private_version_payload).collect::<Vec<_>>(),
+            "nextCursor": Value::Null,
+        }),
+    ))
+}
+
+async fn admin_review_version(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(admin): Extension<AuthenticatedAdmin>,
+    headers: HeaderMap,
+    Path(version_id): Path<String>,
+    Json(payload): Json<AdminReviewRequest>,
+) -> Result<Json<Value>, AppError> {
+    let idempotency_key = idempotency_key(&headers)?;
+    let decision = payload.decision.trim().to_ascii_lowercase();
+    if decision != "approve" && decision != "reject" {
+        return Err(bad_request("审核结论必须是 approve 或 reject"));
+    }
+    let admin_user_id = admin.session().subject.clone();
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(
+            version_id.as_str(),
+            decision.as_str(),
+            payload.expected_publication_revision,
+            payload.review_reason.as_deref(),
+            payload.entry_url.as_deref(),
+        ))
+        .map_err(|error| internal(error.to_string()))?,
+    );
+    let (version, replayed) = if decision == "approve" {
+        // 回滚窗口里“关闭新版本激活”，但拒绝审核与安全下架必须始终可用。
+        ensure_publish_enabled(&state, None).await?;
+        let entry_url = payload
+            .entry_url
+            .as_deref()
+            .ok_or_else(|| bad_request("审核通过必须提供发行网关 HTTPS 入口"))?;
+        validate_release_entry_url(entry_url, !state.config.is_production())?;
+        state
+            .spacetime_client()
+            .approve_game_distribution_version(GameDistributionApproveRecordInput {
+                version_id,
+                admin_user_id,
+                expected_publication_revision: payload.expected_publication_revision,
+                entry_url: entry_url.to_string(),
+                idempotency_key,
+                request_digest,
+                now_micros: now_micros(),
+            })
+            .await
+            .map_err(map_spacetime_error)?
+    } else {
+        let review_reason = payload
+            .review_reason
+            .filter(|value| !value.trim().is_empty())
+            .ok_or_else(|| bad_request("拒绝审核必须填写 reviewReason"))?;
+        state
+            .spacetime_client()
+            .reject_game_distribution_version(GameDistributionRejectRecordInput {
+                version_id,
+                admin_user_id,
+                expected_publication_revision: payload.expected_publication_revision,
+                review_reason,
+                idempotency_key,
+                request_digest,
+                now_micros: now_micros(),
+            })
+            .await
+            .map_err(map_spacetime_error)?
+    };
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "version": private_version_payload(&version), "replayed": replayed }),
+    ))
+}
+
+/// 管理员回读任意版本，用于审核时确认状态、错误和恢复动作。
+async fn admin_get_version(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(_admin): Extension<AuthenticatedAdmin>,
+    Path(version_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let version = state
+        .spacetime_client()
+        .get_game_distribution_version(version_id)
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    let game = state
+        .spacetime_client()
+        .get_game_distribution_game(GameDistributionGetGameRecordInput {
+            game_id: version.game_id.clone(),
+            owner_user_id: Some(version.owner_user_id.clone()),
+        })
+        .await
+        .map_err(map_spacetime_error)?
+        .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    Ok(json_success_body(
+        Some(&ctx),
+        version_detail_payload(&version, &game),
+    ))
+}
+
+/// 校验管理员提交的发行入口。
+///
+/// 生产环境只接受绝对 HTTPS 地址；非生产环境额外允许 http 回环地址，口径与前端
+/// `normalizeGameEntryUrl` 一致，便于本地把发行网关跑在 127.0.0.1 上验证内嵌游玩。
+/// 任何环境都拒绝凭据、query 和 fragment，也不允许服务端自行拼默认地址。
+fn validate_release_entry_url(value: &str, allow_loopback_http: bool) -> Result<(), AppError> {
+    let parsed =
+        url::Url::parse(value.trim()).map_err(|_| bad_request("发行入口必须是有效 URL"))?;
+    let host = parsed.host_str();
+    let scheme_allowed = parsed.scheme() == "https"
+        || (allow_loopback_http
+            && parsed.scheme() == "http"
+            && matches!(
+                host,
+                Some("127.0.0.1") | Some("localhost") | Some("[::1]") | Some("::1")
+            ));
+    if !scheme_allowed
+        || host.is_none()
+        || parsed.username() != ""
+        || parsed.password().is_some()
+        || parsed.query().is_some()
+        || parsed.fragment().is_some()
+    {
+        return Err(bad_request(
+            "发行入口必须是无凭据、无查询参数的 HTTPS URL；仅非生产环境允许回环 http",
+        ));
+    }
+    Ok(())
+}
+
+async fn admin_suspend_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(admin): Extension<AuthenticatedAdmin>,
+    headers: HeaderMap,
+    Path(game_id): Path<String>,
+    Json(payload): Json<AdminSuspendRequest>,
+) -> Result<Json<Value>, AppError> {
+    let idempotency_key = idempotency_key(&headers)?;
+    let admin_user_id = admin.session().subject.clone();
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(
+            game_id.as_str(),
+            payload.expected_publication_revision,
+            payload.reason.as_deref(),
+        ))
+        .map_err(|error| internal(error.to_string()))?,
+    );
+    let game = state
+        .spacetime_client()
+        .suspend_game_distribution_game(GameDistributionSuspendRecordInput {
+            game_id,
+            admin_user_id,
+            expected_publication_revision: payload.expected_publication_revision,
+            reason: payload.reason,
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "game": game_payload(&game.0), "replayed": game.1 }),
+    ))
+}
+
+async fn record_upload_failure(
+    state: &AppState,
+    owner_user_id: &str,
+    version_id: &str,
+    idempotency_key: &str,
+    error_code: &str,
+    error_message: String,
+) {
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(version_id, error_code, error_message.as_str())).unwrap_or_default(),
+    );
+    let _ = state
+        .spacetime_client()
+        .fail_game_distribution_upload(spacetime_client::GameDistributionFailUploadRecordInput {
+            version_id: version_id.to_string(),
+            owner_user_id: owner_user_id.to_string(),
+            idempotency_key: idempotency_key.to_string(),
+            request_digest,
+            error_code: error_code.to_string(),
+            error_message,
+            now_micros: now_micros(),
+        })
+        .await;
+}
+
+/// 本地项目标识只用于同一作者复用游戏身份；它必须是短标识，不能充当路径或所有权凭证。
+fn normalize_local_project_id(value: Option<&str>) -> Result<Option<String>, AppError> {
+    let Some(value) = value.map(str::trim).filter(|value| !value.is_empty()) else {
+        return Ok(None);
+    };
+    if value.chars().count() > 128 {
+        return Err(bad_request("localProjectId 不能超过 128 个字符"));
+    }
+    if value.chars().any(|character| character.is_control())
+        || value.contains('/')
+        || value.contains('\\')
+        || value == "."
+        || value == ".."
+    {
+        return Err(bad_request(
+            "localProjectId 只能是短标识，不能包含路径分隔符",
+        ));
+    }
+    Ok(Some(value.to_string()))
+}
+
+fn validate_game_metadata(payload: &GameDistributionCreateGameRequest) -> Result<(), AppError> {
+    if payload.title.trim().is_empty() || payload.title.chars().count() > 40 {
+        return Err(bad_request("游戏标题必须为 1 到 40 个字符"));
+    }
+    if payload.summary.trim().is_empty() || payload.summary.chars().count() > 120 {
+        return Err(bad_request("游戏简介必须为 1 到 120 个字符"));
+    }
+    if payload.description.as_deref().unwrap_or("").chars().count() > 2_000 {
+        return Err(bad_request("游戏详细介绍不能超过 2000 个字符"));
+    }
+    if !GAME_DISTRIBUTION_CATEGORIES.contains(&payload.category.as_str()) {
+        return Err(bad_request("游戏分类不受支持"));
+    }
+    if payload.tags.len() > 5
+        || payload
+            .tags
+            .iter()
+            .any(|tag| tag.trim().is_empty() || tag.chars().count() > 20)
+    {
+        return Err(bad_request("游戏标签最多 5 个且每个不能超过 20 个字符"));
+    }
+    if !payload.device_support.desktop && !payload.device_support.mobile {
+        return Err(bad_request("游戏至少需要声明支持桌面端或移动端"));
+    }
+    if payload.device_support.mobile && !payload.device_support.touch {
+        return Err(bad_request("声明支持移动端时必须支持触控"));
+    }
+    Ok(())
+}
+
+fn validate_version_declaration(
+    payload: &GameDistributionCreateVersionRequest,
+) -> Result<(), AppError> {
+    if payload.package_entry_path != "index.html" {
+        return Err(bad_request("发行包入口必须是 index.html"));
+    }
+    if payload.package_bytes == 0 || payload.package_bytes > MAX_PACKAGE_BYTES {
+        return Err(
+            AppError::from_status(StatusCode::PAYLOAD_TOO_LARGE).with_message("发行包大小超出限制")
+        );
+    }
+    if payload.package_file_count == 0 {
+        return Err(bad_request("发行包至少需要包含一个文件"));
+    }
+    if payload.package_sha256.len() != 64
+        || !payload
+            .package_sha256
+            .chars()
+            .all(|value| value.is_ascii_hexdigit())
+    {
+        return Err(bad_request("发行包 SHA-256 格式不合法"));
+    }
+    validate_game_metadata(&payload.game_metadata)
+}
+
+fn require_zip_content_type(headers: &HeaderMap) -> Result<(), AppError> {
+    let content_type = headers
+        .get(header::CONTENT_TYPE)
+        .and_then(|value| value.to_str().ok())
+        .map(|value| {
+            value
+                .split(';')
+                .next()
+                .unwrap_or_default()
+                .trim()
+                .to_ascii_lowercase()
+        });
+    if content_type.as_deref() != Some("application/zip") {
+        return Err(bad_request("发行包必须使用 application/zip"));
+    }
+    Ok(())
+}
+
+fn package_manifest_json(manifest: &ReleasePackageManifest) -> Result<String, AppError> {
+    let serialized = serde_json::to_string(&json!({
+        "packageBytes": manifest.package_bytes,
+        "packageSha256": manifest.package_sha256,
+        "files": manifest.files.iter().map(|file| json!({
+            "path": file.path,
+            "sizeBytes": file.size_bytes,
+            "sha256": file.sha256,
+        })).collect::<Vec<_>>(),
+    }))
+    .map_err(|error| internal(error.to_string()))?;
+    if serialized.len() > MAX_PACKAGE_MANIFEST_JSON_BYTES {
+        return Err(AppError::from_status(StatusCode::PAYLOAD_TOO_LARGE)
+            .with_message("发行包文件清单超过大小限制"));
+    }
+    Ok(serialized)
+}
+
+fn public_game_payload(game: GameDistributionPublicGameRecord) -> Value {
+    let mut payload = game_payload(&game.game);
+    if let Value::Object(ref mut object) = payload {
+        object.insert(
+            "currentVersion".to_string(),
+            game.current_version
+                .map(|version| version_summary_payload(&version))
+                .unwrap_or(Value::Null),
+        );
+    }
+    payload
+}
+
+fn game_payload(game: &GameDistributionGameRecord) -> Value {
+    let tags = serde_json::from_str::<Vec<String>>(&game.tags_json).unwrap_or_default();
+    let input_modes =
+        serde_json::from_str::<Vec<GameDistributionInputMode>>(&game.input_modes_json)
+            .unwrap_or_default();
+    json!({
+        "id": game.game_id,
+        "title": game.title,
+        "summary": game.summary,
+        "description": game.description,
+        "category": game.category,
+        "tags": tags,
+        "coverColor": "#F3E4D0",
+        "icon": "🎮",
+        "author": { "id": game.owner_user_id, "name": game.author_name.as_deref().unwrap_or("创作者"), "avatarUrl": game.author_avatar_url },
+        "deviceSupport": { "desktop": game.device_support_desktop, "mobile": game.device_support_mobile, "touch": game.device_support_touch },
+        "inputModes": input_modes,
+        "orientation": game.orientation,
+        "status": game.visibility,
+        "publicationRevision": game.publication_revision,
+        "playCount": game.play_count,
+        "createdAt": game.created_at,
+    })
+}
+
+fn version_summary_payload(version: &GameDistributionVersionRecord) -> Value {
+    json!({
+        "id": version.version_id,
+        "version": version.version_number.to_string(),
+        "entryUrl": version.entry_url,
+        "sha256": version.package_sha256,
+        "publishedAt": version.updated_at,
+        "controls": [],
+    })
+}
+
+fn private_version_payload(version: &GameDistributionVersionRecord) -> Value {
+    json!({
+        "versionId": version.version_id,
+        "gameId": version.game_id,
+        "versionNumber": version.version_number,
+        "packageSha256": version.package_sha256,
+        "packageBytes": version.package_bytes,
+        "status": version.status,
+        "publicationRevision": version.publication_revision,
+        "reviewReason": version.review_reason,
+        "createdAt": version.created_at,
+        "updatedAt": version.updated_at,
+    })
+}
+
+/// 游戏分发写入开关。
+///
+/// 运营在灰度配置里把 `game-distribution:publish` 收紧后，作者写入与新版本激活会返回
+/// 503 `GAME_DISTRIBUTION_PUBLISH_DISABLED`；目录、详情、版本回读、发行网关、审核队列读取、
+/// 拒绝审核与安全下架都不受影响，用于发布事故或回滚窗口期间“关投稿、保在线”。
+/// 开关状态读取失败时按关闭处理，避免绕过运营刚下的收紧动作。
+async fn ensure_publish_enabled(state: &AppState, user_id: Option<&str>) -> Result<(), AppError> {
+    match state
+        .is_game_distribution_publish_enabled_for_user(user_id)
+        .await
+    {
+        Ok(true) => Ok(()),
+        Ok(false) => Err(AppError::from_status(StatusCode::SERVICE_UNAVAILABLE)
+            .with_code("GAME_DISTRIBUTION_PUBLISH_DISABLED")
+            .with_message("游戏发布暂已关闭，已公开游戏仍可继续游玩")),
+        Err(_) => Err(AppError::from_status(StatusCode::SERVICE_UNAVAILABLE)
+            .with_code("GAME_DISTRIBUTION_PUBLISH_DISABLED")
+            .with_message("无法确认游戏发布开关，已按关闭处理")),
+    }
+}
+
+/// 读取当前主体名下的版本；未知版本和别人的版本都按不可见处理（404）。
+async fn load_owner_version_or_404(
+    state: &AppState,
+    owner_user_id: String,
+    version_id: String,
+) -> Result<GameDistributionVersionRecord, AppError> {
+    match state
+        .spacetime_client()
+        .get_owner_game_distribution_version(owner_user_id, version_id)
+        .await
+    {
+        Ok(Some(version)) => Ok(version),
+        Ok(None) => Err(AppError::from_status(StatusCode::NOT_FOUND)),
+        Err(SpacetimeClientError::Procedure(message)) if message.contains("owner 不匹配") => {
+            Err(AppError::from_status(StatusCode::NOT_FOUND))
+        }
+        Err(error) => Err(map_spacetime_error(error)),
+    }
+}
+
+/// 版本私有投影：在通用私有字段上追加客户端恢复动作。
+fn version_detail_payload(
+    version: &GameDistributionVersionRecord,
+    game: &GameDistributionGameRecord,
+) -> Value {
+    let mut payload = private_version_payload(version);
+    if let Value::Object(ref mut object) = payload {
+        object.insert(
+            "recoveryAction".to_string(),
+            Value::String(recovery_action_for_status(version.status.as_str()).to_string()),
+        );
+    }
+    json!({ "game": game_payload(game), "version": payload })
+}
+
+/// 客户端可执行的下一步；状态是唯一事实源，前端不自行推断。
+fn recovery_action_for_status(status: &str) -> &'static str {
+    match status {
+        "awaiting_upload" => "upload",
+        "uploaded" => "submit",
+        "validating" | "pending_review" => "wait",
+        "upload_failed" => "reupload",
+        "validation_failed" => "fix_package",
+        "rejected" => "fix_metadata",
+        _ => "none",
+    }
+}
+
+fn idempotency_key(headers: &HeaderMap) -> Result<String, AppError> {
+    let value = headers
+        .get("idempotency-key")
+        .and_then(|value| value.to_str().ok())
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| bad_request("缺少 Idempotency-Key"))?;
+    if value.chars().count() > MAX_IDEMPOTENCY_KEY_CHARS {
+        return Err(bad_request("Idempotency-Key 过长"));
+    }
+    Ok(value.to_string())
+}
+
+fn normalize_optional(value: Option<String>) -> Option<String> {
+    value
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+fn now_micros() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|value| value.as_micros() as i64)
+        .unwrap_or(0)
+}
+
+fn bad_request(message: impl Into<String>) -> AppError {
+    AppError::from_status(StatusCode::BAD_REQUEST).with_message(message)
+}
+
+fn internal(message: impl Into<String>) -> AppError {
+    AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_message(message)
+}
+
+fn map_package_error(error: ReleasePackageError) -> AppError {
+    AppError::from_status(StatusCode::UNPROCESSABLE_ENTITY)
+        .with_code("PACKAGE_VALIDATION_FAILED")
+        .with_details(json!({ "provider": "game-distribution", "reason": format!("{error:?}") }))
+}
+
+fn map_spacetime_error(error: SpacetimeClientError) -> AppError {
+    match error {
+        SpacetimeClientError::Procedure(message) if message.contains("owner 不匹配") => {
+            AppError::from_status(StatusCode::FORBIDDEN)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
+        SpacetimeClientError::Procedure(message)
+            if message.contains("不存在") || message.contains("已不存在") =>
+        {
+            AppError::from_status(StatusCode::NOT_FOUND)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
+        SpacetimeClientError::Procedure(message)
+            if message.contains("幂等")
+                || message.contains("不匹配")
+                || message.contains("PUBLICATION_CONFLICT")
+                || message.contains("已存在")
+                || message.contains("状态") =>
+        {
+            AppError::from_status(StatusCode::CONFLICT)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
+        SpacetimeClientError::Procedure(message) | SpacetimeClientError::Runtime(message) => {
+            AppError::from_status(StatusCode::BAD_REQUEST)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
+        other => AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+            "provider": "spacetimedb",
+            "message": other.to_string(),
+        })),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use shared_contracts::game_distribution::{
+        GameDistributionDeviceSupport, GameDistributionOrientation,
+    };
+
+    fn metadata() -> GameDistributionCreateGameRequest {
+        GameDistributionCreateGameRequest {
+            local_project_id: None,
+            title: "测试游戏".to_string(),
+            summary: "用于验证发行合同".to_string(),
+            description: Some("描述".to_string()),
+            category: "益智".to_string(),
+            tags: vec!["测试".to_string()],
+            cover_asset_id: None,
+            device_support: GameDistributionDeviceSupport {
+                desktop: true,
+                mobile: false,
+                touch: false,
+            },
+            input_modes: vec![GameDistributionInputMode::Keyboard],
+            orientation: GameDistributionOrientation::Landscape,
+        }
+    }
+
+    #[test]
+    fn metadata_rejects_mobile_games_without_touch_support() {
+        let mut payload = metadata();
+        payload.device_support.mobile = true;
+        assert_eq!(
+            validate_game_metadata(&payload)
+                .expect_err("移动端声明缺少触控应被拒绝")
+                .status_code(),
+            StatusCode::BAD_REQUEST
+        );
+    }
+
+    #[test]
+    fn package_validation_errors_are_unprocessable() {
+        let error = map_package_error(ReleasePackageError::MissingEntry);
+        assert_eq!(error.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
+        assert_eq!(error.code(), "PACKAGE_VALIDATION_FAILED");
+    }
+
+    #[test]
+    fn idempotency_key_requires_a_bounded_non_empty_header() {
+        let mut headers = HeaderMap::new();
+        assert_eq!(
+            idempotency_key(&headers)
+                .expect_err("缺少幂等键应失败")
+                .status_code(),
+            StatusCode::BAD_REQUEST
+        );
+        headers.insert("idempotency-key", "operation-1".parse().unwrap());
+        assert_eq!(idempotency_key(&headers).expect("幂等键"), "operation-1");
+    }
+
+    #[tokio::test]
+    async fn release_gateway_is_mounted_and_never_serves_cookie_bearing_requests() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app = crate::app::build_router(
+            crate::state::AppState::new(crate::config::AppConfig::default())
+                .expect("测试状态应可构建"),
+        );
+        let with_cookie = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/api/game-distribution/releases/game_1/index.html")
+                    .header("cookie", "genarrative.refresh-token=1")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(
+            with_cookie.status(),
+            StatusCode::FORBIDDEN,
+            "带平台 Cookie 的发行请求必须在读对象存储前关闭"
+        );
+
+        // 未在白名单内的扩展名直接 404，不进入 SpacetimeDB 与对象存储。
+        let unknown_extension = app
+            .oneshot(
+                Request::builder()
+                    .uri("/api/game-distribution/releases/game_1/payload.bin")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(unknown_extension.status(), StatusCode::NOT_FOUND);
+    }
+
+    #[tokio::test]
+    async fn catalog_and_publish_routes_are_mounted() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app = crate::app::build_router(
+            crate::state::AppState::new(crate::config::AppConfig::default())
+                .expect("测试状态应可构建"),
+        );
+
+        // 目录路由存在且走到了 SpacetimeDB 调用：测试态没有可用数据库，应是网关错误而不是 404。
+        let catalog = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/api/game-distribution/games")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(catalog.status(), StatusCode::BAD_GATEWAY);
+
+        // 发布写入必须要求登录态，未带 Bearer 时在进入业务前就被拒绝。
+        let unauthenticated_create = app
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/api/game-distribution/games")
+                    .header("content-type", "application/json")
+                    .body(Body::from("{}"))
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(unauthenticated_create.status(), StatusCode::UNAUTHORIZED);
+    }
+
+    #[test]
+    fn recovery_action_covers_every_version_status() {
+        for (status, expected) in [
+            ("awaiting_upload", "upload"),
+            ("uploaded", "submit"),
+            ("validating", "wait"),
+            ("pending_review", "wait"),
+            ("published", "none"),
+            ("upload_failed", "reupload"),
+            ("validation_failed", "fix_package"),
+            ("rejected", "fix_metadata"),
+            ("cancelled", "none"),
+            ("revoked", "none"),
+        ] {
+            assert_eq!(
+                recovery_action_for_status(status),
+                expected,
+                "版本状态 {status} 的恢复动作不正确"
+            );
+        }
+        assert_eq!(recovery_action_for_status("unknown_status"), "none");
+    }
+
+    #[tokio::test]
+    async fn version_readback_and_cancel_routes_are_mounted() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app = crate::app::build_router(
+            crate::state::AppState::new(crate::config::AppConfig::default())
+                .expect("测试状态应可构建"),
+        );
+
+        // 作者回读与撤回都必须要求登录态。
+        let unauthenticated_read = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/api/game-distribution/versions/version_1")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(unauthenticated_read.status(), StatusCode::UNAUTHORIZED);
+
+        let unauthenticated_cancel = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/api/game-distribution/versions/version_1/cancel")
+                    .header("content-type", "application/json")
+                    .body(Body::from("{}"))
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(unauthenticated_cancel.status(), StatusCode::UNAUTHORIZED);
+
+        // 管理员读版本同样先过管理员鉴权，匿名请求不得触达业务。
+        let unauthenticated_admin_read = app
+            .oneshot(
+                Request::builder()
+                    .uri("/admin/api/game-distribution/versions/version_1")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        // 测试态没有可用的管理员鉴权后端，请求必须在进入业务前失败关闭；
+        // 关键是路由已挂载且不会匿名返回业务结果。
+        assert_ne!(
+            unauthenticated_admin_read.status(),
+            StatusCode::NOT_FOUND,
+            "管理员读版本路由未挂载"
+        );
+        assert_ne!(
+            unauthenticated_admin_read.status(),
+            StatusCode::OK,
+            "匿名请求不得读到版本私有状态"
+        );
+    }
+
+    #[test]
+    fn local_project_id_is_a_short_identifier_or_empty() {
+        assert_eq!(normalize_local_project_id(None).expect("空值"), None);
+        assert_eq!(
+            normalize_local_project_id(Some("   ")).expect("空白按空处理"),
+            None
+        );
+        assert_eq!(
+            normalize_local_project_id(Some(" proj-1 ")).expect("合法标识"),
+            Some("proj-1".to_string())
+        );
+        for invalid in ["../escape", "a/b", "a\\b", ".", ".."] {
+            assert_eq!(
+                normalize_local_project_id(Some(invalid))
+                    .expect_err("非法本地项目标识应被拒绝")
+                    .status_code(),
+                StatusCode::BAD_REQUEST,
+                "未拒绝的本地项目标识：{invalid}"
+            );
+        }
+        assert_eq!(
+            normalize_local_project_id(Some(&"x".repeat(129)))
+                .expect_err("超长标识应被拒绝")
+                .status_code(),
+            StatusCode::BAD_REQUEST
+        );
+    }
+
+    #[test]
+    fn approve_requires_credential_free_https_entry_url() {
+        validate_release_entry_url(
+            "https://games.example.test/releases/game_1/index.html",
+            false,
+        )
+        .expect("发行入口");
+        for invalid in [
+            "/releases/game_1/index.html",
+            "http://games.example.test/releases/game_1/index.html",
+            "http://127.0.0.1:10001/releases/game_1/index.html",
+            "https://user:pass@games.example.test/index.html",
+            "https://games.example.test/index.html?token=1",
+            "https://games.example.test/index.html#x",
+        ] {
+            assert_eq!(
+                validate_release_entry_url(invalid, false)
+                    .expect_err("生产环境非法发行入口应被拒绝")
+                    .status_code(),
+                StatusCode::BAD_REQUEST,
+                "未拒绝的发行入口：{invalid}"
+            );
+        }
+    }
+
+    #[test]
+    fn non_production_release_entry_allows_loopback_http_only() {
+        for allowed in [
+            "http://127.0.0.1:10001/api/game-distribution/releases/game_1/index.html",
+            "http://localhost:10001/api/game-distribution/releases/game_1/index.html",
+            "https://games.example.test/releases/game_1/index.html",
+        ] {
+            validate_release_entry_url(allowed, true).expect("非生产环境应接受回环 http");
+        }
+        for invalid in [
+            "http://games.example.test/releases/game_1/index.html",
+            "http://192.168.1.10:10001/index.html",
+            "http://127.0.0.1:10001/index.html?token=1",
+            "http://user:pass@127.0.0.1:10001/index.html",
+        ] {
+            assert_eq!(
+                validate_release_entry_url(invalid, true)
+                    .expect_err("非生产环境也不能放宽回环之外的地址")
+                    .status_code(),
+                StatusCode::BAD_REQUEST,
+                "未拒绝的发行入口：{invalid}"
+            );
+        }
+    }
+
+    #[test]
+    fn release_response_allows_opaque_sandbox_asset_loads() {
+        // 发行文档在 allow-scripts 沙箱里是 opaque origin；CORP same-origin 会让游戏
+        // 自己的脚本被浏览器拦下。
+        let response = release_asset_response(b"x".to_vec(), "text/javascript; charset=utf-8");
+        assert_eq!(
+            response
+                .headers()
+                .get(header::HeaderName::from_static(
+                    "cross-origin-resource-policy"
+                ))
+                .unwrap(),
+            "cross-origin"
+        );
+        assert_eq!(
+            response
+                .headers()
+                .get(header::ACCESS_CONTROL_ALLOW_ORIGIN)
+                .unwrap(),
+            "*"
+        );
+        assert_eq!(
+            response
+                .headers()
+                .get(header::X_CONTENT_TYPE_OPTIONS)
+                .unwrap(),
+            "nosniff"
+        );
+    }
+
+    #[test]
+    fn release_response_sets_nosniff_and_scopes_csp_to_html() {
+        let html = release_asset_response(b"<html></html>".to_vec(), "text/html; charset=utf-8");
+        assert_eq!(
+            html.headers().get(header::X_CONTENT_TYPE_OPTIONS).unwrap(),
+            "nosniff"
+        );
+        assert!(html.headers().contains_key(header::CONTENT_SECURITY_POLICY));
+
+        let image = release_asset_response(vec![1, 2, 3], "image/png");
+        assert_eq!(
+            image.headers().get(header::CONTENT_TYPE).unwrap(),
+            "image/png"
+        );
+        assert!(
+            !image
+                .headers()
+                .contains_key(header::CONTENT_SECURITY_POLICY)
+        );
+    }
+
+    #[test]
+    fn release_package_cache_evicts_by_entry_and_byte_budget() {
+        let mut cache = ReleasePackageCache::default();
+        for index in 0..RELEASE_PACKAGE_CACHE_MAX_ENTRIES {
+            cache.insert(format!("key-{index}"), Arc::new(vec![0_u8; 8]));
+        }
+        assert!(cache.get("key-0").is_some());
+        cache.insert("overflow".to_string(), Arc::new(vec![0_u8; 8]));
+        assert!(cache.get("key-0").is_none(), "最旧条目应被淘汰");
+        assert!(cache.get("overflow").is_some());
+
+        let mut byte_budget = ReleasePackageCache::default();
+        byte_budget.insert_with_limits("big".to_string(), Arc::new(vec![0_u8; 8]), 8, 16);
+        byte_budget.insert_with_limits("second".to_string(), Arc::new(vec![0_u8; 8]), 8, 16);
+        byte_budget.insert_with_limits("third".to_string(), Arc::new(vec![0_u8; 8]), 8, 16);
+        assert!(byte_budget.get("big").is_none(), "超出字节预算时应淘汰旧包");
+        assert_eq!(byte_budget.total_bytes, 16);
+
+        let mut oversized = ReleasePackageCache::default();
+        oversized.insert_with_limits("kept".to_string(), Arc::new(vec![0_u8; 4]), 8, 16);
+        oversized.insert_with_limits("huge".to_string(), Arc::new(vec![0_u8; 17]), 8, 16);
+        assert!(oversized.get("huge").is_none(), "超预算包本身不得进入缓存");
+        assert!(
+            oversized.get("kept").is_some(),
+            "超预算包不应连带淘汰已有条目"
+        );
+        assert_eq!(oversized.total_bytes, 4);
+    }
+}
diff --git a/server-rs/crates/api-server/src/state.rs b/server-rs/crates/api-server/src/state.rs
index 52513b078..51dfa0124 100644
--- a/server-rs/crates/api-server/src/state.rs
+++ b/server-rs/crates/api-server/src/state.rs
@@ -1177,6 +1177,25 @@ impl AppState {
         Ok(module_runtime::is_feature_gate_allowed(gate, &user_context))
     }
 
+    /// 游戏分发写入开关：默认开放，只有运营在灰度配置里显式收紧（白名单/灰度/全关）才拦截。
+    /// 读取、目录、详情、发行网关与安全下架不经过这里。
+    pub async fn is_game_distribution_publish_enabled_for_user(
+        &self,
+        user_id: Option<&str>,
+    ) -> Result<bool, SpacetimeClientError> {
+        let gates = self.get_feature_gate_config().await?;
+        let gate = gates
+            .iter()
+            .find(|item| item.gate_key == module_runtime::GAME_DISTRIBUTION_PUBLISH_GATE_KEY);
+        let user_context = self
+            .feature_gate_user_context(
+                user_id,
+                gate.map(feature_gate_requires_user_tags).unwrap_or(false),
+            )
+            .await;
+        Ok(module_runtime::is_feature_gate_allowed(gate, &user_context))
+    }
+
     pub async fn is_agc_template_library_enabled_for_user(
         &self,
         user_id: Option<&str>,
diff --git a/server-rs/crates/module-game-distribution/Cargo.toml b/server-rs/crates/module-game-distribution/Cargo.toml
new file mode 100644
index 000000000..10fd80369
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "module-game-distribution"
+edition.workspace = true
+version.workspace = true
+license.workspace = true
+
+[dependencies]
+hex = { workspace = true }
+serde = { workspace = true }
+sha2 = { workspace = true }
+shared-kernel = { workspace = true }
+zip = { workspace = true, features = ["deflate"] }
diff --git a/server-rs/crates/module-game-distribution/src/application.rs b/server-rs/crates/module-game-distribution/src/application.rs
new file mode 100644
index 000000000..89276f1e7
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/application.rs
@@ -0,0 +1,1113 @@
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
+
+use crate::{
+    commands::{CreateGameInput, CreateVersionInput, IdempotencyRequest, ReviewDecision},
+    domain::{
+        GameDistributionAction, GameSnapshot, GameVersionSnapshot, GameVersionStatus,
+        GameVisibility, normalize_id,
+    },
+    errors::{GameDistributionError, GameDistributionFieldError},
+};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameOperationResult<T> {
+    pub snapshot: T,
+    pub replayed: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PublicationOperationResult {
+    pub game: GameSnapshot,
+    pub version: GameVersionSnapshot,
+    pub replayed: bool,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct InMemoryGameDistributionStore {
+    inner: Arc<Mutex<GameDistributionState>>,
+}
+
+#[derive(Debug, Default)]
+struct GameDistributionState {
+    games: HashMap<String, GameSnapshot>,
+    versions: HashMap<String, GameVersionSnapshot>,
+    idempotency: HashMap<IdempotencyScope, IdempotencyRecord>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+struct IdempotencyScope {
+    principal_id: String,
+    action: GameDistributionAction,
+    key: String,
+}
+
+#[derive(Clone, Debug)]
+struct IdempotencyRecord {
+    request_digest: String,
+    outcome: StoredOutcome,
+}
+
+#[derive(Clone, Debug)]
+enum StoredOutcome {
+    Game(GameSnapshot),
+    Version(GameVersionSnapshot),
+    Publication {
+        game: GameSnapshot,
+        version: GameVersionSnapshot,
+    },
+}
+
+#[derive(Clone, Debug)]
+pub struct GameDistributionService {
+    store: InMemoryGameDistributionStore,
+}
+
+impl GameDistributionService {
+    pub fn new(store: InMemoryGameDistributionStore) -> Self {
+        Self { store }
+    }
+
+    pub fn store(&self) -> InMemoryGameDistributionStore {
+        self.store.clone()
+    }
+
+    pub fn create_game(
+        &self,
+        input: CreateGameInput,
+    ) -> Result<GameOperationResult<GameSnapshot>, GameDistributionError> {
+        let game_id = required(input.game_id, GameDistributionFieldError::MissingGameId)?;
+        let owner_user_id = required(
+            input.owner_user_id,
+            GameDistributionFieldError::MissingOwnerUserId,
+        )?;
+        let idem = normalize_idempotency(input.idempotency)?;
+        let scope = scope(&owner_user_id, GameDistributionAction::CreateGame, &idem);
+        let mut state = lock(&self.store)?;
+        if let Some(outcome) = replay_outcome(&state, &scope, &idem.request_digest)? {
+            return game_result(outcome, true);
+        }
+        if state.games.contains_key(&game_id) {
+            return Err(GameDistributionError::GameAlreadyExists);
+        }
+        let snapshot = GameSnapshot {
+            game_id: game_id.clone(),
+            owner_user_id,
+            publication_revision: 0,
+            active_version_id: None,
+            visibility: GameVisibility::Unpublished,
+            created_at_micros: input.created_at_micros,
+            updated_at_micros: input.created_at_micros,
+        };
+        state.games.insert(game_id, snapshot.clone());
+        remember(
+            &mut state,
+            scope,
+            idem.request_digest,
+            StoredOutcome::Game(snapshot.clone()),
+        );
+        Ok(GameOperationResult {
+            snapshot,
+            replayed: false,
+        })
+    }
+
+    pub fn create_version(
+        &self,
+        input: CreateVersionInput,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        let game_id = required(input.game_id, GameDistributionFieldError::MissingGameId)?;
+        let owner_user_id = required(
+            input.owner_user_id,
+            GameDistributionFieldError::MissingOwnerUserId,
+        )?;
+        let version_id = required(
+            input.version_id,
+            GameDistributionFieldError::MissingVersionId,
+        )?;
+        let package_sha256 = normalize_package_digest(&input.package_sha256)?;
+        validate_package_bytes(input.package_bytes)?;
+        let idem = normalize_idempotency(input.idempotency)?;
+        let scope = scope(&owner_user_id, GameDistributionAction::CreateVersion, &idem);
+        let mut state = lock(&self.store)?;
+        if let Some(outcome) = replay_outcome(&state, &scope, &idem.request_digest)? {
+            return version_result(outcome, true);
+        }
+        let game = state
+            .games
+            .get(&game_id)
+            .ok_or(GameDistributionError::GameNotFound)?;
+        ensure_owner(game, &owner_user_id)?;
+        if game.visibility == GameVisibility::Suspended {
+            return Err(GameDistributionError::GameSuspended);
+        }
+        if state.versions.contains_key(&version_id) {
+            return Err(GameDistributionError::VersionAlreadyExists);
+        }
+        let version_number = state
+            .versions
+            .values()
+            .filter(|version| version.game_id == game_id)
+            .map(|version| version.version_number)
+            .max()
+            .unwrap_or(0)
+            .saturating_add(1);
+        let snapshot = GameVersionSnapshot {
+            version_id: version_id.clone(),
+            game_id,
+            version_number,
+            package_sha256,
+            package_bytes: input.package_bytes,
+            status: GameVersionStatus::AwaitingUpload,
+            review_reason: None,
+            created_at_micros: input.created_at_micros,
+            updated_at_micros: input.created_at_micros,
+        };
+        state.versions.insert(version_id, snapshot.clone());
+        remember(
+            &mut state,
+            scope,
+            idem.request_digest,
+            StoredOutcome::Version(snapshot.clone()),
+        );
+        Ok(GameOperationResult {
+            snapshot,
+            replayed: false,
+        })
+    }
+
+    pub fn confirm_package(
+        &self,
+        owner_user_id: &str,
+        version_id: &str,
+        package_sha256: &str,
+        package_bytes: u64,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        let owner_user_id = required(
+            owner_user_id.to_string(),
+            GameDistributionFieldError::MissingOwnerUserId,
+        )?;
+        let version_id = required(
+            version_id.to_string(),
+            GameDistributionFieldError::MissingVersionId,
+        )?;
+        let package_sha256 = normalize_package_digest(package_sha256)?;
+        validate_package_bytes(package_bytes)?;
+        let idem = normalize_idempotency(idempotency)?;
+        let scope = scope(
+            &owner_user_id,
+            GameDistributionAction::ConfirmPackage,
+            &idem,
+        );
+        let mut state = lock(&self.store)?;
+        if let Some(outcome) = replay_outcome(&state, &scope, &idem.request_digest)? {
+            return version_result(outcome, true);
+        }
+        let game_id = state
+            .versions
+            .get(&version_id)
+            .ok_or(GameDistributionError::VersionNotFound)?
+            .game_id
+            .clone();
+        let game = state
+            .games
+            .get(&game_id)
+            .ok_or(GameDistributionError::GameNotFound)?;
+        ensure_owner(game, &owner_user_id)?;
+        let version = state
+            .versions
+            .get_mut(&version_id)
+            .ok_or(GameDistributionError::VersionNotFound)?;
+        if version.package_sha256 != package_sha256 || version.package_bytes != package_bytes {
+            return Err(GameDistributionError::PackageMismatch);
+        }
+        if version.status != GameVersionStatus::AwaitingUpload
+            && version.status != GameVersionStatus::UploadFailed
+        {
+            if version.status == GameVersionStatus::Uploaded {
+                let snapshot = version.clone();
+                remember(
+                    &mut state,
+                    scope,
+                    idem.request_digest,
+                    StoredOutcome::Version(snapshot.clone()),
+                );
+                return Ok(GameOperationResult {
+                    snapshot,
+                    replayed: false,
+                });
+            }
+            return Err(invalid_transition(
+                version.status,
+                GameVersionStatus::Uploaded,
+            ));
+        }
+        version.status = GameVersionStatus::Uploaded;
+        version.updated_at_micros = at_micros;
+        let snapshot = version.clone();
+        remember(
+            &mut state,
+            scope,
+            idem.request_digest,
+            StoredOutcome::Version(snapshot.clone()),
+        );
+        Ok(GameOperationResult {
+            snapshot,
+            replayed: false,
+        })
+    }
+
+    pub fn fail_upload(
+        &self,
+        owner_user_id: &str,
+        version_id: &str,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        self.transition_owned_version(
+            owner_user_id,
+            version_id,
+            idempotency,
+            GameDistributionAction::FailUpload,
+            &[GameVersionStatus::AwaitingUpload],
+            GameVersionStatus::UploadFailed,
+            at_micros,
+            None,
+        )
+    }
+
+    pub fn submit_version(
+        &self,
+        owner_user_id: &str,
+        version_id: &str,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        self.transition_owned_version(
+            owner_user_id,
+            version_id,
+            idempotency,
+            GameDistributionAction::SubmitVersion,
+            &[
+                GameVersionStatus::Uploaded,
+                GameVersionStatus::ValidationFailed,
+            ],
+            GameVersionStatus::Validating,
+            at_micros,
+            None,
+        )
+    }
+
+    pub fn pass_validation(
+        &self,
+        owner_user_id: &str,
+        version_id: &str,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        self.transition_owned_version(
+            owner_user_id,
+            version_id,
+            idempotency,
+            GameDistributionAction::PassValidation,
+            &[GameVersionStatus::Validating],
+            GameVersionStatus::PendingReview,
+            at_micros,
+            None,
+        )
+    }
+
+    pub fn fail_validation(
+        &self,
+        owner_user_id: &str,
+        version_id: &str,
+        reason: String,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        let reason = required(reason, GameDistributionFieldError::MissingReviewReason)?;
+        self.transition_owned_version(
+            owner_user_id,
+            version_id,
+            idempotency,
+            GameDistributionAction::FailValidation,
+            &[GameVersionStatus::Validating],
+            GameVersionStatus::ValidationFailed,
+            at_micros,
+            Some(reason),
+        )
+    }
+
+    pub fn cancel_version(
+        &self,
+        owner_user_id: &str,
+        version_id: &str,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        let owner_user_id = required(
+            owner_user_id.to_string(),
+            GameDistributionFieldError::MissingOwnerUserId,
+        )?;
+        let version_id = required(
+            version_id.to_string(),
+            GameDistributionFieldError::MissingVersionId,
+        )?;
+        let idem = normalize_idempotency(idempotency)?;
+        let scope = scope(&owner_user_id, GameDistributionAction::CancelVersion, &idem);
+        let mut state = lock(&self.store)?;
+        if let Some(outcome) = replay_outcome(&state, &scope, &idem.request_digest)? {
+            return version_result(outcome, true);
+        }
+        let game_id = state
+            .versions
+            .get(&version_id)
+            .ok_or(GameDistributionError::VersionNotFound)?
+            .game_id
+            .clone();
+        let game = state
+            .games
+            .get(&game_id)
+            .ok_or(GameDistributionError::GameNotFound)?;
+        ensure_owner(game, &owner_user_id)?;
+        let version = state
+            .versions
+            .get_mut(&version_id)
+            .ok_or(GameDistributionError::VersionNotFound)?;
+        if !version.status.can_cancel() {
+            return Err(invalid_transition(
+                version.status,
+                GameVersionStatus::Cancelled,
+            ));
+        }
+        version.status = GameVersionStatus::Cancelled;
+        version.updated_at_micros = at_micros;
+        let snapshot = version.clone();
+        remember(
+            &mut state,
+            scope,
+            idem.request_digest,
+            StoredOutcome::Version(snapshot.clone()),
+        );
+        Ok(GameOperationResult {
+            snapshot,
+            replayed: false,
+        })
+    }
+
+    pub fn review_version(
+        &self,
+        reviewer_user_id: &str,
+        version_id: &str,
+        decision: ReviewDecision,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<PublicationOperationResult, GameDistributionError> {
+        let reviewer_user_id = required(
+            reviewer_user_id.to_string(),
+            GameDistributionFieldError::MissingActorUserId,
+        )?;
+        let version_id = required(
+            version_id.to_string(),
+            GameDistributionFieldError::MissingVersionId,
+        )?;
+        let idem = normalize_idempotency(idempotency)?;
+        let action = match decision {
+            ReviewDecision::Approve { .. } => GameDistributionAction::ApproveVersion,
+            ReviewDecision::Reject { .. } => GameDistributionAction::RejectVersion,
+        };
+        let scope = scope(&reviewer_user_id, action, &idem);
+        let mut state = lock(&self.store)?;
+        if let Some(outcome) = replay_outcome(&state, &scope, &idem.request_digest)? {
+            return publication_result(outcome, true);
+        }
+        let (expected_revision, reject_reason) = match decision {
+            ReviewDecision::Approve {
+                expected_publication_revision,
+            } => (expected_publication_revision, None),
+            ReviewDecision::Reject {
+                expected_publication_revision,
+                reason,
+            } => (
+                expected_publication_revision,
+                Some(required(
+                    reason,
+                    GameDistributionFieldError::MissingReviewReason,
+                )?),
+            ),
+        };
+        let version = state
+            .versions
+            .get(&version_id)
+            .ok_or(GameDistributionError::VersionNotFound)?
+            .clone();
+        let game = state
+            .games
+            .get(&version.game_id)
+            .ok_or(GameDistributionError::GameNotFound)?
+            .clone();
+        if game.publication_revision != expected_revision {
+            return Err(GameDistributionError::PublicationConflict {
+                expected: expected_revision,
+                actual: game.publication_revision,
+            });
+        }
+        if version.status != GameVersionStatus::PendingReview {
+            return Err(GameDistributionError::ReviewActionNotAllowed);
+        }
+        if game.visibility == GameVisibility::Suspended {
+            return Err(GameDistributionError::GameSuspended);
+        }
+        let mut next_game = game;
+        let mut next_version = version;
+        next_game.publication_revision = next_game.publication_revision.saturating_add(1);
+        next_game.updated_at_micros = at_micros;
+        next_version.updated_at_micros = at_micros;
+        match reject_reason {
+            Some(reason) => {
+                next_version.status = GameVersionStatus::Rejected;
+                next_version.review_reason = Some(reason);
+            }
+            None => {
+                next_version.status = GameVersionStatus::Published;
+                next_version.review_reason = None;
+                next_game.visibility = GameVisibility::Published;
+                next_game.active_version_id = Some(next_version.version_id.clone());
+            }
+        }
+        state
+            .games
+            .insert(next_game.game_id.clone(), next_game.clone());
+        state
+            .versions
+            .insert(next_version.version_id.clone(), next_version.clone());
+        remember(
+            &mut state,
+            scope,
+            idem.request_digest,
+            StoredOutcome::Publication {
+                game: next_game.clone(),
+                version: next_version.clone(),
+            },
+        );
+        Ok(PublicationOperationResult {
+            game: next_game,
+            version: next_version,
+            replayed: false,
+        })
+    }
+
+    pub fn unpublish_game(
+        &self,
+        owner_user_id: &str,
+        game_id: &str,
+        expected_publication_revision: u64,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameSnapshot>, GameDistributionError> {
+        self.mutate_game_visibility(
+            owner_user_id,
+            game_id,
+            expected_publication_revision,
+            idempotency,
+            GameDistributionAction::UnpublishGame,
+            GameVisibility::Unpublished,
+            at_micros,
+        )
+    }
+
+    pub fn suspend_game(
+        &self,
+        actor_user_id: &str,
+        game_id: &str,
+        expected_publication_revision: u64,
+        idempotency: IdempotencyRequest,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameSnapshot>, GameDistributionError> {
+        self.mutate_game_visibility(
+            actor_user_id,
+            game_id,
+            expected_publication_revision,
+            idempotency,
+            GameDistributionAction::SuspendGame,
+            GameVisibility::Suspended,
+            at_micros,
+        )
+    }
+
+    pub fn get_game(&self, game_id: &str) -> Result<GameSnapshot, GameDistributionError> {
+        let game_id = required(
+            game_id.to_string(),
+            GameDistributionFieldError::MissingGameId,
+        )?;
+        let state = lock(&self.store)?;
+        state
+            .games
+            .get(&game_id)
+            .cloned()
+            .ok_or(GameDistributionError::GameNotFound)
+    }
+
+    pub fn get_version(
+        &self,
+        version_id: &str,
+    ) -> Result<GameVersionSnapshot, GameDistributionError> {
+        let version_id = required(
+            version_id.to_string(),
+            GameDistributionFieldError::MissingVersionId,
+        )?;
+        let state = lock(&self.store)?;
+        state
+            .versions
+            .get(&version_id)
+            .cloned()
+            .ok_or(GameDistributionError::VersionNotFound)
+    }
+
+    fn transition_owned_version(
+        &self,
+        owner_user_id: &str,
+        version_id: &str,
+        idempotency: IdempotencyRequest,
+        action: GameDistributionAction,
+        from: &[GameVersionStatus],
+        to: GameVersionStatus,
+        at_micros: i64,
+        reason: Option<String>,
+    ) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+        let owner_user_id = required(
+            owner_user_id.to_string(),
+            GameDistributionFieldError::MissingOwnerUserId,
+        )?;
+        let version_id = required(
+            version_id.to_string(),
+            GameDistributionFieldError::MissingVersionId,
+        )?;
+        let idem = normalize_idempotency(idempotency)?;
+        let scope = scope(&owner_user_id, action, &idem);
+        let mut state = lock(&self.store)?;
+        if let Some(outcome) = replay_outcome(&state, &scope, &idem.request_digest)? {
+            return version_result(outcome, true);
+        }
+        let game_id = state
+            .versions
+            .get(&version_id)
+            .ok_or(GameDistributionError::VersionNotFound)?
+            .game_id
+            .clone();
+        let game = state
+            .games
+            .get(&game_id)
+            .ok_or(GameDistributionError::GameNotFound)?;
+        ensure_owner(game, &owner_user_id)?;
+        let version = state
+            .versions
+            .get_mut(&version_id)
+            .ok_or(GameDistributionError::VersionNotFound)?;
+        if !from.contains(&version.status) {
+            return Err(invalid_transition(version.status, to));
+        }
+        version.status = to;
+        version.review_reason = reason;
+        version.updated_at_micros = at_micros;
+        let snapshot = version.clone();
+        remember(
+            &mut state,
+            scope,
+            idem.request_digest,
+            StoredOutcome::Version(snapshot.clone()),
+        );
+        Ok(GameOperationResult {
+            snapshot,
+            replayed: false,
+        })
+    }
+
+    fn mutate_game_visibility(
+        &self,
+        actor_user_id: &str,
+        game_id: &str,
+        expected_publication_revision: u64,
+        idempotency: IdempotencyRequest,
+        action: GameDistributionAction,
+        visibility: GameVisibility,
+        at_micros: i64,
+    ) -> Result<GameOperationResult<GameSnapshot>, GameDistributionError> {
+        let actor_user_id = required(
+            actor_user_id.to_string(),
+            GameDistributionFieldError::MissingActorUserId,
+        )?;
+        let game_id = required(
+            game_id.to_string(),
+            GameDistributionFieldError::MissingGameId,
+        )?;
+        let idem = normalize_idempotency(idempotency)?;
+        let scope = scope(&actor_user_id, action, &idem);
+        let mut state = lock(&self.store)?;
+        if let Some(outcome) = replay_outcome(&state, &scope, &idem.request_digest)? {
+            return game_result(outcome, true);
+        }
+        let game = state
+            .games
+            .get(&game_id)
+            .ok_or(GameDistributionError::GameNotFound)?
+            .clone();
+        if action == GameDistributionAction::UnpublishGame {
+            ensure_owner(&game, &actor_user_id)?;
+            if game.visibility != GameVisibility::Published {
+                return Err(GameDistributionError::GameNotPublished);
+            }
+        }
+        if game.publication_revision != expected_publication_revision {
+            return Err(GameDistributionError::PublicationConflict {
+                expected: expected_publication_revision,
+                actual: game.publication_revision,
+            });
+        }
+        if action == GameDistributionAction::SuspendGame
+            && game.visibility == GameVisibility::Suspended
+        {
+            return Err(GameDistributionError::GameSuspended);
+        }
+        let active_version_id = game.active_version_id.clone();
+        let mut next_game = game;
+        next_game.visibility = visibility;
+        next_game.publication_revision = next_game.publication_revision.saturating_add(1);
+        next_game.updated_at_micros = at_micros;
+        if visibility == GameVisibility::Unpublished {
+            next_game.active_version_id = None;
+            if let Some(version_id) = active_version_id {
+                if let Some(version) = state.versions.get_mut(&version_id) {
+                    if version.status == GameVersionStatus::Published {
+                        version.status = GameVersionStatus::Revoked;
+                        version.updated_at_micros = at_micros;
+                    }
+                }
+            }
+        }
+        state
+            .games
+            .insert(next_game.game_id.clone(), next_game.clone());
+        remember(
+            &mut state,
+            scope,
+            idem.request_digest,
+            StoredOutcome::Game(next_game.clone()),
+        );
+        Ok(GameOperationResult {
+            snapshot: next_game,
+            replayed: false,
+        })
+    }
+}
+
+fn required(
+    value: String,
+    error: GameDistributionFieldError,
+) -> Result<String, GameDistributionError> {
+    normalize_id(value).ok_or(GameDistributionError::Field(error))
+}
+
+fn normalize_idempotency(
+    value: IdempotencyRequest,
+) -> Result<IdempotencyRequest, GameDistributionError> {
+    value.validate().map_err(GameDistributionError::Field)?;
+    Ok(IdempotencyRequest {
+        key: normalize_id(value.key).ok_or(GameDistributionError::Field(
+            GameDistributionFieldError::MissingIdempotencyKey,
+        ))?,
+        request_digest: normalize_id(value.request_digest).ok_or(GameDistributionError::Field(
+            GameDistributionFieldError::MissingRequestDigest,
+        ))?,
+    })
+}
+
+fn normalize_package_digest(value: &str) -> Result<String, GameDistributionError> {
+    let normalized = value.trim().to_ascii_lowercase();
+    if normalized.len() != 64 || !normalized.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+        return Err(GameDistributionError::Field(
+            GameDistributionFieldError::InvalidPackageDigest,
+        ));
+    }
+    Ok(normalized)
+}
+
+fn validate_package_bytes(value: u64) -> Result<(), GameDistributionError> {
+    if value == 0 {
+        Err(GameDistributionError::Field(
+            GameDistributionFieldError::InvalidPackageBytes,
+        ))
+    } else {
+        Ok(())
+    }
+}
+
+fn scope(
+    principal_id: &str,
+    action: GameDistributionAction,
+    idem: &IdempotencyRequest,
+) -> IdempotencyScope {
+    IdempotencyScope {
+        principal_id: principal_id.to_string(),
+        action,
+        key: idem.key.clone(),
+    }
+}
+
+fn lock(
+    store: &InMemoryGameDistributionStore,
+) -> Result<std::sync::MutexGuard<'_, GameDistributionState>, GameDistributionError> {
+    store
+        .inner
+        .lock()
+        .map_err(|_| GameDistributionError::IdempotencyOutcomeMismatch)
+}
+
+fn replay_outcome(
+    state: &GameDistributionState,
+    scope: &IdempotencyScope,
+    request_digest: &str,
+) -> Result<Option<StoredOutcome>, GameDistributionError> {
+    let Some(record) = state.idempotency.get(scope) else {
+        return Ok(None);
+    };
+    if record.request_digest != request_digest {
+        return Err(GameDistributionError::IdempotencyConflict);
+    }
+    Ok(Some(record.outcome.clone()))
+}
+
+fn remember(
+    state: &mut GameDistributionState,
+    scope: IdempotencyScope,
+    request_digest: String,
+    outcome: StoredOutcome,
+) {
+    state.idempotency.insert(
+        scope,
+        IdempotencyRecord {
+            request_digest,
+            outcome,
+        },
+    );
+}
+
+fn game_result(
+    outcome: StoredOutcome,
+    replayed: bool,
+) -> Result<GameOperationResult<GameSnapshot>, GameDistributionError> {
+    match outcome {
+        StoredOutcome::Game(snapshot) => Ok(GameOperationResult { snapshot, replayed }),
+        _ => Err(GameDistributionError::IdempotencyOutcomeMismatch),
+    }
+}
+
+fn version_result(
+    outcome: StoredOutcome,
+    replayed: bool,
+) -> Result<GameOperationResult<GameVersionSnapshot>, GameDistributionError> {
+    match outcome {
+        StoredOutcome::Version(snapshot) => Ok(GameOperationResult { snapshot, replayed }),
+        _ => Err(GameDistributionError::IdempotencyOutcomeMismatch),
+    }
+}
+
+fn publication_result(
+    outcome: StoredOutcome,
+    replayed: bool,
+) -> Result<PublicationOperationResult, GameDistributionError> {
+    match outcome {
+        StoredOutcome::Publication { game, version } => Ok(PublicationOperationResult {
+            game,
+            version,
+            replayed,
+        }),
+        _ => Err(GameDistributionError::IdempotencyOutcomeMismatch),
+    }
+}
+
+fn ensure_owner(game: &GameSnapshot, owner_user_id: &str) -> Result<(), GameDistributionError> {
+    if game.owner_user_id == owner_user_id {
+        Ok(())
+    } else {
+        Err(GameDistributionError::Forbidden)
+    }
+}
+
+fn invalid_transition(from: GameVersionStatus, to: GameVersionStatus) -> GameDistributionError {
+    GameDistributionError::InvalidVersionTransition { from, to }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        CreateGameInput, CreateVersionInput, IdempotencyRequest, ReviewDecision,
+        compute_request_digest,
+    };
+
+    fn idem(key: &str, body: &str) -> IdempotencyRequest {
+        IdempotencyRequest {
+            key: key.to_string(),
+            request_digest: compute_request_digest(body),
+        }
+    }
+
+    fn service() -> GameDistributionService {
+        GameDistributionService::new(InMemoryGameDistributionStore::default())
+    }
+
+    fn create_game(service: &GameDistributionService) -> GameSnapshot {
+        service
+            .create_game(CreateGameInput {
+                game_id: "game-1".to_string(),
+                owner_user_id: "owner-1".to_string(),
+                idempotency: idem("create-game-1", "game-1"),
+                created_at_micros: 1,
+            })
+            .expect("game should be created")
+            .snapshot
+    }
+
+    fn create_version(service: &GameDistributionService) -> GameVersionSnapshot {
+        create_game(service);
+        service
+            .create_version(CreateVersionInput {
+                game_id: "game-1".to_string(),
+                owner_user_id: "owner-1".to_string(),
+                version_id: "version-1".to_string(),
+                package_sha256: "a".repeat(64),
+                package_bytes: 42,
+                idempotency: idem("create-version-1", "version-1"),
+                created_at_micros: 2,
+            })
+            .expect("version should be created")
+            .snapshot
+    }
+
+    #[test]
+    fn idempotency_replays_same_snapshot_and_rejects_digest_conflict() {
+        let service = service();
+        let first = service
+            .create_game(CreateGameInput {
+                game_id: "game-1".to_string(),
+                owner_user_id: "owner-1".to_string(),
+                idempotency: idem("same-key", "first"),
+                created_at_micros: 1,
+            })
+            .expect("first create should succeed");
+        let replay = service
+            .create_game(CreateGameInput {
+                game_id: "game-2".to_string(),
+                owner_user_id: "owner-1".to_string(),
+                idempotency: idem("same-key", "first"),
+                created_at_micros: 99,
+            })
+            .expect("same request should replay");
+        assert!(replay.replayed);
+        assert_eq!(replay.snapshot, first.snapshot);
+        let conflict = service
+            .create_game(CreateGameInput {
+                game_id: "game-3".to_string(),
+                owner_user_id: "owner-1".to_string(),
+                idempotency: idem("same-key", "different"),
+                created_at_micros: 3,
+            })
+            .expect_err("same key with another digest must fail");
+        assert_eq!(conflict, GameDistributionError::IdempotencyConflict);
+    }
+
+    #[test]
+    fn owner_is_required_for_version_and_package_mutations() {
+        let service = service();
+        create_version(&service);
+        let error = service
+            .confirm_package(
+                "other-owner",
+                "version-1",
+                &"a".repeat(64),
+                42,
+                idem("upload-1", "upload"),
+                3,
+            )
+            .expect_err("other owner must be denied");
+        assert_eq!(error, GameDistributionError::Forbidden);
+    }
+
+    #[test]
+    fn version_state_machine_reaches_pending_review_only_after_package_validation() {
+        let service = service();
+        create_version(&service);
+        let invalid = service
+            .pass_validation(
+                "owner-1",
+                "version-1",
+                idem("pass-before-submit", "pass"),
+                3,
+            )
+            .expect_err("validation cannot start before upload");
+        assert_eq!(
+            invalid,
+            GameDistributionError::InvalidVersionTransition {
+                from: GameVersionStatus::AwaitingUpload,
+                to: GameVersionStatus::PendingReview
+            }
+        );
+        service
+            .confirm_package(
+                "owner-1",
+                "version-1",
+                &"a".repeat(64),
+                42,
+                idem("upload-1", "upload"),
+                3,
+            )
+            .expect("upload should succeed");
+        service
+            .submit_version("owner-1", "version-1", idem("submit-1", "submit"), 4)
+            .expect("submit should start validation");
+        let pending = service
+            .pass_validation("owner-1", "version-1", idem("pass-1", "pass"), 5)
+            .expect("validation should pass");
+        assert_eq!(pending.snapshot.status, GameVersionStatus::PendingReview);
+    }
+
+    #[test]
+    fn validation_failure_can_retry_same_confirmed_package() {
+        let service = service();
+        create_version(&service);
+        service
+            .confirm_package(
+                "owner-1",
+                "version-1",
+                &"a".repeat(64),
+                42,
+                idem("upload-1", "upload"),
+                3,
+            )
+            .expect("upload should succeed");
+        service
+            .submit_version("owner-1", "version-1", idem("submit-1", "submit"), 4)
+            .expect("submit should start validation");
+        service
+            .fail_validation(
+                "owner-1",
+                "version-1",
+                "校验器暂时失败".to_string(),
+                idem("fail-validation-1", "fail"),
+                5,
+            )
+            .expect("validation failure should be recorded");
+        let retried = service
+            .submit_version("owner-1", "version-1", idem("submit-2", "retry"), 6)
+            .expect("same confirmed package should be retryable");
+        assert_eq!(retried.snapshot.status, GameVersionStatus::Validating);
+    }
+
+    #[test]
+    fn publication_cas_rejects_stale_review_and_unpublish() {
+        let service = service();
+        create_version(&service);
+        service
+            .confirm_package(
+                "owner-1",
+                "version-1",
+                &"a".repeat(64),
+                42,
+                idem("upload-1", "upload"),
+                3,
+            )
+            .expect("upload should succeed");
+        service
+            .submit_version("owner-1", "version-1", idem("submit-1", "submit"), 4)
+            .expect("submit should start validation");
+        service
+            .pass_validation("owner-1", "version-1", idem("pass-1", "pass"), 5)
+            .expect("validation should pass");
+        let published = service
+            .review_version(
+                "reviewer-1",
+                "version-1",
+                ReviewDecision::Approve {
+                    expected_publication_revision: 0,
+                },
+                idem("review-1", "approve"),
+                6,
+            )
+            .expect("review should publish");
+        assert_eq!(published.game.publication_revision, 1);
+        assert_eq!(published.game.visibility, GameVisibility::Published);
+        let stale = service
+            .unpublish_game(
+                "owner-1",
+                "game-1",
+                0,
+                idem("unpublish-stale", "unpublish"),
+                7,
+            )
+            .expect_err("stale publication revision must fail");
+        assert_eq!(
+            stale,
+            GameDistributionError::PublicationConflict {
+                expected: 0,
+                actual: 1
+            }
+        );
+        let unpublished = service
+            .unpublish_game("owner-1", "game-1", 1, idem("unpublish-1", "unpublish"), 8)
+            .expect("current revision should unpublish");
+        assert_eq!(unpublished.snapshot.visibility, GameVisibility::Unpublished);
+        assert_eq!(
+            service
+                .get_version("version-1")
+                .expect("version should exist")
+                .status,
+            GameVersionStatus::Revoked
+        );
+    }
+
+    #[test]
+    fn rejected_review_preserves_reason_and_advances_publication_revision() {
+        let service = service();
+        create_version(&service);
+        service
+            .confirm_package(
+                "owner-1",
+                "version-1",
+                &"a".repeat(64),
+                42,
+                idem("upload-1", "upload"),
+                3,
+            )
+            .expect("upload should succeed");
+        service
+            .submit_version("owner-1", "version-1", idem("submit-1", "submit"), 4)
+            .expect("submit should start validation");
+        service
+            .pass_validation("owner-1", "version-1", idem("pass-1", "pass"), 5)
+            .expect("validation should pass");
+        let rejected = service
+            .review_version(
+                "reviewer-1",
+                "version-1",
+                ReviewDecision::Reject {
+                    expected_publication_revision: 0,
+                    reason: "需要修复资源".to_string(),
+                },
+                idem("review-1", "reject"),
+                6,
+            )
+            .expect("review rejection should succeed");
+        assert_eq!(rejected.version.status, GameVersionStatus::Rejected);
+        assert_eq!(
+            rejected.version.review_reason.as_deref(),
+            Some("需要修复资源")
+        );
+        assert_eq!(rejected.game.publication_revision, 1);
+        assert_eq!(rejected.game.visibility, GameVisibility::Unpublished);
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/commands.rs b/server-rs/crates/module-game-distribution/src/commands.rs
new file mode 100644
index 000000000..0cd47fb43
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/commands.rs
@@ -0,0 +1,52 @@
+use serde::{Deserialize, Serialize};
+
+use crate::domain::normalize_id;
+use crate::errors::GameDistributionFieldError;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct IdempotencyRequest {
+    pub key: String,
+    pub request_digest: String,
+}
+
+impl IdempotencyRequest {
+    pub fn validate(&self) -> Result<(), GameDistributionFieldError> {
+        if normalize_id(&self.key).is_none() {
+            return Err(GameDistributionFieldError::MissingIdempotencyKey);
+        }
+        if normalize_id(&self.request_digest).is_none() {
+            return Err(GameDistributionFieldError::MissingRequestDigest);
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CreateGameInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub idempotency: IdempotencyRequest,
+    pub created_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CreateVersionInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_id: String,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub idempotency: IdempotencyRequest,
+    pub created_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ReviewDecision {
+    Approve {
+        expected_publication_revision: u64,
+    },
+    Reject {
+        expected_publication_revision: u64,
+        reason: String,
+    },
+}
diff --git a/server-rs/crates/module-game-distribution/src/domain.rs b/server-rs/crates/module-game-distribution/src/domain.rs
new file mode 100644
index 000000000..4607a2013
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/domain.rs
@@ -0,0 +1,115 @@
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+use shared_kernel::{build_prefixed_seed_id, normalize_required_string};
+
+pub const GAME_ID_PREFIX: &str = "game_";
+pub const GAME_VERSION_ID_PREFIX: &str = "gamever_";
+
+pub fn generate_game_id(seed_micros: i64) -> String {
+    build_prefixed_seed_id(GAME_ID_PREFIX, seed_micros)
+}
+
+pub fn generate_game_version_id(seed_micros: i64, version_number: u64) -> String {
+    format!(
+        "{}{seed_micros:x}_{version_number:x}",
+        GAME_VERSION_ID_PREFIX
+    )
+}
+
+/// Computes the lowercase SHA-256 digest used by the idempotency contract.
+pub fn compute_request_digest(payload: impl AsRef<[u8]>) -> String {
+    let digest = Sha256::digest(payload.as_ref());
+    hex::encode(digest)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum GameVisibility {
+    Unpublished,
+    Published,
+    Suspended,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum GameVersionStatus {
+    AwaitingUpload,
+    Uploaded,
+    Validating,
+    PendingReview,
+    Published,
+    UploadFailed,
+    ValidationFailed,
+    Rejected,
+    Cancelled,
+    Revoked,
+}
+
+impl GameVersionStatus {
+    pub fn is_terminal(self) -> bool {
+        matches!(
+            self,
+            Self::Published
+                | Self::UploadFailed
+                | Self::ValidationFailed
+                | Self::Rejected
+                | Self::Cancelled
+                | Self::Revoked
+        )
+    }
+
+    pub fn can_cancel(self) -> bool {
+        matches!(
+            self,
+            Self::AwaitingUpload
+                | Self::Uploaded
+                | Self::Validating
+                | Self::PendingReview
+                | Self::UploadFailed
+                | Self::ValidationFailed
+        )
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GameSnapshot {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub publication_revision: u64,
+    pub active_version_id: Option<String>,
+    pub visibility: GameVisibility,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GameVersionSnapshot {
+    pub version_id: String,
+    pub game_id: String,
+    pub version_number: u64,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub status: GameVersionStatus,
+    pub review_reason: Option<String>,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum GameDistributionAction {
+    CreateGame,
+    CreateVersion,
+    ConfirmPackage,
+    FailUpload,
+    SubmitVersion,
+    PassValidation,
+    FailValidation,
+    CancelVersion,
+    ApproveVersion,
+    RejectVersion,
+    UnpublishGame,
+    SuspendGame,
+}
+
+pub(crate) fn normalize_id(value: impl AsRef<str>) -> Option<String> {
+    normalize_required_string(value)
+}
diff --git a/server-rs/crates/module-game-distribution/src/errors.rs b/server-rs/crates/module-game-distribution/src/errors.rs
new file mode 100644
index 000000000..e3cb17a65
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/errors.rs
@@ -0,0 +1,105 @@
+use std::{error::Error, fmt};
+
+use crate::{GameVersionStatus, GameVisibility};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum GameDistributionFieldError {
+    MissingGameId,
+    MissingVersionId,
+    MissingOwnerUserId,
+    MissingActorUserId,
+    MissingIdempotencyKey,
+    MissingRequestDigest,
+    InvalidPackageDigest,
+    InvalidPackageBytes,
+    MissingReviewReason,
+}
+
+impl fmt::Display for GameDistributionFieldError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let message = match self {
+            Self::MissingGameId => "gameId 不能为空",
+            Self::MissingVersionId => "versionId 不能为空",
+            Self::MissingOwnerUserId => "ownerUserId 不能为空",
+            Self::MissingActorUserId => "actorUserId 不能为空",
+            Self::MissingIdempotencyKey => "Idempotency-Key 不能为空",
+            Self::MissingRequestDigest => "request digest 不能为空",
+            Self::InvalidPackageDigest => "packageSha256 必须是 64 位十六进制摘要",
+            Self::InvalidPackageBytes => "packageBytes 必须大于 0",
+            Self::MissingReviewReason => "拒绝审核必须提供理由",
+        };
+        formatter.write_str(message)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum GameDistributionError {
+    Field(GameDistributionFieldError),
+    GameNotFound,
+    VersionNotFound,
+    GameAlreadyExists,
+    VersionAlreadyExists,
+    Forbidden,
+    IdempotencyConflict,
+    IdempotencyOutcomeMismatch,
+    InvalidVersionTransition {
+        from: GameVersionStatus,
+        to: GameVersionStatus,
+    },
+    PublicationConflict {
+        expected: u64,
+        actual: u64,
+    },
+    PackageMismatch,
+    GameSuspended,
+    GameNotPublished,
+    VersionNotPublished,
+    VersionAlreadyPublished,
+    ReviewActionNotAllowed,
+}
+
+impl fmt::Display for GameDistributionError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Field(field) => field.fmt(formatter),
+            Self::GameNotFound => formatter.write_str("游戏不存在"),
+            Self::VersionNotFound => formatter.write_str("游戏版本不存在"),
+            Self::GameAlreadyExists => formatter.write_str("游戏已存在"),
+            Self::VersionAlreadyExists => formatter.write_str("游戏版本已存在"),
+            Self::Forbidden => formatter.write_str("无权操作该游戏"),
+            Self::IdempotencyConflict => formatter.write_str("幂等键对应的请求摘要不一致"),
+            Self::IdempotencyOutcomeMismatch => formatter.write_str("幂等记录结果类型不一致"),
+            Self::InvalidVersionTransition { from, to } => {
+                write!(formatter, "版本状态不能从 {from:?} 变为 {to:?}")
+            }
+            Self::PublicationConflict { expected, actual } => {
+                write!(
+                    formatter,
+                    "公开状态版本冲突：期望 {expected}，实际 {actual}"
+                )
+            }
+            Self::PackageMismatch => formatter.write_str("发行包摘要或字节数与版本声明不一致"),
+            Self::GameSuspended => formatter.write_str("游戏已被管理员下架"),
+            Self::GameNotPublished => formatter.write_str("游戏当前未公开"),
+            Self::VersionNotPublished => formatter.write_str("游戏版本当前未公开"),
+            Self::VersionAlreadyPublished => formatter.write_str("游戏版本已经公开"),
+            Self::ReviewActionNotAllowed => formatter.write_str("当前版本不允许审核操作"),
+        }
+    }
+}
+
+impl Error for GameDistributionError {}
+
+impl From<GameDistributionFieldError> for GameDistributionError {
+    fn from(value: GameDistributionFieldError) -> Self {
+        Self::Field(value)
+    }
+}
+
+#[allow(dead_code)]
+fn _visibility_is_exhaustive(visibility: GameVisibility) -> bool {
+    matches!(
+        visibility,
+        GameVisibility::Unpublished | GameVisibility::Published | GameVisibility::Suspended
+    )
+}
diff --git a/server-rs/crates/module-game-distribution/src/events.rs b/server-rs/crates/module-game-distribution/src/events.rs
new file mode 100644
index 000000000..eebdb8406
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/events.rs
@@ -0,0 +1,21 @@
+//! 游戏分发领域事件类型预留。
+//!
+//! 当前阶段的持久化 procedure 直接返回版本/游戏快照；审核和公开切换事件在
+//! 后续人工审核里程碑接入事件审计前，先保留明确的领域落位，避免把事件规则
+//! 下沉到 api-server。
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum GameDistributionEvent {
+    GameCreated {
+        game_id: String,
+        owner_user_id: String,
+    },
+    VersionCreated {
+        game_id: String,
+        version_id: String,
+    },
+    PackageConfirmed {
+        version_id: String,
+        package_sha256: String,
+    },
+}
diff --git a/server-rs/crates/module-game-distribution/src/lib.rs b/server-rs/crates/module-game-distribution/src/lib.rs
new file mode 100644
index 000000000..15b9d726e
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/lib.rs
@@ -0,0 +1,27 @@
+mod application;
+mod commands;
+mod domain;
+mod errors;
+mod events;
+mod package;
+mod release;
+
+pub use application::{
+    GameDistributionService, GameOperationResult, InMemoryGameDistributionStore,
+    PublicationOperationResult,
+};
+pub use commands::{CreateGameInput, CreateVersionInput, IdempotencyRequest, ReviewDecision};
+pub use domain::{
+    GameDistributionAction, GameSnapshot, GameVersionSnapshot, GameVersionStatus, GameVisibility,
+    compute_request_digest, generate_game_id, generate_game_version_id,
+};
+pub use errors::{GameDistributionError, GameDistributionFieldError};
+pub use events::GameDistributionEvent;
+pub use package::{
+    MAX_COMPRESSION_RATIO, MAX_EXPANDED_BYTES, MAX_FILE_BYTES, MAX_FILE_COUNT, MAX_PACKAGE_BYTES,
+    ReleaseFileManifest, ReleasePackageError, ReleasePackageManifest, validate_release_zip,
+};
+pub use release::{
+    MAX_RELEASE_ASSET_BYTES, ReleaseAssetError, extract_release_asset,
+    normalize_release_asset_path, release_asset_content_type,
+};
diff --git a/server-rs/crates/module-game-distribution/src/package.rs b/server-rs/crates/module-game-distribution/src/package.rs
new file mode 100644
index 000000000..5e8faf9f5
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/package.rs
@@ -0,0 +1,225 @@
+use std::{
+    collections::HashSet,
+    io::{Cursor, Read},
+    path::Path,
+};
+
+use sha2::{Digest, Sha256};
+
+pub const MAX_PACKAGE_BYTES: u64 = 100 * 1024 * 1024;
+pub const MAX_EXPANDED_BYTES: u64 = 250 * 1024 * 1024;
+pub const MAX_FILE_BYTES: u64 = 64 * 1024 * 1024;
+pub const MAX_FILE_COUNT: usize = 10_000;
+pub const MAX_COMPRESSION_RATIO: u64 = 100;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ReleaseFileManifest {
+    pub path: String,
+    pub size_bytes: u64,
+    pub sha256: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ReleasePackageManifest {
+    pub package_bytes: u64,
+    pub package_sha256: String,
+    pub files: Vec<ReleaseFileManifest>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ReleasePackageError {
+    EmptyPackage,
+    PackageTooLarge,
+    InvalidArchive,
+    MissingEntry,
+    TooManyFiles,
+    InvalidPath,
+    SymlinkNotAllowed,
+    EncryptedFileNotAllowed,
+    SensitiveFileNotAllowed,
+    NestedArchiveNotAllowed,
+    FileTooLarge,
+    ExpandedPackageTooLarge,
+    CompressionRatioTooHigh,
+    ReadFailed,
+}
+
+pub fn validate_release_zip(bytes: &[u8]) -> Result<ReleasePackageManifest, ReleasePackageError> {
+    if bytes.is_empty() {
+        return Err(ReleasePackageError::EmptyPackage);
+    }
+    let package_bytes = u64::try_from(bytes.len()).unwrap_or(u64::MAX);
+    if package_bytes > MAX_PACKAGE_BYTES {
+        return Err(ReleasePackageError::PackageTooLarge);
+    }
+
+    let mut archive = zip::ZipArchive::new(Cursor::new(bytes))
+        .map_err(|_| ReleasePackageError::InvalidArchive)?;
+    if archive.len() > MAX_FILE_COUNT {
+        return Err(ReleasePackageError::TooManyFiles);
+    }
+
+    let mut paths = HashSet::with_capacity(archive.len());
+    let mut case_folded_paths = HashSet::with_capacity(archive.len());
+    let mut files = Vec::with_capacity(archive.len());
+    let mut expanded_bytes = 0_u64;
+    let mut has_entry = false;
+    for index in 0..archive.len() {
+        let mut file = archive
+            .by_index(index)
+            .map_err(|_| ReleasePackageError::InvalidArchive)?;
+        if file.encrypted() {
+            return Err(ReleasePackageError::EncryptedFileNotAllowed);
+        }
+        if file.is_symlink() {
+            return Err(ReleasePackageError::SymlinkNotAllowed);
+        }
+        let path = file
+            .enclosed_name()
+            .ok_or(ReleasePackageError::InvalidPath)?;
+        let path = normalize_archive_path(&path)?;
+        if !paths.insert(path.clone()) || !case_folded_paths.insert(path.to_ascii_lowercase()) {
+            return Err(ReleasePackageError::InvalidPath);
+        }
+        if path == "index.html" {
+            has_entry = true;
+        }
+        if is_sensitive_path(&path) {
+            return Err(ReleasePackageError::SensitiveFileNotAllowed);
+        }
+        if path.to_ascii_lowercase().ends_with(".zip") {
+            return Err(ReleasePackageError::NestedArchiveNotAllowed);
+        }
+        if file.is_dir() {
+            continue;
+        }
+        let declared_size = file.size();
+        if declared_size > MAX_FILE_BYTES {
+            return Err(ReleasePackageError::FileTooLarge);
+        }
+        expanded_bytes = expanded_bytes.saturating_add(declared_size);
+        if expanded_bytes > MAX_EXPANDED_BYTES {
+            return Err(ReleasePackageError::ExpandedPackageTooLarge);
+        }
+        if declared_size > package_bytes.saturating_mul(MAX_COMPRESSION_RATIO) {
+            return Err(ReleasePackageError::CompressionRatioTooHigh);
+        }
+
+        let mut content = Vec::with_capacity(usize::try_from(declared_size).unwrap_or(0));
+        file.read_to_end(&mut content)
+            .map_err(|_| ReleasePackageError::ReadFailed)?;
+        if u64::try_from(content.len()).unwrap_or(u64::MAX) != declared_size {
+            return Err(ReleasePackageError::ReadFailed);
+        }
+        let digest = Sha256::digest(&content);
+        files.push(ReleaseFileManifest {
+            path,
+            size_bytes: declared_size,
+            sha256: hex::encode(digest),
+        });
+    }
+    if !has_entry {
+        return Err(ReleasePackageError::MissingEntry);
+    }
+
+    let package_digest = Sha256::digest(bytes);
+    Ok(ReleasePackageManifest {
+        package_bytes,
+        package_sha256: hex::encode(package_digest),
+        files,
+    })
+}
+
+pub(crate) fn normalize_archive_path(path: &Path) -> Result<String, ReleasePackageError> {
+    let path = path
+        .to_str()
+        .ok_or(ReleasePackageError::InvalidPath)?
+        .trim_end_matches('/');
+    if path.is_empty() || path.contains('\\') || path.starts_with('/') {
+        return Err(ReleasePackageError::InvalidPath);
+    }
+    let mut parts = Vec::new();
+    for part in path.split('/') {
+        if part.is_empty()
+            || part == "."
+            || part == ".."
+            || part.ends_with(' ')
+            || part.ends_with('.')
+            || part
+                .chars()
+                .any(|character| matches!(character, ':' | '<' | '>' | '"' | '|' | '?' | '*'))
+        {
+            return Err(ReleasePackageError::InvalidPath);
+        }
+        parts.push(part);
+    }
+    Ok(parts.join("/"))
+}
+
+fn is_sensitive_path(path: &str) -> bool {
+    path.split('/').any(|part| {
+        matches!(part, ".git" | ".agent" | "node_modules")
+            || part.starts_with(".env")
+            || part.ends_with(".map")
+            || part.ends_with(".pem")
+            || part.ends_with(".key")
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Write;
+
+    use zip::{ZipWriter, write::SimpleFileOptions};
+
+    use super::*;
+
+    fn archive(files: &[(&str, &[u8])]) -> Vec<u8> {
+        let mut output = Cursor::new(Vec::new());
+        let mut writer = ZipWriter::new(&mut output);
+        for (path, content) in files {
+            writer
+                .start_file(*path, SimpleFileOptions::default())
+                .expect("zip entry");
+            writer.write_all(content).expect("zip content");
+        }
+        writer.finish().expect("finish zip");
+        output.into_inner()
+    }
+
+    #[test]
+    fn accepts_root_entry_and_returns_file_manifest() {
+        let bytes = archive(&[("index.html", b"<html></html>"), ("assets/a.txt", b"a")]);
+        let manifest = validate_release_zip(&bytes).expect("valid archive");
+        assert_eq!(manifest.files.len(), 2);
+        assert_eq!(manifest.files[0].path, "index.html");
+    }
+
+    #[test]
+    fn rejects_missing_entry_sensitive_and_traversal_paths() {
+        let missing = archive(&[("game.html", b"x")]);
+        assert_eq!(
+            validate_release_zip(&missing),
+            Err(ReleasePackageError::MissingEntry)
+        );
+        let sensitive = archive(&[("index.html", b"x"), (".env", b"secret")]);
+        assert_eq!(
+            validate_release_zip(&sensitive),
+            Err(ReleasePackageError::SensitiveFileNotAllowed)
+        );
+        let traversal = archive(&[("index.html", b"x"), ("../escape.txt", b"x")]);
+        assert_eq!(
+            validate_release_zip(&traversal),
+            Err(ReleasePackageError::InvalidPath)
+        );
+        let case_collision = archive(&[
+            ("index.html", b"x"),
+            ("ASSETS/a.txt", b"x"),
+            ("assets/A.txt", b"x"),
+        ]);
+        assert_eq!(
+            validate_release_zip(&case_collision),
+            Err(ReleasePackageError::InvalidPath)
+        );
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/release.rs b/server-rs/crates/module-game-distribution/src/release.rs
new file mode 100644
index 000000000..4cfdd7d29
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/release.rs
@@ -0,0 +1,179 @@
+use std::io::{Cursor, Read};
+
+use crate::package::{MAX_FILE_BYTES, normalize_archive_path};
+
+/// 单次发行资源响应的字节上限，与单文件上限同口径。
+pub const MAX_RELEASE_ASSET_BYTES: u64 = MAX_FILE_BYTES;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ReleaseAssetError {
+    InvalidPath,
+    NotInPackage,
+    FileTooLarge,
+    InvalidArchive,
+    ReadFailed,
+}
+
+/// 归一化发行资源路径。
+///
+/// 路径来自公开 URL，必须在查表前完成归一化并拒绝相对段、控制字符和 Windows
+/// 保留字符，不能依赖 ZIP 条目的原始写法。
+pub fn normalize_release_asset_path(raw: &str) -> Result<String, ReleaseAssetError> {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() || trimmed.len() > 1024 {
+        return Err(ReleaseAssetError::InvalidPath);
+    }
+    if trimmed.contains('\\') || trimmed.starts_with('/') || trimmed.contains('\0') {
+        return Err(ReleaseAssetError::InvalidPath);
+    }
+    normalize_archive_path(std::path::Path::new(trimmed))
+        .map_err(|_| ReleaseAssetError::InvalidPath)
+}
+
+/// 发行资源的响应内容类型白名单。
+///
+/// 未知扩展名返回 `None` 并让调用方失败关闭，避免把未知内容当作 HTML 返回。
+pub fn release_asset_content_type(path: &str) -> Option<&'static str> {
+    let extension = path.rsplit_once('.').map(|(_, value)| value)?;
+    let extension = extension.to_ascii_lowercase();
+    Some(match extension.as_str() {
+        "html" | "htm" => "text/html; charset=utf-8",
+        "js" | "mjs" => "text/javascript; charset=utf-8",
+        "css" => "text/css; charset=utf-8",
+        "json" => "application/json; charset=utf-8",
+        "wasm" => "application/wasm",
+        "svg" => "image/svg+xml",
+        "png" => "image/png",
+        "jpg" | "jpeg" => "image/jpeg",
+        "webp" => "image/webp",
+        "gif" => "image/gif",
+        "avif" => "image/avif",
+        "ico" => "image/x-icon",
+        "mp3" => "audio/mpeg",
+        "ogg" => "audio/ogg",
+        "wav" => "audio/wav",
+        "m4a" => "audio/mp4",
+        "mp4" => "video/mp4",
+        "webm" => "video/webm",
+        "woff" => "font/woff",
+        "woff2" => "font/woff2",
+        "ttf" => "font/ttf",
+        "otf" => "font/otf",
+        "txt" => "text/plain; charset=utf-8",
+        "xml" => "application/xml",
+        _ => return None,
+    })
+}
+
+/// 从已确认的发行包中取出单个资源。
+///
+/// 只按归一化后的精确路径命中，不做大小写折叠或前缀匹配，避免一个资源伪装成另一个。
+pub fn extract_release_asset(
+    package: &[u8],
+    asset_path: &str,
+) -> Result<Vec<u8>, ReleaseAssetError> {
+    let asset_path = normalize_release_asset_path(asset_path)?;
+    let mut archive = zip::ZipArchive::new(Cursor::new(package))
+        .map_err(|_| ReleaseAssetError::InvalidArchive)?;
+    for index in 0..archive.len() {
+        let mut file = archive
+            .by_index(index)
+            .map_err(|_| ReleaseAssetError::InvalidArchive)?;
+        if file.is_dir() || file.is_symlink() || file.encrypted() {
+            continue;
+        }
+        let Ok(candidate) =
+            normalize_archive_path(&file.enclosed_name().ok_or(ReleaseAssetError::InvalidPath)?)
+        else {
+            continue;
+        };
+        if candidate != asset_path {
+            continue;
+        }
+        let size = file.size();
+        if size > MAX_RELEASE_ASSET_BYTES {
+            return Err(ReleaseAssetError::FileTooLarge);
+        }
+        let mut content = Vec::with_capacity(usize::try_from(size).unwrap_or(0));
+        file.read_to_end(&mut content)
+            .map_err(|_| ReleaseAssetError::ReadFailed)?;
+        if u64::try_from(content.len()).unwrap_or(u64::MAX) != size {
+            return Err(ReleaseAssetError::ReadFailed);
+        }
+        return Ok(content);
+    }
+    Err(ReleaseAssetError::NotInPackage)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Write;
+
+    use zip::{ZipWriter, write::SimpleFileOptions};
+
+    use super::*;
+
+    fn archive(files: &[(&str, &[u8])]) -> Vec<u8> {
+        let mut output = Cursor::new(Vec::new());
+        let mut writer = ZipWriter::new(&mut output);
+        for (path, content) in files {
+            writer
+                .start_file(*path, SimpleFileOptions::default())
+                .expect("zip entry");
+            writer.write_all(content).expect("zip content");
+        }
+        writer.finish().expect("finish zip");
+        output.into_inner()
+    }
+
+    #[test]
+    fn content_type_allowlist_fails_closed_for_unknown_extensions() {
+        assert_eq!(
+            release_asset_content_type("index.html"),
+            Some("text/html; charset=utf-8")
+        );
+        assert_eq!(
+            release_asset_content_type("app.js"),
+            Some("text/javascript; charset=utf-8")
+        );
+        assert_eq!(release_asset_content_type("payload"), None);
+        assert_eq!(release_asset_content_type("evil.php"), None);
+    }
+
+    #[test]
+    fn asset_path_rejects_traversal_and_absolute_input() {
+        assert_eq!(
+            normalize_release_asset_path("../secret").expect_err("相对段应拒绝"),
+            ReleaseAssetError::InvalidPath
+        );
+        assert_eq!(
+            normalize_release_asset_path("/etc/passwd").expect_err("绝对路径应拒绝"),
+            ReleaseAssetError::InvalidPath
+        );
+        assert_eq!(
+            normalize_release_asset_path("assets/./a.png").expect_err("点段应拒绝"),
+            ReleaseAssetError::InvalidPath
+        );
+        assert_eq!(
+            normalize_release_asset_path("assets/app.js").expect("合法路径"),
+            "assets/app.js"
+        );
+    }
+
+    #[test]
+    fn extraction_only_returns_the_exact_declared_entry() {
+        let bytes = archive(&[("index.html", b"<html></html>"), ("assets/app.js", b"1")]);
+        assert_eq!(
+            extract_release_asset(&bytes, "assets/app.js").expect("命中"),
+            b"1".to_vec()
+        );
+        assert_eq!(
+            extract_release_asset(&bytes, "assets/./app.js").expect_err("归一化后拒绝"),
+            ReleaseAssetError::InvalidPath
+        );
+        assert_eq!(
+            extract_release_asset(&bytes, "assets/missing.js").expect_err("未命中"),
+            ReleaseAssetError::NotInPackage
+        );
+    }
+}
diff --git a/server-rs/crates/module-runtime/src/application.rs b/server-rs/crates/module-runtime/src/application.rs
index bf3e51bb1..e7f1ead08 100644
--- a/server-rs/crates/module-runtime/src/application.rs
+++ b/server-rs/crates/module-runtime/src/application.rs
@@ -84,6 +84,9 @@ pub fn creation_entry_feature_gate_key(creation_type_id: &str) -> String {
 
 pub const IMAGE_EDITOR_AGENT_SIDEBAR_GATE_KEY: &str = "image-editor:agent-sidebar";
 pub const AGC_TEMPLATE_LIBRARY_GATE_KEY: &str = "agc:template-library";
+/// 游戏分发写入开关：gate 行缺失或 `enabled=false` 时默认开放；`enabled=true` 时
+/// 只有白名单/灰度命中的用户能发布新版本（`rollout_percent=0` 且无白名单即全部关闭）。
+pub const GAME_DISTRIBUTION_PUBLISH_GATE_KEY: &str = "game-distribution:publish";
 
 #[cfg(any())]
 pub fn apply_feature_gates_to_creation_entry_config(
diff --git a/server-rs/crates/platform-oss/src/lib.rs b/server-rs/crates/platform-oss/src/lib.rs
index 7a8aabaa1..1a6d77e57 100644
--- a/server-rs/crates/platform-oss/src/lib.rs
+++ b/server-rs/crates/platform-oss/src/lib.rs
@@ -952,14 +952,87 @@ impl OssClient {
         client: &reqwest::Client,
         request: OssInternalPutObjectRequest,
     ) -> Result<OssPutObjectResponse, OssError> {
+        let object_key = normalize_internal_object_key(&request.object_key)?;
+        self.put_internal_object_bytes(
+            client,
+            object_key,
+            request.content_type,
+            request.access,
+            request.metadata,
+            Bytes::from(request.body),
+        )
+        .await
+    }
+
+    /// 内部对象 PUT 的受控重试：只重试可判定的传输/超时/408/429/5xx，body 只复制一次
+    /// 到引用计数的 `Bytes`，每次 attempt 复用同一份字节。
+    ///
+    /// `max_attempts` 至少为 1，`retry_delays_ms` 至少提供 `max_attempts - 1` 个退避值；
+    /// 参数不满足时按配置错误失败关闭，不静默降级成单次请求。
+    pub async fn put_internal_object_with_retry(
+        &self,
+        client: &reqwest::Client,
+        request: OssInternalPutObjectRequest,
+        max_attempts: usize,
+        retry_delays_ms: &[u64],
+    ) -> Result<OssPutObjectResponse, OssError> {
+        if max_attempts == 0 {
+            return Err(OssError::InvalidConfig(
+                "内部对象 PUT 重试次数至少为 1".to_string(),
+            ));
+        }
+        if retry_delays_ms.len() < max_attempts.saturating_sub(1) {
+            return Err(OssError::InvalidConfig(
+                "内部对象 PUT 重试缺少退避配置".to_string(),
+            ));
+        }
         let object_key = normalize_internal_object_key(&request.object_key)?;
         if request.body.is_empty() && !project_snapshots::is_snapshot_file_key(&object_key) {
             return Err(OssError::InvalidRequest(
                 "服务端内部对象内容不能为空".to_string(),
             ));
         }
-        let content_type = normalize_optional_value(request.content_type);
-        let headers = build_put_object_headers(request.metadata)?;
+        let content_type = request.content_type;
+        let access = request.access;
+        let metadata = request.metadata;
+        let body = Bytes::from(request.body);
+        let retry_log_key = object_key.clone();
+        run_internal_put_with_retry(max_attempts, retry_delays_ms, &retry_log_key, move || {
+            let object_key = object_key.clone();
+            let content_type = content_type.clone();
+            let metadata = metadata.clone();
+            let body = body.clone();
+            async move {
+                self.put_internal_object_bytes(
+                    client,
+                    object_key,
+                    content_type,
+                    access,
+                    metadata,
+                    body,
+                )
+                .await
+            }
+        })
+        .await
+    }
+
+    async fn put_internal_object_bytes(
+        &self,
+        client: &reqwest::Client,
+        object_key: String,
+        content_type: Option<String>,
+        access: OssObjectAccess,
+        metadata: BTreeMap<String, String>,
+        body: Bytes,
+    ) -> Result<OssPutObjectResponse, OssError> {
+        if body.is_empty() && !project_snapshots::is_snapshot_file_key(&object_key) {
+            return Err(OssError::InvalidRequest(
+                "服务端内部对象内容不能为空".to_string(),
+            ));
+        }
+        let content_type = normalize_optional_value(content_type);
+        let headers = build_put_object_headers(metadata)?;
         let target_url = build_object_url(&self.config.bucket, &self.config.endpoint, &object_key)
             .map_err(|error| {
                 request_error(
@@ -967,7 +1040,7 @@ impl OssClient {
                     &format!("构造 OSS 对象 URL 失败：{error}"),
                 )
             })?;
-        let content_length = u64::try_from(request.body.len())
+        let content_length = u64::try_from(body.len())
             .map_err(|_| OssError::InvalidRequest("上传对象大小超出可支持范围".to_string()))?;
         let builder = signed_request_builder(
             client,
@@ -979,7 +1052,7 @@ impl OssClient {
             &headers,
         )?
         .header(reqwest::header::CONTENT_LENGTH, content_length)
-        .body(request.body);
+        .body(body);
         let response = builder
             .send()
             .await
@@ -1009,7 +1082,7 @@ impl OssClient {
             object_key,
             content_type,
             content_length,
-            access: request.access,
+            access,
             etag,
             last_modified,
         })
@@ -1607,6 +1680,45 @@ where
     unreachable!("角色动画 OSS 重试循环必须返回结果")
 }
 
+/// 内部对象 PUT 的重试循环。判定与退避规则集中在 `oss_error_is_retryable`：
+/// 传输/超时/connect、408、429、5xx 以及 400+RequestTimeout 可重试，确定性 4xx 直接失败。
+async fn run_internal_put_with_retry<T, F, Fut>(
+    max_attempts: usize,
+    retry_delays_ms: &[u64],
+    object_key: &str,
+    mut attempt_request: F,
+) -> Result<T, OssError>
+where
+    F: FnMut() -> Fut,
+    Fut: Future<Output = Result<T, OssError>>,
+{
+    let mut attempt = 1_usize;
+    let mut retry_index = 0_usize;
+    loop {
+        let result = attempt_request().await;
+        let retryable = result.as_ref().err().is_some_and(oss_error_is_retryable);
+        let will_retry = retryable && attempt < max_attempts;
+        match result {
+            Ok(response) => return Ok(response),
+            Err(error) if will_retry => {
+                let delay_ms = retry_delays_ms[retry_index];
+                warn!(
+                    object_key = %object_key,
+                    attempt,
+                    max_attempts,
+                    retry_delay_ms = delay_ms,
+                    error = %error,
+                    "OSS 内部对象 PUT 失败，按退避重试"
+                );
+                sleep(std::time::Duration::from_millis(delay_ms)).await;
+                attempt += 1;
+                retry_index += 1;
+            }
+            Err(error) => return Err(error),
+        }
+    }
+}
+
 fn request_error_from_reqwest(operation: OssRequestOperation, error: reqwest::Error) -> OssError {
     let status = error.status().map(|status| status.as_u16());
     let timeout = error.is_timeout();
@@ -2871,6 +2983,86 @@ mod tests {
         assert!(!oss_error_is_retryable(&error));
     }
 
+    #[tokio::test]
+    async fn internal_put_retry_retries_transport_then_succeeds() {
+        let attempts = Arc::new(AtomicUsize::new(0));
+        let attempts_for_request = attempts.clone();
+        let result = run_internal_put_with_retry(
+            3,
+            &[1, 1],
+            "agc/project-snapshots/v1/game-distribution/game_1/gamever_1.zip",
+            move || {
+                let attempts = attempts_for_request.clone();
+                async move {
+                    if attempts.fetch_add(1, Ordering::SeqCst) == 0 {
+                        Err(retryable_request_error(None, false, false, true))
+                    } else {
+                        Ok("uploaded")
+                    }
+                }
+            },
+        )
+        .await;
+
+        assert_eq!(result.expect("第二次尝试应成功"), "uploaded");
+        assert_eq!(attempts.load(Ordering::SeqCst), 2);
+    }
+
+    #[tokio::test]
+    async fn internal_put_retry_stops_on_deterministic_statuses() {
+        for status in [400_u16, 401, 403, 404] {
+            let attempts = Arc::new(AtomicUsize::new(0));
+            let attempts_for_request = attempts.clone();
+            let error = run_internal_put_with_retry::<(), _, _>(
+                3,
+                &[1, 1],
+                "agc/project-snapshots/v1/game-distribution/game_1/gamever_1.zip",
+                move || {
+                    let attempts = attempts_for_request.clone();
+                    async move {
+                        attempts.fetch_add(1, Ordering::SeqCst);
+                        Err::<(), _>(retryable_request_error(Some(status), false, false, false))
+                    }
+                },
+            )
+            .await
+            .expect_err("确定性状态码不应重试");
+
+            assert_eq!(error.kind(), OssErrorKind::Request);
+            assert_eq!(
+                attempts.load(Ordering::SeqCst),
+                1,
+                "status={status} 必须只尝试一次"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn internal_put_retry_returns_last_error_after_budget() {
+        let attempts = Arc::new(AtomicUsize::new(0));
+        let attempts_for_request = attempts.clone();
+        let error = run_internal_put_with_retry::<(), _, _>(
+            3,
+            &[1, 1],
+            "agc/project-snapshots/v1/game-distribution/game_1/gamever_1.zip",
+            move || {
+                let attempts = attempts_for_request.clone();
+                async move {
+                    attempts.fetch_add(1, Ordering::SeqCst);
+                    Err::<(), _>(retryable_request_error(Some(503), false, false, false))
+                }
+            },
+        )
+        .await
+        .expect_err("重试用尽后必须返回最后一次错误");
+
+        assert_eq!(attempts.load(Ordering::SeqCst), 3);
+        let OssError::Request(request_error) = &error else {
+            panic!("应保留 OSS 请求错误");
+        };
+        assert_eq!(request_error.status, Some(503));
+    }
+
     #[tokio::test]
     async fn animation_retry_retries_transport_then_succeeds() {
         let attempts = Arc::new(AtomicUsize::new(0));
diff --git a/server-rs/crates/shared-contracts/src/game_distribution.rs b/server-rs/crates/shared-contracts/src/game_distribution.rs
new file mode 100644
index 000000000..1664b68c7
--- /dev/null
+++ b/server-rs/crates/shared-contracts/src/game_distribution.rs
@@ -0,0 +1,213 @@
+//! 游戏分发 API 的跨端 DTO。
+//!
+//! 领域状态机位于 `module-game-distribution`；本文件只描述 HTTP/客户端可见的
+//! 数据形状，不能承载 owner、审核或公开切换规则。
+
+use serde::{Deserialize, Serialize};
+
+pub const GAME_DISTRIBUTION_CATEGORIES: [&str; 7] =
+    ["休闲", "益智", "动作", "冒险", "模拟", "策略", "其他"];
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameDistributionVersionStatus {
+    AwaitingUpload,
+    Uploaded,
+    Validating,
+    PendingReview,
+    Published,
+    UploadFailed,
+    ValidationFailed,
+    Rejected,
+    Cancelled,
+    Revoked,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameDistributionVisibility {
+    Unpublished,
+    Published,
+    Suspended,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameDistributionInputMode {
+    Keyboard,
+    Mouse,
+    Touch,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GameDistributionOrientation {
+    Landscape,
+    Portrait,
+    Responsive,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionDeviceSupport {
+    pub desktop: bool,
+    pub mobile: bool,
+    pub touch: bool,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionAuthor {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub avatar_url: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionVersionSummary {
+    pub id: String,
+    pub version: String,
+    pub entry_url: String,
+    pub sha256: String,
+    pub published_at: String,
+    pub controls: Vec<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionGameSummary {
+    pub id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: String,
+    pub category: String,
+    pub tags: Vec<String>,
+    pub cover_color: String,
+    pub icon: String,
+    pub author: GameDistributionAuthor,
+    pub device_support: GameDistributionDeviceSupport,
+    #[serde(default)]
+    pub input_modes: Vec<GameDistributionInputMode>,
+    #[serde(default)]
+    pub orientation: Option<GameDistributionOrientation>,
+    pub status: GameDistributionVisibility,
+    pub current_version: Option<GameDistributionVersionSummary>,
+    pub play_count: u64,
+    pub created_at: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionListResponse {
+    pub games: Vec<GameDistributionGameSummary>,
+    #[serde(default)]
+    pub next_cursor: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionCreateGameRequest {
+    #[serde(default)]
+    pub local_project_id: Option<String>,
+    pub title: String,
+    pub summary: String,
+    #[serde(default)]
+    pub description: Option<String>,
+    pub category: String,
+    #[serde(default)]
+    pub tags: Vec<String>,
+    #[serde(default)]
+    pub cover_asset_id: Option<String>,
+    pub device_support: GameDistributionDeviceSupport,
+    pub input_modes: Vec<GameDistributionInputMode>,
+    pub orientation: GameDistributionOrientation,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionCreateVersionRequest {
+    #[serde(default)]
+    pub local_project_id: Option<String>,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub game_metadata: GameDistributionCreateGameRequest,
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionPrivateVersion {
+    pub version_id: String,
+    pub game_id: String,
+    pub version_number: u64,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub status: GameDistributionVersionStatus,
+    #[serde(default)]
+    pub review_reason: Option<String>,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn create_game_request_round_trips_local_project_id() {
+        let payload: GameDistributionCreateGameRequest =
+            serde_json::from_value(serde_json::json!({
+                "localProjectId": "proj-1",
+                "title": "游戏",
+                "summary": "简介",
+                "category": "益智",
+                "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+                "inputModes": ["keyboard"],
+                "orientation": "responsive",
+            }))
+            .expect("请求应可解析");
+        assert_eq!(payload.local_project_id.as_deref(), Some("proj-1"));
+        let serialized = serde_json::to_value(&payload).expect("请求应可序列化");
+        assert_eq!(serialized["localProjectId"], "proj-1");
+    }
+
+    #[test]
+    fn legacy_create_game_request_without_local_project_id_stays_compatible() {
+        let payload: GameDistributionCreateGameRequest =
+            serde_json::from_value(serde_json::json!({
+                "title": "游戏",
+                "summary": "简介",
+                "category": "益智",
+                "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+                "inputModes": ["keyboard"],
+                "orientation": "responsive",
+            }))
+            .expect("旧请求应继续可解析");
+        assert_eq!(payload.local_project_id, None);
+    }
+
+    #[test]
+    fn create_version_request_accepts_local_project_id() {
+        let payload: GameDistributionCreateVersionRequest =
+            serde_json::from_value(serde_json::json!({
+                "localProjectId": "proj-1",
+                "packageSha256": "a".repeat(64),
+                "packageBytes": 10,
+                "packageFileCount": 1,
+                "packageEntryPath": "index.html",
+                "gameMetadata": {
+                    "title": "游戏",
+                    "summary": "简介",
+                    "category": "益智",
+                    "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+                    "inputModes": ["keyboard"],
+                    "orientation": "responsive",
+                },
+            }))
+            .expect("版本请求应可解析");
+        assert_eq!(payload.local_project_id.as_deref(), Some("proj-1"));
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/active.rs b/server-rs/crates/spacetime-client/src/active.rs
index 5f26f6951..c20123daf 100644
--- a/server-rs/crates/spacetime-client/src/active.rs
+++ b/server-rs/crates/spacetime-client/src/active.rs
@@ -21,12 +21,13 @@ mod error_reports;
 pub mod external_api_key;
 pub mod game_distribution;
 pub use game_distribution::{
-    GameDistributionApproveRecordInput, GameDistributionConfirmPackageRecordInput,
-    GameDistributionCreateGameRecordInput, GameDistributionCreateVersionRecordInput,
-    GameDistributionFailUploadRecordInput, GameDistributionGetGameRecordInput,
-    GameDistributionOwnerGameListRecordInput, GameDistributionPublicGameListRecordInput,
-    GameDistributionRejectRecordInput, GameDistributionSubmitReviewRecordInput,
-    GameDistributionSuspendRecordInput, GameDistributionUnpublishRecordInput,
+    GameDistributionApproveRecordInput, GameDistributionCancelVersionRecordInput,
+    GameDistributionConfirmPackageRecordInput, GameDistributionCreateGameRecordInput,
+    GameDistributionCreateVersionRecordInput, GameDistributionFailUploadRecordInput,
+    GameDistributionGetGameRecordInput, GameDistributionOwnerGameListRecordInput,
+    GameDistributionPublicGameListRecordInput, GameDistributionRejectRecordInput,
+    GameDistributionSubmitReviewRecordInput, GameDistributionSuspendRecordInput,
+    GameDistributionUnpublishRecordInput,
 };
 #[path = "active/external_generation.rs"]
 pub mod external_generation;
diff --git a/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs b/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs
new file mode 100644
index 000000000..f361b45b6
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs
@@ -0,0 +1,187 @@
+use super::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionGameRecord {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: String,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub author_name: Option<String>,
+    pub author_avatar_url: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub publication_revision: u64,
+    pub active_version_id: Option<String>,
+    pub visibility: String,
+    pub play_count: u64,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionVersionRecord {
+    pub version_id: String,
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_number: u64,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub status: String,
+    pub review_reason: Option<String>,
+    pub entry_url: Option<String>,
+    pub publication_revision: u64,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionOwnerGameRecord {
+    pub game: GameDistributionGameRecord,
+    pub versions: Vec<GameDistributionVersionRecord>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionPublicGameRecord {
+    pub game: GameDistributionGameRecord,
+    pub current_version: Option<GameDistributionVersionRecord>,
+}
+
+fn map_game(
+    value: crate::module_bindings::GameDistributionGameSnapshot,
+) -> GameDistributionGameRecord {
+    GameDistributionGameRecord {
+        game_id: value.game_id,
+        owner_user_id: value.owner_user_id,
+        title: value.title,
+        summary: value.summary,
+        description: value.description,
+        category: value.category,
+        tags_json: value.tags_json,
+        cover_asset_id: value.cover_asset_id,
+        author_name: value.author_name,
+        author_avatar_url: value.author_avatar_url,
+        device_support_desktop: value.device_support_desktop,
+        device_support_mobile: value.device_support_mobile,
+        device_support_touch: value.device_support_touch,
+        input_modes_json: value.input_modes_json,
+        orientation: value.orientation,
+        publication_revision: value.publication_revision,
+        active_version_id: value.active_version_id,
+        visibility: value.visibility,
+        play_count: value.play_count,
+        created_at: shared_kernel::format_timestamp_micros(value.created_at_micros),
+        updated_at: shared_kernel::format_timestamp_micros(value.updated_at_micros),
+    }
+}
+
+fn map_version(
+    value: crate::module_bindings::GameDistributionVersionSnapshot,
+) -> GameDistributionVersionRecord {
+    GameDistributionVersionRecord {
+        version_id: value.version_id,
+        game_id: value.game_id,
+        owner_user_id: value.owner_user_id,
+        version_number: value.version_number,
+        package_sha256: value.package_sha_256,
+        package_bytes: value.package_bytes,
+        package_file_count: value.package_file_count,
+        package_entry_path: value.package_entry_path,
+        status: value.status,
+        review_reason: value.review_reason,
+        entry_url: value.entry_url,
+        publication_revision: value.publication_revision,
+        created_at: shared_kernel::format_timestamp_micros(value.created_at_micros),
+        updated_at: shared_kernel::format_timestamp_micros(value.updated_at_micros),
+    }
+}
+
+pub(crate) fn map_game_distribution_game_result(
+    result: crate::module_bindings::GameDistributionProcedureResult,
+) -> Result<
+    (
+        Option<GameDistributionGameRecord>,
+        Option<GameDistributionVersionRecord>,
+        bool,
+    ),
+    SpacetimeClientError,
+> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok((
+        result.game.map(map_game),
+        result.version.map(map_version),
+        result.replayed,
+    ))
+}
+
+pub(crate) fn map_game_distribution_owner_game_list_result(
+    result: crate::module_bindings::GameDistributionOwnerGameListProcedureResult,
+) -> Result<Vec<GameDistributionOwnerGameRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result
+        .games
+        .into_iter()
+        .map(|value| GameDistributionOwnerGameRecord {
+            game: map_game(value.game),
+            versions: value.versions.into_iter().map(map_version).collect(),
+        })
+        .collect())
+}
+
+pub(crate) fn map_game_distribution_public_game_list_result(
+    result: crate::module_bindings::GameDistributionGameListProcedureResult,
+) -> Result<Vec<GameDistributionPublicGameRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result
+        .games
+        .into_iter()
+        .map(|value| GameDistributionPublicGameRecord {
+            game: map_game(value.game),
+            current_version: value.current_version.map(map_version),
+        })
+        .collect())
+}
+
+pub(crate) fn map_game_distribution_version_result(
+    result: crate::module_bindings::GameDistributionVersionProcedureResult,
+) -> Result<Option<GameDistributionVersionRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result.version.map(map_version))
+}
+
+pub(crate) fn map_game_distribution_public_game_result(
+    result: crate::module_bindings::GameDistributionGameProcedureResult,
+) -> Result<Option<GameDistributionPublicGameRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result.game.map(|value| GameDistributionPublicGameRecord {
+        game: map_game(value.game),
+        current_version: value.current_version.map(map_version),
+    }))
+}
+
+pub(crate) fn map_game_distribution_review_list_result(
+    result: crate::module_bindings::GameDistributionProcedureResult,
+) -> Result<Vec<GameDistributionVersionRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result.versions.into_iter().map(map_version).collect())
+}
diff --git a/server-rs/crates/spacetime-client/src/game_distribution.rs b/server-rs/crates/spacetime-client/src/game_distribution.rs
new file mode 100644
index 000000000..5ae6e6408
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/game_distribution.rs
@@ -0,0 +1,688 @@
+use super::*;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionPublicGameListRecordInput {
+    pub search: Option<String>,
+    pub category: Option<String>,
+    pub limit: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionOwnerGameListRecordInput {
+    pub owner_user_id: String,
+    pub limit: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionGetGameRecordInput {
+    pub game_id: String,
+    pub owner_user_id: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionCreateGameRecordInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub author_name: Option<String>,
+    pub author_avatar_url: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+    /// 同一作者的本地项目标识；重复发布会复用既有 game_id。
+    pub local_project_id: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionCreateVersionRecordInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_id: String,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub local_project_id: Option<String>,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionConfirmPackageRecordInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub package_object_key: String,
+    pub package_manifest_json: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionFailUploadRecordInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub error_code: String,
+    pub error_message: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionSubmitReviewRecordInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionCancelVersionRecordInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionApproveRecordInput {
+    pub version_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub entry_url: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionRejectRecordInput {
+    pub version_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub review_reason: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionUnpublishRecordInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionSuspendRecordInput {
+    pub game_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub reason: Option<String>,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl SpacetimeClient {
+    pub async fn list_game_distribution_games(
+        &self,
+        input: GameDistributionPublicGameListRecordInput,
+    ) -> Result<Vec<GameDistributionPublicGameRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionPublicGameListInput {
+            search: input.search,
+            category: input.category,
+            limit: input.limit,
+        };
+        self.call_after_connect("list_game_distribution_games", move |connection, sender| {
+            connection
+                .procedures()
+                .list_public_game_distribution_games_and_return_then(input, move |_, result| {
+                    let mapped = result
+                        .map_err(SpacetimeClientError::from_sdk_error)
+                        .and_then(map_game_distribution_public_game_list_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn list_owner_game_distribution_games(
+        &self,
+        input: GameDistributionOwnerGameListRecordInput,
+    ) -> Result<Vec<GameDistributionOwnerGameRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionOwnerGameListInput {
+            owner_user_id: input.owner_user_id,
+            limit: input.limit,
+        };
+        self.call_after_connect(
+            "list_owner_game_distribution_games",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_owner_game_distribution_games_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_owner_game_list_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    pub async fn get_game_distribution_game(
+        &self,
+        input: GameDistributionGetGameRecordInput,
+    ) -> Result<Option<GameDistributionGameRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionGetGameInput {
+            game_id: input.game_id,
+            owner_user_id: input.owner_user_id,
+        };
+        self.call_after_connect("get_game_distribution_game", move |connection, sender| {
+            connection
+                .procedures()
+                .get_game_distribution_game_and_return_then(input, move |_, result| {
+                    let mapped = result
+                        .map_err(SpacetimeClientError::from_sdk_error)
+                        .and_then(|result| {
+                            map_game_distribution_game_result(result).map(|(game, _, _)| game)
+                        });
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn get_public_game_distribution_game(
+        &self,
+        game_id: String,
+    ) -> Result<Option<GameDistributionPublicGameRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionPublicGameInput { game_id };
+        self.call_after_connect(
+            "get_public_game_distribution_game",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .get_public_game_distribution_game_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_public_game_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    pub async fn create_game_distribution_game(
+        &self,
+        input: GameDistributionCreateGameRecordInput,
+    ) -> Result<(GameDistributionGameRecord, bool), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionCreateGameInput {
+            game_id: input.game_id,
+            owner_user_id: input.owner_user_id,
+            title: input.title,
+            summary: input.summary,
+            description: input.description,
+            category: input.category,
+            tags_json: input.tags_json,
+            cover_asset_id: input.cover_asset_id,
+            author_name: input.author_name,
+            author_avatar_url: input.author_avatar_url,
+            device_support_desktop: input.device_support_desktop,
+            device_support_mobile: input.device_support_mobile,
+            device_support_touch: input.device_support_touch,
+            input_modes_json: input.input_modes_json,
+            orientation: input.orientation,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+            local_project_id: input.local_project_id,
+        };
+        self.call_after_connect(
+            "create_game_distribution_game",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .create_game_distribution_game_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_game_result)
+                            .and_then(|(game, _, replayed)| {
+                                game.map(|game| (game, replayed)).ok_or_else(|| {
+                                    SpacetimeClientError::missing_snapshot("游戏创建结果")
+                                })
+                            });
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    pub async fn create_game_distribution_version(
+        &self,
+        input: GameDistributionCreateVersionRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionCreateVersionInput {
+            game_id: input.game_id,
+            owner_user_id: input.owner_user_id,
+            version_id: input.version_id,
+            package_sha_256: input.package_sha256,
+            package_bytes: input.package_bytes,
+            package_file_count: input.package_file_count,
+            package_entry_path: input.package_entry_path,
+            local_project_id: input.local_project_id,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "create_game_distribution_version",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .create_game_distribution_version_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_game_result)
+                            .and_then(|(_, version, replayed)| {
+                                version.map(|version| (version, replayed)).ok_or_else(|| {
+                                    SpacetimeClientError::missing_snapshot("游戏版本创建结果")
+                                })
+                            });
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    pub async fn confirm_game_distribution_package(
+        &self,
+        input: GameDistributionConfirmPackageRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionConfirmPackageInput {
+            version_id: input.version_id,
+            owner_user_id: input.owner_user_id,
+            package_sha_256: input.package_sha256,
+            package_bytes: input.package_bytes,
+            package_file_count: input.package_file_count,
+            package_entry_path: input.package_entry_path,
+            package_object_key: input.package_object_key,
+            package_manifest_json: input.package_manifest_json,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            updated_at_micros: input.updated_at_micros,
+        };
+        self.call_after_connect(
+            "confirm_game_distribution_package",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .confirm_game_distribution_package_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_game_result)
+                            .and_then(|(_, version, replayed)| {
+                                version.map(|version| (version, replayed)).ok_or_else(|| {
+                                    SpacetimeClientError::missing_snapshot("游戏发行包确认结果")
+                                })
+                            });
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    pub async fn get_owner_game_distribution_version(
+        &self,
+        owner_user_id: String,
+        version_id: String,
+    ) -> Result<Option<GameDistributionVersionRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionOwnerVersionInput {
+            owner_user_id,
+            version_id,
+        };
+        self.call_after_connect(
+            "get_owner_game_distribution_version",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .get_owner_game_distribution_version_and_return_then(
+                        input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_version_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    pub async fn get_game_distribution_version(
+        &self,
+        version_id: String,
+    ) -> Result<Option<GameDistributionVersionRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionVersionLookupInput { version_id };
+        self.call_after_connect(
+            "get_game_distribution_version",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .get_game_distribution_version_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_version_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    pub async fn fail_game_distribution_upload(
+        &self,
+        input: GameDistributionFailUploadRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionFailUploadInput {
+            version_id: input.version_id,
+            owner_user_id: input.owner_user_id,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            error_code: input.error_code,
+            error_message: input.error_message,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "fail_game_distribution_upload",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .fail_game_distribution_upload_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_game_result)
+                            .and_then(|(_, version, replayed)| {
+                                version.map(|version| (version, replayed)).ok_or_else(|| {
+                                    SpacetimeClientError::missing_snapshot("游戏发行失败结果")
+                                })
+                            });
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    pub async fn submit_game_distribution_version_for_review(
+        &self,
+        input: GameDistributionSubmitReviewRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionSubmitReviewInput {
+            version_id: input.version_id,
+            owner_user_id: input.owner_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "submit_game_distribution_version_for_review",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .submit_game_distribution_version_for_review_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(_, version, replayed)| {
+                                    version.map(|version| (version, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏送审结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    pub async fn cancel_game_distribution_version(
+        &self,
+        input: GameDistributionCancelVersionRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionCancelVersionInput {
+            version_id: input.version_id,
+            owner_user_id: input.owner_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "cancel_game_distribution_version",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .cancel_game_distribution_version_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(_, version, replayed)| {
+                                    version.map(|version| (version, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏撤回结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    pub async fn approve_game_distribution_version(
+        &self,
+        input: GameDistributionApproveRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionApproveInput {
+            version_id: input.version_id,
+            admin_user_id: input.admin_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            entry_url: input.entry_url,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "approve_game_distribution_version",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .approve_game_distribution_version_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(_, version, replayed)| {
+                                    version.map(|version| (version, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏审核批准结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    pub async fn reject_game_distribution_version(
+        &self,
+        input: GameDistributionRejectRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionRejectInput {
+            version_id: input.version_id,
+            admin_user_id: input.admin_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            review_reason: input.review_reason,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "reject_game_distribution_version",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .reject_game_distribution_version_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(_, version, replayed)| {
+                                    version.map(|version| (version, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏审核拒绝结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    pub async fn unpublish_game_distribution_game(
+        &self,
+        input: GameDistributionUnpublishRecordInput,
+    ) -> Result<(GameDistributionGameRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionUnpublishInput {
+            game_id: input.game_id,
+            owner_user_id: input.owner_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "unpublish_game_distribution_game",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .unpublish_game_distribution_game_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(game, _, replayed)| {
+                                    game.map(|game| (game, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏下架结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    pub async fn suspend_game_distribution_game(
+        &self,
+        input: GameDistributionSuspendRecordInput,
+    ) -> Result<(GameDistributionGameRecord, bool), SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionSuspendInput {
+            game_id: input.game_id,
+            admin_user_id: input.admin_user_id,
+            expected_publication_revision: input.expected_publication_revision,
+            reason: input.reason,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "suspend_game_distribution_game",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .suspend_game_distribution_game_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_game_result)
+                                .and_then(|(game, _, replayed)| {
+                                    game.map(|game| (game, replayed)).ok_or_else(|| {
+                                        SpacetimeClientError::missing_snapshot("游戏暂停结果")
+                                    })
+                                });
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    pub async fn list_game_distribution_reviews(
+        &self,
+        limit: u32,
+    ) -> Result<Vec<GameDistributionVersionRecord>, SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::GameDistributionReviewListInput { limit };
+        self.call_after_connect(
+            "list_game_distribution_reviews",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_game_distribution_reviews_and_return_then(
+                        procedure_input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_review_list_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings.rs b/server-rs/crates/spacetime-client/src/module_bindings.rs
index 81f3f8eaf..ae7484ee8 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings.rs
@@ -173,6 +173,7 @@ pub mod big_fish_runtime_run_type;
 pub mod bind_asset_object_to_entity_and_return_procedure;
 pub mod bind_asset_object_to_entity_reducer;
 pub mod cancel_ai_task_and_return_procedure;
+pub mod cancel_game_distribution_version_and_return_procedure;
 pub mod chapter_pace_band_type;
 pub mod chapter_progression_table;
 pub mod chapter_progression_type;
@@ -458,6 +459,7 @@ pub mod feature_gate_config_table;
 pub mod feature_gate_config_type;
 pub mod find_editor_asset_group_source_and_return_procedure;
 pub mod game_distribution_approve_input_type;
+pub mod game_distribution_cancel_version_input_type;
 pub mod game_distribution_confirm_package_input_type;
 pub mod game_distribution_create_game_input_type;
 pub mod game_distribution_create_version_input_type;
@@ -483,6 +485,7 @@ pub mod game_distribution_review_list_input_type;
 pub mod game_distribution_submit_review_input_type;
 pub mod game_distribution_suspend_input_type;
 pub mod game_distribution_unpublish_input_type;
+pub mod game_distribution_version_lookup_input_type;
 pub mod game_distribution_version_procedure_result_type;
 pub mod game_distribution_version_snapshot_type;
 pub mod game_distribution_version_table;
@@ -505,6 +508,7 @@ pub mod get_external_generation_job_summary_and_return_procedure;
 pub mod get_external_generation_queue_stats_and_return_procedure;
 pub mod get_feature_gate_config_procedure;
 pub mod get_game_distribution_game_and_return_procedure;
+pub mod get_game_distribution_version_and_return_procedure;
 pub mod get_llm_router_account_and_return_procedure;
 pub mod get_owner_game_distribution_version_and_return_procedure;
 pub mod get_profile_dashboard_procedure;
@@ -1128,6 +1132,7 @@ pub use big_fish_runtime_run_type::BigFishRuntimeRun;
 pub use bind_asset_object_to_entity_and_return_procedure::bind_asset_object_to_entity_and_return;
 pub use bind_asset_object_to_entity_reducer::bind_asset_object_to_entity;
 pub use cancel_ai_task_and_return_procedure::cancel_ai_task_and_return;
+pub use cancel_game_distribution_version_and_return_procedure::cancel_game_distribution_version_and_return;
 pub use chapter_pace_band_type::ChapterPaceBand;
 pub use chapter_progression_table::*;
 pub use chapter_progression_type::ChapterProgression;
@@ -1413,6 +1418,7 @@ pub use feature_gate_config_table::*;
 pub use feature_gate_config_type::FeatureGateConfig;
 pub use find_editor_asset_group_source_and_return_procedure::find_editor_asset_group_source_and_return;
 pub use game_distribution_approve_input_type::GameDistributionApproveInput;
+pub use game_distribution_cancel_version_input_type::GameDistributionCancelVersionInput;
 pub use game_distribution_confirm_package_input_type::GameDistributionConfirmPackageInput;
 pub use game_distribution_create_game_input_type::GameDistributionCreateGameInput;
 pub use game_distribution_create_version_input_type::GameDistributionCreateVersionInput;
@@ -1438,6 +1444,7 @@ pub use game_distribution_review_list_input_type::GameDistributionReviewListInpu
 pub use game_distribution_submit_review_input_type::GameDistributionSubmitReviewInput;
 pub use game_distribution_suspend_input_type::GameDistributionSuspendInput;
 pub use game_distribution_unpublish_input_type::GameDistributionUnpublishInput;
+pub use game_distribution_version_lookup_input_type::GameDistributionVersionLookupInput;
 pub use game_distribution_version_procedure_result_type::GameDistributionVersionProcedureResult;
 pub use game_distribution_version_snapshot_type::GameDistributionVersionSnapshot;
 pub use game_distribution_version_table::*;
@@ -1460,6 +1467,7 @@ pub use get_external_generation_job_summary_and_return_procedure::get_external_g
 pub use get_external_generation_queue_stats_and_return_procedure::get_external_generation_queue_stats_and_return;
 pub use get_feature_gate_config_procedure::get_feature_gate_config;
 pub use get_game_distribution_game_and_return_procedure::get_game_distribution_game_and_return;
+pub use get_game_distribution_version_and_return_procedure::get_game_distribution_version_and_return;
 pub use get_llm_router_account_and_return_procedure::get_llm_router_account_and_return;
 pub use get_owner_game_distribution_version_and_return_procedure::get_owner_game_distribution_version_and_return;
 pub use get_profile_dashboard_procedure::get_profile_dashboard;
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/approve_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/approve_game_distribution_version_and_return_procedure.rs
new file mode 100644
index 000000000..7a42c9ec4
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/approve_game_distribution_version_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_approve_input_type::GameDistributionApproveInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ApproveGameDistributionVersionAndReturnArgs {
+    pub input: GameDistributionApproveInput,
+}
+
+impl __sdk::InModule for ApproveGameDistributionVersionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `approve_game_distribution_version_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait approve_game_distribution_version_and_return {
+    fn approve_game_distribution_version_and_return(&self, input: GameDistributionApproveInput) {
+        self.approve_game_distribution_version_and_return_then(input, |_, _| {});
+    }
+
+    fn approve_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionApproveInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl approve_game_distribution_version_and_return for super::RemoteProcedures {
+    fn approve_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionApproveInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "approve_game_distribution_version_and_return",
+                ApproveGameDistributionVersionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/cancel_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/cancel_game_distribution_version_and_return_procedure.rs
new file mode 100644
index 000000000..0f4e6f6d5
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/cancel_game_distribution_version_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_cancel_version_input_type::GameDistributionCancelVersionInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct CancelGameDistributionVersionAndReturnArgs {
+    pub input: GameDistributionCancelVersionInput,
+}
+
+impl __sdk::InModule for CancelGameDistributionVersionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `cancel_game_distribution_version_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait cancel_game_distribution_version_and_return {
+    fn cancel_game_distribution_version_and_return(
+        &self,
+        input: GameDistributionCancelVersionInput,
+    ) {
+        self.cancel_game_distribution_version_and_return_then(input, |_, _| {});
+    }
+
+    fn cancel_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionCancelVersionInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl cancel_game_distribution_version_and_return for super::RemoteProcedures {
+    fn cancel_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionCancelVersionInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "cancel_game_distribution_version_and_return",
+                CancelGameDistributionVersionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_package_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_package_and_return_procedure.rs
new file mode 100644
index 000000000..c6e881e84
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_package_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_confirm_package_input_type::GameDistributionConfirmPackageInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ConfirmGameDistributionPackageAndReturnArgs {
+    pub input: GameDistributionConfirmPackageInput,
+}
+
+impl __sdk::InModule for ConfirmGameDistributionPackageAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `confirm_game_distribution_package_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait confirm_game_distribution_package_and_return {
+    fn confirm_game_distribution_package_and_return(
+        &self,
+        input: GameDistributionConfirmPackageInput,
+    ) {
+        self.confirm_game_distribution_package_and_return_then(input, |_, _| {});
+    }
+
+    fn confirm_game_distribution_package_and_return_then(
+        &self,
+        input: GameDistributionConfirmPackageInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl confirm_game_distribution_package_and_return for super::RemoteProcedures {
+    fn confirm_game_distribution_package_and_return_then(
+        &self,
+        input: GameDistributionConfirmPackageInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "confirm_game_distribution_package_and_return",
+                ConfirmGameDistributionPackageAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_game_and_return_procedure.rs
new file mode 100644
index 000000000..945777c57
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_game_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_create_game_input_type::GameDistributionCreateGameInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct CreateGameDistributionGameAndReturnArgs {
+    pub input: GameDistributionCreateGameInput,
+}
+
+impl __sdk::InModule for CreateGameDistributionGameAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `create_game_distribution_game_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait create_game_distribution_game_and_return {
+    fn create_game_distribution_game_and_return(&self, input: GameDistributionCreateGameInput) {
+        self.create_game_distribution_game_and_return_then(input, |_, _| {});
+    }
+
+    fn create_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionCreateGameInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl create_game_distribution_game_and_return for super::RemoteProcedures {
+    fn create_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionCreateGameInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "create_game_distribution_game_and_return",
+                CreateGameDistributionGameAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_version_and_return_procedure.rs
new file mode 100644
index 000000000..ccb8a9cc8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_version_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_create_version_input_type::GameDistributionCreateVersionInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct CreateGameDistributionVersionAndReturnArgs {
+    pub input: GameDistributionCreateVersionInput,
+}
+
+impl __sdk::InModule for CreateGameDistributionVersionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `create_game_distribution_version_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait create_game_distribution_version_and_return {
+    fn create_game_distribution_version_and_return(
+        &self,
+        input: GameDistributionCreateVersionInput,
+    ) {
+        self.create_game_distribution_version_and_return_then(input, |_, _| {});
+    }
+
+    fn create_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionCreateVersionInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl create_game_distribution_version_and_return for super::RemoteProcedures {
+    fn create_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionCreateVersionInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "create_game_distribution_version_and_return",
+                CreateGameDistributionVersionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/fail_game_distribution_upload_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/fail_game_distribution_upload_and_return_procedure.rs
new file mode 100644
index 000000000..65235c650
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/fail_game_distribution_upload_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_fail_upload_input_type::GameDistributionFailUploadInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct FailGameDistributionUploadAndReturnArgs {
+    pub input: GameDistributionFailUploadInput,
+}
+
+impl __sdk::InModule for FailGameDistributionUploadAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `fail_game_distribution_upload_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait fail_game_distribution_upload_and_return {
+    fn fail_game_distribution_upload_and_return(&self, input: GameDistributionFailUploadInput) {
+        self.fail_game_distribution_upload_and_return_then(input, |_, _| {});
+    }
+
+    fn fail_game_distribution_upload_and_return_then(
+        &self,
+        input: GameDistributionFailUploadInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl fail_game_distribution_upload_and_return for super::RemoteProcedures {
+    fn fail_game_distribution_upload_and_return_then(
+        &self,
+        input: GameDistributionFailUploadInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "fail_game_distribution_upload_and_return",
+                FailGameDistributionUploadAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_approve_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_approve_input_type.rs
new file mode 100644
index 000000000..10cce03d8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_approve_input_type.rs
@@ -0,0 +1,21 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionApproveInput {
+    pub version_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub entry_url: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionApproveInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_cancel_version_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_cancel_version_input_type.rs
new file mode 100644
index 000000000..0f5eb5472
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_cancel_version_input_type.rs
@@ -0,0 +1,20 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionCancelVersionInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionCancelVersionInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_confirm_package_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_confirm_package_input_type.rs
new file mode 100644
index 000000000..f60c14cb8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_confirm_package_input_type.rs
@@ -0,0 +1,25 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionConfirmPackageInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub package_sha_256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub package_object_key: String,
+    pub package_manifest_json: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub updated_at_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionConfirmPackageInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_game_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_game_input_type.rs
new file mode 100644
index 000000000..c9279cef3
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_game_input_type.rs
@@ -0,0 +1,33 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionCreateGameInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub author_name: Option<String>,
+    pub author_avatar_url: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+    pub local_project_id: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionCreateGameInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_type.rs
new file mode 100644
index 000000000..97b8c027f
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_type.rs
@@ -0,0 +1,25 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionCreateVersionInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_id: String,
+    pub package_sha_256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub local_project_id: Option<String>,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionCreateVersionInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fail_upload_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fail_upload_input_type.rs
new file mode 100644
index 000000000..26323e915
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fail_upload_input_type.rs
@@ -0,0 +1,21 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionFailUploadInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub error_code: String,
+    pub error_message: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionFailUploadInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_list_procedure_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_list_procedure_result_type.rs
new file mode 100644
index 000000000..fb6d59a54
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_list_procedure_result_type.rs
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_public_game_snapshot_type::GameDistributionPublicGameSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionGameListProcedureResult {
+    pub ok: bool,
+    pub games: Vec<GameDistributionPublicGameSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionGameListProcedureResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_procedure_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_procedure_result_type.rs
new file mode 100644
index 000000000..fa4be5cca
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_procedure_result_type.rs
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_public_game_snapshot_type::GameDistributionPublicGameSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionGameProcedureResult {
+    pub ok: bool,
+    pub game: Option<GameDistributionPublicGameSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionGameProcedureResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_snapshot_type.rs
new file mode 100644
index 000000000..5d0fe15e1
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_snapshot_type.rs
@@ -0,0 +1,35 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionGameSnapshot {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: String,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub author_name: Option<String>,
+    pub author_avatar_url: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub publication_revision: u64,
+    pub active_version_id: Option<String>,
+    pub visibility: String,
+    pub play_count: u64,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionGameSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_table.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_table.rs
new file mode 100644
index 000000000..6c7d304a8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_table.rs
@@ -0,0 +1,230 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use super::game_distribution_game_type::GameDistributionGame;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_distribution_game`.
+///
+/// Obtain a handle from the [`GameDistributionGameTableAccess::game_distribution_game`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_distribution_game()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_game().on_insert(...)`.
+pub struct GameDistributionGameTableHandle<'ctx> {
+    imp: __sdk::TableHandle<GameDistributionGame>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_distribution_game`.
+pub struct GameDistributionGameTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameDistributionGameTableAccessor {
+    type Row = GameDistributionGame;
+    type Handle<'db> = GameDistributionGameTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_distribution_game()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_distribution_game`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameDistributionGameTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameDistributionGameTableHandle`], which mediates access to the table `game_distribution_game`.
+    fn game_distribution_game(&self) -> GameDistributionGameTableHandle<'_>;
+}
+
+impl GameDistributionGameTableAccess for super::RemoteTables {
+    fn game_distribution_game(&self) -> GameDistributionGameTableHandle<'_> {
+        GameDistributionGameTableHandle {
+            imp: self
+                .imp
+                .get_table::<GameDistributionGame>("game_distribution_game"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameDistributionGameInsertCallbackId(__sdk::CallbackId);
+pub struct GameDistributionGameDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameDistributionGameTableHandle<'ctx> {
+    type Row = GameDistributionGame;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionGame> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameDistributionGameTableHandle<'ctx> {
+    type Row = GameDistributionGame;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionGame> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameDistributionGameInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionGameInsertCallbackId {
+        GameDistributionGameInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionGameInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameDistributionGameDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionGameDeleteCallbackId {
+        GameDistributionGameDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionGameDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameDistributionGameTableHandle<'ctx> {
+    type InsertCallbackId = GameDistributionGameInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionGameInsertCallbackId {
+        GameDistributionGameInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionGameInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameDistributionGameTableHandle<'ctx> {
+    type DeleteCallbackId = GameDistributionGameDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionGameDeleteCallbackId {
+        GameDistributionGameDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionGameDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameDistributionGameUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameDistributionGameTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionGameUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionGameUpdateCallbackId {
+        GameDistributionGameUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionGameUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameDistributionGameTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionGameUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionGameUpdateCallbackId {
+        GameDistributionGameUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionGameUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `game_id` unique index on the table `game_distribution_game`,
+/// which allows point queries on the field of the same name
+/// via the [`GameDistributionGameGameIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_game().game_id().find(...)`.
+pub struct GameDistributionGameGameIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<GameDistributionGame, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameDistributionGameTableHandle<'ctx> {
+    /// Get a handle on the `game_id` unique index on the table `game_distribution_game`.
+    pub fn game_id(&self) -> GameDistributionGameGameIdUnique<'ctx> {
+        GameDistributionGameGameIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("game_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameDistributionGameGameIdUnique<'ctx> {
+    /// Find the subscribed row whose `game_id` column value is equal to `col_val`,
+    /// if such a row is present in the client cache.
+    pub fn find(&self, col_val: &String) -> Option<GameDistributionGame> {
+        self.imp.find(col_val)
+    }
+}
+
+#[doc(hidden)]
+pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
+    let _table = client_cache.get_or_make_table::<GameDistributionGame>("game_distribution_game");
+    _table.add_unique_constraint::<String>("game_id", |row| &row.game_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<GameDistributionGame>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<GameDistributionGame>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `GameDistributionGame`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_distribution_gameQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `GameDistributionGame`.
+    fn game_distribution_game(&self) -> __sdk::__query_builder::Table<GameDistributionGame>;
+}
+
+impl game_distribution_gameQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_distribution_game(&self) -> __sdk::__query_builder::Table<GameDistributionGame> {
+        __sdk::__query_builder::Table::new("game_distribution_game")
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_type.rs
new file mode 100644
index 000000000..9ef982178
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_type.rs
@@ -0,0 +1,126 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionGame {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: String,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub author_name: Option<String>,
+    pub author_avatar_url: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub publication_revision: u64,
+    pub active_version_id: Option<String>,
+    pub visibility: String,
+    pub play_count: u64,
+    pub created_at: __sdk::Timestamp,
+    pub updated_at: __sdk::Timestamp,
+    pub local_project_id: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionGame {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `GameDistributionGame`.
+///
+/// Provides typed access to columns for query building.
+pub struct GameDistributionGameCols {
+    pub game_id: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub title: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub summary: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub description: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub category: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub tags_json: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub cover_asset_id: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
+    pub author_name: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
+    pub author_avatar_url: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
+    pub device_support_desktop: __sdk::__query_builder::Col<GameDistributionGame, bool>,
+    pub device_support_mobile: __sdk::__query_builder::Col<GameDistributionGame, bool>,
+    pub device_support_touch: __sdk::__query_builder::Col<GameDistributionGame, bool>,
+    pub input_modes_json: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub orientation: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub publication_revision: __sdk::__query_builder::Col<GameDistributionGame, u64>,
+    pub active_version_id: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
+    pub visibility: __sdk::__query_builder::Col<GameDistributionGame, String>,
+    pub play_count: __sdk::__query_builder::Col<GameDistributionGame, u64>,
+    pub created_at: __sdk::__query_builder::Col<GameDistributionGame, __sdk::Timestamp>,
+    pub updated_at: __sdk::__query_builder::Col<GameDistributionGame, __sdk::Timestamp>,
+    pub local_project_id: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
+}
+
+impl __sdk::__query_builder::HasCols for GameDistributionGame {
+    type Cols = GameDistributionGameCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        GameDistributionGameCols {
+            game_id: __sdk::__query_builder::Col::new(table_name, "game_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            title: __sdk::__query_builder::Col::new(table_name, "title"),
+            summary: __sdk::__query_builder::Col::new(table_name, "summary"),
+            description: __sdk::__query_builder::Col::new(table_name, "description"),
+            category: __sdk::__query_builder::Col::new(table_name, "category"),
+            tags_json: __sdk::__query_builder::Col::new(table_name, "tags_json"),
+            cover_asset_id: __sdk::__query_builder::Col::new(table_name, "cover_asset_id"),
+            author_name: __sdk::__query_builder::Col::new(table_name, "author_name"),
+            author_avatar_url: __sdk::__query_builder::Col::new(table_name, "author_avatar_url"),
+            device_support_desktop: __sdk::__query_builder::Col::new(
+                table_name,
+                "device_support_desktop",
+            ),
+            device_support_mobile: __sdk::__query_builder::Col::new(
+                table_name,
+                "device_support_mobile",
+            ),
+            device_support_touch: __sdk::__query_builder::Col::new(
+                table_name,
+                "device_support_touch",
+            ),
+            input_modes_json: __sdk::__query_builder::Col::new(table_name, "input_modes_json"),
+            orientation: __sdk::__query_builder::Col::new(table_name, "orientation"),
+            publication_revision: __sdk::__query_builder::Col::new(
+                table_name,
+                "publication_revision",
+            ),
+            active_version_id: __sdk::__query_builder::Col::new(table_name, "active_version_id"),
+            visibility: __sdk::__query_builder::Col::new(table_name, "visibility"),
+            play_count: __sdk::__query_builder::Col::new(table_name, "play_count"),
+            created_at: __sdk::__query_builder::Col::new(table_name, "created_at"),
+            updated_at: __sdk::__query_builder::Col::new(table_name, "updated_at"),
+            local_project_id: __sdk::__query_builder::Col::new(table_name, "local_project_id"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `GameDistributionGame`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct GameDistributionGameIxCols {
+    pub game_id: __sdk::__query_builder::IxCol<GameDistributionGame, String>,
+    pub owner_user_id: __sdk::__query_builder::IxCol<GameDistributionGame, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for GameDistributionGame {
+    type IxCols = GameDistributionGameIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        GameDistributionGameIxCols {
+            game_id: __sdk::__query_builder::IxCol::new(table_name, "game_id"),
+            owner_user_id: __sdk::__query_builder::IxCol::new(table_name, "owner_user_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for GameDistributionGame {}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_get_game_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_get_game_input_type.rs
new file mode 100644
index 000000000..e775ab26e
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_get_game_input_type.rs
@@ -0,0 +1,16 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionGetGameInput {
+    pub game_id: String,
+    pub owner_user_id: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionGetGameInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_idempotency_receipt_table.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_idempotency_receipt_table.rs
new file mode 100644
index 000000000..582ea41cc
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_idempotency_receipt_table.rs
@@ -0,0 +1,243 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use super::game_distribution_idempotency_receipt_type::GameDistributionIdempotencyReceipt;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_distribution_idempotency_receipt`.
+///
+/// Obtain a handle from the [`GameDistributionIdempotencyReceiptTableAccess::game_distribution_idempotency_receipt`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_distribution_idempotency_receipt()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_idempotency_receipt().on_insert(...)`.
+pub struct GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    imp: __sdk::TableHandle<GameDistributionIdempotencyReceipt>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_distribution_idempotency_receipt`.
+pub struct GameDistributionIdempotencyReceiptTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameDistributionIdempotencyReceiptTableAccessor {
+    type Row = GameDistributionIdempotencyReceipt;
+    type Handle<'db> = GameDistributionIdempotencyReceiptTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_distribution_idempotency_receipt()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_distribution_idempotency_receipt`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameDistributionIdempotencyReceiptTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameDistributionIdempotencyReceiptTableHandle`], which mediates access to the table `game_distribution_idempotency_receipt`.
+    fn game_distribution_idempotency_receipt(
+        &self,
+    ) -> GameDistributionIdempotencyReceiptTableHandle<'_>;
+}
+
+impl GameDistributionIdempotencyReceiptTableAccess for super::RemoteTables {
+    fn game_distribution_idempotency_receipt(
+        &self,
+    ) -> GameDistributionIdempotencyReceiptTableHandle<'_> {
+        GameDistributionIdempotencyReceiptTableHandle {
+            imp: self.imp.get_table::<GameDistributionIdempotencyReceipt>(
+                "game_distribution_idempotency_receipt",
+            ),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameDistributionIdempotencyReceiptInsertCallbackId(__sdk::CallbackId);
+pub struct GameDistributionIdempotencyReceiptDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    type Row = GameDistributionIdempotencyReceipt;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionIdempotencyReceipt> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    type Row = GameDistributionIdempotencyReceipt;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionIdempotencyReceipt> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameDistributionIdempotencyReceiptInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionIdempotencyReceiptInsertCallbackId {
+        GameDistributionIdempotencyReceiptInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionIdempotencyReceiptInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameDistributionIdempotencyReceiptDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionIdempotencyReceiptDeleteCallbackId {
+        GameDistributionIdempotencyReceiptDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionIdempotencyReceiptDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    type InsertCallbackId = GameDistributionIdempotencyReceiptInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionIdempotencyReceiptInsertCallbackId {
+        GameDistributionIdempotencyReceiptInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionIdempotencyReceiptInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    type DeleteCallbackId = GameDistributionIdempotencyReceiptDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionIdempotencyReceiptDeleteCallbackId {
+        GameDistributionIdempotencyReceiptDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionIdempotencyReceiptDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameDistributionIdempotencyReceiptUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionIdempotencyReceiptUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionIdempotencyReceiptUpdateCallbackId {
+        GameDistributionIdempotencyReceiptUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionIdempotencyReceiptUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionIdempotencyReceiptUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionIdempotencyReceiptUpdateCallbackId {
+        GameDistributionIdempotencyReceiptUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionIdempotencyReceiptUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `receipt_id` unique index on the table `game_distribution_idempotency_receipt`,
+/// which allows point queries on the field of the same name
+/// via the [`GameDistributionIdempotencyReceiptReceiptIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_idempotency_receipt().receipt_id().find(...)`.
+pub struct GameDistributionIdempotencyReceiptReceiptIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<GameDistributionIdempotencyReceipt, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameDistributionIdempotencyReceiptTableHandle<'ctx> {
+    /// Get a handle on the `receipt_id` unique index on the table `game_distribution_idempotency_receipt`.
+    pub fn receipt_id(&self) -> GameDistributionIdempotencyReceiptReceiptIdUnique<'ctx> {
+        GameDistributionIdempotencyReceiptReceiptIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("receipt_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameDistributionIdempotencyReceiptReceiptIdUnique<'ctx> {
+    /// Find the subscribed row whose `receipt_id` column value is equal to `col_val`,
+    /// if such a row is present in the client cache.
+    pub fn find(&self, col_val: &String) -> Option<GameDistributionIdempotencyReceipt> {
+        self.imp.find(col_val)
+    }
+}
+
+#[doc(hidden)]
+pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
+    let _table = client_cache.get_or_make_table::<GameDistributionIdempotencyReceipt>(
+        "game_distribution_idempotency_receipt",
+    );
+    _table.add_unique_constraint::<String>("receipt_id", |row| &row.receipt_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<GameDistributionIdempotencyReceipt>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse(
+            "TableUpdate<GameDistributionIdempotencyReceipt>",
+            "TableUpdate",
+        )
+        .with_cause(e)
+        .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `GameDistributionIdempotencyReceipt`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_distribution_idempotency_receiptQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `GameDistributionIdempotencyReceipt`.
+    fn game_distribution_idempotency_receipt(
+        &self,
+    ) -> __sdk::__query_builder::Table<GameDistributionIdempotencyReceipt>;
+}
+
+impl game_distribution_idempotency_receiptQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_distribution_idempotency_receipt(
+        &self,
+    ) -> __sdk::__query_builder::Table<GameDistributionIdempotencyReceipt> {
+        __sdk::__query_builder::Table::new("game_distribution_idempotency_receipt")
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_idempotency_receipt_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_idempotency_receipt_type.rs
new file mode 100644
index 000000000..eb58a1ff4
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_idempotency_receipt_type.rs
@@ -0,0 +1,101 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionIdempotencyReceipt {
+    pub receipt_id: String,
+    pub owner_user_id: String,
+    pub action: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub game_id: Option<String>,
+    pub version_id: Option<String>,
+    pub outcome_kind: String,
+    pub outcome_game_id: Option<String>,
+    pub outcome_version_id: Option<String>,
+    pub outcome_json: Option<String>,
+    pub created_at: __sdk::Timestamp,
+    pub expires_at: __sdk::Timestamp,
+    pub completed_at: Option<__sdk::Timestamp>,
+}
+
+impl __sdk::InModule for GameDistributionIdempotencyReceipt {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `GameDistributionIdempotencyReceipt`.
+///
+/// Provides typed access to columns for query building.
+pub struct GameDistributionIdempotencyReceiptCols {
+    pub receipt_id: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, String>,
+    pub action: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, String>,
+    pub idempotency_key: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, String>,
+    pub request_digest: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, String>,
+    pub game_id: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, Option<String>>,
+    pub version_id: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, Option<String>>,
+    pub outcome_kind: __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, String>,
+    pub outcome_game_id:
+        __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, Option<String>>,
+    pub outcome_version_id:
+        __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, Option<String>>,
+    pub outcome_json:
+        __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, Option<String>>,
+    pub created_at:
+        __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, __sdk::Timestamp>,
+    pub expires_at:
+        __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, __sdk::Timestamp>,
+    pub completed_at:
+        __sdk::__query_builder::Col<GameDistributionIdempotencyReceipt, Option<__sdk::Timestamp>>,
+}
+
+impl __sdk::__query_builder::HasCols for GameDistributionIdempotencyReceipt {
+    type Cols = GameDistributionIdempotencyReceiptCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        GameDistributionIdempotencyReceiptCols {
+            receipt_id: __sdk::__query_builder::Col::new(table_name, "receipt_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            action: __sdk::__query_builder::Col::new(table_name, "action"),
+            idempotency_key: __sdk::__query_builder::Col::new(table_name, "idempotency_key"),
+            request_digest: __sdk::__query_builder::Col::new(table_name, "request_digest"),
+            game_id: __sdk::__query_builder::Col::new(table_name, "game_id"),
+            version_id: __sdk::__query_builder::Col::new(table_name, "version_id"),
+            outcome_kind: __sdk::__query_builder::Col::new(table_name, "outcome_kind"),
+            outcome_game_id: __sdk::__query_builder::Col::new(table_name, "outcome_game_id"),
+            outcome_version_id: __sdk::__query_builder::Col::new(table_name, "outcome_version_id"),
+            outcome_json: __sdk::__query_builder::Col::new(table_name, "outcome_json"),
+            created_at: __sdk::__query_builder::Col::new(table_name, "created_at"),
+            expires_at: __sdk::__query_builder::Col::new(table_name, "expires_at"),
+            completed_at: __sdk::__query_builder::Col::new(table_name, "completed_at"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `GameDistributionIdempotencyReceipt`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct GameDistributionIdempotencyReceiptIxCols {
+    pub game_id: __sdk::__query_builder::IxCol<GameDistributionIdempotencyReceipt, Option<String>>,
+    pub owner_user_id: __sdk::__query_builder::IxCol<GameDistributionIdempotencyReceipt, String>,
+    pub receipt_id: __sdk::__query_builder::IxCol<GameDistributionIdempotencyReceipt, String>,
+    pub version_id:
+        __sdk::__query_builder::IxCol<GameDistributionIdempotencyReceipt, Option<String>>,
+}
+
+impl __sdk::__query_builder::HasIxCols for GameDistributionIdempotencyReceipt {
+    type IxCols = GameDistributionIdempotencyReceiptIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        GameDistributionIdempotencyReceiptIxCols {
+            game_id: __sdk::__query_builder::IxCol::new(table_name, "game_id"),
+            owner_user_id: __sdk::__query_builder::IxCol::new(table_name, "owner_user_id"),
+            receipt_id: __sdk::__query_builder::IxCol::new(table_name, "receipt_id"),
+            version_id: __sdk::__query_builder::IxCol::new(table_name, "version_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for GameDistributionIdempotencyReceipt {}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_list_input_type.rs
new file mode 100644
index 000000000..0eff02fb8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_list_input_type.rs
@@ -0,0 +1,16 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionOwnerGameListInput {
+    pub owner_user_id: String,
+    pub limit: u32,
+}
+
+impl __sdk::InModule for GameDistributionOwnerGameListInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_list_procedure_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_list_procedure_result_type.rs
new file mode 100644
index 000000000..4bedf5e9f
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_list_procedure_result_type.rs
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_owner_game_snapshot_type::GameDistributionOwnerGameSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionOwnerGameListProcedureResult {
+    pub ok: bool,
+    pub games: Vec<GameDistributionOwnerGameSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionOwnerGameListProcedureResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_snapshot_type.rs
new file mode 100644
index 000000000..67a5946db
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_game_snapshot_type.rs
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_game_snapshot_type::GameDistributionGameSnapshot;
+use super::game_distribution_version_snapshot_type::GameDistributionVersionSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionOwnerGameSnapshot {
+    pub game: GameDistributionGameSnapshot,
+    pub versions: Vec<GameDistributionVersionSnapshot>,
+}
+
+impl __sdk::InModule for GameDistributionOwnerGameSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_version_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_version_input_type.rs
new file mode 100644
index 000000000..5c8a1316d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_owner_version_input_type.rs
@@ -0,0 +1,16 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionOwnerVersionInput {
+    pub owner_user_id: String,
+    pub version_id: String,
+}
+
+impl __sdk::InModule for GameDistributionOwnerVersionInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_procedure_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_procedure_result_type.rs
new file mode 100644
index 000000000..e27d1fad4
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_procedure_result_type.rs
@@ -0,0 +1,25 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_game_snapshot_type::GameDistributionGameSnapshot;
+use super::game_distribution_version_snapshot_type::GameDistributionVersionSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionProcedureResult {
+    pub ok: bool,
+    pub replayed: bool,
+    pub game: Option<GameDistributionGameSnapshot>,
+    pub games: Vec<GameDistributionGameSnapshot>,
+    pub version: Option<GameDistributionVersionSnapshot>,
+    pub versions: Vec<GameDistributionVersionSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionProcedureResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_input_type.rs
new file mode 100644
index 000000000..1315ec6a3
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_input_type.rs
@@ -0,0 +1,15 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionPublicGameInput {
+    pub game_id: String,
+}
+
+impl __sdk::InModule for GameDistributionPublicGameInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_list_input_type.rs
new file mode 100644
index 000000000..1d02c17ab
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_list_input_type.rs
@@ -0,0 +1,17 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionPublicGameListInput {
+    pub search: Option<String>,
+    pub category: Option<String>,
+    pub limit: u32,
+}
+
+impl __sdk::InModule for GameDistributionPublicGameListInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_snapshot_type.rs
new file mode 100644
index 000000000..554c13887
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_public_game_snapshot_type.rs
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_game_snapshot_type::GameDistributionGameSnapshot;
+use super::game_distribution_version_snapshot_type::GameDistributionVersionSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionPublicGameSnapshot {
+    pub game: GameDistributionGameSnapshot,
+    pub current_version: Option<GameDistributionVersionSnapshot>,
+}
+
+impl __sdk::InModule for GameDistributionPublicGameSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_reject_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_reject_input_type.rs
new file mode 100644
index 000000000..f347cb694
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_reject_input_type.rs
@@ -0,0 +1,21 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionRejectInput {
+    pub version_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub review_reason: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionRejectInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_review_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_review_list_input_type.rs
new file mode 100644
index 000000000..dd4933377
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_review_list_input_type.rs
@@ -0,0 +1,15 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionReviewListInput {
+    pub limit: u32,
+}
+
+impl __sdk::InModule for GameDistributionReviewListInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_submit_review_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_submit_review_input_type.rs
new file mode 100644
index 000000000..a85ca148d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_submit_review_input_type.rs
@@ -0,0 +1,20 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionSubmitReviewInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionSubmitReviewInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_suspend_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_suspend_input_type.rs
new file mode 100644
index 000000000..192323a50
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_suspend_input_type.rs
@@ -0,0 +1,21 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionSuspendInput {
+    pub game_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub reason: Option<String>,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionSuspendInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_unpublish_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_unpublish_input_type.rs
new file mode 100644
index 000000000..7439906ee
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_unpublish_input_type.rs
@@ -0,0 +1,20 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionUnpublishInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionUnpublishInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_lookup_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_lookup_input_type.rs
new file mode 100644
index 000000000..df63e6f7f
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_lookup_input_type.rs
@@ -0,0 +1,15 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionVersionLookupInput {
+    pub version_id: String,
+}
+
+impl __sdk::InModule for GameDistributionVersionLookupInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_procedure_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_procedure_result_type.rs
new file mode 100644
index 000000000..5e5cb747e
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_procedure_result_type.rs
@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_version_snapshot_type::GameDistributionVersionSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionVersionProcedureResult {
+    pub ok: bool,
+    pub version: Option<GameDistributionVersionSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionVersionProcedureResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_snapshot_type.rs
new file mode 100644
index 000000000..45699b193
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_snapshot_type.rs
@@ -0,0 +1,28 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionVersionSnapshot {
+    pub version_id: String,
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_number: u64,
+    pub package_sha_256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub status: String,
+    pub review_reason: Option<String>,
+    pub entry_url: Option<String>,
+    pub publication_revision: u64,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionVersionSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_table.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_table.rs
new file mode 100644
index 000000000..e73257b66
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_table.rs
@@ -0,0 +1,231 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use super::game_distribution_version_type::GameDistributionVersion;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_distribution_version`.
+///
+/// Obtain a handle from the [`GameDistributionVersionTableAccess::game_distribution_version`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_distribution_version()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_version().on_insert(...)`.
+pub struct GameDistributionVersionTableHandle<'ctx> {
+    imp: __sdk::TableHandle<GameDistributionVersion>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_distribution_version`.
+pub struct GameDistributionVersionTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameDistributionVersionTableAccessor {
+    type Row = GameDistributionVersion;
+    type Handle<'db> = GameDistributionVersionTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_distribution_version()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_distribution_version`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameDistributionVersionTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameDistributionVersionTableHandle`], which mediates access to the table `game_distribution_version`.
+    fn game_distribution_version(&self) -> GameDistributionVersionTableHandle<'_>;
+}
+
+impl GameDistributionVersionTableAccess for super::RemoteTables {
+    fn game_distribution_version(&self) -> GameDistributionVersionTableHandle<'_> {
+        GameDistributionVersionTableHandle {
+            imp: self
+                .imp
+                .get_table::<GameDistributionVersion>("game_distribution_version"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameDistributionVersionInsertCallbackId(__sdk::CallbackId);
+pub struct GameDistributionVersionDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameDistributionVersionTableHandle<'ctx> {
+    type Row = GameDistributionVersion;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionVersion> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameDistributionVersionTableHandle<'ctx> {
+    type Row = GameDistributionVersion;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionVersion> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameDistributionVersionInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionVersionInsertCallbackId {
+        GameDistributionVersionInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionVersionInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameDistributionVersionDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionVersionDeleteCallbackId {
+        GameDistributionVersionDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionVersionDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameDistributionVersionTableHandle<'ctx> {
+    type InsertCallbackId = GameDistributionVersionInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionVersionInsertCallbackId {
+        GameDistributionVersionInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionVersionInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameDistributionVersionTableHandle<'ctx> {
+    type DeleteCallbackId = GameDistributionVersionDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionVersionDeleteCallbackId {
+        GameDistributionVersionDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionVersionDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameDistributionVersionUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameDistributionVersionTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionVersionUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionVersionUpdateCallbackId {
+        GameDistributionVersionUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionVersionUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameDistributionVersionTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionVersionUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionVersionUpdateCallbackId {
+        GameDistributionVersionUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionVersionUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `version_id` unique index on the table `game_distribution_version`,
+/// which allows point queries on the field of the same name
+/// via the [`GameDistributionVersionVersionIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_version().version_id().find(...)`.
+pub struct GameDistributionVersionVersionIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<GameDistributionVersion, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameDistributionVersionTableHandle<'ctx> {
+    /// Get a handle on the `version_id` unique index on the table `game_distribution_version`.
+    pub fn version_id(&self) -> GameDistributionVersionVersionIdUnique<'ctx> {
+        GameDistributionVersionVersionIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("version_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameDistributionVersionVersionIdUnique<'ctx> {
+    /// Find the subscribed row whose `version_id` column value is equal to `col_val`,
+    /// if such a row is present in the client cache.
+    pub fn find(&self, col_val: &String) -> Option<GameDistributionVersion> {
+        self.imp.find(col_val)
+    }
+}
+
+#[doc(hidden)]
+pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
+    let _table =
+        client_cache.get_or_make_table::<GameDistributionVersion>("game_distribution_version");
+    _table.add_unique_constraint::<String>("version_id", |row| &row.version_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<GameDistributionVersion>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<GameDistributionVersion>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `GameDistributionVersion`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_distribution_versionQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `GameDistributionVersion`.
+    fn game_distribution_version(&self) -> __sdk::__query_builder::Table<GameDistributionVersion>;
+}
+
+impl game_distribution_versionQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_distribution_version(&self) -> __sdk::__query_builder::Table<GameDistributionVersion> {
+        __sdk::__query_builder::Table::new("game_distribution_version")
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_type.rs
new file mode 100644
index 000000000..e1a08f8e2
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_version_type.rs
@@ -0,0 +1,130 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionVersion {
+    pub version_id: String,
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_number: u64,
+    pub package_sha_256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub status: String,
+    pub review_reason: Option<String>,
+    pub created_at: __sdk::Timestamp,
+    pub updated_at: __sdk::Timestamp,
+    pub local_project_id: Option<String>,
+    pub package_object_key: Option<String>,
+    pub package_manifest_json: Option<String>,
+    pub entry_url: Option<String>,
+    pub reviewed_by_user_id: Option<String>,
+    pub uploaded_at: Option<__sdk::Timestamp>,
+    pub submitted_at: Option<__sdk::Timestamp>,
+    pub reviewed_at: Option<__sdk::Timestamp>,
+    pub published_at: Option<__sdk::Timestamp>,
+    pub revoked_at: Option<__sdk::Timestamp>,
+    pub last_error_code: Option<String>,
+    pub last_error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionVersion {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `GameDistributionVersion`.
+///
+/// Provides typed access to columns for query building.
+pub struct GameDistributionVersionCols {
+    pub version_id: __sdk::__query_builder::Col<GameDistributionVersion, String>,
+    pub game_id: __sdk::__query_builder::Col<GameDistributionVersion, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<GameDistributionVersion, String>,
+    pub version_number: __sdk::__query_builder::Col<GameDistributionVersion, u64>,
+    pub package_sha_256: __sdk::__query_builder::Col<GameDistributionVersion, String>,
+    pub package_bytes: __sdk::__query_builder::Col<GameDistributionVersion, u64>,
+    pub package_file_count: __sdk::__query_builder::Col<GameDistributionVersion, u32>,
+    pub package_entry_path: __sdk::__query_builder::Col<GameDistributionVersion, String>,
+    pub status: __sdk::__query_builder::Col<GameDistributionVersion, String>,
+    pub review_reason: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub created_at: __sdk::__query_builder::Col<GameDistributionVersion, __sdk::Timestamp>,
+    pub updated_at: __sdk::__query_builder::Col<GameDistributionVersion, __sdk::Timestamp>,
+    pub local_project_id: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub package_object_key: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub package_manifest_json: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub entry_url: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub reviewed_by_user_id: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub uploaded_at: __sdk::__query_builder::Col<GameDistributionVersion, Option<__sdk::Timestamp>>,
+    pub submitted_at:
+        __sdk::__query_builder::Col<GameDistributionVersion, Option<__sdk::Timestamp>>,
+    pub reviewed_at: __sdk::__query_builder::Col<GameDistributionVersion, Option<__sdk::Timestamp>>,
+    pub published_at:
+        __sdk::__query_builder::Col<GameDistributionVersion, Option<__sdk::Timestamp>>,
+    pub revoked_at: __sdk::__query_builder::Col<GameDistributionVersion, Option<__sdk::Timestamp>>,
+    pub last_error_code: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub last_error_message: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+}
+
+impl __sdk::__query_builder::HasCols for GameDistributionVersion {
+    type Cols = GameDistributionVersionCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        GameDistributionVersionCols {
+            version_id: __sdk::__query_builder::Col::new(table_name, "version_id"),
+            game_id: __sdk::__query_builder::Col::new(table_name, "game_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            version_number: __sdk::__query_builder::Col::new(table_name, "version_number"),
+            package_sha_256: __sdk::__query_builder::Col::new(table_name, "package_sha_256"),
+            package_bytes: __sdk::__query_builder::Col::new(table_name, "package_bytes"),
+            package_file_count: __sdk::__query_builder::Col::new(table_name, "package_file_count"),
+            package_entry_path: __sdk::__query_builder::Col::new(table_name, "package_entry_path"),
+            status: __sdk::__query_builder::Col::new(table_name, "status"),
+            review_reason: __sdk::__query_builder::Col::new(table_name, "review_reason"),
+            created_at: __sdk::__query_builder::Col::new(table_name, "created_at"),
+            updated_at: __sdk::__query_builder::Col::new(table_name, "updated_at"),
+            local_project_id: __sdk::__query_builder::Col::new(table_name, "local_project_id"),
+            package_object_key: __sdk::__query_builder::Col::new(table_name, "package_object_key"),
+            package_manifest_json: __sdk::__query_builder::Col::new(
+                table_name,
+                "package_manifest_json",
+            ),
+            entry_url: __sdk::__query_builder::Col::new(table_name, "entry_url"),
+            reviewed_by_user_id: __sdk::__query_builder::Col::new(
+                table_name,
+                "reviewed_by_user_id",
+            ),
+            uploaded_at: __sdk::__query_builder::Col::new(table_name, "uploaded_at"),
+            submitted_at: __sdk::__query_builder::Col::new(table_name, "submitted_at"),
+            reviewed_at: __sdk::__query_builder::Col::new(table_name, "reviewed_at"),
+            published_at: __sdk::__query_builder::Col::new(table_name, "published_at"),
+            revoked_at: __sdk::__query_builder::Col::new(table_name, "revoked_at"),
+            last_error_code: __sdk::__query_builder::Col::new(table_name, "last_error_code"),
+            last_error_message: __sdk::__query_builder::Col::new(table_name, "last_error_message"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `GameDistributionVersion`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct GameDistributionVersionIxCols {
+    pub game_id: __sdk::__query_builder::IxCol<GameDistributionVersion, String>,
+    pub owner_user_id: __sdk::__query_builder::IxCol<GameDistributionVersion, String>,
+    pub version_id: __sdk::__query_builder::IxCol<GameDistributionVersion, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for GameDistributionVersion {
+    type IxCols = GameDistributionVersionIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        GameDistributionVersionIxCols {
+            game_id: __sdk::__query_builder::IxCol::new(table_name, "game_id"),
+            owner_user_id: __sdk::__query_builder::IxCol::new(table_name, "owner_user_id"),
+            version_id: __sdk::__query_builder::IxCol::new(table_name, "version_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for GameDistributionVersion {}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_game_and_return_procedure.rs
new file mode 100644
index 000000000..823d4f2e3
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_game_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_get_game_input_type::GameDistributionGetGameInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetGameDistributionGameAndReturnArgs {
+    pub input: GameDistributionGetGameInput,
+}
+
+impl __sdk::InModule for GetGameDistributionGameAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_game_distribution_game_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_game_distribution_game_and_return {
+    fn get_game_distribution_game_and_return(&self, input: GameDistributionGetGameInput) {
+        self.get_game_distribution_game_and_return_then(input, |_, _| {});
+    }
+
+    fn get_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionGetGameInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl get_game_distribution_game_and_return for super::RemoteProcedures {
+    fn get_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionGetGameInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "get_game_distribution_game_and_return",
+                GetGameDistributionGameAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_version_and_return_procedure.rs
new file mode 100644
index 000000000..41de8b95f
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_version_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_version_lookup_input_type::GameDistributionVersionLookupInput;
+use super::game_distribution_version_procedure_result_type::GameDistributionVersionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetGameDistributionVersionAndReturnArgs {
+    pub input: GameDistributionVersionLookupInput,
+}
+
+impl __sdk::InModule for GetGameDistributionVersionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_game_distribution_version_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_game_distribution_version_and_return {
+    fn get_game_distribution_version_and_return(&self, input: GameDistributionVersionLookupInput) {
+        self.get_game_distribution_version_and_return_then(input, |_, _| {});
+    }
+
+    fn get_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionVersionLookupInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl get_game_distribution_version_and_return for super::RemoteProcedures {
+    fn get_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionVersionLookupInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionVersionProcedureResult>(
+                "get_game_distribution_version_and_return",
+                GetGameDistributionVersionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_owner_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_owner_game_distribution_version_and_return_procedure.rs
new file mode 100644
index 000000000..d4cd499f9
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_owner_game_distribution_version_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_owner_version_input_type::GameDistributionOwnerVersionInput;
+use super::game_distribution_version_procedure_result_type::GameDistributionVersionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetOwnerGameDistributionVersionAndReturnArgs {
+    pub input: GameDistributionOwnerVersionInput,
+}
+
+impl __sdk::InModule for GetOwnerGameDistributionVersionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_owner_game_distribution_version_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_owner_game_distribution_version_and_return {
+    fn get_owner_game_distribution_version_and_return(
+        &self,
+        input: GameDistributionOwnerVersionInput,
+    ) {
+        self.get_owner_game_distribution_version_and_return_then(input, |_, _| {});
+    }
+
+    fn get_owner_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionOwnerVersionInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl get_owner_game_distribution_version_and_return for super::RemoteProcedures {
+    fn get_owner_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionOwnerVersionInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionVersionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionVersionProcedureResult>(
+                "get_owner_game_distribution_version_and_return",
+                GetOwnerGameDistributionVersionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_public_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_public_game_distribution_game_and_return_procedure.rs
new file mode 100644
index 000000000..7ed9a62a0
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_public_game_distribution_game_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_game_procedure_result_type::GameDistributionGameProcedureResult;
+use super::game_distribution_public_game_input_type::GameDistributionPublicGameInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetPublicGameDistributionGameAndReturnArgs {
+    pub input: GameDistributionPublicGameInput,
+}
+
+impl __sdk::InModule for GetPublicGameDistributionGameAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_public_game_distribution_game_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_public_game_distribution_game_and_return {
+    fn get_public_game_distribution_game_and_return(&self, input: GameDistributionPublicGameInput) {
+        self.get_public_game_distribution_game_and_return_then(input, |_, _| {});
+    }
+
+    fn get_public_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionPublicGameInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionGameProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl get_public_game_distribution_game_and_return for super::RemoteProcedures {
+    fn get_public_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionPublicGameInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionGameProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionGameProcedureResult>(
+                "get_public_game_distribution_game_and_return",
+                GetPublicGameDistributionGameAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_games_and_return_procedure.rs
new file mode 100644
index 000000000..7c75774e5
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_games_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+use super::game_distribution_public_game_list_input_type::GameDistributionPublicGameListInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListGameDistributionGamesAndReturnArgs {
+    pub input: GameDistributionPublicGameListInput,
+}
+
+impl __sdk::InModule for ListGameDistributionGamesAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_game_distribution_games_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_game_distribution_games_and_return {
+    fn list_game_distribution_games_and_return(&self, input: GameDistributionPublicGameListInput) {
+        self.list_game_distribution_games_and_return_then(input, |_, _| {});
+    }
+
+    fn list_game_distribution_games_and_return_then(
+        &self,
+        input: GameDistributionPublicGameListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl list_game_distribution_games_and_return for super::RemoteProcedures {
+    fn list_game_distribution_games_and_return_then(
+        &self,
+        input: GameDistributionPublicGameListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "list_game_distribution_games_and_return",
+                ListGameDistributionGamesAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_reviews_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_reviews_and_return_procedure.rs
new file mode 100644
index 000000000..0edb574ed
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_reviews_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+use super::game_distribution_review_list_input_type::GameDistributionReviewListInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListGameDistributionReviewsAndReturnArgs {
+    pub input: GameDistributionReviewListInput,
+}
+
+impl __sdk::InModule for ListGameDistributionReviewsAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_game_distribution_reviews_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_game_distribution_reviews_and_return {
+    fn list_game_distribution_reviews_and_return(&self, input: GameDistributionReviewListInput) {
+        self.list_game_distribution_reviews_and_return_then(input, |_, _| {});
+    }
+
+    fn list_game_distribution_reviews_and_return_then(
+        &self,
+        input: GameDistributionReviewListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl list_game_distribution_reviews_and_return for super::RemoteProcedures {
+    fn list_game_distribution_reviews_and_return_then(
+        &self,
+        input: GameDistributionReviewListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "list_game_distribution_reviews_and_return",
+                ListGameDistributionReviewsAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_owner_game_distribution_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_owner_game_distribution_games_and_return_procedure.rs
new file mode 100644
index 000000000..9e495141d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_owner_game_distribution_games_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_owner_game_list_input_type::GameDistributionOwnerGameListInput;
+use super::game_distribution_owner_game_list_procedure_result_type::GameDistributionOwnerGameListProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListOwnerGameDistributionGamesAndReturnArgs {
+    pub input: GameDistributionOwnerGameListInput,
+}
+
+impl __sdk::InModule for ListOwnerGameDistributionGamesAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_owner_game_distribution_games_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_owner_game_distribution_games_and_return {
+    fn list_owner_game_distribution_games_and_return(
+        &self,
+        input: GameDistributionOwnerGameListInput,
+    ) {
+        self.list_owner_game_distribution_games_and_return_then(input, |_, _| {});
+    }
+
+    fn list_owner_game_distribution_games_and_return_then(
+        &self,
+        input: GameDistributionOwnerGameListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionOwnerGameListProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl list_owner_game_distribution_games_and_return for super::RemoteProcedures {
+    fn list_owner_game_distribution_games_and_return_then(
+        &self,
+        input: GameDistributionOwnerGameListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionOwnerGameListProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionOwnerGameListProcedureResult>(
+                "list_owner_game_distribution_games_and_return",
+                ListOwnerGameDistributionGamesAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_public_game_distribution_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_public_game_distribution_games_and_return_procedure.rs
new file mode 100644
index 000000000..90efdc26b
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_public_game_distribution_games_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_game_list_procedure_result_type::GameDistributionGameListProcedureResult;
+use super::game_distribution_public_game_list_input_type::GameDistributionPublicGameListInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListPublicGameDistributionGamesAndReturnArgs {
+    pub input: GameDistributionPublicGameListInput,
+}
+
+impl __sdk::InModule for ListPublicGameDistributionGamesAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_public_game_distribution_games_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_public_game_distribution_games_and_return {
+    fn list_public_game_distribution_games_and_return(
+        &self,
+        input: GameDistributionPublicGameListInput,
+    ) {
+        self.list_public_game_distribution_games_and_return_then(input, |_, _| {});
+    }
+
+    fn list_public_game_distribution_games_and_return_then(
+        &self,
+        input: GameDistributionPublicGameListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionGameListProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl list_public_game_distribution_games_and_return for super::RemoteProcedures {
+    fn list_public_game_distribution_games_and_return_then(
+        &self,
+        input: GameDistributionPublicGameListInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionGameListProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionGameListProcedureResult>(
+                "list_public_game_distribution_games_and_return",
+                ListPublicGameDistributionGamesAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/reject_game_distribution_version_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/reject_game_distribution_version_and_return_procedure.rs
new file mode 100644
index 000000000..c1a720f7b
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/reject_game_distribution_version_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+use super::game_distribution_reject_input_type::GameDistributionRejectInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct RejectGameDistributionVersionAndReturnArgs {
+    pub input: GameDistributionRejectInput,
+}
+
+impl __sdk::InModule for RejectGameDistributionVersionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `reject_game_distribution_version_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait reject_game_distribution_version_and_return {
+    fn reject_game_distribution_version_and_return(&self, input: GameDistributionRejectInput) {
+        self.reject_game_distribution_version_and_return_then(input, |_, _| {});
+    }
+
+    fn reject_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionRejectInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl reject_game_distribution_version_and_return for super::RemoteProcedures {
+    fn reject_game_distribution_version_and_return_then(
+        &self,
+        input: GameDistributionRejectInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "reject_game_distribution_version_and_return",
+                RejectGameDistributionVersionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/submit_game_distribution_version_for_review_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/submit_game_distribution_version_for_review_and_return_procedure.rs
new file mode 100644
index 000000000..f68aeb183
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/submit_game_distribution_version_for_review_and_return_procedure.rs
@@ -0,0 +1,62 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+use super::game_distribution_submit_review_input_type::GameDistributionSubmitReviewInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct SubmitGameDistributionVersionForReviewAndReturnArgs {
+    pub input: GameDistributionSubmitReviewInput,
+}
+
+impl __sdk::InModule for SubmitGameDistributionVersionForReviewAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `submit_game_distribution_version_for_review_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait submit_game_distribution_version_for_review_and_return {
+    fn submit_game_distribution_version_for_review_and_return(
+        &self,
+        input: GameDistributionSubmitReviewInput,
+    ) {
+        self.submit_game_distribution_version_for_review_and_return_then(input, |_, _| {});
+    }
+
+    fn submit_game_distribution_version_for_review_and_return_then(
+        &self,
+        input: GameDistributionSubmitReviewInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl submit_game_distribution_version_for_review_and_return for super::RemoteProcedures {
+    fn submit_game_distribution_version_for_review_and_return_then(
+        &self,
+        input: GameDistributionSubmitReviewInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "submit_game_distribution_version_for_review_and_return",
+                SubmitGameDistributionVersionForReviewAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/suspend_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/suspend_game_distribution_game_and_return_procedure.rs
new file mode 100644
index 000000000..e13060da1
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/suspend_game_distribution_game_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+use super::game_distribution_suspend_input_type::GameDistributionSuspendInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct SuspendGameDistributionGameAndReturnArgs {
+    pub input: GameDistributionSuspendInput,
+}
+
+impl __sdk::InModule for SuspendGameDistributionGameAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `suspend_game_distribution_game_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait suspend_game_distribution_game_and_return {
+    fn suspend_game_distribution_game_and_return(&self, input: GameDistributionSuspendInput) {
+        self.suspend_game_distribution_game_and_return_then(input, |_, _| {});
+    }
+
+    fn suspend_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionSuspendInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl suspend_game_distribution_game_and_return for super::RemoteProcedures {
+    fn suspend_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionSuspendInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "suspend_game_distribution_game_and_return",
+                SuspendGameDistributionGameAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/unpublish_game_distribution_game_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/unpublish_game_distribution_game_and_return_procedure.rs
new file mode 100644
index 000000000..190b12f0c
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/unpublish_game_distribution_game_and_return_procedure.rs
@@ -0,0 +1,59 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+use super::game_distribution_unpublish_input_type::GameDistributionUnpublishInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct UnpublishGameDistributionGameAndReturnArgs {
+    pub input: GameDistributionUnpublishInput,
+}
+
+impl __sdk::InModule for UnpublishGameDistributionGameAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `unpublish_game_distribution_game_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait unpublish_game_distribution_game_and_return {
+    fn unpublish_game_distribution_game_and_return(&self, input: GameDistributionUnpublishInput) {
+        self.unpublish_game_distribution_game_and_return_then(input, |_, _| {});
+    }
+
+    fn unpublish_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionUnpublishInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    );
+}
+
+impl unpublish_game_distribution_game_and_return for super::RemoteProcedures {
+    fn unpublish_game_distribution_game_and_return_then(
+        &self,
+        input: GameDistributionUnpublishInput,
+
+        __callback: impl FnOnce(
+                &super::ProcedureEventContext,
+                Result<GameDistributionProcedureResult, __sdk::InternalError>,
+            ) + Send
+            + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "unpublish_game_distribution_game_and_return",
+                UnpublishGameDistributionGameAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-module/src/game_distribution.rs b/server-rs/crates/spacetime-module/src/game_distribution.rs
new file mode 100644
index 000000000..5b4019150
--- /dev/null
+++ b/server-rs/crates/spacetime-module/src/game_distribution.rs
@@ -0,0 +1,2218 @@
+use crate::*;
+
+// 游戏分发的持久化事实。状态机和输入校验位于 `module-game-distribution`；这些表只保存
+// owner、版本内容摘要、公开版本 CAS 和可恢复操作收据，HTTP / 对象存储编排留在 api-server。
+
+/// 作者创建的游戏身份及当前公开版本指针。
+///
+/// 资料字段使用 JSON 保存数组，避免为尚未冻结的展示 DTO 引入可破坏的 schema 变更。
+#[spacetimedb::table(
+    accessor = game_distribution_game,
+    index(
+        accessor = by_game_distribution_game_owner_user_id,
+        btree(columns = [owner_user_id])
+    )
+)]
+#[derive(Clone)]
+pub struct GameDistributionGame {
+    #[primary_key]
+    pub(crate) game_id: String,
+    pub(crate) owner_user_id: String,
+    pub(crate) title: String,
+    pub(crate) summary: String,
+    pub(crate) description: String,
+    pub(crate) category: String,
+    pub(crate) tags_json: String,
+    pub(crate) cover_asset_id: Option<String>,
+    pub(crate) author_name: Option<String>,
+    pub(crate) author_avatar_url: Option<String>,
+    pub(crate) device_support_desktop: bool,
+    pub(crate) device_support_mobile: bool,
+    pub(crate) device_support_touch: bool,
+    pub(crate) input_modes_json: String,
+    pub(crate) orientation: String,
+    pub(crate) publication_revision: u64,
+    pub(crate) active_version_id: Option<String>,
+    pub(crate) visibility: String,
+    pub(crate) play_count: u64,
+    pub(crate) created_at: Timestamp,
+    pub(crate) updated_at: Timestamp,
+    /// AGC / 网页发布方的本地项目标识。只用于同一作者复用游戏身份，不构成所有权证明。
+    #[default(None::<String>)]
+    pub(crate) local_project_id: Option<String>,
+}
+
+/// 游戏发行版本。包摘要、确认字节数和送审资料在创建后作为不可变快照保留；状态和
+/// 审核/对象安装时间由后续事务推进。
+#[spacetimedb::table(
+    accessor = game_distribution_version,
+    index(
+        accessor = by_game_distribution_version_game_id,
+        btree(columns = [game_id])
+    ),
+    index(
+        accessor = by_game_distribution_version_owner_user_id,
+        btree(columns = [owner_user_id])
+    )
+)]
+#[derive(Clone)]
+pub struct GameDistributionVersion {
+    #[primary_key]
+    pub(crate) version_id: String,
+    pub(crate) game_id: String,
+    pub(crate) owner_user_id: String,
+    pub(crate) version_number: u64,
+    pub(crate) package_sha256: String,
+    pub(crate) package_bytes: u64,
+    pub(crate) package_file_count: u32,
+    pub(crate) package_entry_path: String,
+    pub(crate) status: String,
+    pub(crate) review_reason: Option<String>,
+    pub(crate) created_at: Timestamp,
+    pub(crate) updated_at: Timestamp,
+    #[default(None::<String>)]
+    pub(crate) local_project_id: Option<String>,
+    #[default(None::<String>)]
+    pub(crate) package_object_key: Option<String>,
+    #[default(None::<String>)]
+    pub(crate) package_manifest_json: Option<String>,
+    #[default(None::<String>)]
+    pub(crate) entry_url: Option<String>,
+    #[default(None::<String>)]
+    pub(crate) reviewed_by_user_id: Option<String>,
+    #[default(None::<Timestamp>)]
+    pub(crate) uploaded_at: Option<Timestamp>,
+    #[default(None::<Timestamp>)]
+    pub(crate) submitted_at: Option<Timestamp>,
+    #[default(None::<Timestamp>)]
+    pub(crate) reviewed_at: Option<Timestamp>,
+    #[default(None::<Timestamp>)]
+    pub(crate) published_at: Option<Timestamp>,
+    #[default(None::<Timestamp>)]
+    pub(crate) revoked_at: Option<Timestamp>,
+    #[default(None::<String>)]
+    pub(crate) last_error_code: Option<String>,
+    #[default(None::<String>)]
+    pub(crate) last_error_message: Option<String>,
+}
+
+/// 创建、提交、审核、撤回和下架等写操作的幂等收据。
+///
+/// `receipt_id` 由 api-server 按 owner、动作和 key 生成；组合索引供冲突检查和恢复查询
+/// 使用。结果字段只保存可回读的业务 ID，不保存对象存储凭据或完整上传内容。
+#[spacetimedb::table(
+    accessor = game_distribution_idempotency_receipt,
+    index(
+        accessor = by_game_distribution_receipt_owner_user_id,
+        btree(columns = [owner_user_id])
+    ),
+    index(
+        accessor = by_game_distribution_receipt_game_id,
+        btree(columns = [game_id])
+    ),
+    index(
+        accessor = by_game_distribution_receipt_version_id,
+        btree(columns = [version_id])
+    ),
+    index(
+        accessor = by_game_distribution_receipt_scope,
+        btree(columns = [owner_user_id, action, idempotency_key])
+    )
+)]
+pub struct GameDistributionIdempotencyReceipt {
+    #[primary_key]
+    pub(crate) receipt_id: String,
+    pub(crate) owner_user_id: String,
+    pub(crate) action: String,
+    pub(crate) idempotency_key: String,
+    pub(crate) request_digest: String,
+    pub(crate) game_id: Option<String>,
+    pub(crate) version_id: Option<String>,
+    pub(crate) outcome_kind: String,
+    pub(crate) outcome_game_id: Option<String>,
+    pub(crate) outcome_version_id: Option<String>,
+    pub(crate) outcome_json: Option<String>,
+    pub(crate) created_at: Timestamp,
+    pub(crate) expires_at: Timestamp,
+    #[default(None::<Timestamp>)]
+    pub(crate) completed_at: Option<Timestamp>,
+}
+
+const GAME_DISTRIBUTION_VISIBILITY_UNPUBLISHED: &str = "unpublished";
+const GAME_DISTRIBUTION_VISIBILITY_PUBLISHED: &str = "published";
+const GAME_DISTRIBUTION_VISIBILITY_SUSPENDED: &str = "suspended";
+const GAME_DISTRIBUTION_VERSION_AWAITING_UPLOAD: &str = "awaiting_upload";
+const GAME_DISTRIBUTION_VERSION_UPLOADED: &str = "uploaded";
+const GAME_DISTRIBUTION_VERSION_PUBLISHED: &str = "published";
+const GAME_DISTRIBUTION_VERSION_PENDING_REVIEW: &str = "pending_review";
+const GAME_DISTRIBUTION_VERSION_REJECTED: &str = "rejected";
+const GAME_DISTRIBUTION_VERSION_REVOKED: &str = "revoked";
+const GAME_DISTRIBUTION_VERSION_CANCELLED: &str = "cancelled";
+const GAME_DISTRIBUTION_VERSION_VALIDATING: &str = "validating";
+const GAME_DISTRIBUTION_VERSION_UPLOAD_FAILED: &str = "upload_failed";
+const GAME_DISTRIBUTION_VERSION_VALIDATION_FAILED: &str = "validation_failed";
+const GAME_DISTRIBUTION_ACTION_CREATE_GAME: &str = "create_game";
+const GAME_DISTRIBUTION_ACTION_CREATE_VERSION: &str = "create_version";
+const GAME_DISTRIBUTION_ACTION_CONFIRM_PACKAGE: &str = "confirm_package";
+const GAME_DISTRIBUTION_ACTION_FAIL_UPLOAD: &str = "fail_upload";
+const GAME_DISTRIBUTION_ACTION_SUBMIT_REVIEW: &str = "submit_review";
+const GAME_DISTRIBUTION_ACTION_CANCEL_VERSION: &str = "cancel_version";
+const GAME_DISTRIBUTION_ACTION_APPROVE: &str = "approve";
+const GAME_DISTRIBUTION_ACTION_REJECT: &str = "reject";
+const GAME_DISTRIBUTION_ACTION_UNPUBLISH: &str = "unpublish";
+const GAME_DISTRIBUTION_ACTION_SUSPEND: &str = "suspend";
+const GAME_DISTRIBUTION_RECEIPT_RETENTION_MICROS: i64 = 30 * 24 * 60 * 60 * 1_000_000;
+const GAME_DISTRIBUTION_MAX_LIST_LIMIT: u32 = 48;
+const GAME_DISTRIBUTION_MAX_OWNER_VERSIONS_PER_GAME: usize = 10;
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCreateGameInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub author_name: Option<String>,
+    pub author_avatar_url: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+    /// 同一作者的本地项目标识；重复发布会复用既有 game_id 而不是新建游戏。
+    pub local_project_id: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCreateVersionInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_id: String,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub local_project_id: Option<String>,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionConfirmPackageInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub package_object_key: String,
+    pub package_manifest_json: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionFailUploadInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub error_code: String,
+    pub error_message: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionSubmitReviewInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCancelVersionInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionApproveInput {
+    pub version_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub entry_url: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionRejectInput {
+    pub version_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub review_reason: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionUnpublishInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub expected_publication_revision: u64,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionSuspendInput {
+    pub game_id: String,
+    pub admin_user_id: String,
+    pub expected_publication_revision: u64,
+    pub reason: Option<String>,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionReviewListInput {
+    pub limit: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionOwnerGameListInput {
+    pub owner_user_id: String,
+    pub limit: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionPublicGameListInput {
+    pub search: Option<String>,
+    pub category: Option<String>,
+    pub limit: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionPublicGameInput {
+    pub game_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionOwnerVersionInput {
+    pub owner_user_id: String,
+    pub version_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionVersionLookupInput {
+    pub version_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionGameSnapshot {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub title: String,
+    pub summary: String,
+    pub description: String,
+    pub category: String,
+    pub tags_json: String,
+    pub cover_asset_id: Option<String>,
+    pub author_name: Option<String>,
+    pub author_avatar_url: Option<String>,
+    pub device_support_desktop: bool,
+    pub device_support_mobile: bool,
+    pub device_support_touch: bool,
+    pub input_modes_json: String,
+    pub orientation: String,
+    pub publication_revision: u64,
+    pub active_version_id: Option<String>,
+    pub visibility: String,
+    pub play_count: u64,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionVersionSnapshot {
+    pub version_id: String,
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_number: u64,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub status: String,
+    pub review_reason: Option<String>,
+    pub entry_url: Option<String>,
+    pub publication_revision: u64,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionPublicGameSnapshot {
+    pub game: GameDistributionGameSnapshot,
+    pub current_version: Option<GameDistributionVersionSnapshot>,
+}
+
+/// 作者自有游戏的聚合快照：游戏身份 + 最近若干版本，供作者管理页展示状态与驳回理由。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionOwnerGameSnapshot {
+    pub game: GameDistributionGameSnapshot,
+    pub versions: Vec<GameDistributionVersionSnapshot>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionOwnerGameListProcedureResult {
+    pub ok: bool,
+    pub games: Vec<GameDistributionOwnerGameSnapshot>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionGameProcedureResult {
+    pub ok: bool,
+    pub game: Option<GameDistributionPublicGameSnapshot>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionGameListProcedureResult {
+    pub ok: bool,
+    pub games: Vec<GameDistributionPublicGameSnapshot>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionVersionProcedureResult {
+    pub ok: bool,
+    pub version: Option<GameDistributionVersionSnapshot>,
+    pub error_message: Option<String>,
+}
+
+/// Facade 使用的统一结果合同。列表和公开详情只填 `games` / `game`，写操作只填
+/// `game` 或 `version`；其余字段保留为空，避免为每个 procedure 建立平行结果类型。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionProcedureResult {
+    pub ok: bool,
+    pub replayed: bool,
+    pub game: Option<GameDistributionGameSnapshot>,
+    pub games: Vec<GameDistributionGameSnapshot>,
+    pub version: Option<GameDistributionVersionSnapshot>,
+    pub versions: Vec<GameDistributionVersionSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionGetGameInput {
+    pub game_id: String,
+    pub owner_user_id: Option<String>,
+}
+
+fn game_distribution_result_error(error: String) -> GameDistributionProcedureResult {
+    GameDistributionProcedureResult {
+        ok: false,
+        replayed: false,
+        game: None,
+        games: Vec::new(),
+        version: None,
+        versions: Vec::new(),
+        next_cursor: None,
+        error_message: Some(error),
+    }
+}
+
+fn game_distribution_version_result(
+    version: GameDistributionVersionSnapshot,
+    replayed: bool,
+) -> GameDistributionProcedureResult {
+    GameDistributionProcedureResult {
+        ok: true,
+        replayed,
+        game: None,
+        games: Vec::new(),
+        version: Some(version),
+        versions: Vec::new(),
+        next_cursor: None,
+        error_message: None,
+    }
+}
+
+fn game_distribution_game_result(
+    game: GameDistributionGameSnapshot,
+    replayed: bool,
+) -> GameDistributionProcedureResult {
+    GameDistributionProcedureResult {
+        ok: true,
+        replayed,
+        game: Some(game),
+        games: Vec::new(),
+        version: None,
+        versions: Vec::new(),
+        next_cursor: None,
+        error_message: None,
+    }
+}
+
+/// 创建作者名下的游戏身份并在同一事务内写入幂等收据。
+#[spacetimedb::procedure]
+pub fn create_game_distribution_game_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionCreateGameInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        create_game_distribution_game_tx(tx, input.clone())
+    }) {
+        Ok((game, replayed)) => game_distribution_game_result(game, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 创建待上传发行版本；资料和包摘要先冻结，真实 ZIP 确认由 confirm procedure 完成。
+#[spacetimedb::procedure]
+pub fn create_game_distribution_version_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionCreateVersionInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        create_game_distribution_version_tx(tx, input.clone())
+    }) {
+        Ok((version, replayed)) => game_distribution_version_result(version, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 确认对象存储中的包摘要和校验清单。procedure 不读取、不执行上传内容。
+#[spacetimedb::procedure]
+pub fn confirm_game_distribution_package_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionConfirmPackageInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        confirm_game_distribution_package_tx(tx, input.clone())
+    }) {
+        Ok((version, replayed)) => game_distribution_version_result(version, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 记录上传或包校验失败，供客户端在原版本上恢复重试；不改变版本的冻结摘要。
+#[spacetimedb::procedure]
+pub fn fail_game_distribution_upload_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionFailUploadInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        fail_game_distribution_upload_tx(tx, input.clone())
+    }) {
+        Ok((version, replayed)) => game_distribution_version_result(version, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 作者提交已确认的发行包进入人工审核。提交动作只改变版本状态，不改变当前公开版本。
+#[spacetimedb::procedure]
+pub fn submit_game_distribution_version_for_review_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionSubmitReviewInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        submit_game_distribution_version_for_review_tx(tx, input.clone())
+    }) {
+        Ok((version, replayed)) => game_distribution_version_result(version, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 作者撤回尚未公开的版本；撤回保留幂等收据，不影响仍在服务的旧公开版本。
+#[spacetimedb::procedure]
+pub fn cancel_game_distribution_version_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionCancelVersionInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        cancel_game_distribution_version_tx(tx, input.clone())
+    }) {
+        Ok((version, replayed)) => game_distribution_version_result(version, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 管理员批准待审版本，并在同一事务内以 publication_revision CAS 切换公开版本。
+#[spacetimedb::procedure]
+pub fn approve_game_distribution_version_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionApproveInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        approve_game_distribution_version_tx(tx, input.clone())
+    }) {
+        Ok((version, replayed)) => game_distribution_version_result(version, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 管理员拒绝待审版本；拒绝不会影响仍在服务中的旧公开版本。
+#[spacetimedb::procedure]
+pub fn reject_game_distribution_version_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionRejectInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        reject_game_distribution_version_tx(tx, input.clone())
+    }) {
+        Ok((version, replayed)) => game_distribution_version_result(version, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 作者关闭自己的公开游戏；CAS 失败时不会覆盖管理员或其他版本的最新状态。
+#[spacetimedb::procedure]
+pub fn unpublish_game_distribution_game_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionUnpublishInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        unpublish_game_distribution_game_tx(tx, input.clone())
+    }) {
+        Ok((game, replayed)) => game_distribution_game_result(game, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 管理员安全下架整个游戏。暂停状态只能由后续明确的管理员审核动作解除。
+#[spacetimedb::procedure]
+pub fn suspend_game_distribution_game_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionSuspendInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        suspend_game_distribution_game_tx(tx, input.clone())
+    }) {
+        Ok((game, replayed)) => game_distribution_game_result(game, replayed),
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 返回待审版本给后台；只返回已确认完整包的版本，普通作者不会触达该 procedure。
+#[spacetimedb::procedure]
+pub fn list_game_distribution_reviews_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionReviewListInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        list_game_distribution_reviews_tx(tx, input.clone())
+    }) {
+        Ok(versions) => GameDistributionProcedureResult {
+            ok: true,
+            replayed: false,
+            game: None,
+            games: Vec::new(),
+            version: None,
+            versions,
+            next_cursor: None,
+            error_message: None,
+        },
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 返回作者名下的游戏与最近版本；owner 来自 api-server 的认证主体，调用方不能指定他人。
+#[spacetimedb::procedure]
+pub fn list_owner_game_distribution_games_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionOwnerGameListInput,
+) -> GameDistributionOwnerGameListProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        list_owner_game_distribution_games_tx(tx, input.clone())
+    }) {
+        Ok(games) => GameDistributionOwnerGameListProcedureResult {
+            ok: true,
+            games,
+            error_message: None,
+        },
+        Err(error) => GameDistributionOwnerGameListProcedureResult {
+            ok: false,
+            games: Vec::new(),
+            error_message: Some(error),
+        },
+    }
+}
+
+/// Facade 约定的公开游戏列表名称；公开筛选和排序均在事务内执行。
+#[spacetimedb::procedure]
+pub fn list_game_distribution_games_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionPublicGameListInput,
+) -> GameDistributionProcedureResult {
+    match ctx.try_with_tx(|tx| list_public_game_distribution_games_tx(tx, input.clone())) {
+        Ok(games) => GameDistributionProcedureResult {
+            ok: true,
+            replayed: false,
+            game: None,
+            games: games.into_iter().map(|item| item.game).collect(),
+            version: None,
+            versions: Vec::new(),
+            next_cursor: None,
+            error_message: None,
+        },
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// Facade 约定的游戏详情名称；带 owner 时允许作者读取私有游戏，否则只返回公开版本。
+#[spacetimedb::procedure]
+pub fn get_game_distribution_game_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionGetGameInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        get_game_distribution_game_for_owner_or_public_tx(tx, input.clone())
+    }) {
+        Ok(game) => GameDistributionProcedureResult {
+            ok: true,
+            replayed: false,
+            game,
+            games: Vec::new(),
+            version: None,
+            versions: Vec::new(),
+            next_cursor: None,
+            error_message: None,
+        },
+        Err(error) => game_distribution_result_error(error),
+    }
+}
+
+/// 返回当前公开且已发布版本的游戏目录；审核待处理或已暂停游戏不会出现在结果中。
+#[spacetimedb::procedure]
+pub fn list_public_game_distribution_games_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionPublicGameListInput,
+) -> GameDistributionGameListProcedureResult {
+    match ctx.try_with_tx(|tx| list_public_game_distribution_games_tx(tx, input.clone())) {
+        Ok(games) => GameDistributionGameListProcedureResult {
+            ok: true,
+            games,
+            error_message: None,
+        },
+        Err(error) => GameDistributionGameListProcedureResult {
+            ok: false,
+            games: Vec::new(),
+            error_message: Some(error),
+        },
+    }
+}
+
+/// 按游戏 ID读取当前公开版本；不可见或无可玩版本时返回空结果。
+#[spacetimedb::procedure]
+pub fn get_public_game_distribution_game_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionPublicGameInput,
+) -> GameDistributionGameProcedureResult {
+    match ctx.try_with_tx(|tx| get_public_game_distribution_game_tx(tx, input.clone())) {
+        Ok(game) => GameDistributionGameProcedureResult {
+            ok: true,
+            game,
+            error_message: None,
+        },
+        Err(error) => GameDistributionGameProcedureResult {
+            ok: false,
+            game: None,
+            error_message: Some(error),
+        },
+    }
+}
+
+/// 管理员读取任意版本状态；admin 权限由 api-server 在调用前校验，procedure 只接受受信服务身份。
+#[spacetimedb::procedure]
+pub fn get_game_distribution_version_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionVersionLookupInput,
+) -> GameDistributionVersionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        get_game_distribution_version_tx(tx, input.clone())
+    }) {
+        Ok(version) => GameDistributionVersionProcedureResult {
+            ok: true,
+            version,
+            error_message: None,
+        },
+        Err(error) => GameDistributionVersionProcedureResult {
+            ok: false,
+            version: None,
+            error_message: Some(error),
+        },
+    }
+}
+
+/// 作者读取自己的版本状态；owner 在 procedure 内与持久化行再次比对。
+#[spacetimedb::procedure]
+pub fn get_owner_game_distribution_version_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionOwnerVersionInput,
+) -> GameDistributionVersionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        get_owner_game_distribution_version_tx(tx, input.clone())
+    }) {
+        Ok(version) => GameDistributionVersionProcedureResult {
+            ok: true,
+            version,
+            error_message: None,
+        },
+        Err(error) => GameDistributionVersionProcedureResult {
+            ok: false,
+            version: None,
+            error_message: Some(error),
+        },
+    }
+}
+
+fn create_game_distribution_game_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionCreateGameInput,
+) -> Result<(GameDistributionGameSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let title = required_game_distribution_text(input.title, "title")?;
+    let summary = required_game_distribution_text(input.summary, "summary")?;
+    let category = required_game_distribution_text(input.category, "category")?;
+    let orientation = required_game_distribution_text(input.orientation, "orientation")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_CREATE_GAME,
+        idempotency_key.as_str(),
+    );
+    let local_project_id = input
+        .local_project_id
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string);
+
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let existing_game_id = receipt
+            .outcome_game_id
+            .ok_or_else(|| "幂等收据缺少游戏 ID".to_string())?;
+        let game = ctx
+            .db
+            .game_distribution_game()
+            .game_id()
+            .find(&existing_game_id)
+            .ok_or_else(|| "幂等收据对应的游戏已不存在".to_string())?;
+        if game.owner_user_id != owner_user_id {
+            return Err("游戏 owner 不匹配".to_string());
+        }
+        return Ok((game_distribution_game_snapshot(&game), true));
+    }
+
+    // 同一作者同一本地项目再次发布只新增版本，不新建游戏身份。
+    if let Some(local_project_id) = local_project_id.as_deref() {
+        let existing = ctx
+            .db
+            .game_distribution_game()
+            .by_game_distribution_game_owner_user_id()
+            .filter(&owner_user_id)
+            .find(|game| game.local_project_id.as_deref() == Some(local_project_id));
+        if let Some(game) = existing {
+            insert_game_distribution_receipt(
+                ctx,
+                GameDistributionReceiptInput {
+                    receipt_id,
+                    owner_user_id,
+                    action: GAME_DISTRIBUTION_ACTION_CREATE_GAME.to_string(),
+                    idempotency_key,
+                    request_digest,
+                    game_id: Some(game.game_id.clone()),
+                    version_id: None,
+                    outcome_kind: "game".to_string(),
+                    outcome_game_id: Some(game.game_id.clone()),
+                    outcome_version_id: None,
+                    outcome_json: None,
+                    now_micros: input.now_micros,
+                },
+            )?;
+            return Ok((game_distribution_game_snapshot(&game), false));
+        }
+    }
+
+    if ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&game_id)
+        .is_some()
+    {
+        return Err("游戏 ID 已存在".to_string());
+    }
+
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    ctx.db
+        .game_distribution_game()
+        .insert(GameDistributionGame {
+            game_id: game_id.clone(),
+            owner_user_id: owner_user_id.clone(),
+            title,
+            summary,
+            description: input.description.unwrap_or_default(),
+            category,
+            tags_json: input.tags_json,
+            cover_asset_id: input.cover_asset_id,
+            author_name: input.author_name,
+            author_avatar_url: input.author_avatar_url,
+            device_support_desktop: input.device_support_desktop,
+            device_support_mobile: input.device_support_mobile,
+            device_support_touch: input.device_support_touch,
+            input_modes_json: input.input_modes_json,
+            orientation,
+            publication_revision: 0,
+            active_version_id: None,
+            visibility: GAME_DISTRIBUTION_VISIBILITY_UNPUBLISHED.to_string(),
+            play_count: 0,
+            created_at: now,
+            updated_at: now,
+            local_project_id,
+        });
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_CREATE_GAME.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(game_id.clone()),
+            version_id: None,
+            outcome_kind: "game".to_string(),
+            outcome_game_id: Some(game_id.clone()),
+            outcome_version_id: None,
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+
+    let game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&game_id)
+        .ok_or_else(|| "创建游戏后读取失败".to_string())?;
+    Ok((game_distribution_game_snapshot(&game), false))
+}
+
+fn create_game_distribution_version_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionCreateVersionInput,
+) -> Result<(GameDistributionVersionSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let package_sha256 = required_game_distribution_text(input.package_sha256, "package_sha256")?;
+    let package_entry_path =
+        required_game_distribution_text(input.package_entry_path, "package_entry_path")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_CREATE_VERSION,
+        idempotency_key.as_str(),
+    );
+
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let existing_version_id = receipt
+            .outcome_version_id
+            .ok_or_else(|| "幂等收据缺少版本 ID".to_string())?;
+        let version = ctx
+            .db
+            .game_distribution_version()
+            .version_id()
+            .find(&existing_version_id)
+            .ok_or_else(|| "幂等收据对应的版本已不存在".to_string())?;
+        if version.owner_user_id != owner_user_id {
+            return Err("版本 owner 不匹配".to_string());
+        }
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+
+    let game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    if game.owner_user_id != owner_user_id {
+        return Err("游戏 owner 不匹配".to_string());
+    }
+    if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
+        return Err("游戏已被暂停，不能创建版本".to_string());
+    }
+    if ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .is_some()
+    {
+        return Err("版本 ID 已存在".to_string());
+    }
+
+    let version_number = ctx
+        .db
+        .game_distribution_version()
+        .iter()
+        .filter(|version| version.game_id == game_id)
+        .map(|version| version.version_number)
+        .max()
+        .unwrap_or(0)
+        .checked_add(1)
+        .ok_or_else(|| "版本号溢出".to_string())?;
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    ctx.db
+        .game_distribution_version()
+        .insert(GameDistributionVersion {
+            version_id: version_id.clone(),
+            game_id: game_id.clone(),
+            owner_user_id: owner_user_id.clone(),
+            version_number,
+            package_sha256,
+            package_bytes: input.package_bytes,
+            package_file_count: input.package_file_count,
+            package_entry_path,
+            status: GAME_DISTRIBUTION_VERSION_AWAITING_UPLOAD.to_string(),
+            review_reason: None,
+            created_at: now,
+            updated_at: now,
+            local_project_id: input.local_project_id,
+            package_object_key: None,
+            package_manifest_json: None,
+            entry_url: None,
+            reviewed_by_user_id: None,
+            uploaded_at: None,
+            submitted_at: None,
+            reviewed_at: None,
+            published_at: None,
+            revoked_at: None,
+            last_error_code: None,
+            last_error_message: None,
+        });
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_CREATE_VERSION.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(game_id),
+            version_id: Some(version_id.clone()),
+            outcome_kind: "version".to_string(),
+            outcome_game_id: None,
+            outcome_version_id: Some(version_id.clone()),
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    let version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .ok_or_else(|| "创建版本后读取失败".to_string())?;
+    Ok((
+        game_distribution_version_snapshot_for_game(ctx, &version),
+        false,
+    ))
+}
+
+fn confirm_game_distribution_package_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionConfirmPackageInput,
+) -> Result<(GameDistributionVersionSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let package_sha256 = required_game_distribution_text(input.package_sha256, "package_sha256")?;
+    let package_entry_path =
+        required_game_distribution_text(input.package_entry_path, "package_entry_path")?;
+    let package_object_key =
+        required_game_distribution_text(input.package_object_key, "package_object_key")?;
+    let package_manifest_json =
+        required_game_distribution_text(input.package_manifest_json, "package_manifest_json")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_CONFIRM_PACKAGE,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let version = ctx
+            .db
+            .game_distribution_version()
+            .version_id()
+            .find(&version_id)
+            .ok_or_else(|| "幂等收据对应的版本已不存在".to_string())?;
+        if version.owner_user_id != owner_user_id {
+            return Err("版本 owner 不匹配".to_string());
+        }
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+
+    let mut version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .ok_or_else(|| "版本不存在".to_string())?;
+    if version.owner_user_id != owner_user_id {
+        return Err("版本 owner 不匹配".to_string());
+    }
+    if version.package_sha256 != package_sha256
+        || version.package_bytes != input.package_bytes
+        || version.package_file_count != input.package_file_count
+        || version.package_entry_path != package_entry_path
+    {
+        return Err("上传包摘要与待上传版本不匹配".to_string());
+    }
+    if version.status == GAME_DISTRIBUTION_VERSION_UPLOADED {
+        if version.package_object_key.as_deref() != Some(package_object_key.as_str())
+            || version.package_manifest_json.as_deref() != Some(package_manifest_json.as_str())
+        {
+            return Err("同一版本已确认不同的对象或校验清单".to_string());
+        }
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+    if version.status != GAME_DISTRIBUTION_VERSION_AWAITING_UPLOAD
+        && version.status != "upload_failed"
+    {
+        return Err(format!("版本状态 {} 不允许确认上传", version.status));
+    }
+
+    let now = Timestamp::from_micros_since_unix_epoch(input.updated_at_micros);
+    version.status = GAME_DISTRIBUTION_VERSION_UPLOADED.to_string();
+    version.package_object_key = Some(package_object_key);
+    version.package_manifest_json = Some(package_manifest_json);
+    version.uploaded_at = Some(now);
+    version.updated_at = now;
+    version.last_error_code = None;
+    version.last_error_message = None;
+    ctx.db
+        .game_distribution_version()
+        .version_id()
+        .update(version.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_CONFIRM_PACKAGE.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(version.game_id.clone()),
+            version_id: Some(version.version_id.clone()),
+            outcome_kind: "version".to_string(),
+            outcome_game_id: None,
+            outcome_version_id: Some(version.version_id.clone()),
+            outcome_json: None,
+            now_micros: input.updated_at_micros,
+        },
+    )?;
+    Ok((
+        game_distribution_version_snapshot_for_game(ctx, &version),
+        false,
+    ))
+}
+
+fn fail_game_distribution_upload_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionFailUploadInput,
+) -> Result<(GameDistributionVersionSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let error_code = required_game_distribution_text(input.error_code, "error_code")?;
+    let error_message = required_game_distribution_text(input.error_message, "error_message")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_FAIL_UPLOAD,
+        idempotency_key.as_str(),
+    );
+
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let version = ctx
+            .db
+            .game_distribution_version()
+            .version_id()
+            .find(&version_id)
+            .ok_or_else(|| "幂等收据对应的版本已不存在".to_string())?;
+        if version.owner_user_id != owner_user_id {
+            return Err("版本 owner 不匹配".to_string());
+        }
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+
+    let mut version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .ok_or_else(|| "版本不存在".to_string())?;
+    if version.owner_user_id != owner_user_id {
+        return Err("版本 owner 不匹配".to_string());
+    }
+    if version.status != GAME_DISTRIBUTION_VERSION_AWAITING_UPLOAD
+        && version.status != "validation_failed"
+    {
+        return Err(format!("版本状态 {} 不允许记录上传失败", version.status));
+    }
+
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    version.status = "upload_failed".to_string();
+    version.updated_at = now;
+    version.last_error_code = Some(error_code);
+    version.last_error_message = Some(error_message);
+    ctx.db
+        .game_distribution_version()
+        .version_id()
+        .update(version.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_FAIL_UPLOAD.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(version.game_id.clone()),
+            version_id: Some(version.version_id.clone()),
+            outcome_kind: "version".to_string(),
+            outcome_game_id: None,
+            outcome_version_id: Some(version.version_id.clone()),
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((
+        game_distribution_version_snapshot_for_game(ctx, &version),
+        false,
+    ))
+}
+
+fn submit_game_distribution_version_for_review_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionSubmitReviewInput,
+) -> Result<(GameDistributionVersionSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_SUBMIT_REVIEW,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let version = ctx
+            .db
+            .game_distribution_version()
+            .version_id()
+            .find(&version_id)
+            .ok_or_else(|| "幂等收据对应的版本已不存在".to_string())?;
+        if version.owner_user_id != owner_user_id {
+            return Err("版本 owner 不匹配".to_string());
+        }
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+
+    let mut version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .ok_or_else(|| "版本不存在".to_string())?;
+    if version.owner_user_id != owner_user_id {
+        return Err("版本 owner 不匹配".to_string());
+    }
+    let game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&version.game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    if game.owner_user_id != owner_user_id {
+        return Err("游戏 owner 不匹配".to_string());
+    }
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
+        return Err("游戏已被暂停，不能提交审核".to_string());
+    }
+    if version.status != GAME_DISTRIBUTION_VERSION_UPLOADED {
+        return Err(format!("版本状态 {} 不允许提交审核", version.status));
+    }
+    if version.package_object_key.is_none() || version.package_manifest_json.is_none() {
+        return Err("发行包尚未完成对象确认，不能提交审核".to_string());
+    }
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    version.status = GAME_DISTRIBUTION_VERSION_PENDING_REVIEW.to_string();
+    version.submitted_at = Some(now);
+    version.updated_at = now;
+    version.review_reason = None;
+    version.last_error_code = None;
+    version.last_error_message = None;
+    ctx.db
+        .game_distribution_version()
+        .version_id()
+        .update(version.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_SUBMIT_REVIEW.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(version.game_id.clone()),
+            version_id: Some(version.version_id.clone()),
+            outcome_kind: "version".to_string(),
+            outcome_game_id: None,
+            outcome_version_id: Some(version.version_id.clone()),
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((
+        game_distribution_version_snapshot_for_game(ctx, &version),
+        false,
+    ))
+}
+
+fn cancel_game_distribution_version_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionCancelVersionInput,
+) -> Result<(GameDistributionVersionSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_CANCEL_VERSION,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let version = ctx
+            .db
+            .game_distribution_version()
+            .version_id()
+            .find(&version_id)
+            .ok_or_else(|| "幂等收据对应的版本已不存在".to_string())?;
+        if version.owner_user_id != owner_user_id {
+            return Err("版本 owner 不匹配".to_string());
+        }
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+
+    let mut version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .ok_or_else(|| "版本不存在".to_string())?;
+    if version.owner_user_id != owner_user_id {
+        return Err("版本 owner 不匹配".to_string());
+    }
+    let game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&version.game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    if game.owner_user_id != owner_user_id {
+        return Err("游戏 owner 不匹配".to_string());
+    }
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    if !game_distribution_version_can_cancel(version.status.as_str()) {
+        return Err(format!("版本状态 {} 不允许撤回", version.status));
+    }
+    if game.active_version_id.as_deref() == Some(version_id.as_str()) {
+        return Err("已公开版本不能撤回，请改用下架".to_string());
+    }
+
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    version.status = GAME_DISTRIBUTION_VERSION_CANCELLED.to_string();
+    version.updated_at = now;
+    ctx.db
+        .game_distribution_version()
+        .version_id()
+        .update(version.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_CANCEL_VERSION.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(version.game_id.clone()),
+            version_id: Some(version.version_id.clone()),
+            outcome_kind: "version".to_string(),
+            outcome_game_id: None,
+            outcome_version_id: Some(version.version_id.clone()),
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((
+        game_distribution_version_snapshot_for_game(ctx, &version),
+        false,
+    ))
+}
+
+fn game_distribution_version_can_cancel(status: &str) -> bool {
+    matches!(
+        status,
+        GAME_DISTRIBUTION_VERSION_AWAITING_UPLOAD
+            | GAME_DISTRIBUTION_VERSION_UPLOADED
+            | GAME_DISTRIBUTION_VERSION_VALIDATING
+            | GAME_DISTRIBUTION_VERSION_PENDING_REVIEW
+            | GAME_DISTRIBUTION_VERSION_UPLOAD_FAILED
+            | GAME_DISTRIBUTION_VERSION_VALIDATION_FAILED
+    )
+}
+
+fn approve_game_distribution_version_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionApproveInput,
+) -> Result<(GameDistributionVersionSnapshot, bool), String> {
+    let admin_user_id = required_game_distribution_text(input.admin_user_id, "admin_user_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let entry_url = required_game_distribution_text(input.entry_url, "entry_url")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        admin_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_APPROVE,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let version = ctx
+            .db
+            .game_distribution_version()
+            .version_id()
+            .find(&version_id)
+            .ok_or_else(|| "幂等收据对应的版本已不存在".to_string())?;
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+
+    let mut version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .ok_or_else(|| "版本不存在".to_string())?;
+    let mut game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&version.game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
+        return Err("游戏已被暂停，不能批准版本".to_string());
+    }
+    if version.status != GAME_DISTRIBUTION_VERSION_PENDING_REVIEW {
+        return Err(format!("版本状态 {} 不允许批准", version.status));
+    }
+    if version.package_object_key.is_none() || version.package_manifest_json.is_none() {
+        return Err("发行包对象尚未确认，不能批准版本".to_string());
+    }
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    if let Some(previous_version_id) = game.active_version_id.clone() {
+        if previous_version_id != version.version_id {
+            if let Some(mut previous) = ctx
+                .db
+                .game_distribution_version()
+                .version_id()
+                .find(&previous_version_id)
+            {
+                previous.status = GAME_DISTRIBUTION_VERSION_REVOKED.to_string();
+                previous.revoked_at = Some(now);
+                previous.updated_at = now;
+                ctx.db
+                    .game_distribution_version()
+                    .version_id()
+                    .update(previous);
+            }
+        }
+    }
+    version.status = GAME_DISTRIBUTION_VERSION_PUBLISHED.to_string();
+    version.entry_url = Some(entry_url);
+    version.review_reason = None;
+    version.reviewed_by_user_id = Some(admin_user_id.clone());
+    version.reviewed_at = Some(now);
+    version.published_at = Some(now);
+    version.updated_at = now;
+    version.revoked_at = None;
+    ctx.db
+        .game_distribution_version()
+        .version_id()
+        .update(version.clone());
+    game.active_version_id = Some(version.version_id.clone());
+    game.visibility = GAME_DISTRIBUTION_VISIBILITY_PUBLISHED.to_string();
+    game.publication_revision = game
+        .publication_revision
+        .checked_add(1)
+        .ok_or_else(|| "publication_revision 溢出".to_string())?;
+    game.updated_at = now;
+    ctx.db.game_distribution_game().game_id().update(game);
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id: admin_user_id,
+            action: GAME_DISTRIBUTION_ACTION_APPROVE.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(version.game_id.clone()),
+            version_id: Some(version.version_id.clone()),
+            outcome_kind: "version".to_string(),
+            outcome_game_id: None,
+            outcome_version_id: Some(version.version_id.clone()),
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((
+        game_distribution_version_snapshot_for_game(ctx, &version),
+        false,
+    ))
+}
+
+fn reject_game_distribution_version_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionRejectInput,
+) -> Result<(GameDistributionVersionSnapshot, bool), String> {
+    let admin_user_id = required_game_distribution_text(input.admin_user_id, "admin_user_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let review_reason = required_game_distribution_text(input.review_reason, "review_reason")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        admin_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_REJECT,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let version = ctx
+            .db
+            .game_distribution_version()
+            .version_id()
+            .find(&version_id)
+            .ok_or_else(|| "幂等收据对应的版本已不存在".to_string())?;
+        return Ok((
+            game_distribution_version_snapshot_for_game(ctx, &version),
+            true,
+        ));
+    }
+    let mut version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+        .ok_or_else(|| "版本不存在".to_string())?;
+    let game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&version.game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    if version.status != GAME_DISTRIBUTION_VERSION_PENDING_REVIEW {
+        return Err(format!("版本状态 {} 不允许拒绝", version.status));
+    }
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    version.status = GAME_DISTRIBUTION_VERSION_REJECTED.to_string();
+    version.review_reason = Some(review_reason);
+    version.reviewed_by_user_id = Some(admin_user_id.clone());
+    version.reviewed_at = Some(now);
+    version.updated_at = now;
+    ctx.db
+        .game_distribution_version()
+        .version_id()
+        .update(version.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id: admin_user_id,
+            action: GAME_DISTRIBUTION_ACTION_REJECT.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(version.game_id.clone()),
+            version_id: Some(version.version_id.clone()),
+            outcome_kind: "version".to_string(),
+            outcome_game_id: None,
+            outcome_version_id: Some(version.version_id.clone()),
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((
+        game_distribution_version_snapshot_for_game(ctx, &version),
+        false,
+    ))
+}
+
+fn unpublish_game_distribution_game_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionUnpublishInput,
+) -> Result<(GameDistributionGameSnapshot, bool), String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        owner_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_UNPUBLISH,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let game = ctx
+            .db
+            .game_distribution_game()
+            .game_id()
+            .find(&game_id)
+            .ok_or_else(|| "幂等收据对应的游戏已不存在".to_string())?;
+        return Ok((game_distribution_game_snapshot(&game), true));
+    }
+    let mut game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    if game.owner_user_id != owner_user_id {
+        return Err("游戏 owner 不匹配".to_string());
+    }
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    if game.visibility == GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
+        return Err("游戏已被管理员暂停，作者不能解除暂停".to_string());
+    }
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    let changed = game.visibility != GAME_DISTRIBUTION_VISIBILITY_UNPUBLISHED
+        || game.active_version_id.is_some();
+    if changed {
+        if let Some(active_version_id) = game.active_version_id.clone() {
+            if let Some(mut version) = ctx
+                .db
+                .game_distribution_version()
+                .version_id()
+                .find(&active_version_id)
+            {
+                version.status = GAME_DISTRIBUTION_VERSION_REVOKED.to_string();
+                version.revoked_at = Some(now);
+                version.updated_at = now;
+                ctx.db
+                    .game_distribution_version()
+                    .version_id()
+                    .update(version);
+            }
+        }
+        game.visibility = GAME_DISTRIBUTION_VISIBILITY_UNPUBLISHED.to_string();
+        game.active_version_id = None;
+        game.publication_revision = game
+            .publication_revision
+            .checked_add(1)
+            .ok_or_else(|| "publication_revision 溢出".to_string())?;
+        game.updated_at = now;
+        ctx.db
+            .game_distribution_game()
+            .game_id()
+            .update(game.clone());
+    }
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id,
+            action: GAME_DISTRIBUTION_ACTION_UNPUBLISH.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(game_id),
+            version_id: None,
+            outcome_kind: "game".to_string(),
+            outcome_game_id: Some(game.game_id.clone()),
+            outcome_version_id: None,
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((game_distribution_game_snapshot(&game), false))
+}
+
+fn suspend_game_distribution_game_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionSuspendInput,
+) -> Result<(GameDistributionGameSnapshot, bool), String> {
+    let admin_user_id = required_game_distribution_text(input.admin_user_id, "admin_user_id")?;
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let idempotency_key =
+        required_game_distribution_text(input.idempotency_key, "idempotency_key")?;
+    let request_digest = required_game_distribution_text(input.request_digest, "request_digest")?;
+    let receipt_id = game_distribution_receipt_id(
+        admin_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_SUSPEND,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_receipt_digest(&receipt, request_digest.as_str())?;
+        let game = ctx
+            .db
+            .game_distribution_game()
+            .game_id()
+            .find(&game_id)
+            .ok_or_else(|| "幂等收据对应的游戏已不存在".to_string())?;
+        return Ok((game_distribution_game_snapshot(&game), true));
+    }
+    let mut game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&game_id)
+        .ok_or_else(|| "游戏不存在".to_string())?;
+    ensure_game_distribution_publication_revision(&game, input.expected_publication_revision)?;
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    if game.visibility != GAME_DISTRIBUTION_VISIBILITY_SUSPENDED {
+        if let Some(active_version_id) = game.active_version_id.clone() {
+            if let Some(mut version) = ctx
+                .db
+                .game_distribution_version()
+                .version_id()
+                .find(&active_version_id)
+            {
+                version.status = GAME_DISTRIBUTION_VERSION_REVOKED.to_string();
+                version.revoked_at = Some(now);
+                version.reviewed_by_user_id = Some(admin_user_id.clone());
+                version.review_reason = input.reason.clone();
+                version.reviewed_at = Some(now);
+                version.updated_at = now;
+                ctx.db
+                    .game_distribution_version()
+                    .version_id()
+                    .update(version);
+            }
+        }
+        game.visibility = GAME_DISTRIBUTION_VISIBILITY_SUSPENDED.to_string();
+        game.active_version_id = None;
+        game.publication_revision = game
+            .publication_revision
+            .checked_add(1)
+            .ok_or_else(|| "publication_revision 溢出".to_string())?;
+        game.updated_at = now;
+        ctx.db
+            .game_distribution_game()
+            .game_id()
+            .update(game.clone());
+    }
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id: admin_user_id,
+            action: GAME_DISTRIBUTION_ACTION_SUSPEND.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(game_id),
+            version_id: None,
+            outcome_kind: "game".to_string(),
+            outcome_game_id: Some(game.game_id.clone()),
+            outcome_version_id: None,
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((game_distribution_game_snapshot(&game), false))
+}
+
+fn list_game_distribution_reviews_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionReviewListInput,
+) -> Result<Vec<GameDistributionVersionSnapshot>, String> {
+    let limit = if input.limit == 0 {
+        GAME_DISTRIBUTION_MAX_LIST_LIMIT
+    } else {
+        input.limit.min(GAME_DISTRIBUTION_MAX_LIST_LIMIT)
+    } as usize;
+    let mut versions = ctx
+        .db
+        .game_distribution_version()
+        .iter()
+        .filter(|version| {
+            version.status == GAME_DISTRIBUTION_VERSION_PENDING_REVIEW
+                && version.package_object_key.is_some()
+                && version.package_manifest_json.is_some()
+        })
+        .collect::<Vec<_>>();
+    versions.sort_by(|left, right| {
+        left.submitted_at
+            .cmp(&right.submitted_at)
+            .then_with(|| left.version_id.cmp(&right.version_id))
+    });
+    versions.truncate(limit);
+    Ok(versions
+        .iter()
+        .map(game_distribution_version_snapshot)
+        .collect())
+}
+
+fn ensure_game_distribution_publication_revision(
+    game: &GameDistributionGame,
+    expected: u64,
+) -> Result<(), String> {
+    if game.publication_revision == expected {
+        Ok(())
+    } else {
+        Err(format!(
+            "PUBLICATION_CONFLICT: expected publication_revision {}, actual {}",
+            expected, game.publication_revision
+        ))
+    }
+}
+
+fn list_owner_game_distribution_games_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionOwnerGameListInput,
+) -> Result<Vec<GameDistributionOwnerGameSnapshot>, String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let limit = if input.limit == 0 {
+        GAME_DISTRIBUTION_MAX_LIST_LIMIT
+    } else {
+        input.limit.min(GAME_DISTRIBUTION_MAX_LIST_LIMIT)
+    } as usize;
+    let mut games = ctx
+        .db
+        .game_distribution_game()
+        .by_game_distribution_game_owner_user_id()
+        .filter(&owner_user_id)
+        .collect::<Vec<_>>();
+    games.sort_by(|left, right| {
+        right
+            .updated_at
+            .to_micros_since_unix_epoch()
+            .cmp(&left.updated_at.to_micros_since_unix_epoch())
+            .then_with(|| right.game_id.cmp(&left.game_id))
+    });
+    games.truncate(limit);
+    Ok(games
+        .into_iter()
+        .map(|game| {
+            let mut versions = ctx
+                .db
+                .game_distribution_version()
+                .by_game_distribution_version_game_id()
+                .filter(&game.game_id)
+                .collect::<Vec<_>>();
+            versions.sort_by(|left, right| {
+                right
+                    .version_number
+                    .cmp(&left.version_number)
+                    .then_with(|| right.version_id.cmp(&left.version_id))
+            });
+            versions.truncate(GAME_DISTRIBUTION_MAX_OWNER_VERSIONS_PER_GAME);
+            GameDistributionOwnerGameSnapshot {
+                versions: versions
+                    .iter()
+                    .map(|version| game_distribution_version_snapshot(version))
+                    .collect(),
+                game: game_distribution_game_snapshot(&game),
+            }
+        })
+        .collect())
+}
+
+fn list_public_game_distribution_games_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionPublicGameListInput,
+) -> Result<Vec<GameDistributionPublicGameSnapshot>, String> {
+    let limit = if input.limit == 0 {
+        GAME_DISTRIBUTION_MAX_LIST_LIMIT
+    } else {
+        input.limit.min(GAME_DISTRIBUTION_MAX_LIST_LIMIT)
+    } as usize;
+    let search = input
+        .search
+        .and_then(|value| normalize_game_distribution_optional(value));
+    let category = input
+        .category
+        .and_then(|value| normalize_game_distribution_optional(value));
+    let mut games = ctx
+        .db
+        .game_distribution_game()
+        .iter()
+        .filter(|game| game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED)
+        .filter(|game| game.active_version_id.is_some())
+        .filter(|game| {
+            category
+                .as_deref()
+                .is_none_or(|value| game.category == value)
+        })
+        .filter(|game| {
+            search.as_deref().is_none_or(|value| {
+                game.title.contains(value)
+                    || game.summary.contains(value)
+                    || game.tags_json.contains(value)
+            })
+        })
+        .filter_map(|game| public_game_distribution_snapshot(ctx, &game))
+        .collect::<Vec<_>>();
+    games.sort_by(|left, right| {
+        right
+            .game
+            .created_at_micros
+            .cmp(&left.game.created_at_micros)
+            .then_with(|| left.game.game_id.cmp(&right.game.game_id))
+    });
+    games.truncate(limit);
+    Ok(games)
+}
+
+fn get_public_game_distribution_game_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionPublicGameInput,
+) -> Result<Option<GameDistributionPublicGameSnapshot>, String> {
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let Some(game) = ctx.db.game_distribution_game().game_id().find(&game_id) else {
+        return Ok(None);
+    };
+    if game.visibility != GAME_DISTRIBUTION_VISIBILITY_PUBLISHED || game.active_version_id.is_none()
+    {
+        return Ok(None);
+    }
+    Ok(public_game_distribution_snapshot(ctx, &game))
+}
+
+fn get_game_distribution_game_for_owner_or_public_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionGetGameInput,
+) -> Result<Option<GameDistributionGameSnapshot>, String> {
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let Some(game) = ctx.db.game_distribution_game().game_id().find(&game_id) else {
+        return Ok(None);
+    };
+    if let Some(owner_user_id) = input
+        .owner_user_id
+        .and_then(normalize_game_distribution_optional)
+    {
+        if game.owner_user_id != owner_user_id {
+            return Err("游戏 owner 不匹配".to_string());
+        }
+        return Ok(Some(game_distribution_game_snapshot(&game)));
+    }
+    Ok(public_game_distribution_snapshot(ctx, &game).map(|item| item.game))
+}
+
+fn get_game_distribution_version_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionVersionLookupInput,
+) -> Result<Option<GameDistributionVersionSnapshot>, String> {
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let Some(version) = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+    else {
+        return Ok(None);
+    };
+    Ok(Some(game_distribution_version_snapshot_for_game(
+        ctx, &version,
+    )))
+}
+
+fn get_owner_game_distribution_version_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionOwnerVersionInput,
+) -> Result<Option<GameDistributionVersionSnapshot>, String> {
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let version_id = required_game_distribution_text(input.version_id, "version_id")?;
+    let Some(version) = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(&version_id)
+    else {
+        return Ok(None);
+    };
+    if version.owner_user_id != owner_user_id {
+        return Err("版本 owner 不匹配".to_string());
+    }
+    Ok(Some(game_distribution_version_snapshot_for_game(
+        ctx, &version,
+    )))
+}
+
+struct GameDistributionReceiptInput {
+    receipt_id: String,
+    owner_user_id: String,
+    action: String,
+    idempotency_key: String,
+    request_digest: String,
+    game_id: Option<String>,
+    version_id: Option<String>,
+    outcome_kind: String,
+    outcome_game_id: Option<String>,
+    outcome_version_id: Option<String>,
+    outcome_json: Option<String>,
+    now_micros: i64,
+}
+
+fn insert_game_distribution_receipt(
+    ctx: &ReducerContext,
+    input: GameDistributionReceiptInput,
+) -> Result<(), String> {
+    if ctx
+        .db
+        .game_distribution_idempotency_receipt()
+        .receipt_id()
+        .find(&input.receipt_id)
+        .is_some()
+    {
+        return Err("幂等收据已存在".to_string());
+    }
+    let created_at = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    let expires_at = Timestamp::from_micros_since_unix_epoch(
+        input
+            .now_micros
+            .saturating_add(GAME_DISTRIBUTION_RECEIPT_RETENTION_MICROS),
+    );
+    ctx.db
+        .game_distribution_idempotency_receipt()
+        .insert(GameDistributionIdempotencyReceipt {
+            receipt_id: input.receipt_id,
+            owner_user_id: input.owner_user_id,
+            action: input.action,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            game_id: input.game_id,
+            version_id: input.version_id,
+            outcome_kind: input.outcome_kind,
+            outcome_game_id: input.outcome_game_id,
+            outcome_version_id: input.outcome_version_id,
+            outcome_json: input.outcome_json,
+            created_at,
+            expires_at,
+            completed_at: Some(created_at),
+        });
+    Ok(())
+}
+
+fn find_game_distribution_receipt(
+    ctx: &ReducerContext,
+    receipt_id: &str,
+) -> Option<GameDistributionIdempotencyReceipt> {
+    ctx.db
+        .game_distribution_idempotency_receipt()
+        .receipt_id()
+        .find(&receipt_id.to_string())
+}
+
+fn ensure_game_distribution_receipt_digest(
+    receipt: &GameDistributionIdempotencyReceipt,
+    request_digest: &str,
+) -> Result<(), String> {
+    if receipt.request_digest == request_digest {
+        Ok(())
+    } else {
+        Err("幂等键对应的请求摘要不一致".to_string())
+    }
+}
+
+fn game_distribution_receipt_id(
+    owner_user_id: &str,
+    action: &str,
+    idempotency_key: &str,
+) -> String {
+    format!("game-distribution:{owner_user_id}:{action}:{idempotency_key}")
+}
+
+fn required_game_distribution_text(value: String, field: &str) -> Result<String, String> {
+    normalize_game_distribution_optional(value).ok_or_else(|| format!("{field} 不能为空"))
+}
+
+fn normalize_game_distribution_optional(value: String) -> Option<String> {
+    let value = value.trim();
+    (!value.is_empty()).then(|| value.to_string())
+}
+
+fn game_distribution_game_snapshot(game: &GameDistributionGame) -> GameDistributionGameSnapshot {
+    GameDistributionGameSnapshot {
+        game_id: game.game_id.clone(),
+        owner_user_id: game.owner_user_id.clone(),
+        title: game.title.clone(),
+        summary: game.summary.clone(),
+        description: game.description.clone(),
+        category: game.category.clone(),
+        tags_json: game.tags_json.clone(),
+        cover_asset_id: game.cover_asset_id.clone(),
+        author_name: game.author_name.clone(),
+        author_avatar_url: game.author_avatar_url.clone(),
+        device_support_desktop: game.device_support_desktop,
+        device_support_mobile: game.device_support_mobile,
+        device_support_touch: game.device_support_touch,
+        input_modes_json: game.input_modes_json.clone(),
+        orientation: game.orientation.clone(),
+        publication_revision: game.publication_revision,
+        active_version_id: game.active_version_id.clone(),
+        visibility: game.visibility.clone(),
+        play_count: game.play_count,
+        created_at_micros: game.created_at.to_micros_since_unix_epoch(),
+        updated_at_micros: game.updated_at.to_micros_since_unix_epoch(),
+    }
+}
+
+fn game_distribution_version_snapshot(
+    version: &GameDistributionVersion,
+) -> GameDistributionVersionSnapshot {
+    GameDistributionVersionSnapshot {
+        version_id: version.version_id.clone(),
+        game_id: version.game_id.clone(),
+        owner_user_id: version.owner_user_id.clone(),
+        version_number: version.version_number,
+        package_sha256: version.package_sha256.clone(),
+        package_bytes: version.package_bytes,
+        package_file_count: version.package_file_count,
+        package_entry_path: version.package_entry_path.clone(),
+        status: version.status.clone(),
+        review_reason: version.review_reason.clone(),
+        entry_url: version.entry_url.clone(),
+        publication_revision: 0,
+        created_at_micros: version.created_at.to_micros_since_unix_epoch(),
+        updated_at_micros: version.updated_at.to_micros_since_unix_epoch(),
+    }
+}
+
+fn game_distribution_version_snapshot_for_game(
+    ctx: &ReducerContext,
+    version: &GameDistributionVersion,
+) -> GameDistributionVersionSnapshot {
+    let mut snapshot = game_distribution_version_snapshot(version);
+    snapshot.publication_revision = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&version.game_id)
+        .map(|game| game.publication_revision)
+        .unwrap_or_default();
+    snapshot
+}
+
+fn public_game_distribution_snapshot(
+    ctx: &ReducerContext,
+    game: &GameDistributionGame,
+) -> Option<GameDistributionPublicGameSnapshot> {
+    let version_id = game.active_version_id.as_ref()?;
+    let version = ctx
+        .db
+        .game_distribution_version()
+        .version_id()
+        .find(version_id)
+        .filter(|version| {
+            version.game_id == game.game_id && version.status == GAME_DISTRIBUTION_VERSION_PUBLISHED
+        })?;
+    Some(GameDistributionPublicGameSnapshot {
+        game: game_distribution_game_snapshot(game),
+        current_version: Some(game_distribution_version_snapshot_for_game(ctx, &version)),
+    })
+}
diff --git a/server-rs/crates/spacetime-module/src/migration.rs b/server-rs/crates/spacetime-module/src/migration.rs
index 0f9d78a80..4eddadbe2 100644
--- a/server-rs/crates/spacetime-module/src/migration.rs
+++ b/server-rs/crates/spacetime-module/src/migration.rs
@@ -252,6 +252,8 @@ macro_rules! migration_tables {
             asset_entity_binding,
             asset_event,
             external_api_key,
+            // 游戏分发：游戏身份、不可变发行版本和幂等收据都属于业务事实，
+            // 随迁移导出/导入；私有 ZIP 与展开内容保存在对象存储，不进入这两张表。
             game_distribution_game,
             game_distribution_version,
             game_distribution_idempotency_receipt,
diff --git a/src/components/game-distribution/GameDetailPage.tsx b/src/components/game-distribution/GameDetailPage.tsx
new file mode 100644
index 000000000..fa7252228
--- /dev/null
+++ b/src/components/game-distribution/GameDetailPage.tsx
@@ -0,0 +1,225 @@
+import './gameDistribution.css';
+
+import {
+  ArrowLeft,
+  Gamepad2,
+  Maximize2,
+  Smartphone,
+  Sparkles,
+} from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+import {
+  type GameDistributionGame,
+  type GameDistributionInputMode,
+  getGame,
+} from '../../services/gameDistributionClient';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import {
+  normalizeGameEntryUrl,
+  normalizeGameId,
+  useIsMobileViewport,
+} from './gameDistributionGuards';
+import { GameCover } from './GameGalleryPage';
+
+type GameDetailPageProps = {
+  gameId: string | null;
+  onBack: () => void;
+  onPlay: (gameId: string) => void;
+};
+
+const INPUT_MODE_LABELS: Record<GameDistributionInputMode, string> = {
+  keyboard: '键盘',
+  mouse: '鼠标',
+  touch: '触屏',
+};
+
+/**
+ * 游玩方式优先取版本冻结时声明的输入方式（公开投影里的 `inputModes`），
+ * 再退回版本自由文本 `controls`；两者都没有才显示“未标注操作方式”。
+ */
+function resolveControlsLabel(
+  version: GameDistributionGame['currentVersion'],
+  inputModes?: GameDistributionInputMode[],
+) {
+  if (!version) return '暂未发布可玩版本';
+  const declared = Array.from(
+    new Set((inputModes ?? []).map((mode) => INPUT_MODE_LABELS[mode] ?? mode)),
+  ).filter(Boolean);
+  if (declared.length > 0) return declared.join(' · ');
+  const controls = version.controls.join(' · ').trim();
+  return controls || '未标注操作方式';
+}
+
+export function GameDetailPage({
+  gameId,
+  onBack,
+  onPlay,
+}: GameDetailPageProps) {
+  const [game, setGame] = useState<GameDistributionGame | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState('');
+  const requestSerialRef = useRef(0);
+  const isMobileViewport = useIsMobileViewport();
+
+  const loadGame = useCallback(() => {
+    const requestSerial = ++requestSerialRef.current;
+    const normalizedGameId = normalizeGameId(gameId);
+    setGame(null);
+    setError('');
+    if (!normalizedGameId) {
+      setIsLoading(false);
+      setError('游戏编号无效');
+      return;
+    }
+    setIsLoading(true);
+    void getGame(normalizedGameId)
+      .then((value) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        if (value?.currentVersion) {
+          const entryUrl = normalizeGameEntryUrl(value.currentVersion.entryUrl);
+          if (!entryUrl) {
+            setError('游戏入口地址无效');
+            return;
+          }
+          setGame({
+            ...value,
+            currentVersion: { ...value.currentVersion, entryUrl },
+          });
+          return;
+        }
+        setGame(value);
+        if (!value) setError('找不到这款游戏');
+      })
+      .catch((loadError: unknown) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setError(
+          loadError instanceof Error ? loadError.message : '游戏详情加载失败',
+        );
+      })
+      .finally(() => {
+        if (requestSerial === requestSerialRef.current) setIsLoading(false);
+      });
+  }, [gameId]);
+
+  useEffect(() => {
+    void loadGame();
+    return () => {
+      requestSerialRef.current += 1;
+    };
+  }, [loadGame]);
+
+  if (isLoading)
+    return (
+      <div className="game-detail-page">
+        <div className="game-loading-panel">正在加载游戏详情…</div>
+      </div>
+    );
+  if (error || !game)
+    return (
+      <div className="game-detail-page">
+        <button type="button" className="game-back-button" onClick={onBack}>
+          <ArrowLeft /> 返回游戏广场
+        </button>
+        <PlatformStatusMessage
+          tone="error"
+          surface="platform"
+          className="game-status-message"
+        >
+          <span>{error || '找不到这款游戏'}</span>
+          <button type="button" onClick={loadGame}>
+            重新加载
+          </button>
+        </PlatformStatusMessage>
+      </div>
+    );
+
+  const version = game.currentVersion;
+  const mobilePlaybackBlocked = isMobileViewport && !game.deviceSupport.mobile;
+  const playbackBlocked = !version || mobilePlaybackBlocked;
+  return (
+    <div className="game-detail-page">
+      <button type="button" className="game-back-button" onClick={onBack}>
+        <ArrowLeft /> 返回游戏广场
+      </button>
+      <section className="game-detail-hero">
+        <GameCover game={game} />
+        <div className="game-detail-hero__copy">
+          <span className="game-eyebrow">
+            <Sparkles aria-hidden="true" /> {game.category}
+          </span>
+          <h1>{game.title}</h1>
+          <p className="game-detail-hero__summary">{game.summary}</p>
+          <div className="game-detail-hero__author">
+            <span className="game-avatar">{game.author.name.slice(0, 1)}</span>
+            <span>由 {game.author.name} 制作</span>
+          </div>
+          <div className="game-detail-hero__actions">
+            <PlatformActionButton
+              size="lg"
+              shape="pill"
+              onClick={() => onPlay(game.id)}
+              disabled={playbackBlocked}
+              aria-describedby={
+                mobilePlaybackBlocked
+                  ? 'game-mobile-playback-warning'
+                  : undefined
+              }
+            >
+              <Gamepad2 /> 立即玩
+            </PlatformActionButton>
+            {mobilePlaybackBlocked ? (
+              <span
+                id="game-mobile-playback-warning"
+                className="game-device-warning"
+                role="status"
+              >
+                请在电脑上游玩
+              </span>
+            ) : null}
+            <span className="game-detail-hero__play-count">
+              {game.playCount.toLocaleString()} 次游玩
+            </span>
+          </div>
+        </div>
+      </section>
+      <section className="game-detail-body">
+        <div className="game-detail-main">
+          <h2>关于这款游戏</h2>
+          <p>{game.description}</p>
+          <div className="game-tag-list">
+            {game.tags.map((tag) => (
+              <span key={tag}>{tag}</span>
+            ))}
+          </div>
+        </div>
+        <aside className="game-detail-side">
+          <div className="game-info-card">
+            <strong>游玩方式</strong>
+            <span>{resolveControlsLabel(version, game.inputModes)}</span>
+          </div>
+          <div className="game-info-card">
+            <strong>设备支持</strong>
+            <span>
+              <Smartphone aria-hidden="true" />{' '}
+              {game.deviceSupport.mobile ? '移动端' : ''}
+              {game.deviceSupport.desktop ? ' · 桌面端' : ''}
+              {game.deviceSupport.touch ? ' · 支持触屏' : ''}
+            </span>
+          </div>
+          <div className="game-info-card">
+            <strong>当前版本</strong>
+            <span>{version?.version || '—'}</span>
+          </div>
+        </aside>
+      </section>
+      <p className="game-detail-footnote">
+        <Maximize2 aria-hidden="true" />{' '}
+        游玩时可以切换全屏，游戏运行在独立的安全容器中。
+      </p>
+    </div>
+  );
+}
+
+export default GameDetailPage;
diff --git a/src/components/game-distribution/GameDistributionPages.test.tsx b/src/components/game-distribution/GameDistributionPages.test.tsx
new file mode 100644
index 000000000..f8fae0d08
--- /dev/null
+++ b/src/components/game-distribution/GameDistributionPages.test.tsx
@@ -0,0 +1,420 @@
+/* @vitest-environment jsdom */
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { GameDistributionGame } from '../../services/gameDistributionClient';
+import { GameDetailPage } from './GameDetailPage';
+import { GameGalleryPage } from './GameGalleryPage';
+import { GAME_PLAY_STARTUP_TIMEOUT_MS, GamePlayPage } from './GamePlayPage';
+
+const listGamesMock = vi.hoisted(() => vi.fn());
+const getGameMock = vi.hoisted(() => vi.fn());
+
+vi.mock('../../services/gameDistributionClient', () => ({
+  listGames: listGamesMock,
+  getGame: getGameMock,
+}));
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, reject, resolve };
+}
+
+function createGame(
+  overrides: Partial<GameDistributionGame> = {},
+): GameDistributionGame {
+  return {
+    id: 'game-1',
+    title: '星轨防线',
+    summary: '守住最后一条航线。',
+    description: '一款测试游戏。',
+    category: '动作',
+    tags: ['测试'],
+    coverColor: '#d77a51',
+    icon: '✦',
+    author: { id: 'author-1', name: '测试作者' },
+    deviceSupport: { desktop: true, mobile: true, touch: true },
+    status: 'published',
+    currentVersion: {
+      id: 'version-1',
+      version: '1.0.0',
+      entryUrl: 'https://play.example.test/releases/version-1/index.html',
+      sha256: 'sha256',
+      publishedAt: '2026-09-18T00:00:00.000Z',
+      controls: ['键盘'],
+    },
+    playCount: 12,
+    createdAt: '2026-09-18T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function setViewportWidth(width: number) {
+  Object.defineProperty(window, 'innerWidth', {
+    configurable: true,
+    value: width,
+    writable: true,
+  });
+  Object.defineProperty(window, 'matchMedia', {
+    configurable: true,
+    value: () => ({
+      addEventListener: vi.fn(),
+      matches: width <= 820,
+      removeEventListener: vi.fn(),
+    }),
+    writable: true,
+  });
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  setViewportWidth(1024);
+  listGamesMock.mockResolvedValue([]);
+  getGameMock.mockResolvedValue(createGame());
+});
+
+describe('GameGalleryPage', () => {
+  it('ignores a stale response after search keyword changes', async () => {
+    const first = deferred<GameDistributionGame[]>();
+    const second = deferred<GameDistributionGame[]>();
+    listGamesMock
+      .mockImplementationOnce(() => first.promise)
+      .mockImplementationOnce(() => second.promise);
+    const onOpenDetail = vi.fn();
+    const { rerender } = render(
+      <GameGalleryPage searchKeyword="" onOpenDetail={onOpenDetail} />,
+    );
+
+    await waitFor(() => expect(listGamesMock).toHaveBeenCalledTimes(1));
+    rerender(
+      <GameGalleryPage searchKeyword="新搜索" onOpenDetail={onOpenDetail} />,
+    );
+    await waitFor(() => expect(listGamesMock).toHaveBeenCalledTimes(2));
+
+    const newerGame = createGame({ id: 'game-new', title: '新搜索结果' });
+    second.resolve([newerGame]);
+    await screen.findByText('新搜索结果');
+    first.resolve([createGame({ id: 'game-old', title: '旧搜索结果' })]);
+    await waitFor(() => expect(screen.queryByText('旧搜索结果')).toBeNull());
+  });
+});
+
+describe('GameDetailPage', () => {
+  it('blocks desktop-only games on a mobile viewport', async () => {
+    setViewportWidth(375);
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        deviceSupport: { desktop: true, mobile: false, touch: false },
+      }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const playButton = await screen.findByRole('button', { name: /立即玩/u });
+    expect((playButton as HTMLButtonElement).disabled).toBe(true);
+    expect(screen.getByText('请在电脑上游玩')).toBeTruthy();
+  });
+
+  it('rejects an invalid query id without requesting the API', async () => {
+    render(<GameDetailPage gameId="" onBack={vi.fn()} onPlay={vi.fn()} />);
+
+    expect(await screen.findByText('游戏编号无效')).toBeTruthy();
+    expect(getGameMock).not.toHaveBeenCalled();
+  });
+  it('已发布但未标注操作方式时不谎称没有可玩版本', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        currentVersion: { ...createGame().currentVersion!, controls: [] },
+      }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('未标注操作方式')).toBeTruthy();
+    expect(screen.queryByText('暂未发布可玩版本')).toBeNull();
+  });
+
+  it('优先展示版本声明的输入方式', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        inputModes: ['keyboard', 'touch'],
+        currentVersion: { ...createGame().currentVersion!, controls: [] },
+      }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('键盘 · 触屏')).toBeTruthy();
+    expect(screen.queryByText('未标注操作方式')).toBeNull();
+  });
+
+  it('没有当前版本时才显示暂未发布可玩版本', async () => {
+    getGameMock.mockResolvedValueOnce(createGame({ currentVersion: null }));
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('暂未发布可玩版本')).toBeTruthy();
+  });
+});
+
+describe('GamePlayPage', () => {
+  it('waits for an explicit start before mounting the sandbox iframe', async () => {
+    render(<GamePlayPage gameId="game-1" onBack={vi.fn()} />);
+
+    await screen.findByRole('button', { name: /开始游戏/u });
+    expect(screen.queryByTitle('星轨防线 在线游玩')).toBeNull();
+
+    fireEvent.click(screen.getByRole('button', { name: /开始游戏/u }));
+    const iframe = await screen.findByTitle('星轨防线 在线游玩');
+    expect(iframe.getAttribute('sandbox')).toBe('allow-scripts');
+  });
+
+  it('rejects an unsafe release entry URL before rendering an iframe', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        currentVersion: {
+          ...createGame().currentVersion!,
+          entryUrl: 'javascript:alert(1)',
+        },
+      }),
+    );
+    render(<GamePlayPage gameId="game-1" onBack={vi.fn()} />);
+
+    expect(await screen.findByText('游戏入口地址无效')).toBeTruthy();
+    expect(screen.queryByTitle('星轨防线 在线游玩')).toBeNull();
+  });
+});
+
+describe('GameGalleryPage 筛选与返回上下文', () => {
+  function resetGalleryContext() {
+    window.sessionStorage.clear();
+    window.history.replaceState({}, '', '/games');
+  }
+
+  function openGame(title: string) {
+    fireEvent.click(screen.getByText(title).closest('button')!);
+  }
+
+  it('设备筛选按真实 deviceSupport 过滤，并写回地址栏', async () => {
+    resetGalleryContext();
+    listGamesMock.mockResolvedValue([
+      createGame({
+        id: 'game-desktop',
+        title: '桌面专属',
+        deviceSupport: { desktop: true, mobile: false, touch: false },
+      }),
+      createGame({
+        id: 'game-mobile',
+        title: '移动可玩',
+        deviceSupport: { desktop: false, mobile: true, touch: true },
+      }),
+    ]);
+    render(<GameGalleryPage onOpenDetail={vi.fn()} />);
+
+    expect(await screen.findByText('桌面专属')).toBeTruthy();
+    const deviceTabs = within(
+      screen.getByRole('tablist', { name: '设备筛选' }),
+    );
+    fireEvent.click(deviceTabs.getByRole('tab', { name: /移动/u }));
+
+    await waitFor(() => expect(screen.queryByText('桌面专属')).toBeNull());
+    expect(screen.getByText('移动可玩')).toBeTruthy();
+    expect(window.location.search).toContain('device=');
+    expect(decodeURIComponent(window.location.search)).toContain('device=移动');
+  });
+
+  it('筛选结果为空时提供重置筛选，并清理地址栏条件', async () => {
+    resetGalleryContext();
+    listGamesMock.mockResolvedValue([
+      createGame({
+        id: 'game-desktop',
+        title: '桌面专属',
+        deviceSupport: { desktop: true, mobile: false, touch: false },
+      }),
+    ]);
+    render(<GameGalleryPage onOpenDetail={vi.fn()} />);
+    expect(await screen.findByText('桌面专属')).toBeTruthy();
+
+    fireEvent.click(
+      within(screen.getByRole('tablist', { name: '设备筛选' })).getByRole(
+        'tab',
+        { name: /移动/u },
+      ),
+    );
+    expect(await screen.findByText('还没有找到对应游戏')).toBeTruthy();
+
+    fireEvent.click(screen.getByRole('button', { name: '重置筛选' }));
+    expect(await screen.findByText('桌面专属')).toBeTruthy();
+    expect(window.location.search).not.toContain('device=');
+  });
+
+  it('从地址栏恢复筛选条件', async () => {
+    resetGalleryContext();
+    window.history.replaceState(
+      {},
+      '',
+      '/games?keyword=%E6%98%9F%E8%BD%A8&category=%E5%8A%A8%E4%BD%9C&device=%E7%A7%BB%E5%8A%A8',
+    );
+    listGamesMock.mockResolvedValue([createGame({ title: '星轨防线' })]);
+    render(<GameGalleryPage onOpenDetail={vi.fn()} />);
+
+    await waitFor(() =>
+      expect(listGamesMock).toHaveBeenCalledWith({
+        keyword: '星轨',
+        category: '动作',
+      }),
+    );
+    const search = screen.getByLabelText('搜索游戏') as HTMLInputElement;
+    expect(search.value).toBe('星轨');
+    const deviceTabs = within(
+      screen.getByRole('tablist', { name: '设备筛选' }),
+    );
+    expect(
+      deviceTabs
+        .getByRole('tab', { name: /移动/u })
+        .getAttribute('aria-selected'),
+    ).toBe('true');
+  });
+
+  it('返回游戏广场时按上次筛选恢复列表与滚动位置', async () => {
+    resetGalleryContext();
+    window.sessionStorage.setItem(
+      'game-gallery-filters',
+      JSON.stringify({ keyword: '', category: '全部', device: '移动' }),
+    );
+    window.sessionStorage.setItem('game-gallery-scroll:|全部|移动', '320');
+    listGamesMock.mockResolvedValue([
+      createGame({
+        id: 'game-desktop',
+        title: '桌面专属',
+        deviceSupport: { desktop: true, mobile: false, touch: false },
+      }),
+      createGame({
+        id: 'game-mobile',
+        title: '移动可玩',
+        deviceSupport: { desktop: false, mobile: true, touch: true },
+      }),
+    ]);
+
+    const { container } = render(
+      <div className="platform-tab-panel">
+        <GameGalleryPage onOpenDetail={vi.fn()} />
+      </div>,
+    );
+    const scroller = container.querySelector(
+      '.platform-tab-panel',
+    ) as HTMLElement;
+
+    expect(await screen.findByText('移动可玩')).toBeTruthy();
+    await waitFor(() => expect(scroller.scrollTop).toBe(320));
+    expect(screen.queryByText('桌面专属')).toBeNull();
+  });
+
+  it('打开详情时保存目录滚动位置，返回后按同一容器复位', async () => {
+    resetGalleryContext();
+    const onOpenDetail = vi.fn();
+    listGamesMock.mockResolvedValue([createGame({ title: '星轨防线' })]);
+    const { container } = render(
+      <div className="platform-tab-panel">
+        <GameGalleryPage onOpenDetail={onOpenDetail} />
+      </div>,
+    );
+    const scroller = container.querySelector(
+      '.platform-tab-panel',
+    ) as HTMLElement;
+    expect(await screen.findByText('星轨防线')).toBeTruthy();
+
+    scroller.scrollTop = 180;
+    openGame('星轨防线');
+
+    expect(onOpenDetail).toHaveBeenCalledWith('game-1');
+    await waitFor(() =>
+      expect(
+        window.sessionStorage.getItem('game-gallery-scroll:|全部|全部'),
+      ).toBe('180'),
+    );
+  });
+});
+
+describe('GamePlayPage 启动超时与旋转提示', () => {
+  it('启动超时后给出重试与返回详情，重试可恢复可玩', async () => {
+    vi.useFakeTimers();
+    try {
+      const onBack = vi.fn();
+      getGameMock.mockResolvedValue(createGame());
+      render(<GamePlayPage gameId="game-1" onBack={onBack} />);
+      await act(async () => {
+        await Promise.resolve();
+      });
+
+      fireEvent.click(screen.getByRole('button', { name: /开始游戏/u }));
+      const firstFrame = screen.getByTitle('星轨防线 在线游玩');
+
+      act(() => {
+        vi.advanceTimersByTime(GAME_PLAY_STARTUP_TIMEOUT_MS);
+      });
+      expect(screen.getByText(/启动超时/u)).toBeTruthy();
+      expect(screen.getByRole('button', { name: /返回详情/u })).toBeTruthy();
+
+      fireEvent.click(screen.getByRole('button', { name: /^重试$/u }));
+      const retriedFrame = screen.getByTitle('星轨防线 在线游玩');
+      expect(retriedFrame).not.toBe(firstFrame);
+      expect(screen.queryByText(/启动超时/u)).toBeNull();
+
+      fireEvent.load(retriedFrame);
+      expect(retriedFrame.className.includes('game-player-frame--ready')).toBe(
+        true,
+      );
+
+      act(() => {
+        vi.advanceTimersByTime(GAME_PLAY_STARTUP_TIMEOUT_MS);
+      });
+      expect(screen.queryByText(/启动超时/u)).toBeNull();
+
+      fireEvent.click(screen.getByRole('button', { name: /星轨防线/u }));
+      expect(onBack).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('横屏游戏只在竖屏视口提示旋转', async () => {
+    setViewportWidth(390);
+    getGameMock.mockResolvedValue(createGame({ orientation: 'landscape' }));
+    const { unmount } = render(
+      <GamePlayPage gameId="game-1" onBack={vi.fn()} />,
+    );
+
+    expect(await screen.findByText(/旋转设备/u)).toBeTruthy();
+    unmount();
+
+    setViewportWidth(1280);
+    getGameMock.mockResolvedValue(createGame({ orientation: 'landscape' }));
+    render(<GamePlayPage gameId="game-1" onBack={vi.fn()} />);
+
+    await screen.findByRole('button', { name: /开始游戏/u });
+    expect(screen.queryByText(/旋转设备/u)).toBeNull();
+  });
+});
diff --git a/src/components/game-distribution/GameGalleryPage.tsx b/src/components/game-distribution/GameGalleryPage.tsx
new file mode 100644
index 000000000..4b5d64cdc
--- /dev/null
+++ b/src/components/game-distribution/GameGalleryPage.tsx
@@ -0,0 +1,389 @@
+import './gameDistribution.css';
+
+import { Gamepad2, Monitor, Search, Smartphone, Sparkles } from 'lucide-react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import {
+  type GameCategory,
+  type GameDistributionGame,
+  listGames,
+} from '../../services/gameDistributionClient';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformEmptyState } from '../common/PlatformEmptyState';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import {
+  GAME_GALLERY_CATEGORIES as CATEGORIES,
+  GAME_GALLERY_DEVICE_FILTERS as DEVICE_FILTERS,
+  GAME_GALLERY_SCROLL_CONTAINER_SELECTOR,
+  type GameDeviceFilter,
+  type GameGalleryFilters,
+  gameGalleryScrollKey,
+  matchesGameDeviceFilter,
+  readGameGalleryQueryFilters,
+  readStoredGameGalleryFilters,
+  readStoredGameGalleryScrollTop,
+  syncGameGalleryQuery,
+  writeStoredGameGalleryFilters,
+  writeStoredGameGalleryScrollTop,
+} from './gameGalleryViewState';
+
+type GameGalleryPageProps = {
+  searchKeyword?: string;
+  onOpenDetail: (gameId: string) => void;
+  onOpenMyGames?: () => void;
+  onOpenPublish?: () => void;
+};
+
+export function GameCover({
+  game,
+  compact = false,
+}: {
+  game: GameDistributionGame;
+  compact?: boolean;
+}) {
+  return (
+    <div
+      className={`game-cover ${compact ? 'game-cover--compact' : ''}`}
+      style={{
+        background: `linear-gradient(145deg, ${game.coverColor}, #16151c)`,
+      }}
+      aria-hidden="true"
+    >
+      <span className="game-cover__glow" />
+      <span className="game-cover__icon">{game.icon}</span>
+      <span className="game-cover__grid" />
+    </div>
+  );
+}
+
+function GameCard({
+  game,
+  onOpen,
+}: {
+  game: GameDistributionGame;
+  onOpen: () => void;
+}) {
+  return (
+    <button type="button" className="game-card" onClick={onOpen}>
+      <GameCover game={game} />
+      <span className="game-card__body">
+        <span className="game-card__title-row">
+          <strong>{game.title}</strong>
+          <span className="game-card__play-count">
+            {game.playCount.toLocaleString()} 次游玩
+          </span>
+        </span>
+        <span className="game-card__summary">{game.summary}</span>
+        <span className="game-card__meta">
+          <span>{game.category}</span>
+          <span>·</span>
+          <span>{game.author.name}</span>
+        </span>
+      </span>
+    </button>
+  );
+}
+
+export function GameGalleryPage({
+  searchKeyword = '',
+  onOpenDetail,
+  onOpenMyGames,
+  onOpenPublish,
+}: GameGalleryPageProps) {
+  const initialFiltersRef = useRef<GameGalleryFilters | null>(null);
+  if (initialFiltersRef.current === null) {
+    const queryFilters =
+      typeof window === 'undefined'
+        ? {}
+        : readGameGalleryQueryFilters(window.location.search);
+    const storedFilters = readStoredGameGalleryFilters();
+    initialFiltersRef.current = {
+      keyword: queryFilters.keyword ?? storedFilters.keyword ?? searchKeyword,
+      category: queryFilters.category ?? storedFilters.category ?? '全部',
+      device: queryFilters.device ?? storedFilters.device ?? '全部',
+    };
+  }
+  const initialFilters = initialFiltersRef.current;
+  const [category, setCategory] = useState<GameCategory | '全部'>(
+    initialFilters.category,
+  );
+  const [device, setDevice] = useState<GameDeviceFilter>(initialFilters.device);
+  const [keywordInput, setKeywordInput] = useState(initialFilters.keyword);
+  const [activeKeyword, setActiveKeyword] = useState(initialFilters.keyword);
+  const [games, setGames] = useState<GameDistributionGame[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState('');
+  const requestSerialRef = useRef(0);
+  const scrollContainerRef = useRef<HTMLElement | null>(null);
+  const hasRestoredScrollRef = useRef(false);
+  const didSyncPropKeywordRef = useRef(false);
+
+  const filters = useMemo<GameGalleryFilters>(
+    () => ({ keyword: activeKeyword, category, device }),
+    [activeKeyword, category, device],
+  );
+  const scrollKey = gameGalleryScrollKey(filters);
+
+  const attachPageRoot = useCallback((node: HTMLDivElement | null) => {
+    if (!node) return;
+    const container = node.closest(GAME_GALLERY_SCROLL_CONTAINER_SELECTOR);
+    scrollContainerRef.current =
+      container instanceof HTMLElement ? container : null;
+  }, []);
+
+  const loadGames = useCallback(() => {
+    const requestSerial = ++requestSerialRef.current;
+    setIsLoading(true);
+    setError('');
+    void listGames({ keyword: activeKeyword, category })
+      .then((nextGames) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setGames(nextGames);
+      })
+      .catch((loadError: unknown) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setError(
+          loadError instanceof Error ? loadError.message : '游戏目录加载失败',
+        );
+      })
+      .finally(() => {
+        if (requestSerial === requestSerialRef.current) setIsLoading(false);
+      });
+  }, [activeKeyword, category]);
+
+  useEffect(() => {
+    if (!didSyncPropKeywordRef.current) {
+      didSyncPropKeywordRef.current = true;
+      return;
+    }
+    setKeywordInput(searchKeyword);
+    setActiveKeyword(searchKeyword);
+  }, [searchKeyword]);
+
+  useEffect(() => {
+    void loadGames();
+    return () => {
+      requestSerialRef.current += 1;
+    };
+  }, [loadGames]);
+
+  useEffect(() => {
+    writeStoredGameGalleryFilters(filters);
+    syncGameGalleryQuery(filters);
+  }, [filters]);
+
+  useEffect(() => {
+    hasRestoredScrollRef.current = false;
+  }, [scrollKey]);
+
+  useEffect(() => {
+    if (hasRestoredScrollRef.current || isLoading || games.length === 0) return;
+    hasRestoredScrollRef.current = true;
+    const container = scrollContainerRef.current;
+    const storedScrollTop = readStoredGameGalleryScrollTop(scrollKey);
+    if (!container || storedScrollTop <= 0) return;
+    container.scrollTop = storedScrollTop;
+  }, [games.length, isLoading, scrollKey]);
+
+  useEffect(() => {
+    const key = scrollKey;
+    return () => {
+      const container = scrollContainerRef.current;
+      if (container) writeStoredGameGalleryScrollTop(key, container.scrollTop);
+    };
+  }, [scrollKey]);
+
+  const visibleGames = useMemo(
+    () => games.filter((game) => matchesGameDeviceFilter(game, device)),
+    [device, games],
+  );
+  const featuredGame = useMemo(() => visibleGames[0] ?? null, [visibleGames]);
+  const hasActiveFilters =
+    activeKeyword.trim().length > 0 || category !== '全部' || device !== '全部';
+  const resetFilters = () => {
+    setKeywordInput('');
+    setActiveKeyword('');
+    setCategory('全部');
+    setDevice('全部');
+  };
+  const openDetail = useCallback(
+    (gameId: string) => {
+      const container = scrollContainerRef.current;
+      if (container)
+        writeStoredGameGalleryScrollTop(scrollKey, container.scrollTop);
+      onOpenDetail(gameId);
+    },
+    [onOpenDetail, scrollKey],
+  );
+
+  return (
+    <div className="game-page" ref={attachPageRoot}>
+      <section className="game-hero">
+        <div className="game-hero__copy">
+          <span className="game-eyebrow">
+            <Sparkles aria-hidden="true" /> 陶泥儿游戏分发
+          </span>
+          <h1>
+            把灵感做成游戏，
+            <br />
+            <em>现在就开始玩。</em>
+          </h1>
+          <p>
+            来自 AGC
+            创作者的轻量游戏集合。打开网页即可游玩，每一次尝试都值得被看见。
+          </p>
+          <div className="game-hero__actions">
+            <PlatformActionButton
+              size="md"
+              shape="pill"
+              onClick={() => featuredGame && openDetail(featuredGame.id)}
+            >
+              <Gamepad2 aria-hidden="true" /> 立即试玩
+            </PlatformActionButton>
+            <span className="game-hero__hint">支持桌面端与移动端</span>
+          </div>
+        </div>
+        <div className="game-hero__orb" aria-hidden="true">
+          <span>✦</span>
+        </div>
+      </section>
+
+      <div className="game-toolbar">
+        <div className="game-toolbar__title">
+          <span className="game-eyebrow">发现好玩的</span>
+          <h2>游戏广场</h2>
+        </div>
+        <div className="game-toolbar__actions">
+          {onOpenPublish ? (
+            <PlatformActionButton
+              size="sm"
+              shape="pill"
+              onClick={onOpenPublish}
+            >
+              发布游戏
+            </PlatformActionButton>
+          ) : null}
+          {onOpenMyGames ? (
+            <PlatformActionButton
+              tone="secondary"
+              size="sm"
+              shape="pill"
+              onClick={onOpenMyGames}
+            >
+              我的游戏
+            </PlatformActionButton>
+          ) : null}
+          <label className="game-search">
+            <Search aria-hidden="true" />
+            <input
+              value={keywordInput}
+              placeholder="搜索游戏、作者或标签"
+              aria-label="搜索游戏"
+              onChange={(event) => {
+                const nextKeyword = event.target.value;
+                setKeywordInput(nextKeyword);
+                setActiveKeyword(nextKeyword);
+              }}
+            />
+          </label>
+        </div>
+      </div>
+      <div className="game-category-tabs" role="tablist" aria-label="游戏分类">
+        {CATEGORIES.map((item) => (
+          <button
+            key={item}
+            type="button"
+            role="tab"
+            aria-selected={category === item}
+            className={
+              category === item
+                ? 'game-category-tab game-category-tab--active'
+                : 'game-category-tab'
+            }
+            onClick={() => setCategory(item)}
+          >
+            {item}
+          </button>
+        ))}
+      </div>
+      <div
+        className="game-category-tabs game-category-tabs--device"
+        role="tablist"
+        aria-label="设备筛选"
+      >
+        {DEVICE_FILTERS.map((item) => (
+          <button
+            key={item}
+            type="button"
+            role="tab"
+            aria-selected={device === item}
+            className={
+              device === item
+                ? 'game-category-tab game-category-tab--active'
+                : 'game-category-tab'
+            }
+            onClick={() => setDevice(item)}
+          >
+            {item === '桌面' ? <Monitor aria-hidden="true" /> : null}
+            {item === '移动' ? <Smartphone aria-hidden="true" /> : null}
+            {item}
+          </button>
+        ))}
+      </div>
+
+      {isLoading ? (
+        <div className="game-loading-grid" aria-label="正在加载游戏">
+          <span />
+          <span />
+          <span />
+        </div>
+      ) : null}
+      {!isLoading && error ? (
+        <PlatformStatusMessage
+          tone="error"
+          surface="platform"
+          className="game-status-message"
+        >
+          <span>{error}</span>
+          <button type="button" onClick={loadGames}>
+            重新加载
+          </button>
+        </PlatformStatusMessage>
+      ) : null}
+      {!isLoading && !error && visibleGames.length === 0 ? (
+        <PlatformEmptyState surface="subpanel" size="panel">
+          <strong>还没有找到对应游戏</strong>
+          <br />
+          <span>
+            {hasActiveFilters
+              ? '换个关键词、分类或设备条件再试试。'
+              : '新的游戏正在路上，稍后再来看看。'}
+          </span>
+          {hasActiveFilters ? (
+            <div className="game-empty-actions">
+              <PlatformActionButton
+                tone="secondary"
+                size="sm"
+                shape="pill"
+                onClick={resetFilters}
+              >
+                重置筛选
+              </PlatformActionButton>
+            </div>
+          ) : null}
+        </PlatformEmptyState>
+      ) : null}
+      {!isLoading && !error && visibleGames.length > 0 ? (
+        <div className="game-grid">
+          {visibleGames.map((game) => (
+            <GameCard
+              key={game.id}
+              game={game}
+              onOpen={() => openDetail(game.id)}
+            />
+          ))}
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/src/components/game-distribution/GamePlayPage.tsx b/src/components/game-distribution/GamePlayPage.tsx
new file mode 100644
index 000000000..615af9d18
--- /dev/null
+++ b/src/components/game-distribution/GamePlayPage.tsx
@@ -0,0 +1,247 @@
+import './gameDistribution.css';
+
+import {
+  ArrowLeft,
+  Expand,
+  Gamepad2,
+  RotateCcw,
+  Smartphone,
+} from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+import {
+  type GameDistributionGame,
+  getGame,
+} from '../../services/gameDistributionClient';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import {
+  normalizeGameEntryUrl,
+  normalizeGameId,
+  useIsMobileViewport,
+  useIsPortraitViewport,
+} from './gameDistributionGuards';
+import { GameCover } from './GameGalleryPage';
+
+type GamePlayPageProps = { gameId: string | null; onBack: () => void };
+
+/** 发行包首屏加载上限：超过后给出显式超时与重试，不用无限期“正在启动”。 */
+export const GAME_PLAY_STARTUP_TIMEOUT_MS = 20_000;
+
+type GameStartupState = 'idle' | 'loading' | 'ready' | 'timeout';
+
+export function GamePlayPage({ gameId, onBack }: GamePlayPageProps) {
+  const frameRef = useRef<HTMLIFrameElement>(null);
+  const [game, setGame] = useState<GameDistributionGame | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [startupState, setStartupState] = useState<GameStartupState>('idle');
+  const [hasStarted, setHasStarted] = useState(false);
+  const [frameRunId, setFrameRunId] = useState(0);
+  const [error, setError] = useState('');
+  const requestSerialRef = useRef(0);
+  const isMobileViewport = useIsMobileViewport();
+  const isPortraitViewport = useIsPortraitViewport();
+
+  const loadGame = useCallback(() => {
+    const requestSerial = ++requestSerialRef.current;
+    const normalizedGameId = normalizeGameId(gameId);
+    setGame(null);
+    setHasStarted(false);
+    setStartupState('idle');
+    setError('');
+    if (!normalizedGameId) {
+      setError('缺少游戏编号');
+      setIsLoading(false);
+      return;
+    }
+    setIsLoading(true);
+    void getGame(normalizedGameId)
+      .then((value) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        if (!value?.currentVersion?.entryUrl) {
+          throw new Error('这款游戏暂时没有可玩的版本');
+        }
+        const entryUrl = normalizeGameEntryUrl(value.currentVersion.entryUrl);
+        if (!entryUrl) throw new Error('游戏入口地址无效');
+        setGame({
+          ...value,
+          currentVersion: { ...value.currentVersion, entryUrl },
+        });
+      })
+      .catch((loadError: unknown) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setError(
+          loadError instanceof Error ? loadError.message : '游戏加载失败',
+        );
+      })
+      .finally(() => {
+        if (requestSerial === requestSerialRef.current) setIsLoading(false);
+      });
+  }, [gameId]);
+
+  useEffect(() => {
+    void loadGame();
+    return () => {
+      requestSerialRef.current += 1;
+    };
+  }, [loadGame]);
+
+  useEffect(() => {
+    if (!hasStarted || startupState !== 'loading') return undefined;
+    const timeoutId = window.setTimeout(() => {
+      setStartupState((current) =>
+        current === 'loading' ? 'timeout' : current,
+      );
+    }, GAME_PLAY_STARTUP_TIMEOUT_MS);
+    return () => window.clearTimeout(timeoutId);
+  }, [hasStarted, startupState]);
+
+  const enterFullscreen = () => {
+    void frameRef.current?.requestFullscreen?.();
+  };
+
+  const mobilePlaybackBlocked = isMobileViewport && !game?.deviceSupport.mobile;
+  const showRotationHint =
+    Boolean(game) && game?.orientation === 'landscape' && isPortraitViewport;
+  const startGame = () => {
+    if (mobilePlaybackBlocked) return;
+    setHasStarted(true);
+    setStartupState('loading');
+    setFrameRunId((runId) => runId + 1);
+  };
+
+  /** 重试只重挂载发行页，不改变已开始的会话，也不会在退出后自动重启。 */
+  const retryGame = () => {
+    setStartupState('loading');
+    setFrameRunId((runId) => runId + 1);
+  };
+
+  if (isLoading)
+    return (
+      <div className="game-play-page">
+        <div className="game-loading-panel">正在准备游戏…</div>
+      </div>
+    );
+  if (error || !game?.currentVersion)
+    return (
+      <div className="game-play-page">
+        <button type="button" className="game-back-button" onClick={onBack}>
+          <ArrowLeft /> 返回详情
+        </button>
+        <PlatformStatusMessage
+          tone="error"
+          surface="platform"
+          className="game-status-message"
+        >
+          <span>{error || '游戏版本不可用'}</span>
+          <button type="button" onClick={loadGame}>
+            重新加载
+          </button>
+        </PlatformStatusMessage>
+      </div>
+    );
+
+  return (
+    <div className="game-play-page">
+      <div className="game-play-toolbar">
+        <button type="button" className="game-back-button" onClick={onBack}>
+          <ArrowLeft /> {game.title}
+        </button>
+        <div className="game-play-toolbar__actions">
+          <span className="game-play-device-hint">
+            <Smartphone aria-hidden="true" />{' '}
+            {game.deviceSupport.touch ? '支持触屏' : '桌面端游戏'}
+          </span>
+          <button
+            type="button"
+            className="game-icon-button"
+            aria-label="重新加载游戏"
+            onClick={loadGame}
+          >
+            <RotateCcw />
+          </button>
+          <PlatformActionButton
+            size="sm"
+            shape="pill"
+            onClick={enterFullscreen}
+            disabled={!hasStarted}
+          >
+            <Expand /> 全屏
+          </PlatformActionButton>
+        </div>
+      </div>
+      {showRotationHint ? (
+        <p className="game-device-warning" role="status">
+          这款游戏以横屏设计，旋转设备即可获得完整画面。
+        </p>
+      ) : null}
+      <div className="game-player-shell">
+        {!hasStarted ? (
+          <div className="game-player-launch">
+            <GameCover game={game} compact />
+            <div className="game-player-launch__copy">
+              <h1>{game.title}</h1>
+              <p>{game.summary}</p>
+              {mobilePlaybackBlocked ? (
+                <p
+                  className="game-device-warning"
+                  role="status"
+                  id="game-play-mobile-warning"
+                >
+                  请在电脑上游玩
+                </p>
+              ) : null}
+              <PlatformActionButton
+                size="lg"
+                shape="pill"
+                onClick={startGame}
+                disabled={mobilePlaybackBlocked}
+                aria-describedby={
+                  mobilePlaybackBlocked ? 'game-play-mobile-warning' : undefined
+                }
+              >
+                <Gamepad2 aria-hidden="true" /> 开始游戏
+              </PlatformActionButton>
+            </div>
+          </div>
+        ) : null}
+        {hasStarted && startupState === 'loading' ? (
+          <div className="game-player-loading">游戏正在启动…</div>
+        ) : null}
+        {hasStarted && startupState === 'timeout' ? (
+          <PlatformStatusMessage
+            tone="error"
+            surface="platform"
+            className="game-status-message game-player-timeout"
+          >
+            <span>游戏启动超时，可能是网络较慢或发行包暂时不可用。</span>
+            <button type="button" onClick={retryGame}>
+              重试
+            </button>
+            <button type="button" onClick={onBack}>
+              返回详情
+            </button>
+          </PlatformStatusMessage>
+        ) : null}
+        {hasStarted ? (
+          <iframe
+            ref={frameRef}
+            key={`${game.currentVersion.id}:${frameRunId}`}
+            title={`${game.title} 在线游玩`}
+            src={game.currentVersion.entryUrl}
+            className={`game-player-frame ${startupState === 'ready' ? 'game-player-frame--ready' : ''}`}
+            sandbox="allow-scripts"
+            allow="fullscreen"
+            referrerPolicy="no-referrer"
+            onLoad={() => setStartupState('ready')}
+          />
+        ) : null}
+      </div>
+      <p className="game-play-safety-note">
+        游戏运行在隔离容器中，不会读取你的账号信息或平台数据。
+      </p>
+    </div>
+  );
+}
+
+export default GamePlayPage;
diff --git a/src/components/game-distribution/GamePublishPage.test.tsx b/src/components/game-distribution/GamePublishPage.test.tsx
new file mode 100644
index 000000000..9990c277e
--- /dev/null
+++ b/src/components/game-distribution/GamePublishPage.test.tsx
@@ -0,0 +1,413 @@
+/* @vitest-environment jsdom */
+
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import JSZip from 'jszip';
+import type { ContextType } from 'react';
+import { beforeEach, expect, test, vi } from 'vitest';
+
+import {
+  createGame,
+  createGameVersion,
+  getGameVersion,
+  listMyGames,
+  submitGameVersion,
+  uploadGamePackage,
+} from '../../services/gameDistributionClient';
+import { AuthUiContext } from '../auth/AuthUiContext';
+import { resolvePublishMetadataError } from './gamePublishMetadata';
+import { GamePublishPage } from './GamePublishPage';
+
+vi.mock('../../services/gameDistributionClient', () => ({
+  createGame: vi.fn(),
+  createGameVersion: vi.fn(),
+  getGameVersion: vi.fn(),
+  listMyGames: vi.fn(),
+  submitGameVersion: vi.fn(),
+  uploadGamePackage: vi.fn(),
+}));
+
+type AuthValue = NonNullable<ContextType<typeof AuthUiContext>>;
+
+function createAuthValue(overrides: Partial<AuthValue> = {}): AuthValue {
+  return {
+    user: {
+      id: 'user-1',
+      publicUserCode: '100001',
+      displayName: '测试作者',
+      avatarUrl: null,
+      phoneNumberMasked: null,
+      loginMethod: 'password',
+      bindingStatus: 'active',
+      wechatBound: false,
+    },
+    canAccessProtectedData: true,
+    openLoginModal: vi.fn(),
+    requireAuth: vi.fn((action: () => void) => action()),
+    openSettingsModal: vi.fn(),
+    openAccountModal: vi.fn(),
+    setCurrentUser: vi.fn(),
+    logout: vi.fn(),
+    musicVolume: 0.5,
+    setMusicVolume: vi.fn(),
+    platformTheme: 'light',
+    setPlatformTheme: vi.fn(),
+    isHydratingSettings: false,
+    isPersistingSettings: false,
+    settingsError: null,
+    ...overrides,
+  };
+}
+
+async function buildZipFile() {
+  const zip = new JSZip();
+  zip.file('index.html', '<html><body>ok</body></html>');
+  zip.file('assets/app.js', 'console.log(1)');
+  const bytes = await zip.generateAsync({ type: 'uint8array' });
+  return new File([bytes as unknown as BlobPart], 'game.zip', {
+    type: 'application/zip',
+  });
+}
+
+function renderPage(authValue: AuthValue | null = createAuthValue()) {
+  return render(
+    <AuthUiContext.Provider value={authValue}>
+      <GamePublishPage onBack={vi.fn()} onOpenMyGames={vi.fn()} />
+    </AuthUiContext.Provider>,
+  );
+}
+
+beforeEach(() => {
+  vi.mocked(createGame).mockReset();
+  vi.mocked(createGameVersion).mockReset();
+  vi.mocked(getGameVersion).mockReset();
+  vi.mocked(listMyGames).mockReset();
+  vi.mocked(uploadGamePackage).mockReset();
+  vi.mocked(submitGameVersion).mockReset();
+  window.localStorage.clear();
+});
+
+function writeDraft(ownerUserId: string) {
+  window.localStorage.setItem(
+    'genarrative.game-distribution.publish-draft.v1',
+    JSON.stringify({
+      ownerUserId,
+      gameId: 'game-1',
+      versionId: 'gamever-1',
+      versionNumber: 1,
+      title: '上次的游戏',
+      updatedAt: '2026-09-20T09:00:00.000Z',
+    }),
+  );
+}
+
+test('元数据校验与服务端口径一致', () => {
+  expect(
+    resolvePublishMetadataError({
+      title: '   ',
+      summary: '简介',
+      deviceSupport: { desktop: true, mobile: false, touch: false },
+    }),
+  ).toBe('游戏标题必须为 1 到 40 个字符');
+  expect(
+    resolvePublishMetadataError({
+      title: '游戏',
+      summary: '简介',
+      deviceSupport: { desktop: false, mobile: true, touch: false },
+    }),
+  ).toBe('选择移动端时必须支持触控');
+  expect(
+    resolvePublishMetadataError({
+      title: '游戏',
+      summary: '简介',
+      deviceSupport: { desktop: false, mobile: false, touch: false },
+    }),
+  ).toBe('至少选择桌面端或移动端');
+  expect(
+    resolvePublishMetadataError({
+      title: '游戏',
+      summary: '简介',
+      deviceSupport: { desktop: true, mobile: false, touch: false },
+    }),
+  ).toBe('');
+});
+
+test('未登录时不提交且提示登录', () => {
+  renderPage(null);
+  expect(screen.getByText('登录后才能发布游戏。')).toBeTruthy();
+  fireEvent.click(screen.getByRole('button', { name: /提交审核/u }));
+  expect(createGame).not.toHaveBeenCalled();
+});
+
+test('缺少发行包时不上传', async () => {
+  renderPage();
+  fireEvent.change(screen.getByLabelText('游戏名称'), {
+    target: { value: '测试游戏' },
+  });
+  fireEvent.change(screen.getByLabelText('一句话简介'), {
+    target: { value: '测试简介' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: /提交审核/u }));
+  expect(await screen.findByText('请选择发行包 ZIP')).toBeTruthy();
+  expect(createGame).not.toHaveBeenCalled();
+});
+
+test('按创建游戏、创建版本、上传、送审顺序提交并展示审核中', async () => {
+  vi.mocked(createGame).mockResolvedValue({
+    id: 'game-1',
+    publicationRevision: 0,
+  } as never);
+  vi.mocked(createGameVersion).mockResolvedValue({
+    gameId: 'game-1',
+    versionId: 'gamever-1',
+    versionNumber: 1,
+    status: 'awaiting_upload',
+  });
+  vi.mocked(uploadGamePackage).mockResolvedValue({
+    versionId: 'gamever-1',
+    status: 'uploaded',
+  });
+  vi.mocked(submitGameVersion).mockResolvedValue({
+    version: { status: 'pending_review' },
+  });
+
+  renderPage();
+  const file = await buildZipFile();
+  fireEvent.change(screen.getByLabelText('游戏名称'), {
+    target: { value: '测试游戏' },
+  });
+  fireEvent.change(screen.getByLabelText('一句话简介'), {
+    target: { value: '测试简介' },
+  });
+  fireEvent.change(screen.getByLabelText(/发行包 ZIP/u), {
+    target: { files: [file] },
+  });
+  fireEvent.click(screen.getByRole('button', { name: /提交审核/u }));
+
+  await waitFor(() => expect(submitGameVersion).toHaveBeenCalledTimes(1));
+  expect(vi.mocked(createGame).mock.calls[0]?.[0]).toEqual(
+    expect.objectContaining({
+      title: '测试游戏',
+      summary: '测试简介',
+      category: '休闲',
+      inputModes: ['keyboard', 'mouse', 'touch'],
+    }),
+  );
+  expect(vi.mocked(createGameVersion).mock.calls[0]?.[0]).toBe('game-1');
+  const versionPayload = vi.mocked(createGameVersion).mock.calls[0]?.[1];
+  expect(versionPayload?.packageEntryPath).toBe('index.html');
+  expect(versionPayload?.packageFileCount).toBe(2);
+  expect(versionPayload?.packageSha256).toMatch(/^[0-9a-f]{64}$/u);
+  expect(vi.mocked(uploadGamePackage).mock.calls[0]?.[0]).toBe('gamever-1');
+  expect(vi.mocked(submitGameVersion).mock.calls[0]?.[1]).toBe(0);
+
+  expect(
+    await screen.findByText('已提交审核，审核通过后会自动出现在游戏广场。'),
+  ).toBeTruthy();
+});
+
+test('后端失败时不伪造成功', async () => {
+  vi.mocked(createGame).mockRejectedValue(
+    new Error('游戏分发服务暂不可用（503）'),
+  );
+  renderPage();
+  const file = await buildZipFile();
+  fireEvent.change(screen.getByLabelText('游戏名称'), {
+    target: { value: '测试游戏' },
+  });
+  fireEvent.change(screen.getByLabelText('一句话简介'), {
+    target: { value: '测试简介' },
+  });
+  fireEvent.change(screen.getByLabelText(/发行包 ZIP/u), {
+    target: { files: [file] },
+  });
+  fireEvent.click(screen.getByRole('button', { name: /提交审核/u }));
+
+  expect(await screen.findByText('游戏分发服务暂不可用（503）')).toBeTruthy();
+  expect(
+    screen.queryByText('已提交审核，审核通过后会自动出现在游戏广场。'),
+  ).toBeNull();
+});
+
+test('同一账号回到发布页可以沿用原版本继续送审', async () => {
+  writeDraft('user-1');
+  vi.mocked(getGameVersion).mockResolvedValue({
+    game: {
+      id: 'game-1',
+      title: '上次的游戏',
+      summary: '上次的简介',
+      description: '上次的详细介绍',
+      publicationRevision: 2,
+    },
+    version: {
+      versionId: 'gamever-1',
+      versionNumber: 1,
+      status: 'uploaded',
+      recoveryAction: 'submit',
+    },
+  } as never);
+  vi.mocked(submitGameVersion).mockResolvedValue({
+    version: { status: 'pending_review' },
+  });
+
+  renderPage();
+
+  expect(await screen.findByText(/上次发布未完成|发行包已上传/u)).toBeTruthy();
+  fireEvent.click(await screen.findByRole('button', { name: '继续送审' }));
+
+  // 已上传的版本不再重复创建游戏、创建版本或上传发行包。
+  expect(createGame).not.toHaveBeenCalled();
+  expect(createGameVersion).not.toHaveBeenCalled();
+  expect(uploadGamePackage).not.toHaveBeenCalled();
+  await waitFor(() => expect(submitGameVersion).toHaveBeenCalledTimes(1));
+  expect(vi.mocked(submitGameVersion).mock.calls[0]?.[0]).toBe('gamever-1');
+  expect(vi.mocked(submitGameVersion).mock.calls[0]?.[1]).toBe(2);
+  expect(
+    await screen.findByText('已提交审核，审核通过后会自动出现在游戏广场。'),
+  ).toBeTruthy();
+  expect(
+    window.localStorage.getItem(
+      'genarrative.game-distribution.publish-draft.v1',
+    ),
+  ).toBeNull();
+});
+
+test('换账号不回读上一账号的发布草稿', async () => {
+  writeDraft('user-1');
+  renderPage(
+    createAuthValue({
+      user: { ...createAuthValue().user!, id: 'user-2' },
+    }),
+  );
+
+  await waitFor(() => expect(screen.queryByText(/上次发布未完成/u)).toBeNull());
+  expect(getGameVersion).not.toHaveBeenCalled();
+  // 草稿仍属于原账号，换账号只忽略、不删除。
+  expect(
+    window.localStorage.getItem(
+      'genarrative.game-distribution.publish-draft.v1',
+    ),
+  ).not.toBeNull();
+});
+
+test('更新模式在既有 gameId 下创建新版本并沿用公开修订号', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    {
+      id: 'game-1',
+      title: '星轨防线',
+      summary: '守住轨道城',
+      description: '旧版资料',
+      category: '动作',
+      tags: ['塔防'],
+      publicationRevision: 4,
+      latestVersion: {
+        versionId: 'gamever-2',
+        gameId: 'game-1',
+        versionNumber: 2,
+        packageSha256: 'd'.repeat(64),
+        packageBytes: 1024,
+        status: 'published',
+        publicationRevision: 4,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+      versions: [],
+    } as never,
+  ]);
+  vi.mocked(getGameVersion).mockResolvedValue({
+    game: {
+      id: 'game-1',
+      title: '星轨防线',
+      summary: '守住轨道城',
+      description: '旧版资料',
+      category: '动作',
+      tags: ['塔防'],
+      publicationRevision: 4,
+    },
+    version: {
+      versionId: 'gamever-2',
+      versionNumber: 2,
+      status: 'published',
+      publicationRevision: 4,
+      recoveryAction: 'none',
+    },
+  } as never);
+  vi.mocked(createGameVersion).mockResolvedValue({
+    gameId: 'game-1',
+    versionId: 'gamever-3',
+    versionNumber: 3,
+    status: 'awaiting_upload',
+  });
+  vi.mocked(uploadGamePackage).mockResolvedValue({
+    versionId: 'gamever-3',
+    status: 'uploaded',
+  });
+  vi.mocked(submitGameVersion).mockResolvedValue({
+    version: { status: 'pending_review' },
+  });
+
+  render(
+    <AuthUiContext.Provider value={createAuthValue()}>
+      <GamePublishPage
+        onBack={vi.fn()}
+        onOpenMyGames={vi.fn()}
+        updateGameId="game-1"
+      />
+    </AuthUiContext.Provider>,
+  );
+
+  expect(
+    await screen.findByText(/正在为《星轨防线》发布新版本 v3/u),
+  ).toBeTruthy();
+  expect(screen.getByLabelText('游戏名称')).toHaveProperty('value', '星轨防线');
+  expect(screen.getByLabelText('分类')).toHaveProperty('value', '动作');
+
+  const file = await buildZipFile();
+  fireEvent.change(screen.getByLabelText(/发行包 ZIP/u), {
+    target: { files: [file] },
+  });
+  fireEvent.click(screen.getByRole('button', { name: '提交新版本审核' }));
+
+  await waitFor(() => expect(submitGameVersion).toHaveBeenCalledTimes(1));
+  // 更新模式不得新建游戏，必须在同一个 gameId 下创建新版本。
+  expect(createGame).not.toHaveBeenCalled();
+  expect(vi.mocked(createGameVersion).mock.calls[0]?.[0]).toBe('game-1');
+  expect(vi.mocked(createGameVersion).mock.calls[0]?.[1]).toEqual(
+    expect.objectContaining({
+      packageEntryPath: 'index.html',
+      gameMetadata: expect.objectContaining({
+        title: '星轨防线',
+        category: '动作',
+        tags: ['塔防'],
+      }),
+    }),
+  );
+  expect(vi.mocked(submitGameVersion).mock.calls[0]?.[0]).toBe('gamever-3');
+  expect(vi.mocked(submitGameVersion).mock.calls[0]?.[1]).toBe(4);
+  expect(
+    await screen.findByText('已提交审核，审核通过后会自动出现在游戏广场。'),
+  ).toBeTruthy();
+});
+
+test('更新模式读不到归属游戏时失败关闭且不提交', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([]);
+
+  render(
+    <AuthUiContext.Provider value={createAuthValue()}>
+      <GamePublishPage
+        onBack={vi.fn()}
+        onOpenMyGames={vi.fn()}
+        updateGameId="game-missing"
+      />
+    </AuthUiContext.Provider>,
+  );
+
+  expect(
+    await screen.findByText('找不到这个游戏，或它不属于当前账号'),
+  ).toBeTruthy();
+  expect(screen.getByRole('button', { name: '提交新版本审核' })).toHaveProperty(
+    'disabled',
+    true,
+  );
+  expect(createGameVersion).not.toHaveBeenCalled();
+});
diff --git a/src/components/game-distribution/GamePublishPage.tsx b/src/components/game-distribution/GamePublishPage.tsx
new file mode 100644
index 000000000..8868238b5
--- /dev/null
+++ b/src/components/game-distribution/GamePublishPage.tsx
@@ -0,0 +1,687 @@
+import './gameDistribution.css';
+
+import { ArrowLeft, Upload } from 'lucide-react';
+import { useEffect, useRef, useState } from 'react';
+
+import type {
+  GameDistributionCategory,
+  GameDistributionDeviceSupport,
+  GameDistributionInputMode,
+  GameDistributionOrientation,
+  GameDistributionVersionDetail,
+} from '../../../packages/shared/src/contracts/gameDistribution';
+import {
+  createGame,
+  createGameVersion,
+  getGameVersion,
+  listMyGames,
+  submitGameVersion,
+  uploadGamePackage,
+} from '../../services/gameDistributionClient';
+import { useAuthUi } from '../auth/AuthUiContext';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import {
+  clearPublishDraft,
+  type GamePublishDraft,
+  readPublishDraft,
+  resolvePublishDraftRecoveryCopy,
+  writePublishDraft,
+} from './gamePublishDraft';
+import { resolvePublishMetadataError } from './gamePublishMetadata';
+import { prepareGamePackage } from './gameZipPackage';
+
+const CATEGORIES: GameDistributionCategory[] = [
+  '休闲',
+  '益智',
+  '动作',
+  '冒险',
+  '模拟',
+  '策略',
+  '其他',
+];
+
+const ORIENTATIONS: Array<{
+  value: GameDistributionOrientation;
+  label: string;
+}> = [
+  { value: 'responsive', label: '自适应' },
+  { value: 'landscape', label: '横屏' },
+  { value: 'portrait', label: '竖屏' },
+];
+
+type GamePublishPageProps = {
+  onBack: () => void;
+  onOpenMyGames: () => void;
+  /** 设置后进入“为既有游戏发布新版本”模式，沿用同一个 gameId。 */
+  updateGameId?: string | null;
+};
+
+type GameUpdateContext = {
+  gameId: string;
+  publicationRevision: number;
+  versionNumber: number;
+  title: string;
+};
+
+let publishKeySeed = 0;
+function createPublishKey() {
+  publishKeySeed += 1;
+  const random =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : `${Date.now()}-${publishKeySeed}`;
+  return `web-publish-${random}`;
+}
+
+export function GamePublishPage({
+  onBack,
+  onOpenMyGames,
+  updateGameId = null,
+}: GamePublishPageProps) {
+  const authUi = useAuthUi();
+  const fileInputRef = useRef<HTMLInputElement>(null);
+  const [title, setTitle] = useState('');
+  const [summary, setSummary] = useState('');
+  const [description, setDescription] = useState('');
+  const [category, setCategory] = useState<GameDistributionCategory>('休闲');
+  const [tagsInput, setTagsInput] = useState('');
+  const [deviceSupport, setDeviceSupport] =
+    useState<GameDistributionDeviceSupport>({
+      desktop: true,
+      mobile: true,
+      touch: true,
+    });
+  const [orientation, setOrientation] =
+    useState<GameDistributionOrientation>('responsive');
+  const [packageFile, setPackageFile] = useState<File | null>(null);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState('');
+  const [publishedGameId, setPublishedGameId] = useState('');
+  const [draft, setDraft] = useState<GamePublishDraft | null>(null);
+  const [draftDetail, setDraftDetail] =
+    useState<GameDistributionVersionDetail | null>(null);
+  const [isResumingDraft, setIsResumingDraft] = useState(false);
+  const [updateContext, setUpdateContext] = useState<GameUpdateContext | null>(
+    null,
+  );
+  const [updateContextError, setUpdateContextError] = useState('');
+  const canPublish = Boolean(authUi?.user && authUi.canAccessProtectedData);
+  const currentUserId = authUi?.user?.id ?? '';
+
+  // 更新模式：先按 gameId 从作者中心定位最近版本，再回读它冻结的资料与公开修订号。
+  useEffect(() => {
+    if (!canPublish || !updateGameId) {
+      setUpdateContext(null);
+      setUpdateContextError('');
+      return;
+    }
+    let cancelled = false;
+    setUpdateContextError('');
+    listMyGames()
+      .then(async (games) => {
+        const game = games.find((item) => item.id === updateGameId);
+        if (!game) {
+          throw new Error('找不到这个游戏，或它不属于当前账号');
+        }
+        const latestVersionId = game.latestVersion?.versionId;
+        if (!latestVersionId) {
+          throw new Error('这个游戏还没有可续发的版本，请直接发布新游戏');
+        }
+        const detail = await getGameVersion(latestVersionId);
+        if (cancelled) return;
+        setTitle(detail.game.title);
+        setSummary(detail.game.summary);
+        setDescription(detail.game.description);
+        setCategory(detail.game.category);
+        setTagsInput(detail.game.tags.join('，'));
+        setUpdateContext({
+          gameId: game.id,
+          publicationRevision: detail.version.publicationRevision,
+          versionNumber: detail.version.versionNumber,
+          title: detail.game.title,
+        });
+      })
+      .catch((error: unknown) => {
+        if (cancelled) return;
+        setUpdateContext(null);
+        setUpdateContextError(
+          error instanceof Error ? error.message : '读取待更新游戏失败',
+        );
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [canPublish, updateGameId]);
+
+  // 只在当前账号与草稿 owner 一致时回读版本；换账号时忽略草稿，绝不展示上一账号状态。
+  useEffect(() => {
+    if (updateGameId) return undefined;
+    if (!canPublish || !currentUserId) {
+      setDraft(null);
+      setDraftDetail(null);
+      setIsResumingDraft(false);
+      return;
+    }
+    const stored = readPublishDraft();
+    if (!stored || stored.ownerUserId !== currentUserId) {
+      setDraft(null);
+      setDraftDetail(null);
+      setIsResumingDraft(false);
+      return;
+    }
+    let cancelled = false;
+    setDraft(stored);
+    getGameVersion(stored.versionId)
+      .then((detail) => {
+        if (cancelled) return;
+        setDraftDetail(detail);
+        setTitle(detail.game.title);
+        setSummary(detail.game.summary);
+        setDescription(detail.game.description);
+      })
+      .catch(() => {
+        if (cancelled) return;
+        setDraftDetail(null);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [canPublish, currentUserId, updateGameId]);
+
+  const resumeNeedsPackage =
+    isResumingDraft &&
+    draftDetail !== null &&
+    draftDetail.version.recoveryAction !== 'submit';
+
+  function dismissDraft() {
+    clearPublishDraft();
+    setDraft(null);
+    setDraftDetail(null);
+    setIsResumingDraft(false);
+  }
+
+  async function handleResumeSubmit() {
+    if (!draftDetail) {
+      setError('恢复的版本状态不可用，请重新选择发行包。');
+      return;
+    }
+    if (!packageFile && draftDetail.version.recoveryAction !== 'submit') {
+      setError('请选择上次那个发行包 ZIP 继续上传');
+      return;
+    }
+    setIsSubmitting(true);
+    setError('');
+    try {
+      const resumeKey = createPublishKey();
+      if (draftDetail.version.recoveryAction !== 'submit') {
+        const prepared = await prepareGamePackage(packageFile as File);
+        await uploadGamePackage(
+          draftDetail.version.versionId,
+          new Blob([prepared.bytes as unknown as BlobPart], {
+            type: 'application/zip',
+          }),
+          `${resumeKey}:upload`,
+        );
+      }
+      await submitGameVersion(
+        draftDetail.version.versionId,
+        draftDetail.game.publicationRevision,
+        `${resumeKey}:submit`,
+      );
+      clearPublishDraft();
+      setDraft(null);
+      setDraftDetail(null);
+      setIsResumingDraft(false);
+      setPublishedGameId(draftDetail.game.id);
+    } catch (resumeError: unknown) {
+      setError(
+        resumeError instanceof Error ? resumeError.message : '继续发布失败',
+      );
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  /**
+   * 更新模式：不调用创建游戏接口，直接在既有 `gameId` 下创建不可变新版本并送审；
+   * 公开版本只在管理员通过后切换，期间旧版本继续在线。
+   */
+  async function handleUpdateSubmit() {
+    if (!updateContext) {
+      setError(updateContextError || '待更新游戏尚未就绪，请稍后重试');
+      return;
+    }
+    const metadataError = resolvePublishMetadataError({
+      title,
+      summary,
+      deviceSupport,
+    });
+    if (metadataError) {
+      setError(metadataError);
+      return;
+    }
+    if (!packageFile) {
+      setError('请选择发行包 ZIP');
+      return;
+    }
+    setIsSubmitting(true);
+    setError('');
+    try {
+      const prepared = await prepareGamePackage(packageFile);
+      const updateKey = createPublishKey();
+      const inputModes: GameDistributionInputMode[] = ['keyboard', 'mouse'];
+      if (deviceSupport.touch) inputModes.push('touch');
+      const tags = tagsInput
+        .split(/[,，]/u)
+        .map((tag) => tag.trim())
+        .filter(Boolean)
+        .slice(0, 5);
+      const gameMetadata = {
+        title: title.trim(),
+        summary: summary.trim(),
+        description: description.trim() || summary.trim(),
+        category,
+        tags,
+        deviceSupport,
+        inputModes,
+        orientation,
+      };
+      const version = await createGameVersion(
+        updateContext.gameId,
+        {
+          packageSha256: prepared.sha256,
+          packageBytes: prepared.totalBytes,
+          packageFileCount: prepared.fileCount,
+          packageEntryPath: 'index.html',
+          gameMetadata,
+        },
+        `${updateKey}:version`,
+      );
+      await uploadGamePackage(
+        version.versionId,
+        new Blob([prepared.bytes as unknown as BlobPart], {
+          type: 'application/zip',
+        }),
+        `${updateKey}:upload`,
+      );
+      await submitGameVersion(
+        version.versionId,
+        updateContext.publicationRevision,
+        `${updateKey}:submit`,
+      );
+      setPublishedGameId(updateContext.gameId);
+      setUpdateContext((current) =>
+        current
+          ? { ...current, versionNumber: version.versionNumber }
+          : current,
+      );
+    } catch (updateError: unknown) {
+      setError(
+        updateError instanceof Error ? updateError.message : '发布新版本失败',
+      );
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  async function handleSubmit() {
+    if (updateGameId) {
+      await handleUpdateSubmit();
+      return;
+    }
+    if (isResumingDraft) {
+      await handleResumeSubmit();
+      return;
+    }
+    const metadataError = resolvePublishMetadataError({
+      title,
+      summary,
+      deviceSupport,
+    });
+    if (metadataError) {
+      setError(metadataError);
+      return;
+    }
+    if (!packageFile) {
+      setError('请选择发行包 ZIP');
+      return;
+    }
+    setIsSubmitting(true);
+    setError('');
+    try {
+      const prepared = await prepareGamePackage(packageFile);
+      const inputModes: GameDistributionInputMode[] = ['keyboard', 'mouse'];
+      if (deviceSupport.touch) inputModes.push('touch');
+      const tags = tagsInput
+        .split(/[,，]/u)
+        .map((tag) => tag.trim())
+        .filter(Boolean)
+        .slice(0, 5);
+      const gameMetadata = {
+        title: title.trim(),
+        summary: summary.trim(),
+        description: description.trim() || summary.trim(),
+        category,
+        tags,
+        deviceSupport,
+        inputModes,
+        orientation,
+      };
+      const publishKey = createPublishKey();
+      const game = await createGame(gameMetadata, `${publishKey}:game`);
+      const version = await createGameVersion(
+        game.id,
+        {
+          packageSha256: prepared.sha256,
+          packageBytes: prepared.totalBytes,
+          packageFileCount: prepared.fileCount,
+          packageEntryPath: 'index.html',
+          gameMetadata,
+        },
+        `${publishKey}:version`,
+      );
+      writePublishDraft({
+        ownerUserId: currentUserId,
+        gameId: game.id,
+        versionId: version.versionId,
+        versionNumber: version.versionNumber,
+        title: game.title,
+        updatedAt: new Date().toISOString(),
+      });
+      await uploadGamePackage(
+        version.versionId,
+        new Blob([prepared.bytes as unknown as BlobPart], {
+          type: 'application/zip',
+        }),
+        `${publishKey}:upload`,
+      );
+      await submitGameVersion(
+        version.versionId,
+        game.publicationRevision,
+        `${publishKey}:submit`,
+      );
+      clearPublishDraft();
+      setPublishedGameId(game.id);
+    } catch (submitError: unknown) {
+      setError(
+        submitError instanceof Error ? submitError.message : '发布游戏失败',
+      );
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  return (
+    <div className="game-page game-publish-page">
+      <button type="button" className="game-back-button" onClick={onBack}>
+        <ArrowLeft /> 返回游戏广场
+      </button>
+      <div className="game-toolbar">
+        <div className="game-toolbar__title">
+          <span className="game-eyebrow">
+            {updateGameId ? '发布新版本' : '发布游戏'}
+          </span>
+          <h2>
+            {updateGameId
+              ? updateContext
+                ? `为《${updateContext.title}》发布 v${updateContext.versionNumber + 1}`
+                : '读取待更新游戏…'
+              : '上传可在线游玩的网页游戏'}
+          </h2>
+        </div>
+      </div>
+
+      {error ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          {error}
+        </PlatformStatusMessage>
+      ) : null}
+
+      {canPublish && updateGameId && !publishedGameId ? (
+        <PlatformStatusMessage
+          tone={updateContextError ? 'error' : 'info'}
+          surface="platform"
+        >
+          {updateContextError ? (
+            <span>{updateContextError}</span>
+          ) : updateContext ? (
+            <span>
+              正在为《{updateContext.title}》发布新版本 v
+              {updateContext.versionNumber + 1}
+              ：沿用同一个游戏身份，审核通过后才会替换线上版本。
+            </span>
+          ) : (
+            <span>正在读取待更新游戏…</span>
+          )}
+        </PlatformStatusMessage>
+      ) : null}
+
+      {!updateGameId &&
+      canPublish &&
+      draft &&
+      draftDetail &&
+      !publishedGameId ? (
+        <PlatformStatusMessage tone="info" surface="platform">
+          <span>
+            {
+              resolvePublishDraftRecoveryCopy(
+                draftDetail.version.recoveryAction,
+                draftDetail.version.versionNumber,
+              ).title
+            }
+            {'：'}
+            {
+              resolvePublishDraftRecoveryCopy(
+                draftDetail.version.recoveryAction,
+                draftDetail.version.versionNumber,
+              ).description
+            }
+          </span>
+          <span className="game-publish-recovery-actions">
+            {resolvePublishDraftRecoveryCopy(
+              draftDetail.version.recoveryAction,
+              draftDetail.version.versionNumber,
+            ).actionLabel ? (
+              <button
+                type="button"
+                onClick={() => {
+                  setError('');
+                  setIsResumingDraft(true);
+                  // 发行包已确认的版本不需要重新选包，直接续做送审。
+                  if (draftDetail.version.recoveryAction === 'submit') {
+                    void handleResumeSubmit();
+                  }
+                }}
+                disabled={isSubmitting}
+              >
+                {
+                  resolvePublishDraftRecoveryCopy(
+                    draftDetail.version.recoveryAction,
+                    draftDetail.version.versionNumber,
+                  ).actionLabel
+                }
+              </button>
+            ) : null}
+            <button type="button" onClick={onOpenMyGames}>
+              我的游戏
+            </button>
+            <button type="button" onClick={dismissDraft}>
+              不再提醒
+            </button>
+          </span>
+        </PlatformStatusMessage>
+      ) : null}
+
+      {publishedGameId ? (
+        <PlatformStatusMessage tone="success" surface="platform">
+          <span>已提交审核，审核通过后会自动出现在游戏广场。</span>
+          <button type="button" onClick={onOpenMyGames}>
+            查看我的游戏
+          </button>
+        </PlatformStatusMessage>
+      ) : null}
+
+      {!canPublish ? (
+        <PlatformStatusMessage tone="info" surface="platform">
+          <span>登录后才能发布游戏。</span>
+          <button type="button" onClick={() => authUi?.openLoginModal()}>
+            登录
+          </button>
+        </PlatformStatusMessage>
+      ) : null}
+
+      {isResumingDraft && !updateGameId ? (
+        <PlatformStatusMessage tone="info" surface="platform">
+          <span>
+            继续发布沿用上次冻结的资料与版本号，资料要改就撤回后在「我的游戏」重新发布。
+          </span>
+        </PlatformStatusMessage>
+      ) : null}
+
+      <form
+        className={`game-publish-form${isResumingDraft ? ' game-publish-form--resume' : ''}`}
+        onSubmit={(event) => {
+          event.preventDefault();
+          void handleSubmit();
+        }}
+      >
+        <label className="game-publish-field">
+          游戏名称
+          <input
+            value={title}
+            maxLength={40}
+            disabled={isResumingDraft}
+            onChange={(e) => setTitle(e.target.value)}
+          />
+        </label>
+        <label className="game-publish-field">
+          一句话简介
+          <input
+            value={summary}
+            maxLength={120}
+            disabled={isResumingDraft}
+            onChange={(e) => setSummary(e.target.value)}
+          />
+        </label>
+        <label className="game-publish-field">
+          详细介绍
+          <textarea
+            value={description}
+            rows={3}
+            maxLength={2000}
+            disabled={isResumingDraft}
+            onChange={(e) => setDescription(e.target.value)}
+          />
+        </label>
+        <div className="game-publish-row">
+          <label className="game-publish-field">
+            分类
+            <select
+              value={category}
+              disabled={isResumingDraft}
+              onChange={(e) =>
+                setCategory(e.target.value as GameDistributionCategory)
+              }
+            >
+              {CATEGORIES.map((item) => (
+                <option key={item} value={item}>
+                  {item}
+                </option>
+              ))}
+            </select>
+          </label>
+          <label className="game-publish-field">
+            标签
+            <input
+              value={tagsInput}
+              placeholder="用逗号分隔，最多 5 个"
+              disabled={isResumingDraft}
+              onChange={(e) => setTagsInput(e.target.value)}
+            />
+          </label>
+          <label className="game-publish-field">
+            画面方向
+            <select
+              value={orientation}
+              disabled={isResumingDraft}
+              onChange={(e) =>
+                setOrientation(e.target.value as GameDistributionOrientation)
+              }
+            >
+              {ORIENTATIONS.map((item) => (
+                <option key={item.value} value={item.value}>
+                  {item.label}
+                </option>
+              ))}
+            </select>
+          </label>
+        </div>
+        <fieldset className="game-publish-fieldset">
+          <legend>支持设备</legend>
+          {(
+            [
+              ['desktop', '桌面端'],
+              ['mobile', '移动端'],
+              ['touch', '触控'],
+            ] as const
+          ).map(([key, label]) => (
+            <label key={key} className="game-publish-checkbox">
+              <input
+                type="checkbox"
+                checked={deviceSupport[key]}
+                disabled={isResumingDraft}
+                onChange={(e) =>
+                  setDeviceSupport((current) => ({
+                    ...current,
+                    [key]: e.target.checked,
+                  }))
+                }
+              />
+              {label}
+            </label>
+          ))}
+        </fieldset>
+        <label className="game-publish-field">
+          {resumeNeedsPackage ? '重新选择发行包 ZIP' : '发行包 ZIP'}
+          <input
+            ref={fileInputRef}
+            type="file"
+            accept=".zip,application/zip"
+            onChange={(e) => setPackageFile(e.target.files?.[0] ?? null)}
+          />
+          <span className="game-publish-hint">
+            {resumeNeedsPackage
+              ? '选择与上次相同内容会续用同一个版本，不需要重新创建游戏'
+              : '包内根目录需要包含 index.html，所有素材都要在包内'}
+          </span>
+        </label>
+        <div className="game-publish-actions">
+          <PlatformActionButton
+            type="submit"
+            size="md"
+            shape="pill"
+            disabled={
+              !canPublish ||
+              isSubmitting ||
+              (Boolean(updateGameId) && !updateContext)
+            }
+          >
+            <Upload aria-hidden="true" />{' '}
+            {isSubmitting
+              ? '正在提交…'
+              : isResumingDraft && !updateGameId
+                ? resumeNeedsPackage
+                  ? '继续上传并送审'
+                  : '提交审核'
+                : updateGameId
+                  ? '提交新版本审核'
+                  : '提交审核'}
+          </PlatformActionButton>
+        </div>
+      </form>
+    </div>
+  );
+}
+
+export default GamePublishPage;
diff --git a/src/components/game-distribution/MyGamesPage.test.tsx b/src/components/game-distribution/MyGamesPage.test.tsx
new file mode 100644
index 000000000..3856613ff
--- /dev/null
+++ b/src/components/game-distribution/MyGamesPage.test.tsx
@@ -0,0 +1,252 @@
+/* @vitest-environment jsdom */
+
+import { render, screen, waitFor } from '@testing-library/react';
+import { fireEvent } from '@testing-library/react';
+import type { ContextType } from 'react';
+import { beforeEach, expect, test, vi } from 'vitest';
+
+import {
+  cancelGameVersion,
+  type GameDistributionMyGame,
+  listMyGames,
+  unpublishGame,
+} from '../../services/gameDistributionClient';
+import { AuthUiContext } from '../auth/AuthUiContext';
+import { MyGamesPage } from './MyGamesPage';
+
+vi.mock('../../services/gameDistributionClient', () => ({
+  cancelGameVersion: vi.fn(),
+  listMyGames: vi.fn(),
+  unpublishGame: vi.fn(),
+}));
+
+type AuthValue = NonNullable<ContextType<typeof AuthUiContext>>;
+
+function createAuthValue(overrides: Partial<AuthValue> = {}): AuthValue {
+  return {
+    user: {
+      id: 'user-1',
+      publicUserCode: '100001',
+      displayName: '测试作者',
+      avatarUrl: null,
+      phoneNumberMasked: null,
+      loginMethod: 'password',
+      bindingStatus: 'active',
+      wechatBound: false,
+    },
+    canAccessProtectedData: true,
+    openLoginModal: vi.fn(),
+    requireAuth: vi.fn((action: () => void) => action()),
+    openSettingsModal: vi.fn(),
+    openAccountModal: vi.fn(),
+    setCurrentUser: vi.fn(),
+    logout: vi.fn(),
+    musicVolume: 0.5,
+    setMusicVolume: vi.fn(),
+    platformTheme: 'light',
+    setPlatformTheme: vi.fn(),
+    isHydratingSettings: false,
+    isPersistingSettings: false,
+    settingsError: null,
+    ...overrides,
+  };
+}
+
+function createGame(
+  overrides: Partial<GameDistributionMyGame> = {},
+): GameDistributionMyGame {
+  return {
+    id: 'game-1',
+    title: '我的游戏',
+    summary: '作者自有游戏',
+    description: '',
+    category: '益智',
+    tags: [],
+    coverColor: '#49316d',
+    icon: '✦',
+    author: { id: 'user-1', name: '测试作者' },
+    deviceSupport: { desktop: true, mobile: false, touch: false },
+    status: 'unpublished',
+    publicationRevision: 2,
+    currentVersion: null,
+    playCount: 3,
+    createdAt: '2026-09-20T08:00:00Z',
+    ...overrides,
+  } as GameDistributionMyGame;
+}
+
+function renderPage(
+  authValue: AuthValue | null,
+  overrides: { onPublishVersion?: (gameId: string) => void } = {},
+) {
+  return render(
+    <AuthUiContext.Provider value={authValue}>
+      <MyGamesPage
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+        onPublishVersion={overrides.onPublishVersion}
+      />
+    </AuthUiContext.Provider>,
+  );
+}
+
+beforeEach(() => {
+  vi.mocked(cancelGameVersion).mockReset();
+  vi.mocked(listMyGames).mockReset();
+  vi.mocked(unpublishGame).mockReset();
+  vi.mocked(listMyGames).mockResolvedValue([]);
+});
+
+test('未登录时提示登录且不请求作者接口', () => {
+  renderPage(null);
+  expect(
+    screen.getByText('登录后可以查看已发布的游戏与审核状态。'),
+  ).toBeTruthy();
+  expect(listMyGames).not.toHaveBeenCalled();
+});
+
+test('展示审核中状态与驳回理由', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      status: 'unpublished',
+      latestVersion: {
+        versionId: 'version-1',
+        gameId: 'game-1',
+        versionNumber: 3,
+        packageSha256: 'a'.repeat(64),
+        packageBytes: 1024,
+        status: 'rejected',
+        publicationRevision: 2,
+        reviewReason: '封面需要替换',
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+      versions: [],
+    }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  expect(await screen.findByText('我的游戏')).toBeTruthy();
+  expect(screen.getByText(/版本 v3 · 已拒绝/)).toBeTruthy();
+  expect(screen.getByText('驳回理由：封面需要替换')).toBeTruthy();
+});
+
+test('下架已公开游戏会带上当前 publicationRevision', async () => {
+  const game = createGame({
+    status: 'published',
+    publicationRevision: 7,
+    latestVersion: null,
+    versions: [],
+  });
+  vi.mocked(listMyGames).mockResolvedValue([game]);
+  vi.mocked(unpublishGame).mockResolvedValue({
+    game: { id: 'game-1', status: 'unpublished' },
+  });
+
+  renderPage(createAuthValue());
+
+  fireEvent.click(await screen.findByRole('button', { name: '下架' }));
+
+  await waitFor(() => expect(unpublishGame).toHaveBeenCalledTimes(1));
+  const [gameId, revision, idempotencyKey] =
+    vi.mocked(unpublishGame).mock.calls[0] ?? [];
+  expect(gameId).toBe('game-1');
+  expect(revision).toBe(7);
+  expect(String(idempotencyKey)).toContain('game-1');
+  await waitFor(() => expect(listMyGames).toHaveBeenCalledTimes(2));
+});
+
+test('未公开游戏不提供下架动作', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ status: 'unpublished' }),
+  ]);
+  renderPage(createAuthValue());
+  await screen.findByText('我的游戏');
+  expect(screen.queryByRole('button', { name: '下架' })).toBeNull();
+});
+
+test('审核中的版本二次确认后撤回并带上 publicationRevision', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      status: 'unpublished',
+      publicationRevision: 5,
+      latestVersion: {
+        versionId: 'version-9',
+        gameId: 'game-1',
+        versionNumber: 2,
+        packageSha256: 'b'.repeat(64),
+        packageBytes: 2048,
+        status: 'pending_review',
+        publicationRevision: 5,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+      versions: [],
+    }),
+  ]);
+  vi.mocked(cancelGameVersion).mockResolvedValue({
+    game: {} as never,
+    version: {} as never,
+    replayed: false,
+  });
+
+  renderPage(createAuthValue());
+
+  fireEvent.click(await screen.findByRole('button', { name: '撤回审核' }));
+  // 首次点击只进入确认态，不发送请求。
+  expect(cancelGameVersion).not.toHaveBeenCalled();
+  expect(screen.getByRole('button', { name: '取消' })).toBeTruthy();
+
+  fireEvent.click(screen.getByRole('button', { name: '确认撤回' }));
+
+  await waitFor(() => expect(cancelGameVersion).toHaveBeenCalledTimes(1));
+  const [versionId, revision, idempotencyKey] =
+    vi.mocked(cancelGameVersion).mock.calls[0] ?? [];
+  expect(versionId).toBe('version-9');
+  expect(revision).toBe(5);
+  expect(String(idempotencyKey)).toContain('version-9');
+  await waitFor(() => expect(listMyGames).toHaveBeenCalledTimes(2));
+});
+
+test('已公开版本只能下架，不显示撤回审核', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      status: 'published',
+      publicationRevision: 4,
+      latestVersion: {
+        versionId: 'version-3',
+        gameId: 'game-1',
+        versionNumber: 3,
+        packageSha256: 'c'.repeat(64),
+        packageBytes: 4096,
+        status: 'published',
+        publicationRevision: 4,
+        reviewReason: null,
+        createdAt: '2026-09-20T08:00:00Z',
+        updatedAt: '2026-09-20T09:00:00Z',
+      },
+      versions: [],
+    }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  await screen.findByText('我的游戏');
+  expect(screen.queryByRole('button', { name: '撤回审核' })).toBeNull();
+  expect(screen.getByRole('button', { name: '下架' })).toBeTruthy();
+});
+
+test('作者中心提供发布新版本入口并回传同一个 gameId', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ id: 'game-42', status: 'published', publicationRevision: 3 }),
+  ]);
+  const onPublishVersion = vi.fn();
+
+  renderPage(createAuthValue(), { onPublishVersion });
+
+  fireEvent.click(await screen.findByRole('button', { name: '发布新版本' }));
+
+  expect(onPublishVersion).toHaveBeenCalledWith('game-42');
+});
diff --git a/src/components/game-distribution/MyGamesPage.tsx b/src/components/game-distribution/MyGamesPage.tsx
new file mode 100644
index 000000000..2cfd1ed06
--- /dev/null
+++ b/src/components/game-distribution/MyGamesPage.tsx
@@ -0,0 +1,346 @@
+import './gameDistribution.css';
+
+import { ArrowLeft, RefreshCcw } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+
+import {
+  cancelGameVersion,
+  type GameDistributionMyGame,
+  type GameDistributionVersionStatusEntry,
+  listMyGames,
+  unpublishGame,
+} from '../../services/gameDistributionClient';
+import { useAuthUi } from '../auth/AuthUiContext';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformEmptyState } from '../common/PlatformEmptyState';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import { GameCover } from './GameGalleryPage';
+
+const STATUS_LABEL: Record<string, string> = {
+  unpublished: '未公开',
+  published: '已公开',
+  suspended: '已被封禁',
+};
+
+const VERSION_STATUS_LABEL: Record<string, string> = {
+  awaiting_upload: '待上传',
+  uploaded: '已上传',
+  validating: '校验中',
+  pending_review: '审核中',
+  published: '已发布',
+  upload_failed: '上传失败',
+  validation_failed: '校验失败',
+  rejected: '已拒绝',
+  cancelled: '已撤回',
+  revoked: '已撤回',
+};
+
+type MyGamesPageProps = {
+  onBack: () => void;
+  onOpenDetail: (gameId: string) => void;
+  /** 进入发布页的“新版本”模式；回调缺失时不显示该动作。 */
+  onPublishVersion?: (gameId: string) => void;
+};
+
+let unpublishKeySeed = 0;
+function createUnpublishKey(gameId: string) {
+  unpublishKeySeed += 1;
+  return `game-unpublish-${gameId}-${Date.now()}-${unpublishKeySeed}`;
+}
+
+/** 与服务端 `can_cancel` 保持一致：已公开版本只能下架，不能撤回。 */
+const CANCELLABLE_VERSION_STATUS = new Set([
+  'awaiting_upload',
+  'uploaded',
+  'validating',
+  'pending_review',
+  'upload_failed',
+  'validation_failed',
+]);
+
+let cancelKeySeed = 0;
+function createCancelKey(versionId: string) {
+  cancelKeySeed += 1;
+  return `game-cancel-${versionId}-${Date.now()}-${cancelKeySeed}`;
+}
+
+function resolveVersionStatus(game: GameDistributionMyGame) {
+  const latest = game.latestVersion;
+  if (!latest) return null;
+  return {
+    label: VERSION_STATUS_LABEL[latest.status] ?? latest.status,
+    versionNumber: latest.versionNumber,
+    reviewReason: latest.reviewReason?.trim() || '',
+  };
+}
+
+export function MyGamesPage({
+  onBack,
+  onOpenDetail,
+  onPublishVersion,
+}: MyGamesPageProps) {
+  const authUi = useAuthUi();
+  const [games, setGames] = useState<GameDistributionMyGame[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [busyGameId, setBusyGameId] = useState('');
+  const [cancellingVersionId, setCancellingVersionId] = useState('');
+  const [confirmingVersionId, setConfirmingVersionId] = useState('');
+  const [notice, setNotice] = useState('');
+  const [error, setError] = useState('');
+  const canLoad = Boolean(authUi?.user && authUi.canAccessProtectedData);
+
+  const loadGames = useCallback(async () => {
+    if (!canLoad) {
+      setGames([]);
+      return;
+    }
+    setIsLoading(true);
+    setError('');
+    try {
+      setGames(await listMyGames());
+    } catch (loadError: unknown) {
+      setError(
+        loadError instanceof Error ? loadError.message : '读取我的游戏失败',
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, [canLoad]);
+
+  useEffect(() => {
+    void loadGames();
+  }, [loadGames]);
+
+  async function handleCancelVersion(
+    game: GameDistributionMyGame,
+    version: GameDistributionVersionStatusEntry,
+  ) {
+    setCancellingVersionId(version.versionId);
+    setConfirmingVersionId('');
+    setError('');
+    setNotice('');
+    try {
+      await cancelGameVersion(
+        version.versionId,
+        version.publicationRevision,
+        createCancelKey(version.versionId),
+      );
+      setNotice(`版本 v${version.versionNumber} 已撤回，可以重新上传发行包。`);
+      await loadGames();
+    } catch (cancelError: unknown) {
+      setError(
+        cancelError instanceof Error ? cancelError.message : '撤回版本失败',
+      );
+    } finally {
+      setCancellingVersionId('');
+    }
+  }
+
+  async function handleUnpublish(game: GameDistributionMyGame) {
+    setBusyGameId(game.id);
+    setError('');
+    try {
+      await unpublishGame(
+        game.id,
+        game.publicationRevision,
+        createUnpublishKey(game.id),
+      );
+      await loadGames();
+    } catch (unpublishError: unknown) {
+      setError(
+        unpublishError instanceof Error
+          ? unpublishError.message
+          : '下架游戏失败',
+      );
+    } finally {
+      setBusyGameId('');
+    }
+  }
+
+  return (
+    <div className="game-page">
+      <button type="button" className="game-back-button" onClick={onBack}>
+        <ArrowLeft /> 返回游戏广场
+      </button>
+      <div className="game-toolbar">
+        <div className="game-toolbar__title">
+          <span className="game-eyebrow">作者中心</span>
+          <h2>我的游戏</h2>
+        </div>
+        {canLoad ? (
+          <PlatformActionButton
+            tone="secondary"
+            size="sm"
+            shape="pill"
+            onClick={() => void loadGames()}
+            disabled={isLoading}
+          >
+            <RefreshCcw aria-hidden="true" /> 刷新
+          </PlatformActionButton>
+        ) : null}
+      </div>
+
+      {error ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          {error}
+        </PlatformStatusMessage>
+      ) : null}
+
+      {notice ? (
+        <PlatformStatusMessage tone="success" surface="platform">
+          {notice}
+        </PlatformStatusMessage>
+      ) : null}
+
+      {!canLoad ? (
+        <PlatformEmptyState surface="subpanel" size="panel">
+          <span>登录后可以查看已发布的游戏与审核状态。</span>
+          <PlatformActionButton
+            size="sm"
+            shape="pill"
+            onClick={() => authUi?.openLoginModal(() => void loadGames())}
+          >
+            登录
+          </PlatformActionButton>
+        </PlatformEmptyState>
+      ) : null}
+
+      {canLoad && isLoading ? (
+        <div className="game-loading-panel">正在加载我的游戏…</div>
+      ) : null}
+
+      {canLoad && !isLoading && games.length === 0 && !error ? (
+        <PlatformEmptyState surface="subpanel" size="panel">
+          <span>还没有在平台上发布过游戏。</span>
+        </PlatformEmptyState>
+      ) : null}
+
+      {canLoad && games.length > 0 ? (
+        <div className="my-game-list">
+          {games.map((game) => {
+            const version = resolveVersionStatus(game);
+            const latestVersion = game.latestVersion;
+            return (
+              <article key={game.id} className="my-game-card">
+                <GameCover game={game} compact />
+                <div className="my-game-card__body">
+                  <div className="my-game-card__heading">
+                    <button
+                      type="button"
+                      className="my-game-card__title"
+                      onClick={() => onOpenDetail(game.id)}
+                    >
+                      {game.title}
+                    </button>
+                    <span
+                      className={`my-game-status my-game-status--${game.status}`}
+                    >
+                      {STATUS_LABEL[game.status] ?? game.status}
+                    </span>
+                  </div>
+                  <p className="my-game-card__summary">{game.summary}</p>
+                  <div className="my-game-card__meta">
+                    <span>{game.category}</span>
+                    <span>·</span>
+                    <span>{game.playCount.toLocaleString()} 次游玩</span>
+                    {version ? (
+                      <>
+                        <span>·</span>
+                        <span>
+                          版本 v{version.versionNumber} · {version.label}
+                        </span>
+                      </>
+                    ) : null}
+                  </div>
+                  {version?.reviewReason ? (
+                    <p className="my-game-card__reason">
+                      驳回理由：{version.reviewReason}
+                    </p>
+                  ) : null}
+                  <div className="my-game-card__actions">
+                    <PlatformActionButton
+                      tone="secondary"
+                      size="sm"
+                      shape="pill"
+                      onClick={() => onOpenDetail(game.id)}
+                    >
+                      查看详情
+                    </PlatformActionButton>
+                    {onPublishVersion ? (
+                      <PlatformActionButton
+                        tone="primary"
+                        size="sm"
+                        shape="pill"
+                        onClick={() => onPublishVersion(game.id)}
+                      >
+                        发布新版本
+                      </PlatformActionButton>
+                    ) : null}
+                    {game.status === 'published' ? (
+                      <PlatformActionButton
+                        tone="secondary"
+                        size="sm"
+                        shape="pill"
+                        disabled={busyGameId === game.id}
+                        onClick={() => void handleUnpublish(game)}
+                      >
+                        下架
+                      </PlatformActionButton>
+                    ) : null}
+                    {latestVersion &&
+                    CANCELLABLE_VERSION_STATUS.has(latestVersion.status) ? (
+                      confirmingVersionId === latestVersion.versionId ? (
+                        <>
+                          <PlatformActionButton
+                            tone="danger"
+                            size="sm"
+                            shape="pill"
+                            disabled={
+                              cancellingVersionId === latestVersion.versionId
+                            }
+                            onClick={() =>
+                              void handleCancelVersion(game, latestVersion)
+                            }
+                          >
+                            确认撤回
+                          </PlatformActionButton>
+                          <PlatformActionButton
+                            tone="secondary"
+                            size="sm"
+                            shape="pill"
+                            disabled={
+                              cancellingVersionId === latestVersion.versionId
+                            }
+                            onClick={() => setConfirmingVersionId('')}
+                          >
+                            取消
+                          </PlatformActionButton>
+                        </>
+                      ) : (
+                        <PlatformActionButton
+                          tone="secondary"
+                          size="sm"
+                          shape="pill"
+                          disabled={
+                            cancellingVersionId === latestVersion.versionId
+                          }
+                          onClick={() =>
+                            setConfirmingVersionId(latestVersion.versionId)
+                          }
+                        >
+                          撤回审核
+                        </PlatformActionButton>
+                      )
+                    ) : null}
+                  </div>
+                </div>
+              </article>
+            );
+          })}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+export default MyGamesPage;
diff --git a/src/components/game-distribution/gameDistribution.css b/src/components/game-distribution/gameDistribution.css
new file mode 100644
index 000000000..199133e71
--- /dev/null
+++ b/src/components/game-distribution/gameDistribution.css
@@ -0,0 +1,915 @@
+.game-page,
+.game-detail-page,
+.game-play-page {
+  width: 100%;
+  min-height: 100%;
+  box-sizing: border-box;
+  padding: clamp(1rem, 2.4vw, 2.75rem);
+  color: var(--platform-text-strong);
+}
+
+.game-page {
+  max-width: 92rem;
+  margin: 0 auto;
+}
+
+.game-hero {
+  position: relative;
+  display: flex;
+  min-height: 17rem;
+  align-items: center;
+  justify-content: space-between;
+  overflow: hidden;
+  border: 1px solid rgba(199, 101, 61, 0.25);
+  border-radius: 2rem;
+  padding: clamp(1.5rem, 4vw, 3.5rem);
+  background: radial-gradient(
+      circle at 75% 15%,
+      rgba(241, 159, 95, 0.28),
+      transparent 30%
+    ),
+    linear-gradient(120deg, rgba(91, 49, 42, 0.98), rgba(43, 29, 34, 0.96));
+  box-shadow: 0 1.25rem 3rem rgba(72, 35, 26, 0.18);
+  color: #fff8f0;
+}
+
+.game-hero__copy {
+  position: relative;
+  z-index: 1;
+  max-width: 36rem;
+}
+.game-eyebrow {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.38rem;
+  color: var(--platform-accent-strong);
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+.game-hero .game-eyebrow {
+  color: #ffd3b0;
+}
+.game-eyebrow svg {
+  width: 0.9rem;
+  height: 0.9rem;
+}
+.game-hero h1 {
+  margin: 0.8rem 0 0;
+  font-size: clamp(2rem, 4.1vw, 3.4rem);
+  line-height: 1.08;
+  letter-spacing: -0.05em;
+}
+.game-hero h1 em {
+  color: #ffb77c;
+  font-style: normal;
+}
+.game-hero p {
+  max-width: 31rem;
+  margin: 1rem 0 0;
+  color: rgba(255, 241, 227, 0.74);
+  font-size: 0.95rem;
+  line-height: 1.75;
+}
+.game-hero__actions {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  margin-top: 1.4rem;
+}
+.game-hero__hint {
+  color: rgba(255, 241, 227, 0.66);
+  font-size: 0.75rem;
+}
+.game-hero__orb {
+  display: grid;
+  width: clamp(9rem, 19vw, 16rem);
+  aspect-ratio: 1;
+  place-items: center;
+  margin-right: 4%;
+  border: 1px solid rgba(255, 208, 171, 0.3);
+  border-radius: 50%;
+  background: radial-gradient(
+    circle at 40% 35%,
+    #ef9b68,
+    #7e3b44 46%,
+    rgba(37, 25, 35, 0.25) 70%
+  );
+  box-shadow:
+    0 0 0 1.5rem rgba(245, 141, 90, 0.05),
+    0 0 5rem rgba(245, 141, 90, 0.26);
+  color: #fff4df;
+  font-size: clamp(3rem, 6vw, 5rem);
+}
+.game-hero__orb::after {
+  position: absolute;
+  width: 8rem;
+  height: 1px;
+  content: '';
+  background: rgba(255, 203, 161, 0.35);
+  transform: rotate(-24deg) translate(6rem, -3rem);
+}
+.game-toolbar {
+  display: flex;
+  align-items: end;
+  justify-content: space-between;
+  gap: 1.25rem;
+  margin: 2.3rem 0 1.15rem;
+}
+.game-toolbar h2 {
+  margin: 0.2rem 0 0;
+  font-size: clamp(1.55rem, 3vw, 2.15rem);
+  letter-spacing: -0.04em;
+}
+.game-search {
+  display: flex;
+  min-width: min(100%, 19rem);
+  align-items: center;
+  gap: 0.55rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.68rem 0.95rem;
+  background: var(--platform-panel-fill);
+  color: var(--platform-text-soft);
+}
+.game-search svg {
+  width: 1rem;
+  flex: none;
+}
+.game-search input {
+  width: 100%;
+  border: 0;
+  outline: 0;
+  background: transparent;
+  color: var(--platform-text-strong);
+  font: inherit;
+  font-size: 0.82rem;
+}
+.game-category-tabs {
+  display: flex;
+  gap: 0.45rem;
+  overflow-x: auto;
+  padding: 0.15rem 0 1.45rem;
+  scrollbar-width: none;
+}
+.game-category-tab {
+  flex: none;
+  min-height: 2.75rem;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  padding: 0.52rem 0.95rem;
+  background: transparent;
+  color: var(--platform-text-soft);
+  cursor: pointer;
+  font: inherit;
+  font-size: 0.8rem;
+  font-weight: 700;
+  transition: 160ms ease;
+}
+.game-category-tab:hover {
+  color: var(--platform-text-strong);
+  background: var(--platform-surface-fill);
+}
+.game-category-tab--active {
+  border-color: rgba(199, 101, 61, 0.25);
+  background: rgba(199, 101, 61, 0.12);
+  color: var(--platform-accent-strong);
+}
+.game-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 1.1rem;
+}
+.game-card {
+  display: block;
+  min-width: 0;
+  overflow: hidden;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 1.45rem;
+  padding: 0;
+  background: var(--platform-panel-fill);
+  color: inherit;
+  cursor: pointer;
+  text-align: left;
+  box-shadow: var(--platform-panel-shadow);
+  transition: 180ms ease;
+}
+.game-card:hover {
+  border-color: rgba(199, 101, 61, 0.38);
+  box-shadow: 0 1rem 2.4rem rgba(104, 54, 36, 0.14);
+  transform: translateY(-3px);
+}
+.game-card__body {
+  display: block;
+  padding: 0.95rem 1rem 1.1rem;
+}
+.game-card__title-row {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 0.5rem;
+}
+.game-card__title-row strong {
+  overflow: hidden;
+  font-size: 1rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.game-card__play-count {
+  flex: none;
+  color: var(--platform-text-soft);
+  font-size: 0.66rem;
+}
+.game-card__summary {
+  display: block;
+  overflow: hidden;
+  margin-top: 0.42rem;
+  color: var(--platform-text-base);
+  font-size: 0.78rem;
+  line-height: 1.55;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.game-card__meta {
+  display: flex;
+  gap: 0.38rem;
+  margin-top: 0.85rem;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+}
+.game-cover {
+  position: relative;
+  display: flex;
+  min-height: 12rem;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  isolation: isolate;
+}
+.game-cover--compact {
+  min-height: 7rem;
+}
+.game-cover__grid {
+  position: absolute;
+  inset: 0;
+  opacity: 0.22;
+  background-image: linear-gradient(
+      rgba(255, 255, 255, 0.2) 1px,
+      transparent 1px
+    ),
+    linear-gradient(90deg, rgba(255, 255, 255, 0.2) 1px, transparent 1px);
+  background-size: 2rem 2rem;
+  transform: perspective(12rem) rotateX(58deg) scale(1.7) translateY(25%);
+}
+.game-cover__glow {
+  position: absolute;
+  width: 70%;
+  aspect-ratio: 1;
+  border-radius: 50%;
+  background: radial-gradient(
+    circle,
+    rgba(255, 236, 204, 0.5),
+    transparent 66%
+  );
+  filter: blur(0.6rem);
+}
+.game-cover__icon {
+  position: relative;
+  z-index: 1;
+  display: grid;
+  width: 5.4rem;
+  aspect-ratio: 1;
+  place-items: center;
+  border: 1px solid rgba(255, 255, 255, 0.4);
+  border-radius: 1.5rem;
+  background: rgba(255, 255, 255, 0.13);
+  box-shadow: 0 1rem 2rem rgba(0, 0, 0, 0.2);
+  color: #fff5dc;
+  font-size: 3rem;
+  backdrop-filter: blur(8px);
+}
+.game-loading-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 1.1rem;
+}
+.game-loading-grid span {
+  height: 17rem;
+  border-radius: 1.45rem;
+  background: linear-gradient(
+    100deg,
+    var(--platform-panel-fill),
+    var(--platform-surface-fill),
+    var(--platform-panel-fill)
+  );
+  background-size: 220% 100%;
+  animation: game-shimmer 1.2s ease-in-out infinite;
+}
+@keyframes game-shimmer {
+  from {
+    background-position: 100% 0;
+  }
+  to {
+    background-position: -100% 0;
+  }
+}
+
+.game-detail-page {
+  max-width: 70rem;
+  margin: 0 auto;
+}
+.game-back-button {
+  display: inline-flex;
+  min-height: 2.75rem;
+  align-items: center;
+  gap: 0.4rem;
+  border: 0;
+  padding: 0.25rem 0;
+  background: transparent;
+  color: var(--platform-text-soft);
+  cursor: pointer;
+  font: inherit;
+  font-size: 0.82rem;
+  font-weight: 700;
+}
+.game-back-button svg {
+  width: 1rem;
+}
+.game-detail-hero {
+  display: grid;
+  grid-template-columns: minmax(13rem, 21rem) minmax(0, 1fr);
+  align-items: center;
+  gap: clamp(1.4rem, 4vw, 3.5rem);
+  margin-top: 1.5rem;
+}
+.game-detail-hero .game-cover {
+  border-radius: 1.7rem;
+  box-shadow: 0 1.25rem 2.5rem rgba(70, 42, 34, 0.18);
+}
+.game-detail-hero h1 {
+  margin: 0.65rem 0 0;
+  font-size: clamp(2rem, 4.8vw, 3.7rem);
+  letter-spacing: -0.055em;
+}
+.game-detail-hero__summary {
+  max-width: 32rem;
+  margin: 0.8rem 0 0;
+  color: var(--platform-text-base);
+  font-size: 1rem;
+  line-height: 1.75;
+}
+.game-detail-hero__author {
+  display: flex;
+  align-items: center;
+  gap: 0.55rem;
+  margin-top: 1.15rem;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  font-weight: 700;
+}
+.game-avatar {
+  display: grid;
+  width: 1.8rem;
+  height: 1.8rem;
+  place-items: center;
+  border-radius: 50%;
+  background: rgba(199, 101, 61, 0.18);
+  color: var(--platform-accent-strong);
+  font-weight: 900;
+}
+.game-detail-hero__actions {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  margin-top: 1.4rem;
+}
+.game-detail-hero__play-count {
+  color: var(--platform-text-soft);
+  font-size: 0.75rem;
+}
+.game-device-warning {
+  color: var(--platform-accent-strong);
+  font-size: 0.75rem;
+  font-weight: 800;
+}
+.game-detail-body {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 17rem;
+  gap: 3rem;
+  margin-top: 3rem;
+  border-top: 1px solid var(--platform-surface-border);
+  padding-top: 2rem;
+}
+.game-detail-main h2 {
+  margin: 0;
+  font-size: 1.25rem;
+}
+.game-detail-main p {
+  max-width: 45rem;
+  margin: 0.75rem 0 0;
+  color: var(--platform-text-base);
+  line-height: 1.9;
+}
+.game-tag-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.45rem;
+  margin-top: 1.3rem;
+}
+.game-tag-list span {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.35rem 0.65rem;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  font-weight: 700;
+}
+.game-detail-side {
+  display: grid;
+  gap: 0.7rem;
+  align-content: start;
+}
+.game-info-card {
+  display: grid;
+  gap: 0.3rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 1rem;
+  padding: 0.8rem 0.9rem;
+  background: var(--platform-panel-fill);
+}
+.game-info-card strong {
+  font-size: 0.72rem;
+}
+.game-info-card span {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.28rem;
+  color: var(--platform-text-soft);
+  font-size: 0.72rem;
+  line-height: 1.45;
+}
+.game-info-card svg {
+  width: 0.85rem;
+}
+.game-detail-footnote {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  margin-top: 2.2rem;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+}
+.game-detail-footnote svg {
+  width: 0.9rem;
+}
+.game-loading-panel {
+  display: grid;
+  min-height: 18rem;
+  place-items: center;
+  color: var(--platform-text-soft);
+  font-weight: 700;
+}
+.game-status-message {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  margin-top: 1.2rem;
+}
+.game-status-message button {
+  border: 0;
+  border-radius: 999px;
+  min-height: 2.75rem;
+  padding: 0.38rem 0.7rem;
+  background: rgba(199, 101, 61, 0.14);
+  color: inherit;
+  cursor: pointer;
+  font: inherit;
+  font-size: 0.72rem;
+  font-weight: 800;
+}
+
+.game-play-page {
+  display: flex;
+  flex-direction: column;
+  gap: 0.9rem;
+  min-height: 100%;
+  padding: clamp(0.7rem, 1.8vw, 1.5rem);
+}
+.game-play-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+}
+.game-play-toolbar__actions {
+  display: flex;
+  align-items: center;
+  gap: 0.55rem;
+}
+.game-play-device-hint {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+}
+.game-play-device-hint svg {
+  width: 0.85rem;
+}
+.game-icon-button {
+  display: grid;
+  width: 2.1rem;
+  height: 2.1rem;
+  min-width: 2.75rem;
+  min-height: 2.75rem;
+  place-items: center;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 50%;
+  background: var(--platform-panel-fill);
+  color: var(--platform-text-base);
+  cursor: pointer;
+}
+.game-icon-button svg {
+  width: 0.9rem;
+}
+.game-player-shell {
+  position: relative;
+  flex: 1;
+  min-height: min(72vh, 48rem);
+  overflow: hidden;
+  border: 1px solid rgba(199, 101, 61, 0.24);
+  border-radius: 1.5rem;
+  background: #17131b;
+  box-shadow: 0 1.4rem 3rem rgba(34, 21, 20, 0.2);
+}
+.game-player-launch {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  grid-template-columns: minmax(8rem, 15rem) minmax(0, 1fr);
+  align-items: center;
+  gap: clamp(1.1rem, 4vw, 2.8rem);
+  padding: clamp(1rem, 4vw, 2.5rem);
+  background: linear-gradient(135deg, #1e1820, #302329);
+  color: #fff8f0;
+}
+.game-player-launch .game-cover {
+  border-radius: 1.1rem;
+}
+.game-player-launch__copy {
+  min-width: 0;
+}
+.game-player-launch__copy h1 {
+  margin: 0;
+  overflow: hidden;
+  font-size: clamp(1.4rem, 3vw, 2.2rem);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.game-player-launch__copy p {
+  margin: 0.6rem 0 1.1rem;
+  color: rgba(255, 241, 227, 0.7);
+  font-size: 0.82rem;
+  line-height: 1.65;
+}
+.game-player-launch__copy .game-device-warning {
+  margin-top: -0.4rem;
+}
+.game-player-frame {
+  display: block;
+  width: 100%;
+  height: 100%;
+  min-height: min(72vh, 48rem);
+  border: 0;
+  opacity: 0;
+  transition: opacity 220ms ease;
+}
+.game-player-frame--ready {
+  opacity: 1;
+}
+.game-player-loading {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  color: rgba(255, 241, 227, 0.75);
+  font-size: 0.88rem;
+  font-weight: 700;
+}
+.game-play-safety-note {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  text-align: center;
+}
+
+@media (max-width: 820px) {
+  .game-hero {
+    min-height: 19rem;
+  }
+  .game-hero__orb {
+    position: absolute;
+    right: -2.5rem;
+    bottom: -3rem;
+    width: 11rem;
+    opacity: 0.62;
+  }
+  .game-hero__copy {
+    max-width: 80%;
+  }
+  .game-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+  .game-detail-hero {
+    grid-template-columns: 9rem minmax(0, 1fr);
+    gap: 1.15rem;
+  }
+  .game-detail-hero .game-cover {
+    min-height: 9rem;
+  }
+  .game-cover__icon {
+    width: 3.7rem;
+    border-radius: 1rem;
+    font-size: 2rem;
+  }
+  .game-detail-body {
+    grid-template-columns: 1fr;
+    gap: 1.5rem;
+  }
+  .game-detail-side {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 560px) {
+  .game-page,
+  .game-detail-page {
+    padding: 1rem;
+  }
+  .game-hero {
+    border-radius: 1.5rem;
+    padding: 1.35rem;
+  }
+  .game-hero h1 {
+    font-size: 2rem;
+  }
+  .game-hero p {
+    font-size: 0.82rem;
+  }
+  .game-hero__copy {
+    max-width: 100%;
+  }
+  .game-hero__orb {
+    opacity: 0.3;
+  }
+  .game-hero__hint {
+    display: none;
+  }
+  .game-toolbar {
+    display: block;
+    margin-top: 1.7rem;
+  }
+  .game-search {
+    margin-top: 0.9rem;
+  }
+  .game-grid {
+    grid-template-columns: 1fr;
+  }
+  .game-cover {
+    min-height: 10.5rem;
+  }
+  .game-detail-hero {
+    display: block;
+  }
+  .game-detail-hero .game-cover {
+    min-height: 13rem;
+    margin-top: 1.2rem;
+  }
+  .game-detail-hero h1 {
+    margin-top: 1.4rem;
+  }
+  .game-detail-side {
+    grid-template-columns: 1fr;
+  }
+  .game-play-page {
+    padding: 0.7rem;
+  }
+  .game-player-launch {
+    grid-template-columns: 1fr;
+    align-content: center;
+    gap: 1rem;
+    text-align: center;
+  }
+  .game-player-launch .game-cover {
+    width: min(12rem, 65vw);
+    min-height: 8rem;
+    margin: 0 auto;
+  }
+  .game-player-launch__copy p {
+    margin-bottom: 0.8rem;
+  }
+  .game-player-launch__copy .platform-button {
+    min-height: 2.75rem;
+  }
+  .game-play-toolbar__actions .game-play-device-hint {
+    display: none;
+  }
+  .game-player-shell,
+  .game-player-frame {
+    min-height: calc(100dvh - 8rem);
+  }
+}
+
+.my-game-list {
+  display: grid;
+  gap: 0.9rem;
+}
+.my-game-card {
+  display: flex;
+  gap: 1rem;
+  align-items: stretch;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 1.2rem;
+  padding: 0.85rem;
+  background: var(--platform-panel-fill);
+  box-shadow: var(--platform-panel-shadow);
+}
+.my-game-card .game-cover {
+  flex: none;
+  width: 8.5rem;
+  min-height: 6rem;
+  border-radius: 0.9rem;
+}
+.my-game-card__body {
+  display: flex;
+  min-width: 0;
+  flex: 1;
+  flex-direction: column;
+  gap: 0.35rem;
+}
+.my-game-card__heading {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.6rem;
+}
+.my-game-card__title {
+  border: 0;
+  padding: 0;
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+  font: inherit;
+  font-size: 1rem;
+  font-weight: 800;
+  text-align: left;
+}
+.my-game-card__summary {
+  margin: 0;
+  overflow: hidden;
+  color: var(--platform-text-base);
+  font-size: 0.78rem;
+  line-height: 1.5;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.my-game-card__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+}
+.my-game-card__reason {
+  margin: 0;
+  color: var(--platform-button-danger-text);
+  font-size: 0.72rem;
+}
+.my-game-card__actions {
+  display: flex;
+  gap: 0.5rem;
+  margin-top: auto;
+  padding-top: 0.35rem;
+}
+.my-game-status {
+  flex: none;
+  border-radius: 999px;
+  padding: 0.25rem 0.6rem;
+  font-size: 0.68rem;
+  font-weight: 800;
+  background: var(--platform-surface-fill);
+  color: var(--platform-text-soft);
+}
+.my-game-status--published {
+  background: var(--platform-success-bg);
+  color: var(--platform-success-text);
+}
+.my-game-status--suspended {
+  background: var(--platform-button-danger-fill);
+  color: var(--platform-button-danger-text);
+}
+@media (max-width: 560px) {
+  .my-game-card {
+    flex-direction: column;
+  }
+  .my-game-card .game-cover {
+    width: 100%;
+  }
+}
+
+.game-publish-page {
+  max-width: 54rem;
+}
+.game-publish-form {
+  display: grid;
+  gap: 0.85rem;
+  margin-top: 0.4rem;
+}
+.game-publish-field {
+  display: grid;
+  gap: 0.3rem;
+  font-size: 0.76rem;
+  font-weight: 700;
+  color: var(--platform-text-base);
+}
+.game-publish-field input,
+.game-publish-field select,
+.game-publish-field textarea {
+  width: 100%;
+  box-sizing: border-box;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.7rem;
+  padding: 0.55rem 0.7rem;
+  background: var(--platform-panel-fill);
+  color: var(--platform-text-strong);
+  font: inherit;
+  font-weight: 500;
+}
+.game-publish-field textarea {
+  resize: vertical;
+}
+.game-publish-row {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0.7rem;
+}
+.game-publish-fieldset {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.9rem;
+  margin: 0;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.7rem;
+  padding: 0.6rem 0.8rem;
+}
+.game-publish-fieldset legend {
+  padding: 0 0.3rem;
+  font-size: 0.72rem;
+  font-weight: 700;
+}
+.game-publish-checkbox {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  font-size: 0.76rem;
+}
+.game-publish-hint {
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  font-weight: 500;
+}
+.game-publish-actions {
+  display: flex;
+  justify-content: flex-end;
+}
+@media (max-width: 560px) {
+  .game-publish-row {
+    grid-template-columns: 1fr;
+  }
+}
+
+/* 桌面端首屏：压缩 hero 高度，让第一排游戏卡片在 900px 视口内就能看到。 */
+@media (min-width: 1024px) {
+  .game-hero {
+    min-height: 13rem;
+    padding: clamp(1.5rem, 3vw, 2.5rem) clamp(1.5rem, 3.5vw, 3rem);
+  }
+  .game-hero h1 {
+    margin-top: 0.6rem;
+    font-size: clamp(1.8rem, 3.2vw, 2.6rem);
+  }
+  .game-hero p {
+    margin-top: 0.7rem;
+    max-width: 30rem;
+    font-size: 0.9rem;
+    line-height: 1.6;
+  }
+  .game-hero__actions {
+    margin-top: 1rem;
+  }
+  .game-hero__orb {
+    width: clamp(7rem, 14vw, 12rem);
+  }
+}
diff --git a/src/components/game-distribution/gameDistributionGuards.ts b/src/components/game-distribution/gameDistributionGuards.ts
new file mode 100644
index 000000000..bb11a1059
--- /dev/null
+++ b/src/components/game-distribution/gameDistributionGuards.ts
@@ -0,0 +1,152 @@
+import { useEffect, useState } from 'react';
+
+const MAX_GAME_ID_LENGTH = 128;
+const MAX_ENTRY_URL_LENGTH = 4096;
+
+function containsControlCharacter(value: string) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint !== undefined && (codePoint < 0x20 || codePoint === 0x7f)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Route query values are untrusted input. Keep the client side guard small and
+ * permissive enough for server assigned ids while rejecting values that can
+ * become ambiguous path segments or control characters in diagnostics.
+ */
+export function normalizeGameId(value: string | null | undefined) {
+  const normalized = value?.trim() ?? '';
+  if (
+    !normalized ||
+    normalized.length > MAX_GAME_ID_LENGTH ||
+    containsControlCharacter(normalized)
+  ) {
+    return null;
+  }
+  return normalized;
+}
+
+/**
+ * The API is the authority for which release host is allowed. The browser
+ * still refuses executable URL schemes and credential-bearing URLs before a
+ * value can reach an iframe.
+ */
+export function normalizeGameEntryUrl(value: string | null | undefined) {
+  const normalized = value?.trim() ?? '';
+  if (
+    !normalized ||
+    normalized.length > MAX_ENTRY_URL_LENGTH ||
+    containsControlCharacter(normalized)
+  ) {
+    return null;
+  }
+
+  try {
+    const url = new URL(
+      normalized,
+      typeof window === 'undefined'
+        ? 'http://localhost'
+        : window.location.origin,
+    );
+    const isLocalDevelopmentHttp =
+      url.protocol === 'http:' &&
+      (url.hostname === 'localhost' ||
+        url.hostname === '127.0.0.1' ||
+        url.hostname === '[::1]');
+    if (
+      (url.protocol !== 'https:' && !isLocalDevelopmentHttp) ||
+      url.username ||
+      url.password ||
+      (typeof window !== 'undefined' &&
+        url.origin === window.location.origin &&
+        !import.meta.env.DEV)
+    ) {
+      return null;
+    }
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+
+function readMobileViewport() {
+  if (typeof window === 'undefined') return false;
+  if (typeof window.matchMedia === 'function') {
+    return window.matchMedia('(max-width: 820px)').matches;
+  }
+  return window.innerWidth <= 820;
+}
+
+export function useIsMobileViewport() {
+  const [isMobileViewport, setIsMobileViewport] = useState(readMobileViewport);
+
+  useEffect(() => {
+    if (typeof window === 'undefined') return undefined;
+
+    const mediaQuery =
+      typeof window.matchMedia === 'function'
+        ? window.matchMedia('(max-width: 820px)')
+        : null;
+    const update = () => setIsMobileViewport(readMobileViewport());
+    update();
+    window.addEventListener('resize', update);
+    mediaQuery?.addEventListener?.('change', update);
+
+    return () => {
+      window.removeEventListener('resize', update);
+      mediaQuery?.removeEventListener?.('change', update);
+    };
+  }, []);
+
+  return isMobileViewport;
+}
+
+function readPortraitViewport() {
+  if (typeof window === 'undefined') return false;
+  const { innerHeight, innerWidth } = window;
+  if (
+    typeof innerHeight === 'number' &&
+    typeof innerWidth === 'number' &&
+    innerHeight > 0 &&
+    innerWidth > 0 &&
+    innerHeight !== innerWidth
+  ) {
+    return innerHeight > innerWidth;
+  }
+  if (typeof window.matchMedia === 'function') {
+    return window.matchMedia('(orientation: portrait)').matches;
+  }
+  return false;
+}
+
+/**
+ * 横屏游戏的旋转提示只在竖屏视口出现；视口比例优先，matchMedia 作为兜底，
+ * 让没有方向查询能力的嵌入浏览器也能给出提示。
+ */
+export function useIsPortraitViewport() {
+  const [isPortrait, setIsPortrait] = useState(readPortraitViewport);
+
+  useEffect(() => {
+    if (typeof window === 'undefined') return undefined;
+
+    const mediaQuery =
+      typeof window.matchMedia === 'function'
+        ? window.matchMedia('(orientation: portrait)')
+        : null;
+    const update = () => setIsPortrait(readPortraitViewport());
+    update();
+    window.addEventListener('resize', update);
+    mediaQuery?.addEventListener?.('change', update);
+
+    return () => {
+      window.removeEventListener('resize', update);
+      mediaQuery?.removeEventListener?.('change', update);
+    };
+  }, []);
+
+  return isPortrait;
+}
diff --git a/src/components/game-distribution/gameGalleryViewState.ts b/src/components/game-distribution/gameGalleryViewState.ts
new file mode 100644
index 000000000..d2f8439aa
--- /dev/null
+++ b/src/components/game-distribution/gameGalleryViewState.ts
@@ -0,0 +1,183 @@
+import type {
+  GameCategory,
+  GameDistributionGame,
+} from '../../services/gameDistributionClient';
+
+export const GAME_GALLERY_CATEGORIES: Array<GameCategory | '全部'> = [
+  '全部',
+  '动作',
+  '益智',
+  '冒险',
+  '休闲',
+  '模拟',
+  '策略',
+  '其他',
+];
+
+export type GameDeviceFilter = '全部' | '桌面' | '移动';
+
+export const GAME_GALLERY_DEVICE_FILTERS: GameDeviceFilter[] = [
+  '全部',
+  '桌面',
+  '移动',
+];
+
+/** 目录筛选写入地址栏，分享和刷新都能回到同一份上下文。 */
+const GALLERY_QUERY_KEYS = {
+  keyword: 'keyword',
+  category: 'category',
+  device: 'device',
+} as const;
+
+const GALLERY_STORAGE_KEYS = {
+  filters: 'game-gallery-filters',
+  scroll: 'game-gallery-scroll',
+} as const;
+
+/** 画廊挂在平台页签的滚动容器里，返回时按同一容器恢复位置。 */
+export const GAME_GALLERY_SCROLL_CONTAINER_SELECTOR = '.platform-tab-panel';
+
+export type GameGalleryFilters = {
+  keyword: string;
+  category: GameCategory | '全部';
+  device: GameDeviceFilter;
+};
+
+function readGalleryStorage() {
+  try {
+    return globalThis.sessionStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeCategory(value: string | null | undefined) {
+  const normalized = value?.trim() ?? '';
+  return (
+    GAME_GALLERY_CATEGORIES.find(
+      (item) => item !== '全部' && item === normalized,
+    ) ?? '全部'
+  );
+}
+
+function normalizeDevice(value: string | null | undefined) {
+  const normalized = value?.trim() ?? '';
+  return (
+    GAME_GALLERY_DEVICE_FILTERS.find((item) => item === normalized) ?? '全部'
+  );
+}
+
+export function gameGalleryScrollKey(filters: GameGalleryFilters) {
+  return `${GALLERY_STORAGE_KEYS.scroll}:${filters.keyword.trim()}|${filters.category}|${filters.device}`;
+}
+
+/**
+ * 只有地址栏里明确出现的筛选项才覆盖返回上下文，避免把用户分享的
+ * `?category=动作` 当成“其他筛选项已被清空”。
+ */
+export function readGameGalleryQueryFilters(
+  search: string,
+): Partial<GameGalleryFilters> {
+  const params = new URLSearchParams(search);
+  const filters: Partial<GameGalleryFilters> = {};
+  const keyword = params.get(GALLERY_QUERY_KEYS.keyword);
+  if (keyword !== null) filters.keyword = keyword;
+  const category = params.get(GALLERY_QUERY_KEYS.category);
+  if (category !== null) filters.category = normalizeCategory(category);
+  const device = params.get(GALLERY_QUERY_KEYS.device);
+  if (device !== null) filters.device = normalizeDevice(device);
+  return filters;
+}
+
+export function readStoredGameGalleryFilters(): Partial<GameGalleryFilters> {
+  const storage = readGalleryStorage();
+  if (!storage) return {};
+  try {
+    const raw = storage.getItem(GALLERY_STORAGE_KEYS.filters);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw) as Partial<GameGalleryFilters> | null;
+    if (!parsed || typeof parsed !== 'object') return {};
+    const filters: Partial<GameGalleryFilters> = {};
+    if (typeof parsed.keyword === 'string') filters.keyword = parsed.keyword;
+    if (typeof parsed.category === 'string') {
+      filters.category = normalizeCategory(parsed.category);
+    }
+    if (typeof parsed.device === 'string') {
+      filters.device = normalizeDevice(parsed.device);
+    }
+    return filters;
+  } catch {
+    return {};
+  }
+}
+
+export function writeStoredGameGalleryFilters(filters: GameGalleryFilters) {
+  const storage = readGalleryStorage();
+  if (!storage) return;
+  try {
+    storage.setItem(GALLERY_STORAGE_KEYS.filters, JSON.stringify(filters));
+  } catch {
+    // 存储被禁用时筛选仍在本页生效，只是刷新后不再恢复。
+  }
+}
+
+export function readStoredGameGalleryScrollTop(key: string) {
+  const storage = readGalleryStorage();
+  if (!storage) return 0;
+  try {
+    const value = Number(storage.getItem(key));
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  } catch {
+    return 0;
+  }
+}
+
+export function writeStoredGameGalleryScrollTop(
+  key: string,
+  scrollTop: number,
+) {
+  const storage = readGalleryStorage();
+  if (!storage) return;
+  try {
+    if (scrollTop > 0) storage.setItem(key, String(Math.round(scrollTop)));
+    else storage.removeItem(key);
+  } catch {
+    // 忽略存储失败，滚动位置不是业务状态。
+  }
+}
+
+export function syncGameGalleryQuery(filters: GameGalleryFilters) {
+  if (typeof window === 'undefined' || !window.history?.replaceState) return;
+  try {
+    const url = new URL(window.location.href);
+    const assign = (key: string, value: string) => {
+      if (value) url.searchParams.set(key, value);
+      else url.searchParams.delete(key);
+    };
+    assign(GALLERY_QUERY_KEYS.keyword, filters.keyword.trim());
+    assign(
+      GALLERY_QUERY_KEYS.category,
+      filters.category === '全部' ? '' : filters.category,
+    );
+    assign(
+      GALLERY_QUERY_KEYS.device,
+      filters.device === '全部' ? '' : filters.device,
+    );
+    window.history.replaceState(
+      window.history.state,
+      '',
+      `${url.pathname}${url.search}${url.hash}`,
+    );
+  } catch {
+    // 地址栏同步失败不影响筛选本身。
+  }
+}
+
+export function matchesGameDeviceFilter(
+  game: GameDistributionGame,
+  device: GameDeviceFilter,
+) {
+  if (device === '桌面') return game.deviceSupport.desktop;
+  if (device === '移动') return game.deviceSupport.mobile;
+  return true;
+}
diff --git a/src/components/game-distribution/gamePublishDraft.ts b/src/components/game-distribution/gamePublishDraft.ts
new file mode 100644
index 000000000..e3185e6f4
--- /dev/null
+++ b/src/components/game-distribution/gamePublishDraft.ts
@@ -0,0 +1,118 @@
+import type { GameDistributionRecoveryAction } from '../../../packages/shared/src/contracts/gameDistribution';
+
+/**
+ * 网页发布的恢复标识。
+ *
+ * 只保存服务端已经分配的游戏/版本标识与本地标题，用于窗口关闭或网络中断后回到同一
+ * 版本继续上传；不保存 ZIP 字节、凭据或账号资料。`ownerUserId` 用于换账号时拒绝恢复，
+ * 避免把上一个账号的私有状态展示给新账号。
+ */
+export type GamePublishDraft = {
+  ownerUserId: string;
+  gameId: string;
+  versionId: string;
+  versionNumber: number;
+  title: string;
+  updatedAt: string;
+};
+
+export const GAME_PUBLISH_DRAFT_STORAGE_KEY =
+  'genarrative.game-distribution.publish-draft.v1';
+
+type StorageLike = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+
+function resolveStorage(storage?: StorageLike): StorageLike | null {
+  if (storage) return storage;
+  if (typeof window === 'undefined') return null;
+  try {
+    // 某些隐私模式会直接抛 SecurityError，读不到存储时放弃恢复能力而不是让页面崩溃。
+    return window.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function isDraft(value: unknown): value is GamePublishDraft {
+  if (!value || typeof value !== 'object') return false;
+  const draft = value as Partial<GamePublishDraft>;
+  return Boolean(
+    draft.ownerUserId &&
+      draft.gameId &&
+      draft.versionId &&
+      typeof draft.versionNumber === 'number' &&
+      typeof draft.title === 'string',
+  );
+}
+
+export function readPublishDraft(
+  storage?: StorageLike,
+): GamePublishDraft | null {
+  const target = resolveStorage(storage);
+  if (!target) return null;
+  try {
+    const raw = target.getItem(GAME_PUBLISH_DRAFT_STORAGE_KEY);
+    if (!raw) return null;
+    const parsed: unknown = JSON.parse(raw);
+    return isDraft(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export function writePublishDraft(
+  draft: GamePublishDraft,
+  storage?: StorageLike,
+): void {
+  const target = resolveStorage(storage);
+  if (!target) return;
+  try {
+    target.setItem(GAME_PUBLISH_DRAFT_STORAGE_KEY, JSON.stringify(draft));
+  } catch {
+    // 隐私模式或配额不足时放弃恢复能力，不影响本次发布。
+  }
+}
+
+export function clearPublishDraft(storage?: StorageLike): void {
+  const target = resolveStorage(storage);
+  if (!target) return;
+  try {
+    target.removeItem(GAME_PUBLISH_DRAFT_STORAGE_KEY);
+  } catch {
+    // 清理失败时保留草稿，最多多显示一次恢复提示。
+  }
+}
+
+export type PublishDraftRecoveryCopy = {
+  title: string;
+  description: string;
+  actionLabel: string | null;
+};
+
+/** 恢复提示的文案完全由服务端 recoveryAction 派生，前端不推断版本状态。 */
+export function resolvePublishDraftRecoveryCopy(
+  action: GameDistributionRecoveryAction,
+  versionNumber: number,
+): PublishDraftRecoveryCopy {
+  switch (action) {
+    case 'upload':
+    case 'reupload':
+      return {
+        title: `上次发布未完成（版本 v${versionNumber}）`,
+        description: '重新选择同一个发行包 ZIP，会沿用原版本继续上传并送审。',
+        actionLabel: '继续上传',
+      };
+    case 'submit':
+      return {
+        title: `发行包已上传（版本 v${versionNumber}）`,
+        description: '可以直接继续提交审核，不需要重新上传。',
+        actionLabel: '继续送审',
+      };
+    default:
+      return {
+        title: `上次发布已交接（版本 v${versionNumber}）`,
+        description:
+          '该版本已经进入服务端流程，可以在「我的游戏」查看最新状态。',
+        actionLabel: null,
+      };
+  }
+}
diff --git a/src/components/game-distribution/gamePublishMetadata.ts b/src/components/game-distribution/gamePublishMetadata.ts
new file mode 100644
index 000000000..795ac4e29
--- /dev/null
+++ b/src/components/game-distribution/gamePublishMetadata.ts
@@ -0,0 +1,24 @@
+import type { GameDistributionDeviceSupport } from '../../../packages/shared/src/contracts/gameDistribution';
+
+/** 作者侧元数据校验；口径与服务端 `validate_game_metadata` 保持一致。 */
+export function resolvePublishMetadataError(input: {
+  title: string;
+  summary: string;
+  deviceSupport: GameDistributionDeviceSupport;
+}) {
+  const title = input.title.trim();
+  const summary = input.summary.trim();
+  if (!title || Array.from(title).length > 40) {
+    return '游戏标题必须为 1 到 40 个字符';
+  }
+  if (!summary || Array.from(summary).length > 120) {
+    return '游戏简介必须为 1 到 120 个字符';
+  }
+  if (!input.deviceSupport.desktop && !input.deviceSupport.mobile) {
+    return '至少选择桌面端或移动端';
+  }
+  if (input.deviceSupport.mobile && !input.deviceSupport.touch) {
+    return '选择移动端时必须支持触控';
+  }
+  return '';
+}
diff --git a/src/components/game-distribution/gameZipPackage.test.ts b/src/components/game-distribution/gameZipPackage.test.ts
new file mode 100644
index 000000000..d4f4181a0
--- /dev/null
+++ b/src/components/game-distribution/gameZipPackage.test.ts
@@ -0,0 +1,55 @@
+/* @vitest-environment jsdom */
+
+import JSZip from 'jszip';
+import { describe, expect, it } from 'vitest';
+
+import { prepareGamePackage } from './gameZipPackage';
+
+async function buildZip(files: Record<string, string>) {
+  const zip = new JSZip();
+  for (const [name, content] of Object.entries(files)) {
+    zip.file(name, content);
+  }
+  const bytes = await zip.generateAsync({ type: 'uint8array' });
+  return new File([bytes as unknown as BlobPart], 'game.zip', {
+    type: 'application/zip',
+  });
+}
+
+describe('prepareGamePackage', () => {
+  it('读取根 index.html、统计文件数并给出稳定摘要', async () => {
+    const file = await buildZip({
+      'index.html': '<html></html>',
+      'assets/app.js': 'console.log(1)',
+    });
+    const prepared = await prepareGamePackage(file);
+    expect(prepared.fileCount).toBe(2);
+    expect(prepared.totalBytes).toBe(file.size);
+    expect(prepared.sha256).toMatch(/^[0-9a-f]{64}$/u);
+    const again = await prepareGamePackage(file);
+    expect(again.sha256).toBe(prepared.sha256);
+  });
+
+  it('缺少根 index.html 时失败关闭', async () => {
+    const file = await buildZip({ 'game/index.html': '<html></html>' });
+    await expect(prepareGamePackage(file)).rejects.toThrow(
+      '发行包根目录必须包含 index.html',
+    );
+  });
+
+  it('拒绝空文件与非 ZIP 内容', async () => {
+    await expect(
+      prepareGamePackage(
+        new File([], 'empty.zip', { type: 'application/zip' }),
+      ),
+    ).rejects.toThrow('请选择非空的发行包 ZIP');
+
+    await expect(
+      prepareGamePackage(
+        new File(['not a zip' as unknown as BlobPart], 'bad.zip', {
+          type: 'application/zip',
+        }),
+      ),
+    ).rejects.toThrow('发行包不是有效的 ZIP');
+  });
+});
diff --git a/src/components/game-distribution/gameZipPackage.ts b/src/components/game-distribution/gameZipPackage.ts
new file mode 100644
index 000000000..eb8497f18
--- /dev/null
+++ b/src/components/game-distribution/gameZipPackage.ts
@@ -0,0 +1,92 @@
+import JSZip from 'jszip';
+
+export const GAME_PACKAGE_MAX_BYTES = 100 * 1024 * 1024;
+export const GAME_PACKAGE_MAX_FILE_COUNT = 10_000;
+
+export type PreparedGamePackage = {
+  bytes: Uint8Array;
+  sha256: string;
+  fileCount: number;
+  totalBytes: number;
+};
+
+function toHex(buffer: ArrayBuffer) {
+  return Array.from(new Uint8Array(buffer))
+    .map((byte) => byte.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+/** 浏览器端发行包摘要；与服务端 `packageSha256` 同口径。 */
+export async function computeGamePackageSha256(bytes: Uint8Array) {
+  const digest = globalThis.crypto?.subtle;
+  if (!digest) {
+    throw new Error('当前浏览器无法计算发行包摘要，请升级浏览器后重试');
+  }
+  const copy = new Uint8Array(bytes);
+  return toHex(await digest.digest('SHA-256', copy.buffer as ArrayBuffer));
+}
+
+/**
+ * 上传前读取并校验 ZIP。
+ *
+ * 这里只做作者侧的前置校验，服务端仍会独立重算摘要与文件清单；两边口径必须一致，
+ * 前端校验通过不代表服务端一定接受。
+ */
+/** 读取 Blob 字节；FileReader 兜底覆盖不实现 `Blob.arrayBuffer()` 的旧 WebView 与 jsdom。 */
+export function readGamePackageBytes(blob: Blob): Promise<Uint8Array> {
+  if (typeof blob.arrayBuffer === 'function') {
+    return blob.arrayBuffer().then((buffer) => new Uint8Array(buffer));
+  }
+  return new Promise<Uint8Array>((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result;
+      if (result instanceof ArrayBuffer) {
+        resolve(new Uint8Array(result));
+        return;
+      }
+      reject(new Error('读取发行包失败'));
+    };
+    reader.onerror = () => reject(new Error('读取发行包失败'));
+    reader.readAsArrayBuffer(blob);
+  });
+}
+
+export async function prepareGamePackage(
+  file: Blob,
+): Promise<PreparedGamePackage> {
+  if (!file || file.size === 0) {
+    throw new Error('请选择非空的发行包 ZIP');
+  }
+  if (file.size > GAME_PACKAGE_MAX_BYTES) {
+    throw new Error('发行包不能超过 100 MiB');
+  }
+  const bytes = await readGamePackageBytes(file);
+  let archive: JSZip;
+  try {
+    archive = await JSZip.loadAsync(bytes);
+  } catch {
+    throw new Error('发行包不是有效的 ZIP');
+  }
+
+  const entries = Object.values(archive.files).filter((entry) => !entry.dir);
+  if (entries.length === 0) {
+    throw new Error('发行包至少需要一个文件');
+  }
+  if (entries.length > GAME_PACKAGE_MAX_FILE_COUNT) {
+    throw new Error(`发行包文件数量不能超过 ${GAME_PACKAGE_MAX_FILE_COUNT} 个`);
+  }
+  if (!entries.some((entry) => entry.name === 'index.html')) {
+    throw new Error('发行包根目录必须包含 index.html');
+  }
+
+  // 展开总量、单文件上限与压缩比由服务端 ZIP 校验独立判定；前端不在浏览器里解压
+  // 整包，避免大包在客户端产生额外内存与耗时。
+
+  return {
+    bytes,
+    sha256: await computeGamePackageSha256(bytes),
+    fileCount: entries.length,
+    totalBytes: bytes.byteLength,
+  };
+}
diff --git a/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx b/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
index 1b71fc729..05420b903 100644
--- a/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
+++ b/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
@@ -43,6 +43,21 @@ const profileCenterMock = vi.hoisted(() => ({
   rechargeCenter: null as { walletBalance: number } | null,
 }));
 
+const gameDistributionMock = vi.hoisted(() => ({
+  cancelGameVersion: vi.fn(),
+  createGame: vi.fn(),
+  createGameVersion: vi.fn(),
+  getGame: vi.fn(),
+  getGameVersion: vi.fn(),
+  listGames: vi.fn(),
+  listMyGames: vi.fn(),
+  submitGameVersion: vi.fn(),
+  unpublishGame: vi.fn(),
+  uploadGamePackage: vi.fn(),
+}));
+
+vi.mock('../../services/gameDistributionClient', () => gameDistributionMock);
+
 vi.mock('../auth/AuthUiContext', () => ({
   useAuthUi: () => authUiMock.value,
 }));
@@ -187,6 +202,10 @@ describe('PlatformEntryActiveFlowShell', () => {
     profileCenterMock.rechargeCenter = null;
     authUiMock.value.user = null;
     authUiMock.value.canAccessProtectedData = false;
+    window.history.replaceState(null, '', '/creation');
+    for (const mock of Object.values(gameDistributionMock)) {
+      mock.mockReset();
+    }
     authUiMock.value.openLoginModal.mockReset();
     responsiveMock.isDesktopLayout = true;
   });
@@ -417,7 +436,7 @@ describe('PlatformEntryActiveFlowShell', () => {
       within(navigation)
         .getAllByRole('button')
         .map((button) => button.getAttribute('aria-label')),
-    ).toEqual(['创作', '项目', '我的']);
+    ).toEqual(['创作', '项目', '游戏', '我的']);
     expect(
       within(navigation)
         .getByRole('button', { name: '创作' })
@@ -466,7 +485,7 @@ describe('PlatformEntryActiveFlowShell', () => {
     ).toBe('page');
   });
 
-  it('keeps only profile reachable from the mobile dock', async () => {
+  it('keeps only games and profile reachable from the mobile dock', async () => {
     responsiveMock.isDesktopLayout = false;
     const setSelectionStage = vi.fn();
     render(
@@ -483,7 +502,7 @@ describe('PlatformEntryActiveFlowShell', () => {
       within(navigation)
         .getAllByRole('button')
         .map((button) => button.getAttribute('aria-label')),
-    ).toEqual(['我的']);
+    ).toEqual(['游戏', '我的']);
     expect(await screen.findByRole('main', { name: '我的' })).toBeTruthy();
     expect(screen.getByRole('button', { name: '下载客户端' })).toBeTruthy();
     expect(
@@ -568,7 +587,7 @@ describe('PlatformEntryActiveFlowShell', () => {
         within(navigation)
           .getAllByRole('button')
           .map((button) => button.getAttribute('aria-label')),
-      ).toEqual(['我的']);
+      ).toEqual(['游戏', '我的']);
       expect(
         within(navigation)
           .getByRole('button', { name: '我的' })
@@ -653,6 +672,146 @@ describe('PlatformEntryActiveFlowShell', () => {
     });
   });
 
+  it('在我的游戏里进入发布新版本时沿用同一个 gameId', async () => {
+    authUiMock.value.user = {
+      id: 'user-1',
+      publicUserCode: '100001',
+      displayName: '测试用户',
+      avatarUrl: null,
+      phoneNumberMasked: null,
+      loginMethod: 'password',
+      bindingStatus: 'active',
+      wechatBound: false,
+    };
+    authUiMock.value.canAccessProtectedData = true;
+    gameDistributionMock.listMyGames.mockResolvedValue([
+      {
+        id: 'game-1',
+        title: '星轨防线',
+        summary: '守住轨道城',
+        description: '旧版资料',
+        category: '动作',
+        tags: ['塔防'],
+        coverColor: '#d77a51',
+        icon: '✦',
+        author: { id: 'user-1', name: '测试用户' },
+        deviceSupport: { desktop: true, mobile: false, touch: false },
+        status: 'published',
+        publicationRevision: 3,
+        currentVersion: null,
+        playCount: 1,
+        createdAt: '2026-09-20T08:00:00Z',
+        latestVersion: {
+          versionId: 'gamever-2',
+          gameId: 'game-1',
+          versionNumber: 2,
+          packageSha256: 'e'.repeat(64),
+          packageBytes: 1024,
+          status: 'published',
+          publicationRevision: 3,
+          reviewReason: null,
+          createdAt: '2026-09-20T08:00:00Z',
+          updatedAt: '2026-09-20T09:00:00Z',
+        },
+        versions: [],
+      },
+    ]);
+    const setSelectionStage = vi.fn();
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-mine"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: '发布新版本' }));
+
+    expect(setSelectionStage).toHaveBeenCalledWith('game-publish', {
+      path: '/games/publish?game=game-1',
+    });
+  });
+
+  it('发布页带 game 参数时进入更新模式并预填既有资料', async () => {
+    authUiMock.value.user = {
+      id: 'user-1',
+      publicUserCode: '100001',
+      displayName: '测试用户',
+      avatarUrl: null,
+      phoneNumberMasked: null,
+      loginMethod: 'password',
+      bindingStatus: 'active',
+      wechatBound: false,
+    };
+    authUiMock.value.canAccessProtectedData = true;
+    gameDistributionMock.listMyGames.mockResolvedValue([
+      {
+        id: 'game-9',
+        title: '星轨防线',
+        summary: '守住轨道城',
+        description: '旧版资料',
+        category: '动作',
+        tags: ['塔防'],
+        coverColor: '#d77a51',
+        icon: '✦',
+        author: { id: 'user-1', name: '测试用户' },
+        deviceSupport: { desktop: true, mobile: false, touch: false },
+        status: 'published',
+        publicationRevision: 5,
+        currentVersion: null,
+        playCount: 1,
+        createdAt: '2026-09-20T08:00:00Z',
+        latestVersion: {
+          versionId: 'gamever-9',
+          gameId: 'game-9',
+          versionNumber: 4,
+          packageSha256: 'f'.repeat(64),
+          packageBytes: 2048,
+          status: 'published',
+          publicationRevision: 5,
+          reviewReason: null,
+          createdAt: '2026-09-20T08:00:00Z',
+          updatedAt: '2026-09-20T09:00:00Z',
+        },
+        versions: [],
+      },
+    ]);
+    gameDistributionMock.getGameVersion.mockResolvedValue({
+      game: {
+        id: 'game-9',
+        title: '星轨防线',
+        summary: '守住轨道城',
+        description: '旧版资料',
+        category: '动作',
+        tags: ['塔防'],
+        publicationRevision: 5,
+      },
+      version: {
+        versionId: 'gamever-9',
+        versionNumber: 4,
+        status: 'published',
+        publicationRevision: 5,
+        recoveryAction: 'none',
+      },
+    });
+    window.history.replaceState(null, '', '/games/publish?game=game-9');
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-publish"
+        setSelectionStage={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByText(/正在为《星轨防线》发布新版本 v5/u),
+    ).toBeTruthy();
+    expect(screen.getByLabelText('游戏名称')).toHaveProperty(
+      'value',
+      '星轨防线',
+    );
+  });
+
   it('keeps guide and tool intent in editor navigation URLs', async () => {
     const setSelectionStage = vi.fn();
     const { rerender } = render(
diff --git a/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx b/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
index 19aaaaf81..95927bce5 100644
--- a/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
+++ b/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
@@ -402,6 +402,14 @@ export function PlatformEntryFlowShellImpl({
     setSelectionStage('game-publish', { path: '/games/publish' });
   }, [setSelectionStage]);
 
+  const openGamePublishVersion = useCallback(
+    (gameId: string) => {
+      const path = `/games/publish?game=${encodeURIComponent(gameId)}`;
+      setSelectionStage('game-publish', { path });
+    },
+    [setSelectionStage],
+  );
+
   const openMyGames = useCallback(() => {
     setSelectionStage('game-mine', { path: '/games/mine' });
   }, [setSelectionStage]);
@@ -505,9 +513,11 @@ export function PlatformEntryFlowShellImpl({
     selectionStage === 'game-play' ||
     selectionStage === 'game-mine' ||
     selectionStage === 'game-publish';
-  const gameId = new URLSearchParams(
+  const gameSearchParams = new URLSearchParams(
     typeof window === 'undefined' ? '' : window.location.search,
-  ).get('id');
+  );
+  const gameId = gameSearchParams.get('id');
+  const publishGameId = gameSearchParams.get('game');
   const avatarUrl = authUi?.user?.avatarUrl?.trim() || null;
   const avatarLabel = resolveActiveUserAvatarLabel(authUi?.user);
   const publicUserCode = resolveActivePublicUserCode(authUi?.user);
@@ -727,11 +737,13 @@ export function PlatformEntryFlowShellImpl({
                       <GamePublishPage
                         onBack={openGames}
                         onOpenMyGames={openMyGames}
+                        updateGameId={publishGameId}
                       />
                     ) : selectionStage === 'game-mine' ? (
                       <MyGamesPage
                         onBack={openGames}
                         onOpenDetail={openGameDetail}
+                        onPublishVersion={openGamePublishVersion}
                       />
                     ) : selectionStage === 'game-detail' ? (
                       <GameDetailPage
diff --git a/src/services/gameDistributionClient.test.ts b/src/services/gameDistributionClient.test.ts
new file mode 100644
index 000000000..8cddda454
--- /dev/null
+++ b/src/services/gameDistributionClient.test.ts
@@ -0,0 +1,251 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { clearStoredAccessToken, setStoredAccessToken } from './apiClient';
+
+import {
+  cancelGameVersion,
+  createGameVersion,
+  getGame,
+  getGameVersion,
+  listGames,
+  listMyGames,
+  unpublishGame,
+  uploadGamePackage,
+} from './gameDistributionClient';
+
+describe('gameDistributionClient', () => {
+  beforeEach(() => {
+    clearStoredAccessToken({ emit: false });
+  });
+
+  it('按关键词和分类读取后端目录', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue(
+        new Response(
+          JSON.stringify({
+            games: [
+              {
+                id: 'game-1',
+                title: '星轨防线',
+                summary: '测试游戏',
+                currentVersion: { id: 'v1' },
+              },
+            ],
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      ),
+    );
+    const games = await listGames({ keyword: '星轨', category: '动作' });
+    expect(games).toHaveLength(1);
+    expect(games[0]?.id).toBe('game-1');
+  });
+
+  it('读取详情时拒绝空 id', async () => {
+    expect(await getGame('')).toBeNull();
+  });
+
+  it('版本创建携带幂等键并保留后端失败状态', async () => {
+    setStoredAccessToken('test-access-token', { emit: false });
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockImplementation(
+        () =>
+          new Response(JSON.stringify({ message: '包校验失败' }), {
+            status: 422,
+            headers: { 'Content-Type': 'application/json' },
+          }),
+      ),
+    );
+    await expect(
+      createGameVersion(
+        'game-1',
+        {
+          packageSha256: 'x',
+          packageBytes: 1,
+          packageFileCount: 1,
+          packageEntryPath: 'index.html',
+          gameMetadata: {
+            title: '测试游戏',
+            summary: '测试',
+            category: '益智',
+            deviceSupport: { desktop: true, mobile: false, touch: false },
+            inputModes: ['keyboard'],
+            orientation: 'responsive',
+          },
+        },
+        'idem-1',
+      ),
+    ).rejects.toMatchObject({ status: 422 });
+  });
+
+  it('发行包上传使用独立版本资源和幂等键', async () => {
+    const fetchMock = vi.fn().mockImplementation(
+      () =>
+        new Response(
+          JSON.stringify({ versionId: 'version-1', status: 'uploaded' }),
+          {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+          },
+        ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+    setStoredAccessToken('test-access-token', { emit: false });
+    await uploadGamePackage('version-1', new ArrayBuffer(2), 'idem-upload');
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/game-distribution/versions/version-1/package',
+      expect.objectContaining({
+        method: 'PUT',
+        body: expect.any(ArrayBuffer),
+        headers: expect.objectContaining({
+          'Content-Type': 'application/zip',
+          'Idempotency-Key': 'idem-upload',
+        }),
+      }),
+    );
+  });
+});
+
+describe('gameDistributionClient 作者接口', () => {
+  beforeEach(() => {
+    clearStoredAccessToken({ emit: false });
+  });
+
+  it('读取我的游戏只返回带 id 的条目', async () => {
+    setStoredAccessToken('author-token', { emit: false });
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockImplementation(() =>
+        Promise.resolve(
+          new Response(
+            JSON.stringify({
+              ok: true,
+              data: { games: [{ id: 'game-1' }, {}, null] },
+              error: null,
+              meta: { apiVersion: 'v1' },
+            }),
+            { status: 200, headers: { 'Content-Type': 'application/json' } },
+          ),
+        ),
+      ),
+    );
+    const games = await listMyGames();
+    expect(games.map((game) => game.id)).toEqual(['game-1']);
+    const myGamesCall = vi
+      .mocked(fetch)
+      .mock.calls.find(([url]) => String(url).includes('/my-games'));
+    expect(myGamesCall?.[0]).toBe('/api/game-distribution/my-games');
+  });
+
+  it('下架请求携带 CAS 版本与幂等键，空入参在本地失败关闭', async () => {
+    setStoredAccessToken('author-token', { emit: false });
+    const fetchMock = vi.fn().mockImplementation(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            ok: true,
+            data: { game: { id: 'game-1', status: 'unpublished' } },
+            error: null,
+            meta: { apiVersion: 'v1' },
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    await unpublishGame('game-1', 4, 'unpublish-key-1');
+    const unpublishCalls = () =>
+      fetchMock.mock.calls.filter(([url]) =>
+        String(url).includes('/unpublish'),
+      );
+    expect(unpublishCalls()).toHaveLength(1);
+    expect(unpublishCalls()[0]?.[0]).toBe(
+      '/api/game-distribution/games/game-1/unpublish',
+    );
+    expect(unpublishCalls()[0]?.[1]).toEqual(
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({ expectedPublicationRevision: 4 }),
+        headers: expect.objectContaining({
+          'Idempotency-Key': 'unpublish-key-1',
+        }),
+      }),
+    );
+
+    await expect(unpublishGame('   ', 1, 'k')).rejects.toThrow('缺少游戏编号');
+    await expect(unpublishGame('game-1', 1, '   ')).rejects.toThrow(
+      '缺少幂等键',
+    );
+    // 本地校验失败不得发出任何下架请求。
+    expect(unpublishCalls()).toHaveLength(1);
+  });
+
+  it('回读单个版本状态与服务端恢复动作', async () => {
+    setStoredAccessToken('test-access-token', { emit: false });
+    const fetchMock = vi.fn().mockImplementation(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            game: { id: 'game-1' },
+            version: {
+              versionId: 'version-1',
+              status: 'upload_failed',
+              recoveryAction: 'reupload',
+            },
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    const detail = await getGameVersion('version-1');
+    expect(detail.version.recoveryAction).toBe('reupload');
+    const readCall = fetchMock.mock.calls.find(([url]) =>
+      String(url).includes('/api/game-distribution/versions/version-1'),
+    );
+    expect(readCall?.[0]).toBe('/api/game-distribution/versions/version-1');
+    expect(readCall?.[1]?.method).toBe('GET');
+  });
+
+  it('撤回版本带幂等键与公开修订号，并拒绝空标识', async () => {
+    setStoredAccessToken('test-access-token', { emit: false });
+    const fetchMock = vi.fn().mockImplementation(() =>
+      Promise.resolve(
+        new Response(JSON.stringify({ replayed: false }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    await cancelGameVersion('version-1', 3, 'idem-1', '看错了');
+    const cancelCalls = () =>
+      fetchMock.mock.calls.filter(([url]) =>
+        String(url).includes('/versions/version-1/cancel'),
+      );
+    expect(cancelCalls()).toHaveLength(1);
+    const cancelCall = cancelCalls()[0];
+    expect(cancelCall?.[1]?.method).toBe('POST');
+    expect(
+      (cancelCall?.[1]?.headers as Record<string, string>)['Idempotency-Key'],
+    ).toBe('idem-1');
+    expect(JSON.parse(String(cancelCall?.[1]?.body))).toEqual({
+      expectedPublicationRevision: 3,
+      reason: '看错了',
+    });
+
+    await expect(cancelGameVersion('', 1, 'idem-2')).rejects.toThrow(
+      '撤回版本缺少版本编号',
+    );
+    await expect(cancelGameVersion('version-1', 1, ' ')).rejects.toThrow(
+      '撤回版本缺少幂等键',
+    );
+    // 本地校验失败不得发出任何撤回请求。
+    expect(cancelCalls()).toHaveLength(1);
+  });
+});
diff --git a/src/services/gameDistributionClient.ts b/src/services/gameDistributionClient.ts
new file mode 100644
index 000000000..325392da9
--- /dev/null
+++ b/src/services/gameDistributionClient.ts
@@ -0,0 +1,286 @@
+import type {
+  GameDistributionAuthor,
+  GameDistributionCreateGameRequest,
+  GameDistributionCategory,
+  GameDistributionCreateVersionRequest,
+  GameDistributionDeviceSupport,
+  GameDistributionInputMode,
+  GameDistributionGame,
+  GameDistributionCancelVersionResponse,
+  GameDistributionRecoveryAction,
+  GameDistributionVersionDetail,
+  GameDistributionVersionStatus as GameDistributionVersionStatusValue,
+  GameDistributionVersionSummary,
+} from '../../packages/shared/src/contracts/gameDistribution';
+import {
+  requestJson as requestApiJson,
+  type ApiRequestOptions,
+} from './apiClient';
+
+export type {
+  GameDistributionAuthor,
+  GameDistributionDeviceSupport,
+  GameDistributionGame,
+  GameDistributionInputMode,
+  GameDistributionRecoveryAction,
+  GameDistributionVersionDetail,
+  GameDistributionVersionSummary,
+} from '../../packages/shared/src/contracts/gameDistribution';
+
+export type GameCategory = GameDistributionCategory;
+export type GameDeviceSupport = GameDistributionDeviceSupport;
+export type GameAuthor = GameDistributionAuthor;
+export type GameVersionSummary = GameDistributionVersionSummary;
+
+export type GameListQuery = {
+  keyword?: string;
+  category?: GameCategory | '全部';
+};
+
+export type GameVersionCreateResult = {
+  gameId: string;
+  versionId: string;
+  versionNumber: number;
+  status: 'awaiting_upload';
+};
+
+const API_BASE = '/api/game-distribution';
+
+function normalizeGameList(value: unknown): GameDistributionGame[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is GameDistributionGame => {
+    if (!item || typeof item !== 'object') return false;
+    const game = item as Partial<GameDistributionGame>;
+    return Boolean(game.id && game.title && game.currentVersion);
+  });
+}
+
+const PUBLIC_GAME_REQUEST_OPTIONS: ApiRequestOptions = {
+  skipAuth: true,
+  skipRefresh: true,
+  notifyAuthStateChange: false,
+  clearAuthOnUnauthorized: false,
+};
+
+async function requestJson<T>(
+  path: string,
+  init: RequestInit,
+  fallbackMessage: string,
+  options?: ApiRequestOptions,
+) {
+  return requestApiJson<T>(
+    `${API_BASE}${path}`,
+    {
+      ...init,
+      headers: {
+        Accept: 'application/json',
+        ...(init.body instanceof FormData ||
+        (typeof Blob !== 'undefined' && init.body instanceof Blob) ||
+        init.body instanceof ArrayBuffer
+          ? {}
+          : init.body
+            ? { 'Content-Type': 'application/json' }
+            : {}),
+        ...init.headers,
+      },
+    },
+    fallbackMessage,
+    options,
+  );
+}
+
+export async function listGames(query: GameListQuery = {}) {
+  const params = new URLSearchParams();
+  if (query.keyword?.trim()) params.set('keyword', query.keyword.trim());
+  if (query.category && query.category !== '全部')
+    params.set('category', query.category);
+  const payload = await requestJson<unknown>(
+    `/games${params.size ? `?${params.toString()}` : ''}`,
+    { method: 'GET' },
+    '读取游戏目录失败',
+    PUBLIC_GAME_REQUEST_OPTIONS,
+  );
+  return normalizeGameList(
+    Array.isArray(payload) ? payload : (payload as { games?: unknown[] }).games,
+  );
+}
+
+export type GameDistributionMyGame = GameDistributionGame & {
+  latestVersion: GameDistributionVersionStatusEntry | null;
+  versions: GameDistributionVersionStatusEntry[];
+};
+
+export type GameDistributionVersionStatusEntry = {
+  versionId: string;
+  gameId: string;
+  versionNumber: number;
+  packageSha256: string;
+  packageBytes: number;
+  status: GameDistributionVersionStatusValue;
+  publicationRevision: number;
+  reviewReason?: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export async function listMyGames() {
+  const payload = await requestJson<{ games?: unknown[] }>(
+    '/my-games',
+    { method: 'GET' },
+    '读取我的游戏失败',
+  );
+  const games = Array.isArray(payload?.games) ? payload.games : [];
+  return games.filter((item): item is GameDistributionMyGame =>
+    Boolean(item && typeof item === 'object' && (item as { id?: string }).id),
+  );
+}
+
+export async function unpublishGame(
+  gameId: string,
+  expectedPublicationRevision: number,
+  idempotencyKey: string,
+) {
+  const normalizedGameId = gameId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedGameId) throw new Error('缺少游戏编号');
+  if (!normalizedKey) throw new Error('缺少幂等键');
+  return requestJson<{ game: { id: string; status: string } }>(
+    `/games/${encodeURIComponent(normalizedGameId)}/unpublish`,
+    {
+      method: 'POST',
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: JSON.stringify({ expectedPublicationRevision }),
+    },
+    '下架游戏失败',
+  );
+}
+
+export async function getGame(gameId: string) {
+  const normalizedId = gameId.trim();
+  if (!normalizedId) return null;
+  return requestJson<GameDistributionGame>(
+    `/games/${encodeURIComponent(normalizedId)}`,
+    { method: 'GET' },
+    '读取游戏详情失败',
+    PUBLIC_GAME_REQUEST_OPTIONS,
+  );
+}
+
+export async function createGame(
+  payload: GameDistributionCreateGameRequest,
+  idempotencyKey: string,
+) {
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedKey) throw new Error('创建游戏缺少幂等键');
+  return requestJson<GameDistributionGame>(
+    '/games',
+    {
+      method: 'POST',
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: JSON.stringify(payload),
+    },
+    '创建游戏失败',
+  );
+}
+
+export async function createGameVersion(
+  gameId: string,
+  payload: GameDistributionCreateVersionRequest,
+  idempotencyKey: string,
+) {
+  const normalizedGameId = gameId.trim();
+  const normalizedIdempotencyKey = idempotencyKey.trim();
+  if (!normalizedGameId || !normalizedIdempotencyKey) {
+    throw new Error('游戏版本创建缺少必要标识');
+  }
+  return requestJson<GameVersionCreateResult>(
+    `/games/${encodeURIComponent(normalizedGameId)}/versions`,
+    {
+      method: 'POST',
+      headers: { 'Idempotency-Key': normalizedIdempotencyKey },
+      body: JSON.stringify(payload),
+    },
+    '创建游戏版本失败',
+  );
+}
+
+/** 回读单个版本状态、驳回理由与服务端给出的恢复动作。 */
+export async function getGameVersion(versionId: string) {
+  const normalizedVersionId = versionId.trim();
+  if (!normalizedVersionId) throw new Error('缺少版本编号');
+  return requestJson<GameDistributionVersionDetail>(
+    `/versions/${encodeURIComponent(normalizedVersionId)}`,
+    { method: 'GET' },
+    '读取版本状态失败',
+  );
+}
+
+/** 撤回尚未公开的版本；幂等键由调用方生成，重复提交返回同一结果。 */
+export async function cancelGameVersion(
+  versionId: string,
+  expectedPublicationRevision: number,
+  idempotencyKey: string,
+  reason?: string,
+) {
+  const normalizedVersionId = versionId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedVersionId) throw new Error('撤回版本缺少版本编号');
+  if (!normalizedKey) throw new Error('撤回版本缺少幂等键');
+  const normalizedReason = reason?.trim();
+  return requestJson<GameDistributionCancelVersionResponse>(
+    `/versions/${encodeURIComponent(normalizedVersionId)}/cancel`,
+    {
+      method: 'POST',
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: JSON.stringify({
+        expectedPublicationRevision,
+        ...(normalizedReason ? { reason: normalizedReason } : {}),
+      }),
+    },
+    '撤回版本失败',
+  );
+}
+
+export async function submitGameVersion(
+  versionId: string,
+  expectedPublicationRevision: number,
+  idempotencyKey: string,
+) {
+  const normalizedVersionId = versionId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedVersionId) throw new Error('提交审核缺少版本 ID');
+  if (!normalizedKey) throw new Error('提交审核缺少幂等键');
+  return requestJson<{ version?: { status?: string } }>(
+    `/versions/${encodeURIComponent(normalizedVersionId)}/submit`,
+    {
+      method: 'POST',
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: JSON.stringify({ expectedPublicationRevision }),
+    },
+    '提交审核失败',
+  );
+}
+
+export async function uploadGamePackage(
+  versionId: string,
+  packageBody: Blob | ArrayBuffer,
+  idempotencyKey: string,
+) {
+  const normalizedVersionId = versionId.trim();
+  const normalizedIdempotencyKey = idempotencyKey.trim();
+  if (!normalizedVersionId || !normalizedIdempotencyKey) {
+    throw new Error('游戏发行包上传缺少必要标识');
+  }
+  return requestJson<{ versionId: string; status: 'uploaded' }>(
+    `/versions/${encodeURIComponent(normalizedVersionId)}/package`,
+    {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/zip',
+        'Idempotency-Key': normalizedIdempotencyKey,
+      },
+      body: packageBody,
+    },
+    '上传游戏发行包失败',
+  );
+}