diff --git a/apps/admin-web/src/api/adminApiClient.ts b/apps/admin-web/src/api/adminApiClient.ts
index 241019468..efdce973b 100644
--- a/apps/admin-web/src/api/adminApiClient.ts
+++ b/apps/admin-web/src/api/adminApiClient.ts
@@ -101,12 +101,34 @@ import type {
   ProfileTaskConfigAdminResponse,
   ProfileWalletConfigAdminResponse,
 } from './adminApiTypes';
+import type {
+  AdminThemeStatusFilter,
+  GameDistributionAdminThemeListResponse,
+  GameDistributionAdminThemeMemberListResponse,
+  GameDistributionAdminThemeMemberRemovalResponse,
+  GameDistributionAdminThemeMemberResponse,
+  GameDistributionAdminThemeMutationResponse,
+  GameDistributionCreateThemeRequest,
+  GameDistributionUpdateThemeRequest,
+  GameDistributionUpsertThemeMemberRequest,
+} from './adminGameThemeTypes';
 
 const API_RESPONSE_ENVELOPE_HEADER = 'x-genarrative-response-envelope';
 const ADMIN_API_BASE_URL = normalizeBaseUrl(
   import.meta.env.VITE_ADMIN_API_BASE_URL ?? '',
 );
 
+/**
+ * 后台主题列表的 `limit` 上界：与服务端 `MAX_ADMIN_THEME_LIST_LIMIT` 同值。
+ *
+ * 服务端按上限截断（不报错），客户端也按同一口径夹一次，避免发出一条注定被截断的请求。
+ */
+const ADMIN_THEME_LIST_LIMIT_MAX = 200;
+
+/** 后台成员名单每页条数：缺省与服务端一致，上限 50（超出服务端截断，这里先夹）。 */
+const ADMIN_THEME_MEMBER_PAGE_SIZE = 20;
+const ADMIN_THEME_MEMBER_PAGE_SIZE_MAX = 50;
+
 interface AdminRequestOptions {
   method?: string;
   token?: string;
@@ -1512,3 +1534,156 @@ export function importAdminAgcTemplates(token: string, formData: FormData) {
     },
   );
 }
+
+/**
+ * 后台共创主题列表：`GET /admin/api/game-distribution/themes?limit=&status=`。
+ *
+ * 含 draft / archived；`status=all`（或省略）不过滤。**没有游标**：`limit` 上限 200，服务端按
+ * 上限截断，这里也按同一口径夹一次，避免把一条必然被截断的请求发出去。
+ */
+export function listAdminGameDistributionThemes(
+  token: string,
+  options: {
+    limit?: number;
+    status?: AdminThemeStatusFilter;
+  } = {},
+  signal?: AbortSignal,
+) {
+  const requestedLimit = options.limit ?? ADMIN_THEME_LIST_LIMIT_MAX;
+  const normalizedLimit = Number.isFinite(requestedLimit)
+    ? Math.min(
+        Math.max(Math.trunc(requestedLimit), 1),
+        ADMIN_THEME_LIST_LIMIT_MAX,
+      )
+    : ADMIN_THEME_LIST_LIMIT_MAX;
+  const params = new URLSearchParams({ limit: String(normalizedLimit) });
+  const status = options.status?.trim();
+  if (status && status !== 'all') params.set('status', status);
+  return request<GameDistributionAdminThemeListResponse>(
+    `/admin/api/game-distribution/themes?${params.toString()}`,
+    { token, signal },
+  );
+}
+
+/** 后台创建主题：`theme_id` 由服务端生成，客户端只给字段；写操作必须带幂等键。 */
+export function createAdminGameDistributionTheme(
+  token: string,
+  idempotencyKey: string,
+  payload: GameDistributionCreateThemeRequest,
+) {
+  return request<GameDistributionAdminThemeMutationResponse>(
+    '/admin/api/game-distribution/themes',
+    {
+      token,
+      method: 'POST',
+      headers: {
+        'Idempotency-Key': normalizeThemeIdempotencyKey(idempotencyKey),
+      },
+      body: payload,
+    },
+  );
+}
+
+/** 后台整体覆盖主题字段：`name/summary/badge/sortOrder/status` 都是必填（不是部分更新）。 */
+export function updateAdminGameDistributionTheme(
+  token: string,
+  themeId: string,
+  idempotencyKey: string,
+  payload: GameDistributionUpdateThemeRequest,
+) {
+  return request<GameDistributionAdminThemeMutationResponse>(
+    `/admin/api/game-distribution/themes/${encodeURIComponent(normalizeThemeId(themeId))}`,
+    {
+      token,
+      method: 'PUT',
+      headers: {
+        'Idempotency-Key': normalizeThemeIdempotencyKey(idempotencyKey),
+      },
+      body: payload,
+    },
+  );
+}
+
+/**
+ * 增 / 改主题成员：**不要求幂等键**（成员身份完全由路径给出，重复调用只改 `sortOrder`）。
+ *
+ * 只允许根作品：非根作品服务端回 409 `THEME_MEMBER_NOT_ROOT`。
+ */
+export function upsertAdminGameDistributionThemeMember(
+  token: string,
+  themeId: string,
+  rootGameId: string,
+  payload: GameDistributionUpsertThemeMemberRequest,
+) {
+  return request<GameDistributionAdminThemeMemberResponse>(
+    `/admin/api/game-distribution/themes/${encodeURIComponent(normalizeThemeId(themeId))}/members/${encodeURIComponent(normalizeRootGameId(rootGameId))}`,
+    { token, method: 'PUT', body: payload },
+  );
+}
+
+/** 移除主题成员：不要求幂等键；成员不存在也算成功（200，返回同一个形状）。 */
+export function removeAdminGameDistributionThemeMember(
+  token: string,
+  themeId: string,
+  rootGameId: string,
+) {
+  return request<GameDistributionAdminThemeMemberRemovalResponse>(
+    `/admin/api/game-distribution/themes/${encodeURIComponent(normalizeThemeId(themeId))}/members/${encodeURIComponent(normalizeRootGameId(rootGameId))}`,
+    { token, method: 'DELETE' },
+  );
+}
+
+/**
+ * 后台主题成员名单：`GET …/themes/{themeId}/members?limit=&cursor=`。
+ *
+ * **不套公开可见性过滤**，草稿 / 归档主题照常可读——这正是这条接口存在的理由。每行带
+ * `visible`（此刻公开投影是否包含它）与 `visibility`（为什么：`published`/`unpublished`/
+ * `suspended`/`deleted`/`missing`）两个独立字段，界面不要互相推导。
+ *
+ * `limit` 缺省 20 / 上限 50（服务端口径），这里按同一口径夹一次；`cursor` 用上一页的 `nextCursor`。
+ */
+export function listAdminGameDistributionThemeMembers(
+  token: string,
+  themeId: string,
+  options: { limit?: number; cursor?: string | null } = {},
+  signal?: AbortSignal,
+) {
+  const requestedLimit = options.limit ?? ADMIN_THEME_MEMBER_PAGE_SIZE;
+  const normalizedLimit = Number.isFinite(requestedLimit)
+    ? Math.min(
+        Math.max(Math.trunc(requestedLimit), 1),
+        ADMIN_THEME_MEMBER_PAGE_SIZE_MAX,
+      )
+    : ADMIN_THEME_MEMBER_PAGE_SIZE;
+  const params = new URLSearchParams({ limit: String(normalizedLimit) });
+  const cursor = options.cursor?.trim();
+  if (cursor) params.set('cursor', cursor);
+  return request<GameDistributionAdminThemeMemberListResponse>(
+    `/admin/api/game-distribution/themes/${encodeURIComponent(normalizeThemeId(themeId))}/members?${params.toString()}`,
+    { token, signal },
+  );
+}
+
+function normalizeThemeId(themeId: string) {
+  const normalized = themeId.trim();
+  if (!normalized) {
+    throw new Error('缺少主题 ID');
+  }
+  return normalized;
+}
+
+function normalizeRootGameId(rootGameId: string) {
+  const normalized = rootGameId.trim();
+  if (!normalized) {
+    throw new Error('缺少根作品 ID');
+  }
+  return normalized;
+}
+
+function normalizeThemeIdempotencyKey(idempotencyKey: string) {
+  const normalized = idempotencyKey.trim();
+  if (!normalized || normalized.length > 128) {
+    throw new Error('主题写操作幂等键必须是 1 到 128 个字符');
+  }
+  return normalized;
+}
diff --git a/apps/admin-web/src/api/adminGameThemeTypes.ts b/apps/admin-web/src/api/adminGameThemeTypes.ts
new file mode 100644
index 000000000..81b4f6281
--- /dev/null
+++ b/apps/admin-web/src/api/adminGameThemeTypes.ts
@@ -0,0 +1,34 @@
+/**
+ * 后台「共创主题」接口用到的契约类型**透传**入口。
+ *
+ * 这里**不再重复定义任何载荷**：主题的后台类型已在
+ * `packages/shared/src/contracts/gameDistribution.ts` 登记（并纳入 DTO parity 的
+ * `TS_ONLY_TYPES` / `RESPONSE_BUILDERS`），后台 UI 直接用契约名，避免两份定义并存漂移。
+ *
+ * 为什么用相对路径而不是包名 `@genarrative/shared`：仓库根的
+ * `node_modules/@genarrative/shared` 软链指向**主工作树**，主题契约只在本分支上，走包名会拿到
+ * 缺这些类型的旧副本（实测 TS2724）。AGC 侧同样用这种相对引用。
+ */
+export type {
+  GameDistributionAdminTheme,
+  GameDistributionAdminThemeListResponse,
+  GameDistributionAdminThemeMemberListResponse,
+  GameDistributionAdminThemeMemberRemovalResponse,
+  GameDistributionAdminThemeMemberResponse,
+  GameDistributionAdminThemeMemberRow,
+  GameDistributionAdminThemeMemberVisibility,
+  GameDistributionAdminThemeMutationResponse,
+  GameDistributionCreateThemeRequest,
+  GameDistributionThemeStatus,
+  GameDistributionUpdateThemeRequest,
+  GameDistributionUpsertThemeMemberRequest,
+} from '../../../../packages/shared/src/contracts/gameDistribution';
+
+import type { GameDistributionThemeStatus } from '../../../../packages/shared/src/contracts/gameDistribution';
+
+/**
+ * 后台主题列表的 `status` 查询值。
+ *
+ * `all` 是**接口查询参数**的白名单取值（不过滤），不是主题状态本身，所以没有进共享契约。
+ */
+export type AdminThemeStatusFilter = GameDistributionThemeStatus | 'all';
diff --git a/apps/admin-web/src/app/AdminApp.tsx b/apps/admin-web/src/app/AdminApp.tsx
index 7e7a5fe6f..47bc29188 100644
--- a/apps/admin-web/src/app/AdminApp.tsx
+++ b/apps/admin-web/src/app/AdminApp.tsx
@@ -33,6 +33,7 @@ import { AdminErrorReportsPage } from '../pages/AdminErrorReportsPage';
 import { AdminGameDistributionReviewPage } from '../pages/AdminGameDistributionReviewPage';
 import { AdminGameManagementPage } from '../pages/AdminGameManagementPage';
 import { AdminGameReviewsPage } from '../pages/AdminGameReviewsPage';
+import { AdminGameThemesPage } from '../pages/AdminGameThemesPage';
 import { AdminGrayReleaseConfigPage } from '../pages/AdminGrayReleaseConfigPage';
 import { AdminInviteCodePage } from '../pages/AdminInviteCodePage';
 import { AdminLoginPage } from '../pages/AdminLoginPage';
@@ -360,6 +361,12 @@ export function AdminApp() {
           onUnauthorized={handleUnauthorized}
         />
       ) : null}
+      {activeRouteId === 'game-themes' ? (
+        <AdminGameThemesPage
+          token={token}
+          onUnauthorized={handleUnauthorized}
+        />
+      ) : null}
       {activeRouteId === 'editor-assets' ? (
         <AdminEditorAssetQueryPage
           token={token}
diff --git a/apps/admin-web/src/app/AdminShell.tsx b/apps/admin-web/src/app/AdminShell.tsx
index 09bf415da..d6303e815 100644
--- a/apps/admin-web/src/app/AdminShell.tsx
+++ b/apps/admin-web/src/app/AdminShell.tsx
@@ -10,6 +10,7 @@ import {
   Gamepad2,
   GitBranch,
   Images,
+  Layers,
   LayoutDashboard,
   ListChecks,
   LogOut,
@@ -64,6 +65,7 @@ const routeIcons = {
   'game-distribution': Gamepad2,
   'game-management': Swords,
   'game-reviews': Star,
+  'game-themes': Layers,
   'editor-assets': Images,
   'project-snapshots': FolderArchive,
   accounts: Users,
diff --git a/apps/admin-web/src/app/adminRoutes.ts b/apps/admin-web/src/app/adminRoutes.ts
index 39f504faf..5d8d3126a 100644
--- a/apps/admin-web/src/app/adminRoutes.ts
+++ b/apps/admin-web/src/app/adminRoutes.ts
@@ -21,6 +21,7 @@ export type AdminRouteId =
   | 'game-distribution'
   | 'game-management'
   | 'game-reviews'
+  | 'game-themes'
   | 'editor-assets'
   | 'project-snapshots'
   | 'agc-models'
@@ -68,6 +69,7 @@ export const adminRoutes: AdminRouteDefinition[] = [
   { id: 'game-distribution', label: '游戏审核', hash: '#game-distribution' },
   { id: 'game-management', label: '游戏管理', hash: '#game-management' },
   { id: 'game-reviews', label: '游戏评价', hash: '#game-reviews' },
+  { id: 'game-themes', label: '共创主题', hash: '#game-themes' },
   { id: 'editor-assets', label: '素材查询', hash: '#editor-assets' },
   { id: 'project-snapshots', label: '项目工程', hash: '#project-snapshots' },
   { id: 'accounts', label: '账号管理', hash: '#accounts', ownerOnly: true },
@@ -131,6 +133,7 @@ export const adminNavGroups: AdminNavGroupDefinition[] = [
       'game-distribution',
       'game-management',
       'game-reviews',
+      'game-themes',
       'editor-assets',
       'project-snapshots',
     ],
diff --git a/apps/admin-web/src/pages/AdminGameThemesPage.test.tsx b/apps/admin-web/src/pages/AdminGameThemesPage.test.tsx
new file mode 100644
index 000000000..b52846a10
--- /dev/null
+++ b/apps/admin-web/src/pages/AdminGameThemesPage.test.tsx
@@ -0,0 +1,468 @@
+/* @vitest-environment jsdom */
+
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from '@testing-library/react';
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+
+import {
+  createAdminGameDistributionTheme,
+  listAdminGameDistributionThemeMembers,
+  listAdminGameDistributionThemes,
+  removeAdminGameDistributionThemeMember,
+  updateAdminGameDistributionTheme,
+  upsertAdminGameDistributionThemeMember,
+} from '../api/adminApiClient';
+import type { GameDistributionAdminTheme } from '../api/adminGameThemeTypes';
+import { AdminGameThemesPage } from './AdminGameThemesPage';
+
+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 : '请求失败',
+  ),
+  listAdminGameDistributionThemes: vi.fn(),
+  createAdminGameDistributionTheme: vi.fn(),
+  updateAdminGameDistributionTheme: vi.fn(),
+  upsertAdminGameDistributionThemeMember: vi.fn(),
+  removeAdminGameDistributionThemeMember: vi.fn(),
+  listAdminGameDistributionThemeMembers: vi.fn(),
+}));
+
+const publishedTheme: GameDistributionAdminTheme = {
+  themeId: 'theme_1',
+  name: '星际防线',
+  summary: '同一母版下的二创合集',
+  badge: '热门',
+  sortOrder: 10,
+  status: 'published',
+  memberCount: 3,
+  createdAt: '2026-10-01T08:00:00Z',
+  updatedAt: '2026-10-02T08:00:00Z',
+};
+
+const draftTheme: GameDistributionAdminTheme = {
+  ...publishedTheme,
+  themeId: 'theme_2',
+  name: '草稿主题',
+  badge: '新',
+  sortOrder: 20,
+  status: 'draft',
+  memberCount: 0,
+};
+
+function mockList(themes: GameDistributionAdminTheme[] = [publishedTheme]) {
+  vi.mocked(listAdminGameDistributionThemes).mockResolvedValue({ themes });
+}
+
+function renderPage(
+  onUnauthorized: (message?: string) => void = () => undefined,
+) {
+  return render(
+    <AdminGameThemesPage token="admin-token" onUnauthorized={onUnauthorized} />,
+  );
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockList();
+  // 成员面板默认给一份空名单，个别用例再覆盖。
+  vi.mocked(listAdminGameDistributionThemeMembers).mockResolvedValue({
+    themeId: 'theme_1',
+    totalMembers: 0,
+    members: [],
+    nextCursor: null,
+  });
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+test('列表展示名称、角标、状态、排序与成员数，并按状态过滤', async () => {
+  renderPage();
+
+  const row = (await screen.findByText('星际防线')).closest('tr')!;
+  expect(within(row).getByText('热门')).toBeTruthy();
+  expect(within(row).getByText('已发布')).toBeTruthy();
+  expect(within(row).getByText('10')).toBeTruthy();
+  expect(within(row).getByText('3')).toBeTruthy();
+  expect(within(row).getByText('theme_1')).toBeTruthy();
+
+  expect(listAdminGameDistributionThemes).toHaveBeenCalledWith(
+    'admin-token',
+    { limit: 200, status: 'all' },
+    expect.anything(),
+  );
+
+  // 切到归档过滤：请求带上 status，且列表按新数据渲染。
+  mockList([{ ...draftTheme, status: 'archived', name: '归档主题' }]);
+  fireEvent.change(screen.getByLabelText('状态过滤'), {
+    target: { value: 'archived' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: /查询/ }));
+
+  await waitFor(() =>
+    expect(listAdminGameDistributionThemes).toHaveBeenLastCalledWith(
+      'admin-token',
+      { limit: 200, status: 'archived' },
+      expect.anything(),
+    ),
+  );
+  expect(await screen.findByText('归档主题')).toBeTruthy();
+});
+
+test('创建主题：先校验再写，写操作带幂等键，重放要提示', async () => {
+  vi.mocked(createAdminGameDistributionTheme).mockResolvedValue({
+    theme: publishedTheme,
+    replayed: true,
+  });
+  renderPage();
+  await screen.findByText('星际防线');
+
+  fireEvent.click(screen.getByRole('button', { name: '新建主题' }));
+  const dialog = await screen.findByRole('dialog');
+
+  // 名称为空：本地就拦下，不发请求。
+  fireEvent.click(within(dialog).getByRole('button', { name: '创建' }));
+  expect(await within(dialog).findByText('主题名不能为空')).toBeTruthy();
+  expect(createAdminGameDistributionTheme).not.toHaveBeenCalled();
+
+  fireEvent.change(within(dialog).getByLabelText('新建主题主题名'), {
+    target: { value: '星际防线二' },
+  });
+  fireEvent.change(within(dialog).getByLabelText('新建主题简介'), {
+    target: { value: '第二个主题' },
+  });
+  fireEvent.change(within(dialog).getByLabelText('新建主题角标'), {
+    target: { value: '新' },
+  });
+  fireEvent.change(within(dialog).getByLabelText('新建主题排序号'), {
+    target: { value: '5' },
+  });
+  fireEvent.click(within(dialog).getByRole('button', { name: '创建' }));
+
+  // 写操作要先过确认对话框。
+  const confirm = await screen.findByRole('dialog', { name: '确认操作' });
+  fireEvent.click(within(confirm).getByRole('button', { name: '确认' }));
+
+  await waitFor(() =>
+    expect(createAdminGameDistributionTheme).toHaveBeenCalledTimes(1),
+  );
+  const [token, idempotencyKey, payload] =
+    vi.mocked(createAdminGameDistributionTheme).mock.calls[0] ?? [];
+  expect(token).toBe('admin-token');
+  expect(payload).toEqual({
+    name: '星际防线二',
+    summary: '第二个主题',
+    badge: '新',
+    sortOrder: 5,
+    status: 'draft',
+  });
+  expect(String(idempotencyKey).length).toBeGreaterThan(8);
+  expect(String(idempotencyKey).length).toBeLessThanOrEqual(128);
+  expect(
+    await screen.findByText(/已存在（幂等重放，未重复写入）/),
+  ).toBeTruthy();
+});
+
+test('创建时同键换请求的 409 要原样解释给运营', async () => {
+  vi.mocked(createAdminGameDistributionTheme).mockRejectedValue(
+    Object.assign(new Error('Idempotency-Key 已用于不同的请求'), {
+      status: 409,
+      code: 'ADMIN_IDEMPOTENCY_CONFLICT',
+    }),
+  );
+  renderPage();
+  await screen.findByText('星际防线');
+
+  fireEvent.click(screen.getByRole('button', { name: '新建主题' }));
+  const dialog = await screen.findByRole('dialog');
+  fireEvent.change(within(dialog).getByLabelText('新建主题主题名'), {
+    target: { value: '冲突主题' },
+  });
+  fireEvent.click(within(dialog).getByRole('button', { name: '创建' }));
+  const confirm = await screen.findByRole('dialog', { name: '确认操作' });
+  fireEvent.click(within(confirm).getByRole('button', { name: '确认' }));
+
+  expect(
+    await within(dialog).findByText(/Idempotency-Key 已用于不同的请求/),
+  ).toBeTruthy();
+});
+
+test('编辑主题：整体覆盖字段，并提示归档后公开侧不可读', async () => {
+  vi.mocked(updateAdminGameDistributionTheme).mockResolvedValue({
+    theme: { ...draftTheme, status: 'archived' },
+    replayed: false,
+  });
+  renderPage();
+  const row = (await screen.findByText('星际防线')).closest('tr')!;
+  fireEvent.click(within(row).getByRole('button', { name: '编辑' }));
+
+  const dialog = await screen.findByRole('dialog');
+  expect(
+    within(dialog).getByText(/归档（archived）后公开侧不可读/),
+  ).toBeTruthy();
+
+  fireEvent.change(within(dialog).getByLabelText('编辑主题主题名'), {
+    target: { value: '星际防线（归档）' },
+  });
+  fireEvent.change(within(dialog).getByLabelText('编辑主题状态'), {
+    target: { value: 'archived' },
+  });
+  fireEvent.click(within(dialog).getByRole('button', { name: '保存' }));
+  const confirm = await screen.findByRole('dialog', { name: '确认操作' });
+  fireEvent.click(within(confirm).getByRole('button', { name: '确认' }));
+
+  await waitFor(() =>
+    expect(updateAdminGameDistributionTheme).toHaveBeenCalledTimes(1),
+  );
+  const [token, themeId, , payload] =
+    vi.mocked(updateAdminGameDistributionTheme).mock.calls[0] ?? [];
+  expect(token).toBe('admin-token');
+  expect(themeId).toBe('theme_1');
+  expect(payload).toMatchObject({
+    name: '星际防线（归档）',
+    status: 'archived',
+  });
+});
+
+test('加非根作品：把 409 翻成「只能收录根作品」的可读原因', async () => {
+  vi.mocked(upsertAdminGameDistributionThemeMember).mockRejectedValue(
+    Object.assign(new Error('not root'), {
+      status: 409,
+      code: 'THEME_MEMBER_NOT_ROOT',
+    }),
+  );
+  renderPage();
+  const row = (await screen.findByText('星际防线')).closest('tr')!;
+  fireEvent.click(within(row).getByRole('button', { name: '成员' }));
+
+  const dialog = await screen.findByRole('dialog');
+  fireEvent.change(within(dialog).getByLabelText('根作品 ID'), {
+    target: { value: 'game_child_1' },
+  });
+  fireEvent.click(within(dialog).getByRole('button', { name: '添加成员' }));
+
+  expect(
+    await within(dialog).findByText(
+      '该作品不是根作品（母版）；主题只能收录根作品',
+    ),
+  ).toBeTruthy();
+  expect(upsertAdminGameDistributionThemeMember).toHaveBeenCalledWith(
+    'admin-token',
+    'theme_1',
+    'game_child_1',
+    { sortOrder: 0 },
+  );
+});
+
+test('成员面板：草稿主题也能读到成员名单，逐条可移除', async () => {
+  mockList([draftTheme]);
+  vi.mocked(listAdminGameDistributionThemeMembers).mockResolvedValue({
+    themeId: 'theme_2',
+    totalMembers: 2,
+    members: [
+      {
+        rootGameId: 'game_root_1',
+        title: '母版作品',
+        sortOrder: 0,
+        createdAt: '2026-10-01T08:00:00Z',
+        visible: true,
+        visibility: 'published',
+      },
+      {
+        rootGameId: 'game_root_2',
+        title: null,
+        sortOrder: 5,
+        createdAt: '2026-10-01T09:00:00Z',
+        visible: false,
+        visibility: 'missing',
+      },
+    ],
+    nextCursor: null,
+  });
+  vi.mocked(removeAdminGameDistributionThemeMember).mockResolvedValue({
+    themeId: 'theme_2',
+    rootGameId: 'game_root_1',
+  });
+  renderPage();
+  const row = (await screen.findByText('草稿主题')).closest('tr')!;
+  fireEvent.click(within(row).getByRole('button', { name: '成员' }));
+
+  // 草稿主题也走后台名单接口（不套公开可见性过滤，也不再借公开投影）。
+  expect(listAdminGameDistributionThemeMembers).toHaveBeenCalledWith(
+    'admin-token',
+    'theme_2',
+    { limit: 20 },
+    expect.anything(),
+  );
+
+  const dialog = await screen.findByRole('dialog');
+  const members = await within(dialog).findByRole('list', {
+    name: '主题成员名单',
+  });
+  expect(within(members).getByText('母版作品')).toBeTruthy();
+  // 游戏行不存在时标题为 null：仍要出现在名单里，否则与 totalMembers 对不上。
+  expect(within(members).getByText('（游戏行不存在）')).toBeTruthy();
+  expect(within(members).getByText('game_root_2')).toBeTruthy();
+  expect(within(members).getByText('公开可见')).toBeTruthy();
+  expect(within(members).getByText('游戏行不存在')).toBeTruthy();
+  expect(within(dialog).getByText(/成员行总数 2；已加载 2 条/)).toBeTruthy();
+
+  // 只移除点中的那一条。
+  fireEvent.click(within(members).getAllByRole('button', { name: '移除' })[0]!);
+  await waitFor(() =>
+    expect(removeAdminGameDistributionThemeMember).toHaveBeenCalledWith(
+      'admin-token',
+      'theme_2',
+      'game_root_1',
+    ),
+  );
+  // 移除后重读第一页（不是本地删行：游标基于排序）。
+  await waitFor(() =>
+    expect(listAdminGameDistributionThemeMembers).toHaveBeenCalledTimes(2),
+  );
+});
+
+test('成员面板：区分「已公开但无公开版本」与其它不可见原因', async () => {
+  vi.mocked(listAdminGameDistributionThemeMembers).mockResolvedValue({
+    themeId: 'theme_1',
+    totalMembers: 3,
+    members: [
+      {
+        rootGameId: 'game_root_a',
+        title: '已公开无版本',
+        sortOrder: 0,
+        createdAt: '2026-10-01T08:00:00Z',
+        // 关键异常态：游戏行 published 但此刻公开投影不含它。
+        visible: false,
+        visibility: 'published',
+      },
+      {
+        rootGameId: 'game_root_b',
+        title: '已下架',
+        sortOrder: 1,
+        createdAt: '2026-10-01T08:00:00Z',
+        visible: false,
+        visibility: 'suspended',
+      },
+      {
+        rootGameId: 'game_root_c',
+        title: '已删除',
+        sortOrder: 2,
+        createdAt: '2026-10-01T08:00:00Z',
+        visible: false,
+        visibility: 'deleted',
+      },
+    ],
+    nextCursor: null,
+  });
+  renderPage();
+  const row = (await screen.findByText('星际防线')).closest('tr')!;
+  fireEvent.click(within(row).getByRole('button', { name: '成员' }));
+
+  const dialog = await screen.findByRole('dialog');
+  const members = await within(dialog).findByRole('list', {
+    name: '主题成员名单',
+  });
+  // `visible` 与 `visibility` 独立：published + 不可见必须说清是「没有公开版本」。
+  expect(within(members).getByText('已公开，但无公开版本')).toBeTruthy();
+  expect(within(members).getByText('作品已下架')).toBeTruthy();
+  expect(within(members).getByText('作品已删除')).toBeTruthy();
+});
+
+test('成员面板：成员多于首页时可按游标加载更多', async () => {
+  vi.mocked(listAdminGameDistributionThemeMembers)
+    .mockResolvedValueOnce({
+      themeId: 'theme_1',
+      totalMembers: 2,
+      members: [
+        {
+          rootGameId: 'game_root_1',
+          title: '母版一',
+          sortOrder: 0,
+          createdAt: '2026-10-01T08:00:00Z',
+          visible: true,
+          visibility: 'published',
+        },
+      ],
+      nextCursor: '0:theme_1:game_root_1',
+    })
+    .mockResolvedValueOnce({
+      themeId: 'theme_1',
+      totalMembers: 2,
+      members: [
+        {
+          rootGameId: 'game_root_2',
+          title: '母版二',
+          sortOrder: 1,
+          createdAt: '2026-10-01T09:00:00Z',
+          visible: true,
+          visibility: 'published',
+        },
+      ],
+      nextCursor: null,
+    });
+  renderPage();
+  const row = (await screen.findByText('星际防线')).closest('tr')!;
+  fireEvent.click(within(row).getByRole('button', { name: '成员' }));
+
+  const dialog = await screen.findByRole('dialog');
+  await within(dialog).findByRole('list', { name: '主题成员名单' });
+  fireEvent.click(within(dialog).getByRole('button', { name: '加载更多成员' }));
+
+  await waitFor(() =>
+    expect(listAdminGameDistributionThemeMembers).toHaveBeenLastCalledWith(
+      'admin-token',
+      'theme_1',
+      { limit: 20, cursor: '0:theme_1:game_root_1' },
+    ),
+  );
+  await waitFor(() =>
+    expect(within(dialog).getByText('game_root_2')).toBeTruthy(),
+  );
+  // 末页没有 nextCursor → 按钮消失。
+  expect(
+    within(dialog).queryByRole('button', { name: '加载更多成员' }),
+  ).toBeNull();
+});
+
+test('成员面板：读取失败时如实报错，不渲染成空名单', async () => {
+  vi.mocked(listAdminGameDistributionThemeMembers).mockRejectedValue(
+    Object.assign(new Error('游标非法'), {
+      status: 400,
+      code: 'THEME_INVALID_CURSOR',
+    }),
+  );
+  renderPage();
+  const row = (await screen.findByText('星际防线')).closest('tr')!;
+  fireEvent.click(within(row).getByRole('button', { name: '成员' }));
+
+  const dialog = await screen.findByRole('dialog');
+  expect(await within(dialog).findByText('游标非法')).toBeTruthy();
+  expect(within(dialog).queryByText(/还没有成员/)).toBeNull();
+});
+
+test('401 时交给上层处理登录失效，不把错误塞进页面', async () => {
+  const onUnauthorized = vi.fn();
+  vi.mocked(listAdminGameDistributionThemes).mockRejectedValue(
+    Object.assign(new Error('unauthorized'), { status: 401 }),
+  );
+  renderPage(onUnauthorized);
+
+  await waitFor(() =>
+    expect(onUnauthorized).toHaveBeenCalledWith('登录状态已失效'),
+  );
+});
diff --git a/apps/admin-web/src/pages/AdminGameThemesPage.tsx b/apps/admin-web/src/pages/AdminGameThemesPage.tsx
new file mode 100644
index 000000000..891e7e6d5
--- /dev/null
+++ b/apps/admin-web/src/pages/AdminGameThemesPage.tsx
@@ -0,0 +1,1031 @@
+import type { AdminStatusTone } from '@genarrative/shared/components';
+import {
+  AdminActionRow,
+  AdminAlert,
+  AdminButton,
+  AdminDialog,
+  AdminField,
+  AdminListPanel,
+  AdminPage,
+  AdminPageHeading,
+  AdminStatusPill,
+  formatAdminDateTime,
+} from '@genarrative/shared/components';
+import { RefreshCcw, Search } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+import {
+  createAdminGameDistributionTheme,
+  isAdminApiError,
+  listAdminGameDistributionThemeMembers,
+  listAdminGameDistributionThemes,
+  removeAdminGameDistributionThemeMember,
+  updateAdminGameDistributionTheme,
+  upsertAdminGameDistributionThemeMember,
+} from '../api/adminApiClient';
+import type {
+  AdminThemeStatusFilter,
+  GameDistributionAdminTheme,
+  GameDistributionAdminThemeMemberRow,
+  GameDistributionAdminThemeMemberVisibility,
+  GameDistributionThemeStatus,
+} from '../api/adminGameThemeTypes';
+import { useAdminWriteConfirm } from '../components/useAdminWriteConfirm';
+import { handlePageError } from './pageUtils';
+
+interface AdminGameThemesPageProps {
+  token: string;
+  onUnauthorized: (message?: string) => void;
+}
+
+/** 主题状态与文案：`archived` 后公开侧读不到，这一点必须在界面上说清。 */
+const THEME_STATUS_META: Record<
+  GameDistributionThemeStatus,
+  { label: string; tone: AdminStatusTone }
+> = {
+  draft: { label: '草稿', tone: 'pending' },
+  published: { label: '已发布', tone: 'ok' },
+  archived: { label: '已归档', tone: 'error' },
+};
+
+const THEME_STATUS_OPTIONS: {
+  value: GameDistributionThemeStatus;
+  label: string;
+}[] = [
+  { value: 'draft', label: '草稿（公开侧不可读）' },
+  { value: 'published', label: '已发布（公开侧可读）' },
+  { value: 'archived', label: '已归档（公开侧不可读）' },
+];
+
+const STATUS_FILTER_OPTIONS: {
+  value: AdminThemeStatusFilter;
+  label: string;
+}[] = [
+  { value: 'all', label: '全部状态' },
+  { value: 'draft', label: '草稿' },
+  { value: 'published', label: '已发布' },
+  { value: 'archived', label: '已归档' },
+];
+
+/** 与接口契约同值的文本上限（前端先拦，服务端仍会独立校验）。 */
+const THEME_NAME_MAX_CHARS = 40;
+const THEME_SUMMARY_MAX_CHARS = 200;
+const THEME_BADGE_MAX_CHARS = 16;
+/** 列表 `limit` 上界：与服务端 `MAX_ADMIN_THEME_LIST_LIMIT` 同值。 */
+const THEME_LIST_LIMIT = 200;
+/** 成员名单每页条数：与服务端缺省值同值（上限 50 由 api 客户端夹住）。 */
+const MEMBER_PAGE_SIZE = 20;
+
+interface ThemeFormDraft {
+  name: string;
+  summary: string;
+  badge: string;
+  sortOrder: string;
+  status: GameDistributionThemeStatus;
+}
+
+const EMPTY_THEME_FORM: ThemeFormDraft = {
+  name: '',
+  summary: '',
+  badge: '',
+  sortOrder: '0',
+  status: 'draft',
+};
+
+function themeStatusMeta(status: string) {
+  return (
+    THEME_STATUS_META[status as GameDistributionThemeStatus] ?? {
+      label: status || '—',
+      tone: 'pending' as AdminStatusTone,
+    }
+  );
+}
+
+function draftFromTheme(theme: GameDistributionAdminTheme): ThemeFormDraft {
+  return {
+    name: theme.name,
+    summary: theme.summary,
+    badge: theme.badge,
+    sortOrder: String(theme.sortOrder),
+    status: theme.status,
+  };
+}
+
+/**
+ * 成员行的可见性文案。
+ *
+ * `visible` 与 `visibility` 是**两个独立字段**，这里按服务端给的事实映射，不做互相推导：
+ * `visible === false` 且 `visibility === 'published'` 表示「作品已公开，但没有当前公开版本」——
+ * 这是刻意要让人看出来的异常，不能糊成一句「不可见」。
+ */
+function memberVisibilityMeta(member: GameDistributionAdminThemeMemberRow): {
+  label: string;
+  tone: AdminStatusTone;
+} {
+  if (member.visible) {
+    return { label: '公开可见', tone: 'ok' };
+  }
+  const reasons: Record<GameDistributionAdminThemeMemberVisibility, string> = {
+    published: '已公开，但无公开版本',
+    unpublished: '作品未公开',
+    suspended: '作品已下架',
+    deleted: '作品已删除',
+    missing: '游戏行不存在',
+  };
+  const reason = reasons[member.visibility] ?? '不可见';
+  return {
+    label: reason,
+    tone: member.visibility === 'published' ? 'pending' : 'error',
+  };
+}
+
+/**
+ * 主题写操作的幂等键：**按请求指纹复用**。
+ *
+ * 同一次编辑（指纹不变）重试必须复用同一个键，否则服务端会把它当成新请求；而改了内容再提交就是
+ * 另一次操作，键必须换（同键换请求服务端回 409）。键前缀只用于排障时区分是哪个页面的写入。
+ */
+function createThemeIdempotencyKey(action: string) {
+  const random =
+    typeof crypto !== 'undefined' && 'randomUUID' in crypto
+      ? crypto.randomUUID()
+      : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  return `theme-${action}-${random}`.slice(0, 128);
+}
+
+/** 表单校验：返回可读错误（与接口契约同值），空串表示通过。 */
+export function validateThemeForm(draft: ThemeFormDraft): string {
+  const name = draft.name.trim();
+  if (!name) {
+    return '主题名不能为空';
+  }
+  if (Array.from(name).length > THEME_NAME_MAX_CHARS) {
+    return `主题名最多 ${THEME_NAME_MAX_CHARS} 个字符`;
+  }
+  if (Array.from(draft.summary.trim()).length > THEME_SUMMARY_MAX_CHARS) {
+    return `主题简介最多 ${THEME_SUMMARY_MAX_CHARS} 个字符`;
+  }
+  if (Array.from(draft.badge.trim()).length > THEME_BADGE_MAX_CHARS) {
+    return `角标最多 ${THEME_BADGE_MAX_CHARS} 个字符`;
+  }
+  if (
+    !Number.isFinite(Number(draft.sortOrder)) ||
+    !Number.isInteger(Number(draft.sortOrder))
+  ) {
+    return '排序号必须是整数';
+  }
+  return '';
+}
+
+/**
+ * 主题写操作的可读错误：按**服务端稳定错误码**分支（不匹配中文文案），
+ * 其余按服务端 message 原样展示（不吞掉真实原因）。
+ */
+export function themeWriteErrorMessage(error: unknown): string {
+  if (isAdminApiError(error)) {
+    switch (error.code) {
+      case 'THEME_MEMBER_NOT_ROOT':
+        return '该作品不是根作品（母版）；主题只能收录根作品';
+      case 'THEME_MEMBER_GAME_NOT_FOUND':
+        return '没有找到这个根作品 ID，请确认后再添加';
+      case 'THEME_NOT_FOUND':
+        return '这个主题已不存在，请刷新列表';
+      case 'THEME_IDEMPOTENCY_CONFLICT':
+        return '这次提交的幂等键已经用在别的内容上，请刷新页面后重试';
+      default:
+        return error.message;
+    }
+  }
+  return error instanceof Error ? error.message : '操作失败';
+}
+
+export function AdminGameThemesPage({
+  token,
+  onUnauthorized,
+}: AdminGameThemesPageProps) {
+  const [themes, setThemes] = useState<GameDistributionAdminTheme[]>([]);
+  const [statusFilter, setStatusFilter] =
+    useState<AdminThemeStatusFilter>('all');
+  const [draftFilter, setDraftFilter] = useState<AdminThemeStatusFilter>('all');
+  const [isLoading, setIsLoading] = useState(false);
+  const [hasLoaded, setHasLoaded] = useState(false);
+  const [errorMessage, setErrorMessage] = useState('');
+  const [statusMessage, setStatusMessage] = useState('');
+  const [createOpen, setCreateOpen] = useState(false);
+  const [createDraft, setCreateDraft] =
+    useState<ThemeFormDraft>(EMPTY_THEME_FORM);
+  const [createError, setCreateError] = useState('');
+  const [editing, setEditing] = useState<GameDistributionAdminTheme | null>(
+    null,
+  );
+  const [editDraft, setEditDraft] = useState<ThemeFormDraft>(EMPTY_THEME_FORM);
+  const [editError, setEditError] = useState('');
+  const [memberTheme, setMemberTheme] =
+    useState<GameDistributionAdminTheme | null>(null);
+  const [memberRootGameId, setMemberRootGameId] = useState('');
+  const [memberSortOrder, setMemberSortOrder] = useState('0');
+  const [memberError, setMemberError] = useState('');
+  const [memberNotice, setMemberNotice] = useState('');
+  /**
+   * 成员名单（后台接口，含当前对外不可见的成员）。
+   *
+   * `memberTotal` 是成员行总数、**不受分页影响**；`memberRows` 只是已加载的这几页，
+   * 两者不要互相推导。
+   */
+  const [memberRows, setMemberRows] = useState<
+    GameDistributionAdminThemeMemberRow[]
+  >([]);
+  const [memberTotal, setMemberTotal] = useState(0);
+  const [memberNextCursor, setMemberNextCursor] = useState<string | null>(null);
+  const [memberListState, setMemberListState] = useState<
+    'idle' | 'loading' | 'ready' | 'error'
+  >('idle');
+  const [memberListError, setMemberListError] = useState('');
+  const [memberBusyId, setMemberBusyId] = useState('');
+  const [busy, setBusy] = useState(false);
+  const writeConfirm = useAdminWriteConfirm();
+  const listController = useRef<AbortController | null>(null);
+  // 幂等键按「动作 + 请求指纹」复用：草稿不变时重试同一个键，改了内容才换键。
+  const idempotencyRef = useRef<{ fingerprint: string; key: string } | null>(
+    null,
+  );
+
+  const loadThemes = useCallback(
+    async (status: AdminThemeStatusFilter) => {
+      listController.current?.abort();
+      const controller = new AbortController();
+      listController.current = controller;
+      setIsLoading(true);
+      try {
+        const response = await listAdminGameDistributionThemes(
+          token,
+          { limit: THEME_LIST_LIMIT, status },
+          controller.signal,
+        );
+        setThemes(response.themes ?? []);
+        setHasLoaded(true);
+        setErrorMessage('');
+      } catch (error) {
+        if (controller.signal.aborted) {
+          return;
+        }
+        handlePageError(error, onUnauthorized, setErrorMessage);
+      } finally {
+        if (!controller.signal.aborted) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [token, onUnauthorized],
+  );
+
+  useEffect(() => {
+    void loadThemes(statusFilter);
+    return () => {
+      listController.current?.abort();
+    };
+  }, [loadThemes, statusFilter]);
+
+  /**
+   * 成员面板打开时从**后台成员名单接口**读取首页。
+   *
+   * 这条接口不套公开可见性过滤，草稿 / 归档主题也照常可读——所以不再借公开投影（那条路对未发布
+   * 主题会 404，只能看到「可见成员」，两种口径混在一页里更让人困惑）。
+   */
+  useEffect(() => {
+    const themeId = memberTheme?.themeId;
+    if (!themeId) {
+      setMemberRows([]);
+      setMemberTotal(0);
+      setMemberNextCursor(null);
+      setMemberListState('idle');
+      setMemberListError('');
+      return;
+    }
+    const controller = new AbortController();
+    setMemberListState('loading');
+    setMemberListError('');
+    void listAdminGameDistributionThemeMembers(
+      token,
+      themeId,
+      { limit: MEMBER_PAGE_SIZE },
+      controller.signal,
+    )
+      .then((response) => {
+        setMemberRows(response.members ?? []);
+        setMemberTotal(response.totalMembers);
+        setMemberNextCursor(response.nextCursor);
+        setMemberListState('ready');
+      })
+      .catch((error: unknown) => {
+        if (controller.signal.aborted) {
+          return;
+        }
+        setMemberRows([]);
+        setMemberTotal(0);
+        setMemberNextCursor(null);
+        setMemberListState('error');
+        setMemberListError(
+          themeWriteErrorMessage(error) || '读取成员名单失败，请稍后重试',
+        );
+      });
+    return () => {
+      controller.abort();
+    };
+  }, [memberTheme?.themeId, token]);
+
+  /** 追加下一页成员（游标来自上一页的 `nextCursor`；非法游标服务端回 400，这里原样展示）。 */
+  async function loadMoreMembers() {
+    const themeId = memberTheme?.themeId;
+    const cursor = memberNextCursor;
+    if (!themeId || !cursor || memberListState === 'loading') {
+      return;
+    }
+    setMemberListState('loading');
+    setMemberListError('');
+    try {
+      const response = await listAdminGameDistributionThemeMembers(
+        token,
+        themeId,
+        {
+          limit: MEMBER_PAGE_SIZE,
+          cursor,
+        },
+      );
+      setMemberRows((current) => [...current, ...(response.members ?? [])]);
+      setMemberTotal(response.totalMembers);
+      setMemberNextCursor(response.nextCursor);
+      setMemberListState('ready');
+    } catch (error) {
+      setMemberListState('ready');
+      setMemberListError(themeWriteErrorMessage(error));
+    }
+  }
+
+  /** 成员名单重新读第一页（增删成员后调用，避免游标失效）。 */
+  async function reloadMembers(themeId: string) {
+    try {
+      const response = await listAdminGameDistributionThemeMembers(
+        token,
+        themeId,
+        {
+          limit: MEMBER_PAGE_SIZE,
+        },
+      );
+      setMemberRows(response.members ?? []);
+      setMemberTotal(response.totalMembers);
+      setMemberNextCursor(response.nextCursor);
+      setMemberListState('ready');
+    } catch (error) {
+      setMemberListState('error');
+      setMemberListError(themeWriteErrorMessage(error));
+    }
+  }
+
+  function themeFingerprint(action: string, payload: object) {
+    return `${action}-${JSON.stringify(payload)}`;
+  }
+
+  function stableThemeIdempotencyKey(action: string, payload: object) {
+    const fingerprint = themeFingerprint(action, payload);
+    if (idempotencyRef.current?.fingerprint === fingerprint) {
+      return idempotencyRef.current.key;
+    }
+    const key = createThemeIdempotencyKey(action);
+    idempotencyRef.current = { fingerprint, key };
+    return key;
+  }
+
+  async function submitCreate() {
+    const validation = validateThemeForm(createDraft);
+    if (validation) {
+      setCreateError(validation);
+      return;
+    }
+    const payload = {
+      name: createDraft.name.trim(),
+      summary: createDraft.summary.trim(),
+      badge: createDraft.badge.trim(),
+      sortOrder: Number(createDraft.sortOrder),
+      status: createDraft.status,
+    };
+    const confirmed = await writeConfirm.confirmWrite({
+      action: '创建共创主题',
+      target: payload.name,
+    });
+    if (!confirmed) {
+      return;
+    }
+    setBusy(true);
+    setCreateError('');
+    try {
+      const result = await createAdminGameDistributionTheme(
+        token,
+        stableThemeIdempotencyKey('create', payload),
+        payload,
+      );
+      setCreateOpen(false);
+      setCreateDraft(EMPTY_THEME_FORM);
+      idempotencyRef.current = null;
+      setStatusMessage(
+        result.replayed
+          ? `主题《${result.theme.name}》已存在（幂等重放，未重复写入）`
+          : `已创建主题《${result.theme.name}》`,
+      );
+      await loadThemes(statusFilter);
+    } catch (error) {
+      setCreateError(themeWriteErrorMessage(error));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function submitEdit() {
+    if (!editing) {
+      return;
+    }
+    const validation = validateThemeForm(editDraft);
+    if (validation) {
+      setEditError(validation);
+      return;
+    }
+    const payload = {
+      name: editDraft.name.trim(),
+      summary: editDraft.summary.trim(),
+      badge: editDraft.badge.trim(),
+      sortOrder: Number(editDraft.sortOrder),
+      status: editDraft.status,
+    };
+    const confirmed = await writeConfirm.confirmWrite({
+      action: '保存共创主题',
+      target: payload.name,
+    });
+    if (!confirmed) {
+      return;
+    }
+    setBusy(true);
+    setEditError('');
+    try {
+      const result = await updateAdminGameDistributionTheme(
+        token,
+        editing.themeId,
+        stableThemeIdempotencyKey('update', {
+          themeId: editing.themeId,
+          ...payload,
+        }),
+        payload,
+      );
+      setEditing(null);
+      idempotencyRef.current = null;
+      setStatusMessage(`已保存主题《${result.theme.name}》`);
+      await loadThemes(statusFilter);
+    } catch (error) {
+      setEditError(themeWriteErrorMessage(error));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function addMember() {
+    if (!memberTheme) {
+      return;
+    }
+    const rootGameId = memberRootGameId.trim();
+    if (!rootGameId) {
+      setMemberError('请填写根作品 ID');
+      return;
+    }
+    if (
+      !Number.isFinite(Number(memberSortOrder)) ||
+      !Number.isInteger(Number(memberSortOrder))
+    ) {
+      setMemberError('排序号必须是整数');
+      return;
+    }
+    setBusy(true);
+    setMemberError('');
+    setMemberNotice('');
+    try {
+      await upsertAdminGameDistributionThemeMember(
+        token,
+        memberTheme.themeId,
+        rootGameId,
+        { sortOrder: Number(memberSortOrder) },
+      );
+      setMemberRootGameId('');
+      setMemberSortOrder('0');
+      setMemberNotice(
+        `已把 ${rootGameId} 加入主题《${memberTheme.name}》（重复添加只更新排序号）`,
+      );
+      await loadThemes(statusFilter);
+      await reloadMembers(memberTheme.themeId);
+    } catch (error) {
+      setMemberError(themeWriteErrorMessage(error));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function removeMember(rootGameId: string) {
+    if (!memberTheme) {
+      return;
+    }
+    setBusy(true);
+    setMemberBusyId(rootGameId);
+    setMemberError('');
+    setMemberNotice('');
+    try {
+      await removeAdminGameDistributionThemeMember(
+        token,
+        memberTheme.themeId,
+        rootGameId,
+      );
+      setMemberNotice(`已从主题《${memberTheme.name}》移除 ${rootGameId}`);
+      await loadThemes(statusFilter);
+      // 重读第一页而不是本地删一行：游标基于排序，本地删会让后续翻页错位。
+      await reloadMembers(memberTheme.themeId);
+    } catch (error) {
+      setMemberError(themeWriteErrorMessage(error));
+    } finally {
+      setBusy(false);
+      setMemberBusyId('');
+    }
+  }
+
+  const currentTheme = memberTheme
+    ? (themes.find((theme) => theme.themeId === memberTheme.themeId) ??
+      memberTheme)
+    : null;
+
+  return (
+    <AdminPage wide>
+      <AdminPageHeading
+        title="共创主题"
+        actions={
+          <>
+            <AdminButton
+              variant="primary"
+              type="button"
+              onClick={() => {
+                setCreateDraft(EMPTY_THEME_FORM);
+                setCreateError('');
+                setCreateOpen(true);
+              }}
+            >
+              新建主题
+            </AdminButton>
+            <AdminButton
+              variant="secondary"
+              type="button"
+              onClick={() => void loadThemes(statusFilter)}
+              disabled={isLoading}
+            >
+              <RefreshCcw aria-hidden="true" />
+              刷新
+            </AdminButton>
+          </>
+        }
+      />
+
+      {errorMessage ? (
+        <AdminAlert tone="warning" role="alert">
+          {errorMessage}
+        </AdminAlert>
+      ) : null}
+      {statusMessage ? (
+        <AdminAlert tone="success">{statusMessage}</AdminAlert>
+      ) : null}
+
+      <p className="admin-muted-text">
+        主题把同一母版（根作品）下的二创作品收在一起对外展示。最多一次读取{' '}
+        {THEME_LIST_LIMIT} 条（服务端上限，超出按上限截断，没有游标）。
+      </p>
+
+      <form
+        className="admin-stack"
+        onSubmit={(event) => {
+          event.preventDefault();
+          setStatusFilter(draftFilter);
+        }}
+      >
+        <AdminActionRow>
+          <AdminField label="状态" compact>
+            <select
+              aria-label="状态过滤"
+              value={draftFilter}
+              onChange={(event) =>
+                setDraftFilter(event.target.value as AdminThemeStatusFilter)
+              }
+              disabled={isLoading}
+            >
+              {STATUS_FILTER_OPTIONS.map((option) => (
+                <option key={option.value} value={option.value}>
+                  {option.label}
+                </option>
+              ))}
+            </select>
+          </AdminField>
+          <AdminButton variant="primary" type="submit" disabled={isLoading}>
+            <Search aria-hidden="true" />
+            查询
+          </AdminButton>
+        </AdminActionRow>
+      </form>
+
+      <AdminListPanel
+        ariaLabel="共创主题列表"
+        busy={isLoading}
+        busyText="正在加载共创主题…"
+        busyVariant="line"
+        emptyText={
+          statusFilter === 'all' ? '暂无共创主题。' : '没有这个状态的主题。'
+        }
+        emptyVariant="text"
+        showEmpty={hasLoaded && themes.length === 0 && !errorMessage}
+        title="共创主题"
+        extra={
+          <span className="admin-muted-text">
+            {themes.length ? `共 ${themes.length} 条` : ''}
+          </span>
+        }
+        rows={themes}
+        size="wide"
+        tableClassName="admin-game-themes-table"
+        columns={[
+          { key: 'name', label: '名称' },
+          { key: 'badge', label: '角标' },
+          { key: 'status', label: '状态' },
+          { key: 'sortOrder', label: '排序' },
+          { key: 'memberCount', label: '成员数' },
+          { key: 'themeId', label: 'themeId' },
+          { key: 'actions', label: '操作' },
+        ]}
+        renderRow={(theme) => {
+          const status = themeStatusMeta(theme.status);
+          return (
+            <tr key={theme.themeId}>
+              <td>
+                <strong>{theme.name?.trim() || '—'}</strong>
+                {theme.summary?.trim() ? (
+                  <small className="admin-muted-text">{theme.summary}</small>
+                ) : null}
+              </td>
+              <td>{theme.badge?.trim() || '—'}</td>
+              <td>
+                <AdminStatusPill tone={status.tone}>
+                  {status.label}
+                </AdminStatusPill>
+                {theme.status === 'archived' ? (
+                  <small className="admin-muted-text">
+                    已归档：公开侧不可读
+                  </small>
+                ) : null}
+              </td>
+              <td>{theme.sortOrder}</td>
+              <td>{theme.memberCount}</td>
+              <td>
+                <code
+                  className="admin-table-cell-ellipsis"
+                  title={theme.themeId}
+                >
+                  {theme.themeId}
+                </code>
+              </td>
+              <td className="admin-game-actions-cell">
+                <AdminActionRow>
+                  <AdminButton
+                    variant="secondary"
+                    type="button"
+                    onClick={() => {
+                      setEditDraft(draftFromTheme(theme));
+                      setEditError('');
+                      setEditing(theme);
+                    }}
+                  >
+                    编辑
+                  </AdminButton>
+                  <AdminButton
+                    variant="secondary"
+                    type="button"
+                    onClick={() => {
+                      setMemberTheme(theme);
+                      setMemberRootGameId('');
+                      setMemberSortOrder('0');
+                      setMemberError('');
+                      setMemberNotice('');
+                    }}
+                  >
+                    成员
+                  </AdminButton>
+                </AdminActionRow>
+              </td>
+            </tr>
+          );
+        }}
+      />
+
+      {createOpen ? (
+        <AdminDialog
+          as="form"
+          closeLabel="关闭新建主题面板"
+          panelClassName="admin-confirm-panel"
+          title="新建共创主题"
+          description="主题按「母版（根作品）」聚合二创作品；创建后可继续加成员。"
+          titleProps={{ id: 'admin-game-theme-create-title' }}
+          onClose={() => setCreateOpen(false)}
+          onSubmit={(event) => {
+            event.preventDefault();
+            void submitCreate();
+          }}
+        >
+          <ThemeFormFields
+            draft={createDraft}
+            disabled={busy}
+            namePrefix="新建主题"
+            onChange={setCreateDraft}
+          />
+          {createError ? (
+            <AdminAlert tone="warning" role="alert">
+              {createError}
+            </AdminAlert>
+          ) : null}
+          <AdminActionRow>
+            <AdminButton variant="primary" type="submit" disabled={busy}>
+              {busy ? '提交中…' : '创建'}
+            </AdminButton>
+            <AdminButton
+              variant="secondary"
+              type="button"
+              disabled={busy}
+              onClick={() => setCreateOpen(false)}
+            >
+              取消
+            </AdminButton>
+          </AdminActionRow>
+        </AdminDialog>
+      ) : null}
+
+      {editing ? (
+        <AdminDialog
+          as="form"
+          closeLabel="关闭编辑主题面板"
+          panelClassName="admin-confirm-panel"
+          title="编辑共创主题"
+          description={<>整体覆盖主题字段（{editing.themeId}）</>}
+          titleProps={{ id: 'admin-game-theme-edit-title' }}
+          onClose={() => setEditing(null)}
+          onSubmit={(event) => {
+            event.preventDefault();
+            void submitEdit();
+          }}
+        >
+          <ThemeFormFields
+            draft={editDraft}
+            disabled={busy}
+            namePrefix="编辑主题"
+            onChange={setEditDraft}
+          />
+          {editError ? (
+            <AdminAlert tone="warning" role="alert">
+              {editError}
+            </AdminAlert>
+          ) : null}
+          <AdminActionRow>
+            <AdminButton variant="primary" type="submit" disabled={busy}>
+              {busy ? '保存中…' : '保存'}
+            </AdminButton>
+            <AdminButton
+              variant="secondary"
+              type="button"
+              disabled={busy}
+              onClick={() => setEditing(null)}
+            >
+              取消
+            </AdminButton>
+          </AdminActionRow>
+        </AdminDialog>
+      ) : null}
+
+      {currentTheme ? (
+        <AdminDialog
+          as="form"
+          closeLabel="关闭成员面板"
+          panelClassName="admin-confirm-panel"
+          title="主题成员"
+          description={
+            <>
+              《{currentTheme.name}》· 成员数 {currentTheme.memberCount}
+            </>
+          }
+          titleProps={{ id: 'admin-game-theme-members-title' }}
+          onClose={() => setMemberTheme(null)}
+          onSubmit={(event) => {
+            event.preventDefault();
+            void addMember();
+          }}
+        >
+          <AdminField label="根作品 ID">
+            <input
+              aria-label="根作品 ID"
+              placeholder="game_…（必须是母版，非根作品会被拒绝）"
+              value={memberRootGameId}
+              onChange={(event) => {
+                setMemberRootGameId(event.target.value);
+                if (memberError) setMemberError('');
+              }}
+              disabled={busy}
+            />
+          </AdminField>
+          <AdminField label="排序号（可选，越小越靠前）">
+            <input
+              aria-label="成员排序号"
+              inputMode="numeric"
+              value={memberSortOrder}
+              onChange={(event) => setMemberSortOrder(event.target.value)}
+              disabled={busy}
+            />
+          </AdminField>
+          {memberError ? (
+            <AdminAlert tone="warning" role="alert">
+              {memberError}
+            </AdminAlert>
+          ) : null}
+          {memberNotice ? (
+            <AdminAlert tone="success">{memberNotice}</AdminAlert>
+          ) : null}
+          {/*
+            成员名单来自后台接口：**不套公开可见性过滤**，草稿 / 归档主题也照常可读，且每行都带
+            `visible`（此刻公开投影是否包含它）与 `visibility`（为什么）。两者独立，界面不互相推导：
+            `published` + 不可见 = 「作品已公开、但没有公开版本」这种异常，必须能看出来。
+          */}
+          {memberListState === 'loading' && memberRows.length === 0 ? (
+            <p className="admin-muted-text">正在读取成员名单…</p>
+          ) : null}
+          {memberListError ? (
+            <AdminAlert tone="warning" role="alert">
+              {memberListError}
+            </AdminAlert>
+          ) : null}
+          {memberRows.length > 0 ? (
+            <>
+              <ul className="admin-plain-list" aria-label="主题成员名单">
+                {memberRows.map((member) => {
+                  const visibility = memberVisibilityMeta(member);
+                  return (
+                    <li key={member.rootGameId}>
+                      <span>
+                        {member.title?.trim() || '（游戏行不存在）'}{' '}
+                        <code>{member.rootGameId}</code>{' '}
+                        <small className="admin-muted-text">
+                          排序 {member.sortOrder} · 挂载于{' '}
+                          {formatAdminDateTime(member.createdAt)}
+                        </small>
+                      </span>
+                      <AdminStatusPill tone={visibility.tone}>
+                        {visibility.label}
+                      </AdminStatusPill>
+                      <AdminButton
+                        variant="secondary"
+                        type="button"
+                        disabled={busy}
+                        onClick={() => void removeMember(member.rootGameId)}
+                      >
+                        {memberBusyId === member.rootGameId
+                          ? '移除中…'
+                          : '移除'}
+                      </AdminButton>
+                    </li>
+                  );
+                })}
+              </ul>
+              <p className="admin-muted-text">
+                成员行总数 {memberTotal}；已加载 {memberRows.length} 条。
+              </p>
+              {memberNextCursor ? (
+                <AdminButton
+                  variant="secondary"
+                  type="button"
+                  disabled={busy || memberListState === 'loading'}
+                  onClick={() => void loadMoreMembers()}
+                >
+                  {memberListState === 'loading' ? '加载中…' : '加载更多成员'}
+                </AdminButton>
+              ) : null}
+            </>
+          ) : memberListState === 'ready' ? (
+            <p className="admin-muted-text">
+              这个主题还没有成员；用上面的「根作品 ID」添加。
+            </p>
+          ) : null}
+          <AdminActionRow>
+            <AdminButton variant="primary" type="submit" disabled={busy}>
+              {busy ? '提交中…' : '添加成员'}
+            </AdminButton>
+            <AdminButton
+              variant="secondary"
+              type="button"
+              disabled={busy}
+              onClick={() => setMemberTheme(null)}
+            >
+              关闭
+            </AdminButton>
+          </AdminActionRow>
+          {/*
+            服务端没有「后台读取主题成员」的接口（只有 PUT/DELETE 按根作品 ID 操作），因此这里
+            不假装给出一份成员名单：只能按 ID 移除。列表里的成员数是成员行总数。
+          */}
+          <p className="admin-muted-text">
+            目前只能按根作品 ID
+            移除成员（后台暂无成员读取接口）；成员总数见上方「成员数」。
+          </p>
+        </AdminDialog>
+      ) : null}
+
+      {writeConfirm.confirmDialog}
+    </AdminPage>
+  );
+}
+
+function ThemeFormFields({
+  draft,
+  disabled,
+  namePrefix,
+  onChange,
+}: {
+  draft: ThemeFormDraft;
+  disabled: boolean;
+  namePrefix: string;
+  onChange: (draft: ThemeFormDraft) => void;
+}) {
+  return (
+    <>
+      <AdminField label={`主题名（最多 ${THEME_NAME_MAX_CHARS} 字）`}>
+        <input
+          autoFocus
+          aria-label={`${namePrefix}主题名`}
+          maxLength={THEME_NAME_MAX_CHARS}
+          value={draft.name}
+          onChange={(event) => onChange({ ...draft, name: event.target.value })}
+          disabled={disabled}
+        />
+      </AdminField>
+      <AdminField label={`简介（最多 ${THEME_SUMMARY_MAX_CHARS} 字）`}>
+        <textarea
+          aria-label={`${namePrefix}简介`}
+          maxLength={THEME_SUMMARY_MAX_CHARS}
+          rows={3}
+          value={draft.summary}
+          onChange={(event) =>
+            onChange({ ...draft, summary: event.target.value })
+          }
+          disabled={disabled}
+        />
+      </AdminField>
+      <AdminField label={`角标（最多 ${THEME_BADGE_MAX_CHARS} 字）`}>
+        <input
+          aria-label={`${namePrefix}角标`}
+          maxLength={THEME_BADGE_MAX_CHARS}
+          value={draft.badge}
+          onChange={(event) =>
+            onChange({ ...draft, badge: event.target.value })
+          }
+          disabled={disabled}
+        />
+      </AdminField>
+      <AdminField label="排序号（越小越靠前）">
+        <input
+          aria-label={`${namePrefix}排序号`}
+          inputMode="numeric"
+          value={draft.sortOrder}
+          onChange={(event) =>
+            onChange({ ...draft, sortOrder: event.target.value })
+          }
+          disabled={disabled}
+        />
+      </AdminField>
+      <AdminField label="状态">
+        <select
+          aria-label={`${namePrefix}状态`}
+          value={draft.status}
+          onChange={(event) =>
+            onChange({
+              ...draft,
+              status: event.target.value as GameDistributionThemeStatus,
+            })
+          }
+          disabled={disabled}
+        >
+          {THEME_STATUS_OPTIONS.map((option) => (
+            <option key={option.value} value={option.value}>
+              {option.label}
+            </option>
+          ))}
+        </select>
+      </AdminField>
+      <p className="admin-muted-text">
+        归档（archived）后公开侧不可读；草稿（draft）同样不对外展示，只有「已发布」会在主题页与
+        作品详情里出现。
+      </p>
+    </>
+  );
+}
diff --git a/apps/ai-game-creator-shell/scripts/check-config.mjs b/apps/ai-game-creator-shell/scripts/check-config.mjs
index 1d13d7c28..f176e5092 100644
--- a/apps/ai-game-creator-shell/scripts/check-config.mjs
+++ b/apps/ai-game-creator-shell/scripts/check-config.mjs
@@ -135,6 +135,20 @@ const allowedUncalledTauriCommands = [
   // 资料建议三条命令已随旧的发布表单一起退役（Rust 侧实现与注册都已删除），不再登记。
   'read_game_publish_availability',
   'read_game_distribution_publication',
+  // 共创列表封面：命令名由渲染层以常量 `COVER_COMMAND` 传给**注入的** invoke
+  // （`src/features/platform-fork/platformForkCover.ts`，注入是为了让封面解析能单测），
+  // 静态扫描只认字面量调用点，因此采不到这条命令名 → 显式登记为 native-only 白名单。
+  // 同一批的 `list_platform_game_catalog` 与 `create_local_project_from_platform_game`
+  // 都是字面量调用点，不需要登记。
+  'read_public_game_cover_preview',
+  // 父作品卡（Fork 工程确认页与发布面板）：与封面同理，命令名以常量 `DETAIL_COMMAND` 传给
+  // **注入的** invoke（`src/features/platform-fork/forkParentCard.ts`），静态扫描只认字面量
+  // 调用点，因此显式登记为 native-only 白名单。
+  'read_public_game_detail',
+  // 共创取件来源读取：前端调用方随旧的发布表单一起退役（Rust 发布链路改为在 Rust 内直读
+  // `.agent/fork-source.json`，本命令留给发布面板接线后复用），命令本身仍注册在 Rust 侧，
+  // 仅不出现在 App 前端源码里。
+  'read_local_project_fork_source',
   // 账户与钱包由 Rust typed command 持有 origin/Bearer/envelope；命令名在 `accountHost.ts`
   // 里以字面量出现，静态扫描仍按共享注册表核验。
   'read_profile_recharge_center',
diff --git a/apps/ai-game-creator-shell/src-tauri/Cargo.lock b/apps/ai-game-creator-shell/src-tauri/Cargo.lock
index 8f641dfe6..412a201ac 100644
--- a/apps/ai-game-creator-shell/src-tauri/Cargo.lock
+++ b/apps/ai-game-creator-shell/src-tauri/Cargo.lock
@@ -671,7 +671,7 @@ dependencies = [
  "tracing",
  "url",
  "which",
- "windows-registry",
+ "windows-registry 0.6.1",
 ]
 
 [[package]]
@@ -820,6 +820,26 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "tiny-keccak",
+]
+
 [[package]]
 name = "const_fn"
 version = "0.4.12"
@@ -1164,6 +1184,15 @@ dependencies = [
  "syn 2.0.118",
 ]
 
+[[package]]
+name = "dlv-list"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"
+dependencies = [
+ "const-random",
+]
+
 [[package]]
 name = "dom_query"
 version = "0.27.0"
@@ -1767,6 +1796,7 @@ dependencies = [
  "jsonschema",
  "libc",
  "maud",
+ "module-game-distribution",
  "nalgebra",
  "oxc_allocator",
  "oxc_ast",
@@ -1789,8 +1819,10 @@ dependencies = [
  "tauri",
  "tauri-build",
  "tauri-plugin-clipboard-manager",
+ "tauri-plugin-deep-link",
  "tauri-plugin-dialog",
  "tauri-plugin-opener",
+ "tauri-plugin-single-instance",
  "tauri-plugin-updater",
  "tempfile",
  "tokio",
@@ -2068,6 +2100,12 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -2242,7 +2280,7 @@ dependencies = [
  "tokio",
  "tower-service",
  "tracing",
- "windows-registry",
+ "windows-registry 0.6.1",
 ]
 
 [[package]]
@@ -2890,6 +2928,17 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "module-game-distribution"
+version = "0.1.0"
+dependencies = [
+ "hex",
+ "serde",
+ "sha2",
+ "shared-kernel",
+ "zip 2.4.2",
+]
+
 [[package]]
 name = "moxcms"
 version = "0.8.1"
@@ -3420,6 +3469,16 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "ordered-multimap"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
+dependencies = [
+ "dlv-list",
+ "hashbrown 0.14.5",
+]
+
 [[package]]
 name = "ordered-stream"
 version = "0.2.0"
@@ -4488,6 +4547,16 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "rust-ini"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7"
+dependencies = [
+ "cfg-if",
+ "ordered-multimap",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.2"
@@ -5000,6 +5069,14 @@ dependencies = [
  "ts-rs 12.0.1",
 ]
 
+[[package]]
+name = "shared-kernel"
+version = "0.1.0"
+dependencies = [
+ "time",
+ "uuid",
+]
+
 [[package]]
 name = "shared_library"
 version = "0.1.9"
@@ -5535,6 +5612,27 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "tauri-plugin-deep-link"
+version = "2.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92d489b8ecceae1cd09f6e1f7606f2095ac721cc8d54cf2f0e6bb377cc52cff6"
+dependencies = [
+ "dunce",
+ "plist",
+ "rust-ini",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "tracing",
+ "url",
+ "windows-registry 0.5.3",
+ "windows-result 0.3.4",
+]
+
 [[package]]
 name = "tauri-plugin-dialog"
 version = "2.7.1"
@@ -5599,6 +5697,23 @@ dependencies = [
  "zbus",
 ]
 
+[[package]]
+name = "tauri-plugin-single-instance"
+version = "2.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db817fe9295e19b7d8357e900af31edb93703dd9fb6de524b007b47b6afc63b0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin-deep-link",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "windows-sys 0.60.2",
+ "zbus",
+]
+
 [[package]]
 name = "tauri-plugin-updater"
 version = "2.11.0"
@@ -5859,6 +5974,15 @@ dependencies = [
  "time-core",
 ]
 
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
 [[package]]
 name = "tinystr"
 version = "0.8.3"
@@ -6999,6 +7123,17 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-registry"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
+dependencies = [
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
 [[package]]
 name = "windows-registry"
 version = "0.6.1"
diff --git a/apps/ai-game-creator-shell/src-tauri/Cargo.toml b/apps/ai-game-creator-shell/src-tauri/Cargo.toml
index 5f3f50505..cc8eb3042 100644
--- a/apps/ai-game-creator-shell/src-tauri/Cargo.toml
+++ b/apps/ai-game-creator-shell/src-tauri/Cargo.toml
@@ -68,6 +68,8 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "mul
 regex = "1"
 shared-contracts = { path = "../../../server-rs/crates/shared-contracts", default-features = false, features = ["ts-bindings"] }
 tauri = { version = "2.11.2", features = [] }
+tauri-plugin-deep-link = "2.4.9"
+tauri-plugin-single-instance = { version = "2.4.2", features = ["deep-link"] }
 tauri-plugin-dialog = "2.7.1"
 tauri-plugin-opener = "2"
 tauri-plugin-updater = "2.11.0"
@@ -82,6 +84,11 @@ zip = { version = "2", default-features = false, features = ["deflate"] }
 tauri-plugin-clipboard-manager = "2.3.2"
 maud = "0.27.0"
 
+# P1-b 执行级交叉证据：客户端打包器产出的字节直接喂给服务端校验器
+# （`module-game-distribution::validate_project_bundle_zip`），替代只有文本级的一致性门禁。
+[dev-dependencies]
+module-game-distribution = { path = "../../../server-rs/crates/module-game-distribution" }
+
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
 
diff --git a/apps/ai-game-creator-shell/src-tauri/src/analytics/contract.rs b/apps/ai-game-creator-shell/src-tauri/src/analytics/contract.rs
index 2c3e38b94..2d56ff21c 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/analytics/contract.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/analytics/contract.rs
@@ -60,7 +60,9 @@ values!(CreationSource {
     HomeGame,
     HomeDesign,
     Template,
-    SelectedDirectory
+    SelectedDirectory,
+    // 从平台作品 Fork：把平台作品的工程复制成本地项目继续改造。
+    PlatformGame
 });
 values!(OpenSource {
     Create,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/analytics/contract_tests.rs b/apps/ai-game-creator-shell/src-tauri/src/analytics/contract_tests.rs
index 25eacdf5c..f5d787b4c 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/analytics/contract_tests.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/analytics/contract_tests.rs
@@ -275,3 +275,24 @@ fn frozen_context_and_origin_do_not_inherit_new_account() {
             == false
     );
 }
+
+/// 新增创建来源变体（平台作品改编）不得改变既有取值或解析：老变体照常，新变体按 snake_case
+/// 落到 `platform_game`，未知值仍然失败关闭。
+#[test]
+fn creation_source_gains_platform_game_without_breaking_existing_values() {
+    for (wire, expected) in [
+        ("home_game", CreationSource::HomeGame),
+        ("home_design", CreationSource::HomeDesign),
+        ("template", CreationSource::Template),
+        ("selected_directory", CreationSource::SelectedDirectory),
+        ("platform_game", CreationSource::PlatformGame),
+    ] {
+        assert_eq!(
+            serde_json::from_value::<CreationSource>(json!(wire)).unwrap(),
+            expected,
+            "{wire}"
+        );
+        assert_eq!(serde_json::to_value(expected).unwrap(), json!(wire));
+    }
+    assert!(serde_json::from_value::<CreationSource>(json!("remix")).is_err());
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/desktop.rs b/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
index 8cceb9bef..bf2b43f39 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/desktop.rs
@@ -16,6 +16,7 @@ use export::draft::xhs_minitool::commands::{
     save_xhs_minitool_export_form,
 };
 use game_distribution_publish::*;
+use game_fork::*;
 use plugin_host::{
     call_agc_plugin, list_agc_extensions, list_agc_plugins, read_agc_plugin_panel,
     refresh_agc_plugins, reload_agc_plugin, set_agc_plugin_enabled, set_agc_plugin_project_path,
@@ -398,6 +399,13 @@ pub(super) fn run() {
     )));
     let setup_log = Arc::clone(&startup_log);
     let app = tauri::Builder::default()
+        // 单实例必须第一个注册：Windows/Linux 的深链是「带 URL 启动第二个进程」，
+        // 单实例插件把第二个实例的 argv 转交给已有实例（`deep-link` feature 会让 deep-link
+        // 插件据此发事件），否则用户点第二次链接会再开一个窗口而不是回到已有窗口。
+        .plugin(tauri_plugin_single_instance::init(|app, _argv, _cwd| {
+            game_fork::focus_main_window_for_deep_link(app);
+        }))
+        .plugin(tauri_plugin_deep_link::init())
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_clipboard_manager::init())
@@ -535,6 +543,8 @@ pub(super) fn run() {
                     )
                 })?;
             setup_log.append("startup.runner.start.complete");
+            // Fork 深链：先取冷启动 URL，再订阅后续链接（并补一次协议注册）。
+            game_fork::initialize_fork_deep_link(app.handle());
             setup_log.append("startup.setup.complete");
             Ok(())
         })
@@ -547,6 +557,7 @@ pub(super) fn run() {
             stop_game_creator_external_mcp,
             create_automatic_local_game_project,
             create_automatic_local_game_project_from_template,
+            create_local_project_from_platform_game,
             init_local_game_project,
             fetch_game_template_library,
             get_game_template_library_access,
@@ -618,6 +629,10 @@ pub(super) fn run() {
             login_client_with_phone_code,
             logout_client_session,
             read_game_publish_availability,
+            list_platform_game_catalog,
+            read_public_game_cover_preview,
+            read_public_game_detail,
+            read_local_project_fork_source,
             read_game_distribution_publication,
             publish_local_project_game,
             read_game_creator_app_config,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs b/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs
index de9cfca44..6d0b85892 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_distribution_publish.rs
@@ -6,13 +6,15 @@
 
 use crate::game_package_upload::{
     game_package_upload_staging_dir, server_error_detail, stage_game_package_bytes,
-    upload_staged_game_package, GamePackageUploadOutcome, GamePackageUploadRequest,
-    StagedGamePackage,
+    upload_staged_version_asset, GamePackageUploadOutcome, GamePackageUploadRequest,
+    PackageUploadAsset, StagedGamePackage,
 };
 use crate::http_client::agc_main_site_client_builder;
 use crate::platform_session::{
     current_platform_session, validate_platform_session_identity, PlatformSessionSnapshot,
 };
+use base64::Engine;
+use futures::StreamExt;
 
 use reqwest::header::{HeaderName, HeaderValue, CONTENT_TYPE};
 use reqwest::{Method, StatusCode};
@@ -24,8 +26,9 @@ use shared_contracts::game_creation_app::{
     GameCreationAppManifest, GameCreationAppPublicationBinding,
 };
 use shared_contracts::game_distribution::{
-    GameDistributionDeviceSupport, GameDistributionInputMode, GameDistributionOrientation,
-    GameMetadata,
+    GameDistributionDeviceSupport, GameDistributionForkAuthorization,
+    GameDistributionForkDeclaration, GameDistributionForkSource, GameDistributionInputMode,
+    GameDistributionListResponse, GameDistributionOrientation, GameMetadata,
 };
 use std::io::Read;
 use std::path::Path;
@@ -38,6 +41,8 @@ const AGC_CLIENT_MARKER_HEADER: &str = "x-genarrative-client";
 const AGC_CLIENT_MARKER_VALUE: &str = "agc";
 const HTTP_TIMEOUT: Duration = Duration::from_secs(60);
 
+const COVER_PREVIEW_MAX_BYTES: usize = 8 * 1024 * 1024;
+
 const PACKAGE_UPLOAD_PROGRESS_EVENT: &str = "game-package-upload-progress";
 
 /// JS `Number.MAX_SAFE_INTEGER`：版本号经 JSON number 传递，超过它就会丢精度。
@@ -68,6 +73,12 @@ pub(crate) struct GameDistributionPublishResult {
     /// 本次写回的发布绑定，便于调用方不解析 manifest 也能就地更新。
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub(crate) publication: Option<GameCreationAppPublicationBinding>,
+    /// 工程源包**未**随版本上传时的用户可见原因（`None` = 未尝试或已成功）。
+    ///
+    /// 上传工程源包失败绝不阻断发布：作者的作品已经可玩可发布，只是退化为「产物级改编」。
+    /// 面板据此提示「未上传工程源码，本作品只能被产物级改编」。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub(crate) project_bundle_warning: Option<String>,
 }
 
 /// 回读版本冻结资料时带回的封面/截图草稿条目。
@@ -188,6 +199,11 @@ struct PublishVersionMetadata<'a> {
     package_file_count: u32,
     package_entry_path: &'a str,
     game_metadata: &'a GameMetadata,
+    /// 二创「本次核心改动说明」：面板采集后原样透传；必填与长度规则只在服务端
+    /// （`game_distribution_change_summary_violation`），这里不预校验，避免两套判据漂移。
+    /// trim 后为空按「未填写」处理，与契约的 `skip_serializing_if` 语义一致。
+    #[serde(skip_serializing_if = "Option::is_none")]
+    change_summary: Option<String>,
 }
 
 /// 统一发布响应：一次拿到游戏身份（含 `publicationRevision`）与冻结版本。
@@ -272,7 +288,10 @@ struct SubmittedVersionSummary {
     status: Option<String>,
 }
 
-fn require_platform_session() -> Result<PlatformSessionSnapshot, String> {
+/// 取当前平台会话；缺失时给出可操作的登录提示。
+///
+/// `pub(crate)`：Fork 取件（`game_fork`）在建项前要冻结同一份会话身份。
+pub(crate) fn require_platform_session() -> Result<PlatformSessionSnapshot, String> {
     current_platform_session()
         .ok_or_else(|| "authentication-required: 陶泥儿登录态缺失，请重新登录后重试".to_string())
 }
@@ -584,6 +603,227 @@ fn parse_owner_game_entry(value: Value) -> Result<OwnerGameEntry, String> {
     serde_json::from_value(value).map_err(|error| format!("作者作品响应无效：{error}"))
 }
 
+/// 取件整包上限：与模板整包同一档（512 MiB），也远低于服务端进程内缓存上限的 4 倍余量。
+const FORK_SOURCE_PACKAGE_MAX_BYTES: u64 = 512 * 1024 * 1024;
+
+/// 取件失败的用户可见分类：404 / 409 / 403 / 401 四态必须可区分。
+///
+/// 状态码本身就是服务端合同（`fork_source_target`）：行不存在 → 404；不可用作来源
+/// （未公开 / 已软删除 / 没有当前公开版本 / 缺版本元数据）→ 409；授权禁止或未知 → 403；
+/// 未登录 → 401。因此这里按状态映射，不依赖 `error.code`。
+///
+/// 四个分类各自带稳定前缀（`authentication-required:` / `permission-denied:` /
+/// `fork-source-not-found:` / `fork-source-not-available:`）：渲染层按前缀区分「需要登录 /
+/// 未开放授权 / 作品不存在 / 作品不可用」并按需要去掉前缀展示，不做子串猜测。
+fn map_fork_source_http_error(status: StatusCode, body: &str) -> String {
+    crate::platform_maintenance::watch_platform_response(status.as_u16(), body);
+    let (code, message) = parse_error_payload(body);
+    match status {
+        StatusCode::UNAUTHORIZED => {
+            "authentication-required: 陶泥儿登录态已过期，请重新登录后重试".to_string()
+        }
+        StatusCode::FORBIDDEN => {
+            "permission-denied: 作者没有开放这个作品的共创授权，无法开始共创".to_string()
+        }
+        StatusCode::NOT_FOUND => {
+            "fork-source-not-found: 该作品不存在或已被删除，无法开始共创".to_string()
+        }
+        StatusCode::CONFLICT => {
+            "fork-source-not-available: 该作品当前不能开始共创（未公开、已下架或没有公开版本）"
+                .to_string()
+        }
+        _ => format!(
+            "读取共创信息失败：{}",
+            server_error_detail(code, message, || format!("HTTP {}", status.as_u16()))
+        ),
+    }
+}
+
+/// 取件下载路径 → 路径段：只接受同源相对路径，拒绝绝对 URL、盘符、反斜杠与查询/片段。
+fn fork_source_download_segments(download_path: &str) -> Result<Vec<String>, String> {
+    let trimmed = download_path.trim();
+    if !trimmed.starts_with('/') || trimmed.starts_with("//") {
+        return Err("共创内容下载路径无效".to_string());
+    }
+    if trimmed.contains(['\\', '?', '#']) || trimmed.contains("://") {
+        return Err("共创内容下载路径无效".to_string());
+    }
+    let segments = trimmed
+        .split('/')
+        .filter(|segment| !segment.is_empty())
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    if segments.is_empty()
+        || segments
+            .iter()
+            .any(|segment| segment == "." || segment == ".." || segment.contains(':'))
+    {
+        return Err("共创内容下载路径无效".to_string());
+    }
+    Ok(segments)
+}
+
+/// 取件元数据（`GET …/fork-source`）：受鉴权但不叠加发布灰度。
+async fn request_fork_source_metadata(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    game_id: &str,
+) -> Result<Value, String> {
+    let current = current_scoped_session(snapshot)?;
+    let url = endpoint(
+        snapshot,
+        &["api", "game-distribution", "games", game_id, "fork-source"],
+    )?;
+    let response = client
+        .request(Method::GET, &url)
+        .bearer_auth(&current.access_token)
+        .header(
+            HeaderName::from_static(AGC_CLIENT_MARKER_HEADER),
+            HeaderValue::from_static(AGC_CLIENT_MARKER_VALUE),
+        )
+        .header(
+            HeaderName::from_static(API_RESPONSE_ENVELOPE_HEADER),
+            HeaderValue::from_static(API_RESPONSE_ENVELOPE_VERSION),
+        )
+        .timeout(HTTP_TIMEOUT)
+        .send()
+        .await
+        .map_err(|error| {
+            if error.is_timeout() {
+                "读取共创信息失败：请求超时，请稍后重试".to_string()
+            } else {
+                "读取共创信息失败：无法连接登录服务，请确认配套后端或 API 代理已启动后重试"
+                    .to_string()
+            }
+        })?;
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .map_err(|error| format!("读取共创信息失败：读取响应失败：{error}"))?;
+    validate_session(snapshot)?;
+    if !status.is_success() {
+        return Err(map_fork_source_http_error(status, &text));
+    }
+    response_data(&text).map_err(|error| format!("读取共创信息失败：{error}"))
+}
+
+/// 取件本体（`GET {downloadPath}`）：整包进内存，超过契约上限即失败关闭。
+///
+/// **必须带 Bearer**：取件包与发行网关同源受保护，模板库那条 `fetch_limited_bytes` 的签名
+/// 写死 `client.get(url)`、带不了鉴权头，绝不能复用它来取受保护内容（会静默变成匿名下载）。
+async fn request_fork_source_package(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    segments: &[String],
+    max_bytes: u64,
+) -> Result<Vec<u8>, String> {
+    let current = current_scoped_session(snapshot)?;
+    let segment_refs = segments.iter().map(String::as_str).collect::<Vec<_>>();
+    let url = endpoint(snapshot, &segment_refs)?;
+    let response = client
+        .request(Method::GET, &url)
+        .bearer_auth(&current.access_token)
+        .header(
+            HeaderName::from_static(AGC_CLIENT_MARKER_HEADER),
+            HeaderValue::from_static(AGC_CLIENT_MARKER_VALUE),
+        )
+        .header(
+            HeaderName::from_static(API_RESPONSE_ENVELOPE_HEADER),
+            HeaderValue::from_static(API_RESPONSE_ENVELOPE_VERSION),
+        )
+        .timeout(HTTP_TIMEOUT)
+        .send()
+        .await
+        .map_err(|error| {
+            if error.is_timeout() {
+                "下载共创内容失败：请求超时，请稍后重试".to_string()
+            } else {
+                "下载共创内容失败：无法连接登录服务，请确认配套后端或 API 代理已启动后重试"
+                    .to_string()
+            }
+        })?;
+    let status = response.status();
+    if !status.is_success() {
+        let text = response.text().await.unwrap_or_default();
+        validate_session(snapshot)?;
+        return Err(map_fork_source_http_error(status, &text));
+    }
+    if response
+        .content_length()
+        .is_some_and(|length| length > max_bytes)
+    {
+        return Err("共创内容超过客户端下载上限，无法完成".to_string());
+    }
+    let mut body = Vec::new();
+    let mut stream = response.bytes_stream();
+    while let Some(chunk) = stream.next().await {
+        let chunk = chunk.map_err(|error| format!("下载共创内容失败：读取响应失败：{error}"))?;
+        if body.len() as u64 + chunk.len() as u64 > max_bytes {
+            return Err("共创内容超过客户端下载上限，无法完成".to_string());
+        }
+        body.extend_from_slice(&chunk);
+    }
+    validate_session(snapshot)?;
+    Ok(body)
+}
+
+/// 公开目录每页条数：与服务端口径一致（缺省 20 / 上限 50）。
+pub(crate) fn clamped_catalog_limit(limit: Option<u32>) -> u32 {
+    const DEFAULT: u32 = 20;
+    const MAX: u32 = 50;
+    match limit {
+        Some(0) | None => DEFAULT,
+        Some(value) => value.min(MAX),
+    }
+}
+
+/// 作品 ID 的路径安全判据：只接受 ASCII 字母数字与 `-`/`_`。
+///
+/// 取件请求把作品 ID 当路径段拼进 URL，深链解析也用它校验链接里的取值——两处同一口径。
+pub(crate) fn is_safe_fork_game_id(value: &str) -> bool {
+    !value.is_empty()
+        && value.chars().all(|character| {
+            character.is_ascii_alphanumeric() || character == '-' || character == '_'
+        })
+}
+
+/// 取件：读 Fork 来源元数据，再按 `bytes` 上限下载整包字节。
+///
+/// 摘要与字节数**不在这里**校验：调用方（`game_fork`）必须在任何落盘之前用
+/// `verify_fork_source_bytes` 校验，保证失败关闭发生在解压之前。
+pub(crate) async fn fetch_platform_game_fork_source(
+    game_id: &str,
+) -> Result<(GameDistributionForkSource, Vec<u8>), String> {
+    let game_id = game_id.trim();
+    // 路径安全判据与发行入口一致：只接受 ASCII 字母数字与 `-`/`_`，不接受分隔符与盘符。
+    if !is_safe_fork_game_id(game_id) {
+        return Err("共创来源作品 ID 无效".to_string());
+    }
+    let snapshot = require_platform_session()?;
+    let client = build_client()?;
+    let value = request_fork_source_metadata(&client, &snapshot, game_id).await?;
+    let source: GameDistributionForkSource = serde_json::from_value(
+        value
+            .get("forkSource")
+            .cloned()
+            .ok_or_else(|| "共创信息响应缺少来源信息，请稍后重试".to_string())?,
+    )
+    .map_err(|error| format!("共创信息响应无效：{error}"))?;
+    if source.game_id.trim().is_empty() || source.version_id.trim().is_empty() {
+        return Err("共创信息响应无效：缺少作品或版本标识".to_string());
+    }
+    if source.bytes == 0 || source.bytes > FORK_SOURCE_PACKAGE_MAX_BYTES {
+        return Err(format!(
+            "共创内容大小异常（{} 字节），客户端无法下载",
+            source.bytes
+        ));
+    }
+    let segments = fork_source_download_segments(&source.download_path)?;
+    let bytes = request_fork_source_package(&client, &snapshot, &segments, source.bytes).await?;
+    Ok((source, bytes))
+}
+
 fn first_publish_state(message: Option<String>) -> GameDistributionPublicationReadResult {
     GameDistributionPublicationReadResult {
         state: "first-publish".to_string(),
@@ -1006,6 +1246,155 @@ pub(crate) async fn read_game_publish_availability() -> Result<bool, String> {
         .unwrap_or(false))
 }
 
+/// 匿名读平台公开 JSON：目录与详情共用同一段（**不带 Bearer**、带客户端标识与 envelope 头）。
+///
+/// 带上 Bearer 会把「匿名可读」变成依赖登录态，因此这里刻意不加；非 2xx 折成可读错误。
+async fn get_public_platform_json(
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    url: &str,
+    failure_label: &str,
+) -> Result<Value, String> {
+    let response = client
+        .request(Method::GET, url)
+        .header(
+            HeaderName::from_static(AGC_CLIENT_MARKER_HEADER),
+            HeaderValue::from_static(AGC_CLIENT_MARKER_VALUE),
+        )
+        .header(
+            HeaderName::from_static(API_RESPONSE_ENVELOPE_HEADER),
+            HeaderValue::from_static(API_RESPONSE_ENVELOPE_VERSION),
+        )
+        .timeout(HTTP_TIMEOUT)
+        .send()
+        .await
+        .map_err(|error| {
+            if error.is_timeout() {
+                format!("{failure_label}：请求超时，请稍后重试")
+            } else {
+                format!("{failure_label}：无法连接登录服务，请确认配套后端或 API 代理已启动后重试")
+            }
+        })?;
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .map_err(|error| format!("{failure_label}：读取响应失败：{error}"))?;
+    if !status.is_success() {
+        let (code, message) = parse_error_payload(&text);
+        return Err(format!(
+            "{failure_label}：{}",
+            server_error_detail(code, message, || format!("HTTP {}", status.as_u16()))
+        ));
+    }
+    response_data(&text).map_err(|error| format!("{failure_label}：{error}"))
+}
+
+/// 单个公开作品详情（匿名单读）：父作品确认页要的标题 / 作者 / 授权类型 / 封面对象键都在这里。
+///
+/// 复用平台**既有**的公开详情接口（不新增平台接口），同样不带 Bearer。响应体是公开投影，由
+/// 服务端逐字段手拼 JSON，因此这里原样透传 `Value`，类型在渲染层按共享契约的
+/// `GameDistributionGame` 收口（Rust 侧不重复定义一份）。
+#[tauri::command]
+pub(crate) async fn read_public_game_detail(game_id: String) -> Result<Value, String> {
+    let game_id = game_id.trim();
+    if !is_safe_fork_game_id(game_id) {
+        return Err("作品标识无效".to_string());
+    }
+    let snapshot = require_platform_session()?;
+    let client = build_client()?;
+    let url = endpoint(&snapshot, &["api", "game-distribution", "games", game_id])?;
+    let value = get_public_platform_json(&client, &snapshot, &url, "读取作品详情失败").await?;
+    Ok(value)
+}
+
+/// 平台公开作品目录（`GET /api/game-distribution/games?limit=&cursor=`）。
+///
+/// 这条接口**匿名可读**，因此不叠加发布灰度、按公开投影返回；这里仍取平台会话只为拿 base URL
+/// （启动器本身在登录后才渲染，所以正常路径一定有会话），**不带 Bearer**——带上反而会把
+/// 「匿名可读」变成依赖登录态。
+///
+/// 分页与服务端同口径（缺省 20 / 上限 50），游标原样透传（服务端校验非法游标并回 400）。
+/// 「共创」页拿它当数据源，在该页做「只保留 `forkAuthorization !== 'forbidden'`」的过滤。
+#[tauri::command]
+pub(crate) async fn list_platform_game_catalog(
+    limit: Option<u32>,
+    cursor: Option<String>,
+) -> Result<GameDistributionListResponse, String> {
+    let snapshot = require_platform_session()?;
+    let client = build_client()?;
+    let limit = clamped_catalog_limit(limit);
+    let cursor = cursor
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty());
+    // 用 `url` 拼查询串：游标形如 `"{ts}:{id}"`，必须按 query 规则编码而不是手拼。
+    let mut url = url::Url::parse(&endpoint(
+        &snapshot,
+        &["api", "game-distribution", "games"],
+    )?)
+    .map_err(|error| format!("拼装共创目录请求失败：{error}"))?;
+    {
+        let mut query = url.query_pairs_mut();
+        query.append_pair("limit", &limit.to_string());
+        if let Some(cursor) = cursor.as_deref() {
+            query.append_pair("cursor", cursor);
+        }
+    }
+    let value =
+        get_public_platform_json(&client, &snapshot, url.as_str(), "读取共创目录失败").await?;
+    serde_json::from_value(value).map_err(|error| format!("共创目录响应无效：{error}"))
+}
+
+/// 公开作品封面预览：把公开目录里的 `coverObjectKey` 换成**有界 data URL**。
+///
+/// 为什么不让渲染层直接拿签名地址去 `<img src>`：AGC 既有约定是「渲染层不自行拼 read-url、
+/// 不接触对象键与 bearer token、也不让 WebView 直连签名地址」（见 `commands.rs` 里同一口径的注释）。
+/// 因此这里走与发布面板封面同一套链路：`read-url` 换签 + 有界下载 + data URL。
+///
+/// 失败与「没有封面」都由调用方按同一个分支处理（回落到首字占位），所以这里把失败如实返回成
+/// `Err`，不吞成空串。
+#[tauri::command]
+pub(crate) async fn read_public_game_cover_preview(object_key: String) -> Result<String, String> {
+    let object_key = object_key.trim().to_string();
+    if object_key.is_empty() || object_key.len() > 512 || object_key.contains("..") {
+        return Err("封面对象键无效".to_string());
+    }
+    let snapshot = require_platform_session()?;
+    current_scoped_session(&snapshot)?;
+    let client = build_client()?;
+    let source = json!({ "objectKey": object_key });
+    let download = crate::assets::resolve_canvas_resource_download_with_limit_route_and_fence(
+        &client,
+        snapshot.api_base_url.as_str(),
+        snapshot.access_token.as_str(),
+        &source,
+        COVER_PREVIEW_MAX_BYTES,
+        "/api/assets/read-url",
+        || Ok(()),
+    )
+    .await?
+    .ok_or_else(|| "封面内容为空".to_string())?;
+    current_scoped_session(&snapshot)?;
+    cover_preview_data_url(&download.media_type, &download.bytes)
+}
+
+fn cover_preview_data_url(media_type: &str, bytes: &[u8]) -> Result<String, String> {
+    let media_type = media_type
+        .split(';')
+        .next()
+        .unwrap_or(media_type)
+        .trim()
+        .to_ascii_lowercase();
+    if !media_type.starts_with("image/") {
+        return Err("游戏封面预览不是受支持的图片类型".to_string());
+    }
+    if bytes.is_empty() || bytes.len() > COVER_PREVIEW_MAX_BYTES {
+        return Err("游戏封面预览超过安全大小限制".to_string());
+    }
+    let encoded = base64::engine::general_purpose::STANDARD.encode(bytes);
+    Ok(format!("data:{media_type};base64,{encoded}"))
+}
+
 /// 发布面板打开时的绑定恢复。
 ///
 /// 只有「本地绑定（且属于当前账号/origin）+ 线上作品」或「无本地绑定时按作者 + projectKey
@@ -1390,6 +1779,89 @@ fn emit_publish_progress(
     }
 }
 
+/// 把工程源包（当前项目源码）打成包并随版本上传。
+///
+/// 调用点在发布流程送审之前——服务端只允许 `awaiting_upload` / `upload_failed` 档位补传工程包，
+/// 送审后就是 409。失败只向上抛一句原因，由调用方转成面板提示，**不阻断发布**。
+#[allow(clippy::too_many_arguments)]
+async fn upload_project_bundle_for_version(
+    app: &AppHandle,
+    client: &reqwest::Client,
+    snapshot: &PlatformSessionSnapshot,
+    session_identity: &crate::platform_session::PlatformSessionIdentity,
+    app_data_dir: &Path,
+    project_root: &Path,
+    version_id: &str,
+    root_key: &str,
+) -> Result<(), String> {
+    let bundle = crate::project_bundle::build_project_bundle(
+        project_root,
+        crate::project_bundle::ProjectBundleScope::WholeProject,
+    )?;
+    // 与发行包同一套内容寻址暂存：同一份源码重传复用同一文件，续传才有意义。
+    let staged = stage_game_package_bytes(
+        &game_package_upload_staging_dir(app_data_dir),
+        &bundle.sha256,
+        &bundle.bytes,
+    )?;
+    let message = "正在上传工程源包（供他人源码级改编）…";
+    emit_publish_progress(
+        app,
+        root_key,
+        version_id,
+        "upload",
+        message,
+        0,
+        staged.package_size_bytes,
+    );
+    let emit_handle = app.clone();
+    let progress_publish_id = root_key.to_string();
+    let progress_version_id = version_id.to_string();
+    let verify_handle = app.clone();
+    let verify_publish_id = root_key.to_string();
+    let verify_version_id = version_id.to_string();
+    upload_staged_version_asset(
+        client,
+        GamePackageUploadRequest {
+            asset: PackageUploadAsset::ProjectBundle,
+            staging_path: Path::new(&staged.staging_path),
+            version_id,
+            api_base_url: &snapshot.api_base_url,
+            access_token: &snapshot.access_token,
+            idempotency_key: &format!("{root_key}:project-bundle"),
+            session_identity: Some(session_identity),
+        },
+        move |received_bytes, total_bytes| {
+            emit_publish_progress(
+                &emit_handle,
+                &progress_publish_id,
+                &progress_version_id,
+                "upload",
+                message,
+                received_bytes,
+                total_bytes,
+            );
+        },
+        move || {
+            emit_publish_progress(
+                &verify_handle,
+                &verify_publish_id,
+                &verify_version_id,
+                "verify",
+                "正在校验工程源包…",
+                0,
+                0,
+            );
+        },
+    )
+    .await?;
+    Ok(())
+}
+
+/// 发布：建游戏（首次）→ 建版本 → 上传发行包 → 〔授权非禁止时〕上传工程源包 → 送审。
+///
+/// `include_project_bundle`：是否随版本上传工程源包（面板勾选）。`None`/`true` = 授权非禁止时
+/// 默认上传；`false` = 作者取消（源码不外发，作品退化为产物级改编）。
 #[tauri::command]
 pub(crate) async fn publish_local_project_game(
     app: AppHandle,
@@ -1405,8 +1877,12 @@ pub(crate) async fn publish_local_project_game(
     version_number: Option<u64>,
     expected_publication_revision: Option<u64>,
     idempotency_key: Option<String>,
+    include_project_bundle: Option<bool>,
     // 买断价（整数泥点，`0` 表示免费）。旧前端不传时为 `None`，按免费提交，保持向后兼容。
     price_mud_points: Option<u64>,
+    // 衍生作品的「本次核心改动说明」（母版可空）：面板采集后原样透传；必填与长度规则只在服务端
+    // （`game_distribution_change_summary_violation`），这里不预校验，避免两套判据漂移。
+    change_summary: Option<String>,
 ) -> Result<GameDistributionPublishResult, String> {
     let snapshot = require_platform_session()?;
     let app_data_dir = app
@@ -1448,12 +1924,34 @@ pub(crate) async fn publish_local_project_game(
     if target_game_id.is_some() && expected_publication_revision.is_none() {
         return Err("缺少公开修订号，请重新打开发布面板后再试".to_string());
     }
+    // 改编声明只来自项目内真实取过件的来源记录（`.agent/fork-source.json`，由「从平台作品开始
+    // 创作」写入），渲染层传不进也伪造不了。声明只在**首次发布**并入：服务端对「复用既有作品
+    // 身份时再声明来源」失败关闭（`resolve_game_distribution_fork_declaration_tx`），更新发布
+    // （带 gameId）重复带声明会变成不可恢复的 409。判据就是目标 gameId 是否属于更新发布。
+    let mut metadata = metadata;
+    if target_game_id.is_none() {
+        if let Some(source) =
+            crate::project::read_project_fork_source(Path::new(project_path.trim()))
+        {
+            metadata.fork = Some(GameDistributionForkDeclaration {
+                parent_game_id: source.game_id,
+                parent_version_id: source.version_id,
+            });
+        }
+    }
     // 买断价只允许 `0..=上限`；面板已按同一口径拦住非法输入，这里对命令边界再收一次口。
     let price_mud_points = price_mud_points.unwrap_or(0);
     if price_mud_points > MAX_GAME_PRICE_MUD_POINTS {
         return Err(format!("买断价不能超过 {MAX_GAME_PRICE_MUD_POINTS} 泥点"));
     }
     let digest = metadata_digest(&metadata, price_mud_points, &media)?;
+    // 工程源包要不要一起传，只取决于**授权档位**与面板勾选，与后面把 metadata 交给
+    // 创建版本请求无关：这里先算出来，避免 metadata 被 move 之后再用它。
+    let fork_authorized = !matches!(
+        metadata.fork_authorization,
+        GameDistributionForkAuthorization::Forbidden
+    );
+    let include_project_bundle = fork_authorized && include_project_bundle.unwrap_or(true);
     // 根幂等键由账本按「账号 + origin + 本地项目 + 包摘要 + 目标游戏/版本 + 资料摘要」解析：
     // 同一份包重发、响应丢失后重试、进程重启后的分片续传都落在同一次服务端尝试上；
     // 包内容、目标版本标签或资料任一变化都换键，新标签的提交不会被幂等收据吞掉。
@@ -1507,6 +2005,9 @@ pub(crate) async fn publish_local_project_game(
         package_file_count: staged.package_file_count,
         package_entry_path: "index.html",
         game_metadata: &metadata,
+        change_summary: change_summary
+            .map(|value| value.trim().to_string())
+            .filter(|value| !value.is_empty()),
     };
     let publish_value = request_multipart(
         &client,
@@ -1550,9 +2051,10 @@ pub(crate) async fn publish_local_project_game(
     );
     let upload_publish_id = root_key.clone();
     let verify_publish_id = root_key.clone();
-    let uploaded: GamePackageUploadOutcome = upload_staged_game_package(
+    let uploaded: GamePackageUploadOutcome = upload_staged_version_asset(
         &client,
         GamePackageUploadRequest {
+            asset: PackageUploadAsset::ReleasePackage,
             staging_path: Path::new(&staged.staging_path),
             version_id: &version.version_id,
             api_base_url: &snapshot.api_base_url,
@@ -1585,6 +2087,26 @@ pub(crate) async fn publish_local_project_game(
     )
     .await?;
     validate_session(&snapshot)?;
+    // 工程源包（M2b）：授权非「禁止共创」且作者没取消时，随这次版本一起传上去。发布流程在这里
+    // 还不是终态（下面才送审），正是服务端允许传工程包的阶段（`awaiting_upload` / `upload_failed`）；
+    // 传失败**不阻断发布**，只把原因交给面板提示「只能被产物级改编」。
+    let project_bundle_warning = if include_project_bundle {
+        upload_project_bundle_for_version(
+            &app,
+            &client,
+            &snapshot,
+            &session_identity,
+            &app_data_dir,
+            root,
+            version.version_id.as_str(),
+            root_key.as_str(),
+        )
+        .await
+        .err()
+        .map(|error| format!("未上传工程源码，他人开始共创时只能拿到平台已发布的成品：{error}"))
+    } else {
+        None
+    };
     emit_publish_progress(
         &app,
         &root_key,
@@ -1665,6 +2187,7 @@ pub(crate) async fn publish_local_project_game(
         screenshot_object_keys,
         manifest: Some(manifest),
         publication: Some(binding),
+        project_bundle_warning,
     })
 }
 
@@ -1804,6 +2327,11 @@ mod tests {
             input_modes: vec![],
             orientation:
                 shared_contracts::game_distribution::GameDistributionOrientation::Responsive,
+            // 上架时的共创授权档位；AGC 发布面板接线前先按缺省值构造（与不传该字段等价）。
+            fork_authorization:
+                shared_contracts::game_distribution::GameDistributionForkAuthorization::Forbidden,
+            // 改编来源声明：只在从平台作品改编时由发布链路并入，这里构造基线资料时为空。
+            fork: None,
         };
         let media = PublishMedia::default();
         let first = metadata_digest(&metadata, 0, &media).expect("digest");
@@ -1859,6 +2387,117 @@ mod tests {
             metadata_digest(&metadata, 0, &split_a).expect("split a"),
             metadata_digest(&metadata, 0, &split_b).expect("split b")
         );
+
+        // 改编声明也参与幂等摘要：同内容稳定，并入声明即变（这是预期行为，不是漂移）。
+        metadata.title = "游戏".to_string();
+        assert_eq!(
+            metadata_digest(&metadata, 0, &media).expect("restored"),
+            first
+        );
+        metadata.fork = Some(
+            shared_contracts::game_distribution::GameDistributionForkDeclaration {
+                parent_game_id: "game_parent".to_string(),
+                parent_version_id: "gamever_parent".to_string(),
+            },
+        );
+        let with_fork = metadata_digest(&metadata, 0, &media).expect("digest with fork");
+        assert_ne!(with_fork, first);
+        assert_eq!(
+            metadata_digest(&metadata, 0, &media).expect("stable with fork"),
+            with_fork
+        );
+    }
+
+    #[test]
+    fn catalog_limit_clamps_to_server_range() {
+        // 缺省 20 / 上限 50，与服务端公开目录同口径；0 视作缺省（服务端同义）。
+        assert_eq!(clamped_catalog_limit(None), 20);
+        assert_eq!(clamped_catalog_limit(Some(0)), 20);
+        assert_eq!(clamped_catalog_limit(Some(7)), 7);
+        assert_eq!(clamped_catalog_limit(Some(50)), 50);
+        assert_eq!(clamped_catalog_limit(Some(500)), 50);
+    }
+
+    #[test]
+    fn fork_source_errors_keep_contract_statuses_distinguishable() {
+        assert_eq!(
+            map_fork_source_http_error(StatusCode::UNAUTHORIZED, "{}"),
+            "authentication-required: 陶泥儿登录态已过期，请重新登录后重试"
+        );
+        assert_eq!(
+            map_fork_source_http_error(
+                StatusCode::FORBIDDEN,
+                r#"{"error":{"code":"FORK_NOT_AUTHORIZED","message":"未开放共创"}}"#
+            ),
+            "permission-denied: 作者没有开放这个作品的共创授权，无法开始共创"
+        );
+        assert_eq!(
+            map_fork_source_http_error(
+                StatusCode::NOT_FOUND,
+                r#"{"error":{"code":"FORK_SOURCE_NOT_FOUND"}}"#
+            ),
+            "fork-source-not-found: 该作品不存在或已被删除，无法开始共创"
+        );
+        assert_eq!(
+            map_fork_source_http_error(
+                StatusCode::CONFLICT,
+                r#"{"error":{"code":"FORK_SOURCE_NOT_AVAILABLE"}}"#
+            ),
+            "fork-source-not-available: 该作品当前不能开始共创（未公开、已下架或没有公开版本）"
+        );
+        // 其它失败保留原始 detail，便于排障，但仍是可读文案而不是裸 HTTP 码。
+        assert_eq!(
+            map_fork_source_http_error(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                r#"{"error":{"code":"INTERNAL","message":"服务异常"}}"#
+            ),
+            "读取共创信息失败：服务异常"
+        );
+    }
+
+    #[test]
+    fn fork_source_download_path_accepts_only_same_origin_relative_paths() {
+        assert_eq!(
+            fork_source_download_segments(
+                "/api/game-distribution/games/game_1/fork-source/package"
+            )
+            .expect("relative path"),
+            vec![
+                "api",
+                "game-distribution",
+                "games",
+                "game_1",
+                "fork-source",
+                "package"
+            ]
+        );
+        for unsafe_path in [
+            "",
+            "api/game-distribution/games/game_1/fork-source/package",
+            "//evil.example.com/package",
+            "https://evil.example.com/package",
+            "/api/../package",
+            "/api\\package",
+            "/api/package?token=1",
+            "/api/package#frag",
+            "/api/C:package",
+        ] {
+            assert!(
+                fork_source_download_segments(unsafe_path).is_err(),
+                "should reject {unsafe_path:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn cover_preview_data_url_accepts_images_and_rejects_invalid_payloads() {
+        assert_eq!(
+            cover_preview_data_url("image/png; charset=binary", &[0, 1, 2])
+                .expect("image data URL"),
+            "data:image/png;base64,AAEC"
+        );
+        assert!(cover_preview_data_url("text/plain", &[0, 1, 2]).is_err());
+        assert!(cover_preview_data_url("image/png", &[]).is_err());
     }
 
     #[test]
@@ -2068,6 +2707,10 @@ mod tests {
             input_modes: vec![],
             orientation:
                 shared_contracts::game_distribution::GameDistributionOrientation::Responsive,
+            // 共创授权档位与改编声明：这里构造的是「不涉及共创」的基线资料（与不传这两个字段等价）。
+            fork_authorization:
+                shared_contracts::game_distribution::GameDistributionForkAuthorization::Forbidden,
+            fork: None,
         }
     }
 
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_fork.rs b/apps/ai-game-creator-shell/src-tauri/src/game_fork.rs
new file mode 100644
index 000000000..c8d74da42
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_fork.rs
@@ -0,0 +1,731 @@
+//! 从平台作品 Fork：受鉴权取件 → 摘要校验 → 建成一份可在本项目里继续改造、并且**立刻可运行**
+//! 的工程。
+//!
+//! 两种取件形态（服务端 `source`）落法不同，实现事实如下：
+//! - `Project`（工程源包）：包本身就是作者的工程，解到项目根即可继续改造。包内**不含**构建产物
+//!   （`project_bundle.rs` 排除 `game/dist`），所以本机还没有可运行的产物：建项只登记一条初始
+//!   工程版本，`code-prototype` 保持 `pending`，由运行视图如实提示「需要先构建」。
+//! - `Package`（已构建成品包）：平台只有成品时，先按标准初始化生成脚手架，再把成品铺进**预览根**
+//!   （`fork_playable_root`，即 `game/dist`）——运行视图只服务预览根，铺在别处的副本用户既看不到
+//!   也播不了。成品包自带可玩入口，因此建项同时把 `code-prototype` 登记为已完成。
+//!
+//! 关键顺序（顺序本身就是合同）：
+//! 1. 先取件并按元数据校验字节（失败关闭，不落盘）；
+//! 2. 再 `init_local_game_project_at` 生成脚手架——它的 `create_npm_scaffold` 判据是
+//!    「没有 manifest 且根/`game` 都没有 index.html、没有 package.json」，所以 `Package`
+//!    形态的成品必须等脚手架生成之后再铺，且不能铺进项目根或 `game/` 根；
+//! 3. 然后 `register_forked_project_state_at` 登记「可运行原型」与初始工程版本；
+//! 4. 最后写 `.agent/fork-source.json`，供发布链路在首次发布时声明 Fork 来源。
+
+#[cfg(not(test))]
+mod desktop;
+#[cfg(not(test))]
+pub(crate) use desktop::*;
+
+use super::*;
+
+/// 取件字节校验：字节数与 SHA-256 都必须与取件元数据一致，任一不符即失败关闭。
+///
+/// 抽成纯函数是为了让「失败就绝不落盘」这条规则可被单测钉住：调用点在解压之前。
+pub(crate) fn verify_fork_source_bytes(
+    bytes: &[u8],
+    expected_sha256: &str,
+    expected_bytes: u64,
+) -> Result<(), String> {
+    if bytes.len() as u64 != expected_bytes {
+        return Err(format!(
+            "共创内容大小校验失败（期望 {expected_bytes} 字节，实际 {} 字节），已放弃落盘",
+            bytes.len()
+        ));
+    }
+    let actual = crate::project_bundle::sha256_hex(bytes);
+    if actual != expected_sha256.trim().to_ascii_lowercase() {
+        return Err("共创内容完整性校验失败，已放弃落盘".to_string());
+    }
+    Ok(())
+}
+
+/// 可玩参考的落点：项目的**预览根**。
+///
+/// 成品包 fork 把取到的发行产物铺在这里，而不是另找一个"参考目录"：运行视图只服务
+/// `preview::project_game_root()` 指向的那一个根（`preview.rs` 的
+/// `start_local_game_preview_for_project` / `resolve_preview_path`），铺在根之外的副本用户
+/// 既看不到也播不了——那正是「fork 之后没法直接运行」的成因之一。
+///
+/// 预览根由 `project_game_root` 单点推导，这里不另写第二份判据：本形态必然是刚生成的 npm
+/// 脚手架（`game/package.json` 存在），预览根就是 `game/dist`（AGC 网页脚手架的 vite
+/// `outDir`）。它**不**在项目根或 `game/` 根，因此不会打断 `create_npm_scaffold` 判据；它也
+/// 被工程源包的排除清单覆盖（`project_bundle.rs` 的 `game/dist`），fork 来的成品**不会**被当成
+/// 作者自己的源码重新上传。
+pub(crate) fn fork_playable_root(project_root: &Path) -> PathBuf {
+    crate::preview::project_game_root(project_root)
+}
+
+/// Fork 建项收口：把「本项目已有可运行原型」与初始工程版本**如实**登记进 manifest。
+///
+/// 为什么必须有这一条：运行视图与发布导出都以 `manifest.tasks[code-prototype] == completed`
+/// （或存在运行中的预览）作为「项目里已有可运行原型」的**唯一**事实——前端
+/// `view/project-development/index.tsx` 的 `runAvailable`、后端 `project/export.rs` 的
+/// `project_has_runnable_prototype` 都是这一条。Fork 建项过去只生成脚手架与全新 manifest
+/// （seed 任务全 `pending`、`versions` 为空），于是 fork 出来的项目一进来就被判成「首个可运行
+/// 原型尚未完成」：运行页签点了没反应、发布也被拦——而它其实已经带了一份可玩的成品。
+///
+/// 写入顺序照既有 AI 直连回合收口（`agent/direct_runtime/mod.rs` 的同一套模式，见
+/// `sync_direct_codex_project_file_projection_at`）：任务状态 → 推进 project revision →
+/// 追加 `initial-<revision>` 版本 → 宣告清单失效。这里不新造状态写入路径，也不动 manifest
+/// 契约（改编来源仍只写在 `.agent/fork-source.json`）。
+///
+/// **只在项目里确实存在可玩入口时才标完成**（判据与预览同源：预览根下的 `index.html`）：
+/// - 成品包形态：发行产物已铺进预览根，`<预览根>/index.html` 存在 → 登记为已完成，运行与
+///   发布都立刻可用；
+/// - 工程源包形态：按产品口径**不自动构建**（与「不自动安装外部工程依赖」的既有策略一致），
+///   本机还没有可运行产物 → 只追加初始工程版本、`code-prototype` 保持 `pending`，由运行视图
+///   如实提示「需要先构建」，绝不谎报原型已完成。
+///
+/// `emit_game_creator_manifest_invalidated` 不是可选项：资源画布「项目版本」卡与发布面板的
+/// 版本标签只读清单快照，不宣告失效就看不到刚写进去的初始版本。
+fn register_forked_project_state_at(root: &Path) -> Result<GameCreationAppManifest, String> {
+    if fork_playable_root(root).join("index.html").is_file() {
+        update_manifest_task_status_at(
+            root,
+            "code-prototype",
+            GameCreationAppTaskStatus::Completed,
+        )?;
+    }
+    // 顺序是合同：先推进 durable revision，再把该 revision 绑成正式版本
+    // （`append_agent_game_iteration_version_at` 明确要求 revision > 0 且由调用方先推进）。
+    let revision = advance_agent_runtime_project_revision_locked(root)?;
+    append_agent_game_iteration_version_at(root, revision)?;
+    emit_game_creator_manifest_invalidated(root, FORK_MANIFEST_INVALIDATED_SOURCE);
+    read_manifest_for_project(root)
+}
+
+/// 清单失效事件的来源标识（与 `direct-codex.version` 等既有来源并列，便于排障定位写入者）。
+const FORK_MANIFEST_INVALIDATED_SOURCE: &str = "game-fork.project";
+
+/// 用平台作品的取件内容建一个新项目。
+///
+/// 两种取件形态（`source`）落法不同：
+/// - `Package`（已构建成品包）：先按标准初始化生成脚手架，再把成品铺进**预览根**
+///   （`fork_playable_root`）——平台只有成品时只有这一份内容可用，而且它必须落在预览根才播得了。
+/// - `Project`（工程源包）：包本身就是作者的工程（自带 `package.json` / `vite.config.*`），
+///   因此**先把包解到项目根**再走标准初始化：初始化会跳过 npm 脚手架（`game/index.html` 已存在），
+///   只补 `.agent` 身份、目录与 agent.db。
+///
+/// 任一形态建项成功后都走 `register_forked_project_state_at` 收口（登记「可运行原型」与初始
+/// 工程版本），任一步失败都删掉半成品目录，不留无法解释的项目。
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn create_project_from_platform_fork_at(
+    projects_root: &Path,
+    game_id: &str,
+    version_id: &str,
+    source: ProjectForkSourceKind,
+    package_bytes: &[u8],
+    requested_name: Option<&str>,
+    planning: bool,
+    // 阶段回调：真实发生到哪一步就报哪一步（渲染层状态条据此渲染，不造百分比）。
+    on_stage: &dyn Fn(ForkSyncStage),
+) -> Result<InitLocalProjectResult, String> {
+    let requested_name = requested_name
+        .map(normalize_game_creation_project_name)
+        .transpose()?;
+    // 作品 ID 来自平台响应：先把形状钉住再创建任何目录，非法标识不得留下半成品。
+    if !crate::game_distribution_publish::is_safe_fork_game_id(game_id.trim()) {
+        return Err("共创来源作品 ID 无效，无法建立来源记录".to_string());
+    }
+    if projects_root.as_os_str().is_empty() || !projects_root.is_absolute() {
+        return Err("自动工作区根目录必须是绝对路径".to_string());
+    }
+    ensure_game_creator_private_directory_tree(projects_root, "自动工作区根目录")?;
+    prepare_game_creator_private_path_for_read(projects_root, true, "自动工作区根目录")?;
+    let metadata = fs::symlink_metadata(projects_root).map_err(|error| {
+        format!(
+            "读取自动工作区根目录失败：{}: {error}",
+            projects_root.display()
+        )
+    })?;
+    if metadata.file_type().is_symlink() || !metadata.is_dir() {
+        return Err("自动工作区根目录必须是普通文件夹".to_string());
+    }
+
+    for _ in 0..16 {
+        let workspace_id = uuid::Uuid::new_v4().simple().to_string();
+        let short_id = &workspace_id[..8];
+        let project_name = requested_name.clone().unwrap_or_else(|| {
+            let prefix = if planning {
+                "策划项目"
+            } else {
+                "共创项目"
+            };
+            format!("{prefix} {short_id}")
+        });
+        let project_root = projects_root.join(format!("gameagent-{short_id}"));
+        match fs::create_dir(&project_root) {
+            Ok(()) => {
+                let result = (|| {
+                    harden_new_game_creator_private_path(&project_root, true, "自动项目目录")?;
+                    enforce_project_permission_policy(&project_root, "project.create")?;
+                    let _lock = acquire_project_write_lock(&project_root, "project.create")?;
+                    let mut project = match source {
+                        // 工程源包：包本身就是可编辑工程，先解到项目根再初始化。
+                        ProjectForkSourceKind::Project => {
+                            on_stage(ForkSyncStage::Extract);
+                            // 复用模板归档的同一套门禁：条目数上限、单文件上限、拒符号链接、
+                            // 条目路径只允许项目内相对路径（ZIP 根 == 项目根）。
+                            crate::template_library::extract_template_archive(
+                                package_bytes,
+                                &project_root,
+                            )
+                            .map_err(|error| format!("共创工程源包解压失败：{error}"))?;
+                            on_stage(ForkSyncStage::Project);
+                            let project = init_local_game_project_at(
+                                &project_root,
+                                &format!("gameagent-{workspace_id}"),
+                                &project_name,
+                            )?;
+                            write_project_fork_source(
+                                &project_root,
+                                &ProjectForkSourceRecord::new(
+                                    game_id,
+                                    version_id,
+                                    ProjectForkSourceKind::Project,
+                                ),
+                            )?;
+                            project
+                        }
+                        // 成品包：脚手架必须先生成，否则 `create_npm_scaffold` 判据被成品包里的
+                        // `index.html` / `package.json` 打断，项目从此无法发布；铺到哪里则由
+                        // `fork_playable_root` 决定（预览根），不能铺进项目根或 `game/` 根。
+                        ProjectForkSourceKind::Package => {
+                            on_stage(ForkSyncStage::Project);
+                            let project = init_local_game_project_at(
+                                &project_root,
+                                &format!("gameagent-{workspace_id}"),
+                                &project_name,
+                            )?;
+                            on_stage(ForkSyncStage::Extract);
+                            let playable_root = fork_playable_root(&project_root);
+                            ensure_game_creator_private_directory_tree(
+                                &playable_root,
+                                "可玩参考目录",
+                            )?;
+                            // 发行包契约：入口 `index.html` 固定在包根（服务端 `validate_release_zip`
+                            // 与 api-server 的 `package_entry_path` 都强制），所以整包解到预览根后
+                            // 就是 `<预览根>/index.html`。
+                            crate::template_library::extract_template_archive(
+                                package_bytes,
+                                &playable_root,
+                            )
+                            .map_err(|error| format!("共创内容解压失败：{error}"))?;
+                            write_project_fork_source(
+                                &project_root,
+                                &ProjectForkSourceRecord::new(
+                                    game_id,
+                                    version_id,
+                                    ProjectForkSourceKind::Package,
+                                ),
+                            )?;
+                            project
+                        }
+                    };
+                    // 建项收口：登记「可运行原型」与初始工程版本。返回收口**之后**重读的清单，
+                    // 免得把过期快照交给进项目通道（它会据这份清单渲染首帧）。
+                    project.manifest = register_forked_project_state_at(&project_root)?;
+                    Ok(project)
+                })();
+                if result.is_err() {
+                    let _ = fs::remove_dir_all(&project_root);
+                }
+                return result;
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
+            Err(error) => {
+                return Err(format!(
+                    "创建自动工作区失败：{}: {error}",
+                    project_root.display()
+                ));
+            }
+        }
+    }
+    Err("自动工作区命名冲突，请重试".to_string())
+}
+
+/// Fork 工程同步的**真实阶段**：状态条只呈现这里真实发出的阶段，不造百分比、不预估进度。
+///
+/// 与需求文档「源码 / 素材 / 场景 / 配置」四分类的对应关系：文档那四类假设的是「按资产种类分别
+/// 同步」，而客户端这条链路是**整包取回**（一次下载、一次校验、一次解压、一次建项），没有按种类
+/// 分开的可测量阶段，所以这里如实降级成四个真实阶段，并在渲染层说明当前阶段在做什么。
+#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum ForkSyncStage {
+    /// 取回作品内容：读取件元数据 + 下载整包。
+    Download,
+    /// 校验整包字节数与 SHA-256（失败即放弃落盘）。
+    Verify,
+    /// 解压到项目：工程源包解到项目根，成品包解到 `reference/<gameId>/`。
+    Extract,
+    /// 生成工程与来源记录：脚手架 / `.agent` 身份 / `.agent/fork-source.json`。
+    Project,
+}
+
+impl ForkSyncStage {
+    /// 事件里用的稳定键（渲染层按它匹配阶段，不匹配文案）。
+    pub(crate) fn key(self) -> &'static str {
+        match self {
+            Self::Download => "download",
+            Self::Verify => "verify",
+            Self::Extract => "extract",
+            Self::Project => "project",
+        }
+    }
+
+    /// 状态条上给用户看的阶段名。
+    pub(crate) fn label(self) -> &'static str {
+        match self {
+            Self::Download => "取回作品内容",
+            Self::Verify => "校验摘要与字节",
+            Self::Extract => "解压到项目",
+            Self::Project => "生成工程与来源记录",
+        }
+    }
+}
+
+/// 深链协议名：与 `tauri.conf.json` 的 `plugins.deep-link.desktop.schemes` 必须一致。
+pub(crate) const FORK_DEEP_LINK_SCHEME: &str = "genarrative";
+
+/// 从深链 URL 解析要 Fork 的作品 ID。
+///
+/// 冻结约定：`genarrative://fork?gameId=<gameId>`，同时接受 `genarrative://fork/<gameId>`。
+/// 只做解析与形状校验，不碰网络也不建项目：非法链接返回可读原因，由桌面层聚焦窗口后把原因交给
+/// 渲染层展示（用户点错链接时得到的是提示，而不是静默无事发生）。
+pub(crate) fn fork_game_id_from_deep_link(raw_url: &str) -> Result<String, String> {
+    let trimmed = raw_url.trim();
+    if trimmed.is_empty() {
+        return Err("链接为空，无法识别要共创的作品".to_string());
+    }
+    let url = url::Url::parse(trimmed).map_err(|_| format!("无法解析链接：{trimmed}"))?;
+    if !url.scheme().eq_ignore_ascii_case(FORK_DEEP_LINK_SCHEME) {
+        return Err(format!("只接受 {FORK_DEEP_LINK_SCHEME}:// 开头的共创链接"));
+    }
+    // `genarrative://fork/...` 里的 `fork` 是协议的 host（对外动作名叫「开始共创」，协议名与内部标识不改），作品 ID 走查询参数或路径段。
+    let route = url.host_str().unwrap_or_default().to_ascii_lowercase();
+    if route != "fork" {
+        return Err(format!(
+            "不支持的链接形式：需要 {FORK_DEEP_LINK_SCHEME}://fork?gameId=…"
+        ));
+    }
+    let from_query = url
+        .query_pairs()
+        .find(|(key, _)| matches!(key.as_ref(), "gameId" | "gameid" | "game_id" | "id"))
+        .map(|(_, value)| value.trim().to_string())
+        .filter(|value| !value.is_empty());
+    let from_path = url
+        .path_segments()
+        .and_then(|mut segments| segments.find(|segment| !segment.is_empty()))
+        .map(str::to_string);
+    let game_id = from_query
+        .or(from_path)
+        .ok_or_else(|| "链接里没有 gameId，无法确定要共创的作品".to_string())?;
+    if !crate::game_distribution_publish::is_safe_fork_game_id(&game_id) {
+        return Err(format!("链接里的 gameId 不合法：{game_id}"));
+    }
+    Ok(game_id)
+}
+
+/// 测试断言用：与运行视图 / 发布导出同源，「项目里已有可运行原型」的唯一事实是
+/// `manifest.tasks[code-prototype] == completed`（见 `register_forked_project_state_at` 的注释）。
+///
+/// 只服务 `game_fork` 的建项收口用例，因此留在 `cfg(test)` 内，不新增生产 API。
+#[cfg(test)]
+fn project_has_runnable_prototype(manifest: &GameCreationAppManifest) -> bool {
+    manifest.tasks.iter().any(|task| {
+        task.id == "code-prototype" && task.status == GameCreationAppTaskStatus::Completed
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::project_bundle::sha256_hex;
+    use zip::write::SimpleFileOptions;
+
+    fn test_root(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|elapsed| elapsed.as_nanos())
+            .unwrap_or_default();
+        let root = std::env::temp_dir().join(format!(
+            "agc-game-fork-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&root).expect("create temp root");
+        root
+    }
+
+    /// 最小成品包：发行包的真实形状是「运行产物 + 根 index.html」，不含 package.json。
+    fn release_package_bytes() -> Vec<u8> {
+        let mut writer = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+        let options = SimpleFileOptions::default();
+        writer
+            .start_file("index.html", options)
+            .expect("start entry");
+        std::io::Write::write_all(&mut writer, b"<html></html>").expect("write entry");
+        writer
+            .start_file("game/main.js", options)
+            .expect("start script");
+        std::io::Write::write_all(&mut writer, b"console.log('playable')").expect("write script");
+        writer.finish().expect("finish zip").into_inner()
+    }
+
+    #[test]
+    fn fork_sync_stages_keep_stable_keys_and_readable_labels() {
+        // 事件键必须与 serde 的 kebab-case 序列化一致：渲染层按 key 匹配阶段。
+        for (stage, key) in [
+            (ForkSyncStage::Download, "download"),
+            (ForkSyncStage::Verify, "verify"),
+            (ForkSyncStage::Extract, "extract"),
+            (ForkSyncStage::Project, "project"),
+        ] {
+            assert_eq!(stage.key(), key);
+            assert_eq!(
+                serde_json::to_string(&stage).expect("serialize stage"),
+                format!("\"{key}\"")
+            );
+            assert!(!stage.label().is_empty(), "阶段必须有可读名");
+        }
+        // 真实顺序：取回 → 校验 → 解压 → 建项（状态条按这个顺序排）。
+        assert_eq!(ForkSyncStage::Download.label(), "取回作品内容");
+        assert_eq!(ForkSyncStage::Verify.label(), "校验摘要与字节");
+        assert_eq!(ForkSyncStage::Extract.label(), "解压到项目");
+        assert_eq!(ForkSyncStage::Project.label(), "生成工程与来源记录");
+    }
+
+    #[test]
+    fn deep_link_accepts_both_fork_forms_and_ignores_extra_parameters() {
+        assert_eq!(
+            fork_game_id_from_deep_link("genarrative://fork?gameId=game_parent_1").unwrap(),
+            "game_parent_1"
+        );
+        assert_eq!(
+            fork_game_id_from_deep_link("genarrative://fork/game_parent_2").unwrap(),
+            "game_parent_2"
+        );
+        // 大小写：scheme 与动作名由 url crate 归一，作品 ID 原样保留。
+        assert_eq!(
+            fork_game_id_from_deep_link("GENARRATIVE://FORK?gameId=Game_Parent_3").unwrap(),
+            "Game_Parent_3"
+        );
+        // 多余参数与其它键名（兼容 game_id / id）不影响解析。
+        assert_eq!(
+            fork_game_id_from_deep_link("genarrative://fork?from=share&game_id=game_parent_4")
+                .unwrap(),
+            "game_parent_4"
+        );
+        assert_eq!(
+            fork_game_id_from_deep_link("genarrative://fork?gameId=game_parent_5&extra=1").unwrap(),
+            "game_parent_5"
+        );
+        // 两种形式同时出现时以查询参数为准（约定形式优先）。
+        assert_eq!(
+            fork_game_id_from_deep_link("genarrative://fork/ignored?gameId=game_parent_6").unwrap(),
+            "game_parent_6"
+        );
+    }
+
+    #[test]
+    fn deep_link_rejects_empty_wrong_scheme_route_and_missing_or_illegal_game_id() {
+        for (raw, expected) in [
+            ("", "链接为空"),
+            ("   ", "链接为空"),
+            (
+                "https://platform.test/games/detail?id=game_1",
+                "只接受 genarrative:// 开头的共创链接",
+            ),
+            ("genarrative://other?gameId=game_1", "不支持的链接形式"),
+            ("genarrative://fork", "链接里没有 gameId"),
+            ("genarrative://fork/", "链接里没有 gameId"),
+            ("genarrative://fork?gameId=", "链接里没有 gameId"),
+            (
+                "genarrative://fork?gameId=../escape",
+                "链接里的 gameId 不合法",
+            ),
+            (
+                "genarrative://fork?gameId=game%2Fslash",
+                "链接里的 gameId 不合法",
+            ),
+            ("not a url", "无法解析链接"),
+        ] {
+            let error = fork_game_id_from_deep_link(raw)
+                .expect_err(&format!("{raw:?} 应被拒绝（期望原因含「{expected}」）"));
+            assert!(
+                error.contains(expected),
+                "{raw:?} 的原因不是期望文案：{error}"
+            );
+        }
+    }
+
+    #[test]
+    fn fork_game_id_shape_rule_is_shared_with_the_fetch_path() {
+        assert!(crate::game_distribution_publish::is_safe_fork_game_id(
+            "game_1"
+        ));
+        assert!(crate::game_distribution_publish::is_safe_fork_game_id(
+            "a-b_c"
+        ));
+        for bad in ["", " ", "game/1", "game 1", "game\\1", "game:1"] {
+            assert!(
+                !crate::game_distribution_publish::is_safe_fork_game_id(bad),
+                "{bad:?} 不应通过"
+            );
+        }
+    }
+
+    #[test]
+    fn fork_source_bytes_must_match_declared_size_and_digest() {
+        let bytes = release_package_bytes();
+        let digest = sha256_hex(&bytes);
+        assert!(verify_fork_source_bytes(&bytes, &digest, bytes.len() as u64).is_ok());
+        // 摘要大小写不敏感（服务端回小写，客户端仍按同一口径比较）。
+        assert!(
+            verify_fork_source_bytes(&bytes, &digest.to_uppercase(), bytes.len() as u64).is_ok()
+        );
+
+        let size_error = verify_fork_source_bytes(&bytes, &digest, bytes.len() as u64 + 1)
+            .expect_err("大小不符必须失败");
+        assert!(size_error.contains("大小校验失败"), "{size_error}");
+        let digest_error = verify_fork_source_bytes(&bytes, &"a".repeat(64), bytes.len() as u64)
+            .expect_err("摘要不符必须失败");
+        assert!(digest_error.contains("完整性校验失败"), "{digest_error}");
+        assert!(verify_fork_source_bytes(&[], &digest, 0).is_err());
+    }
+
+    #[test]
+    fn playable_reference_root_is_the_project_preview_root() {
+        // 生产路径把成品包铺到「预览根」。它必须与预览服务读取的根（`project_game_root`）
+        // 是同一个答案，否则「铺进项目」与「预览服务哪里」会分叉成两份判据——fork 之后能跑
+        // 不能跑就取决于这份判据是否一致。
+        let root = test_root("playable-root");
+        fs::create_dir_all(root.join("game")).expect("create game dir");
+        fs::write(
+            root.join("game/package.json"),
+            r#"{"scripts":{"build":"vite build"}}"#,
+        )
+        .expect("write package.json");
+
+        let playable_root = fork_playable_root(&root);
+        assert_eq!(playable_root, root.join("game/dist"));
+        // 可玩参考永远落在项目内，不会拼出项目外的路径。
+        assert!(playable_root.starts_with(&root));
+        fs::remove_dir_all(&root).ok();
+    }
+
+    /// 最小工程源包：自带 `game/package.json` 与 `game/index.html`（这正是「解压即工程」的条件）。
+    fn project_bundle_bytes() -> Vec<u8> {
+        let mut writer = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+        let options = SimpleFileOptions::default();
+        for (name, content) in [
+            ("game/index.html", "<html>source entry</html>"),
+            (
+                "game/package.json",
+                "{\"dependencies\":{\"phaser\":\"4.2.1\"}}",
+            ),
+            ("game/vite.config.js", "export default {};"),
+            ("game/src/game.js", "console.log('from bundle');"),
+        ] {
+            writer.start_file(name, options).expect("start entry");
+            std::io::Write::write_all(&mut writer, content.as_bytes()).expect("write entry");
+        }
+        writer.finish().expect("finish zip").into_inner()
+    }
+
+    #[test]
+    fn platform_project_bundle_source_stays_source_only_with_an_initial_version() {
+        let projects_root = test_root("create-project-source");
+        let bytes = project_bundle_bytes();
+        let project = create_project_from_platform_fork_at(
+            &projects_root,
+            "game_upstream",
+            "gamever_upstream",
+            ProjectForkSourceKind::Project,
+            &bytes,
+            Some("源码改编测试"),
+            false,
+            &|_| {},
+        )
+        .expect("create fork project from project bundle");
+        let root = Path::new(&project.project_path);
+
+        // 1) 源包内容逐字节落地：工程源码不被脚手架覆盖（package.json 必须是包里的那份）。
+        assert_eq!(
+            fs::read_to_string(root.join("game/package.json")).unwrap(),
+            "{\"dependencies\":{\"phaser\":\"4.2.1\"}}"
+        );
+        assert_eq!(
+            fs::read_to_string(root.join("game/src/game.js")).unwrap(),
+            "console.log('from bundle');"
+        );
+        assert_eq!(
+            fs::read_to_string(root.join("game/index.html")).unwrap(),
+            "<html>source entry</html>"
+        );
+
+        // 2) 标准初始化仍然跑过：补上项目身份与 agent.db，工程才能被 AGC 正常打开。
+        assert!(root.join(".agent/manifest.json").is_file());
+        assert!(root.join(".agent/agent.db").is_file());
+
+        // 3) 工程源包不做参考副本，也不在 fork 时构建：包内不含构建产物（工程源包排除
+        //    `game/dist`），因此本机还没有可运行的产物。
+        assert!(!root.join("reference").exists());
+        assert!(!root.join("game/dist").exists());
+
+        // 4) 收口**如实**：登记一条初始工程版本，但 `code-prototype` 保持未完成——运行视图会
+        //    提示「需要先构建」，绝不谎报原型已完成。
+        let code_prototype = project
+            .manifest
+            .tasks
+            .iter()
+            .find(|task| task.id == "code-prototype")
+            .map(|task| task.status.clone())
+            .expect("code-prototype 必须存在于 seed 任务里");
+        assert_eq!(code_prototype, GameCreationAppTaskStatus::Pending);
+        assert!(!project_has_runnable_prototype(&project.manifest));
+        assert_eq!(
+            project.manifest.versions.len(),
+            1,
+            "fork 建项必须有初始版本"
+        );
+        let initial = &project.manifest.versions[0];
+        assert_eq!(initial.version_id, "initial-1");
+        assert_eq!(initial.project_revision, 1);
+        assert_eq!(
+            initial.created_reason,
+            GameIterationVersionCreatedReason::Initial
+        );
+        assert_eq!(initial.parent_version_id, None);
+
+        // 5) 来源记录带上取件形态（v2）。
+        let record = read_project_fork_source(root).expect("fork source record");
+        assert_eq!(record.schema_version, FORK_SOURCE_SCHEMA_VERSION);
+        assert_eq!(record.source, ProjectForkSourceKind::Project);
+        assert_eq!(record.game_id, "game_upstream");
+        assert_eq!(record.version_id, "gamever_upstream");
+    }
+
+    #[test]
+    fn platform_fork_project_gets_playable_reference_at_the_preview_root() {
+        let projects_root = test_root("create");
+        let bytes = release_package_bytes();
+        let project = create_project_from_platform_fork_at(
+            &projects_root,
+            "game_parent",
+            "gamever_parent",
+            ProjectForkSourceKind::Package,
+            &bytes,
+            Some("改编测试"),
+            false,
+            &|_| {},
+        )
+        .expect("create fork project");
+        let root = Path::new(&project.project_path);
+
+        // 1) 合规脚手架正常生成：`create_npm_scaffold` 的判据没有被参考产物打断。
+        assert!(root.join("game/package.json").is_file());
+        assert!(root.join("game/vite.config.js").is_file());
+        assert!(root.join("game/index.html").is_file());
+        assert!(root.join(".agent/manifest.json").is_file());
+
+        // 2) 成品铺在**预览根**（`game/dist`），与脚手架互不覆盖：预览根下必须有可玩入口，
+        //    否则运行视图即使放行也会报「游戏目录不存在」。不再另写一份 `reference/` 副本
+        //    （第二份副本用户既看不到也播不了，还会翻倍占磁盘）。
+        assert!(!root.join("reference").exists());
+        assert_eq!(
+            fs::read_to_string(root.join("game/dist/index.html")).unwrap(),
+            "<html></html>"
+        );
+        assert_eq!(
+            fs::read_to_string(root.join("game/dist/game/main.js")).unwrap(),
+            "console.log('playable')"
+        );
+        assert_ne!(
+            fs::read_to_string(root.join("game/dist/index.html")).unwrap(),
+            fs::read_to_string(root.join("game/index.html")).unwrap()
+        );
+
+        // 3) 收口把「可运行原型」登记上：成品包自带可玩入口，所以任务置完成、版本为初始版本，
+        //    运行与发布门禁同时放行（这就是「fork 之后能直接运行」的判据本身）。
+        let code_prototype = project
+            .manifest
+            .tasks
+            .iter()
+            .find(|task| task.id == "code-prototype")
+            .map(|task| task.status.clone())
+            .expect("code-prototype 必须存在于 seed 任务里");
+        assert_eq!(code_prototype, GameCreationAppTaskStatus::Completed);
+        assert!(project_has_runnable_prototype(&project.manifest));
+        assert_eq!(
+            project.manifest.versions.len(),
+            1,
+            "fork 建项必须有初始版本"
+        );
+        assert_eq!(project.manifest.versions[0].version_id, "initial-1");
+        assert_eq!(project.manifest.versions[0].project_revision, 1);
+
+        // 4) 来源记录与项目身份一致，并标明这条是成品包取件（v2 字段）。
+        let record = read_project_fork_source(root).expect("fork source record");
+        assert_eq!(record.source, ProjectForkSourceKind::Package);
+        assert_eq!(record.game_id, "game_parent");
+        assert_eq!(record.version_id, "gamever_parent");
+        assert_eq!(project.manifest.name, "改编测试");
+    }
+
+    #[test]
+    fn failed_fork_creation_leaves_no_half_built_project() {
+        let projects_root = test_root("rollback");
+        // 不是合法 zip：解压必须在铺参考副本这一步失败，然后整个项目目录被移除。
+        let error = create_project_from_platform_fork_at(
+            &projects_root,
+            "game_parent",
+            "gamever_parent",
+            ProjectForkSourceKind::Package,
+            b"not-a-zip",
+            None,
+            false,
+            &|_| {},
+        )
+        .expect_err("invalid archive must fail");
+        assert!(error.contains("zip"), "{error}");
+        let leftovers = fs::read_dir(&projects_root)
+            .expect("read projects root")
+            .filter_map(Result::ok)
+            .filter(|entry| {
+                entry
+                    .file_name()
+                    .to_string_lossy()
+                    .starts_with("gameagent-")
+            })
+            .count();
+        assert_eq!(leftovers, 0, "失败的项目目录必须被清理");
+    }
+
+    #[test]
+    fn unsafe_game_id_fails_before_any_directory_is_created() {
+        let projects_root = test_root("unsafe-id");
+        let bytes = release_package_bytes();
+        assert!(create_project_from_platform_fork_at(
+            &projects_root,
+            "../escape",
+            "gamever_parent",
+            ProjectForkSourceKind::Package,
+            &bytes,
+            None,
+            false,
+            &|_| {},
+        )
+        .is_err());
+        assert_eq!(
+            fs::read_dir(&projects_root).expect("read root").count(),
+            0,
+            "标识非法时不得创建任何目录"
+        );
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_fork/desktop.rs b/apps/ai-game-creator-shell/src-tauri/src/game_fork/desktop.rs
new file mode 100644
index 000000000..4fc1120de
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_fork/desktop.rs
@@ -0,0 +1,167 @@
+// 桌面 Fork 取件接入；摘要校验、参考副本落点与来源记录规则保留在父模块供现有测试验证。
+use super::*;
+use crate::game_distribution_publish::{fetch_platform_game_fork_source, require_platform_session};
+use serde_json::{json, Value};
+use shared_contracts::game_distribution::GameDistributionForkSourceKind;
+use tauri::{Emitter, Manager};
+use tauri_plugin_deep_link::DeepLinkExt;
+
+/// 深链事件名：渲染层订阅同名事件，收到后预填 Fork 入口（**不**自动开始下载）。
+pub(crate) const FORK_DEEP_LINK_EVENT: &str = "game-fork-deep-link";
+
+/// 主窗口标签，与 `tauri.conf.json` 的 `app.windows[0].label` 一致。
+const MAIN_WINDOW_LABEL: &str = "client";
+
+/// 把主窗口带到前台：深链可能来自浏览器点击，用户期望看到的正是这个窗口。
+pub(crate) fn focus_main_window_for_deep_link(app: &tauri::AppHandle) {
+    let Some(window) = app.get_webview_window(MAIN_WINDOW_LABEL) else {
+        app_log!("game.fork.deep_link.window_missing: 找不到主窗口 {MAIN_WINDOW_LABEL}");
+        return;
+    };
+    let _ = window.unminimize();
+    let _ = window.show();
+    let _ = window.set_focus();
+}
+
+/// 处理一条深链：解析出 gameId 就交给渲染层预填，解析失败就把原因交给渲染层展示。
+///
+/// 两种结果都先聚焦窗口——用户点了链接却什么都没发生是最糟的失败方式。
+fn handle_fork_deep_link_url(app: &tauri::AppHandle, raw_url: &str) {
+    focus_main_window_for_deep_link(app);
+    let payload = match fork_game_id_from_deep_link(raw_url) {
+        Ok(game_id) => json!({ "gameId": game_id, "message": Value::Null }),
+        Err(message) => {
+            app_log!("game.fork.deep_link.invalid: {message}");
+            json!({ "gameId": Value::Null, "message": message })
+        }
+    };
+    if let Err(error) = app.emit(FORK_DEEP_LINK_EVENT, payload) {
+        app_log!("game.fork.deep_link.emit_failed: {error}");
+    }
+}
+
+/// 注册并接管 Fork 深链。
+///
+/// - **冷启动**（Windows/Linux）：URL 是启动参数，deep-link 插件在插件初始化阶段就解析并暂存，
+///   而应用的 `setup` 晚于插件，所以这里先取「当前值」，再订阅后续链接。
+/// - **已运行**：Windows/Linux 会再起一个进程，由 `tauri-plugin-single-instance`（带 `deep-link`
+///   feature）把第二个实例的 argv 转交给已有实例，交给 deep-link 插件发事件；macOS 由系统把
+///   URL 交给已运行的 .app。
+/// - **协议注册**：Windows 写 `HKCU\Software\Classes\<scheme>`、Linux 写用户级 `.desktop`
+///   （macOS 由打包时注入 `Info.plist` 的 `CFBundleURLTypes`）。这里运行时再注册一次，覆盖
+///   便携/未按安装器安装的场景；失败只记日志，不影响启动。
+pub(crate) fn initialize_fork_deep_link(app: &tauri::AppHandle) {
+    match app.deep_link().get_current() {
+        Ok(Some(urls)) => {
+            for url in urls {
+                handle_fork_deep_link_url(app, url.as_str());
+            }
+        }
+        Ok(None) => {}
+        Err(error) => app_log!("game.fork.deep_link.current_failed: {error}"),
+    }
+    let handle = app.clone();
+    app.deep_link().on_open_url(move |event| {
+        for url in event.urls() {
+            handle_fork_deep_link_url(&handle, url.as_str());
+        }
+    });
+    #[cfg(any(windows, target_os = "linux"))]
+    if let Err(error) = app.deep_link().register_all() {
+        app_log!("game.fork.deep_link.register_failed: {error}");
+    }
+}
+
+/// Fork 工程同步进度事件：每进入一个**真实阶段**发一次，渲染层据此渲染状态条。
+pub(crate) const FORK_PROGRESS_EVENT: &str = "game-fork-progress";
+
+/// 把阶段透给渲染层；发事件失败只记日志，绝不影响 Fork 本身。
+fn emit_fork_stage(app: &tauri::AppHandle, stage: ForkSyncStage) {
+    if let Err(error) = app.emit(
+        FORK_PROGRESS_EVENT,
+        json!({ "stage": stage.key(), "label": stage.label() }),
+    ) {
+        app_log!("game.fork.progress.emit_failed: {error}");
+    }
+}
+
+/// 读本项目的改编来源记录（`.agent/fork-source.json`）。
+///
+/// 发布面板用它判断「这是不是衍生作品」：衍生作品的「本次核心改动说明」必填、授权档位继承父作品
+/// 且不可选（服务端口径）。文件缺失/损坏按「不是衍生作品」处理（`None`），与发布链路读它时的口径
+/// 一致——同一个可选元数据文件不该让面板报错。
+#[tauri::command]
+pub(crate) fn read_local_project_fork_source(
+    project_path: String,
+) -> Result<Option<ProjectForkSourceRecord>, String> {
+    let root = Path::new(project_path.trim());
+    if root.as_os_str().is_empty() {
+        return Err("读取改编来源需要本地项目路径".to_string());
+    }
+    Ok(read_project_fork_source(root))
+}
+
+/// 从平台作品 Fork：按取件形态建成项目。
+///
+/// - `source: "project"`（工程源包）：解压即得作者的工程，再走标准初始化补 `.agent` 身份。
+/// - `source: "package"`（成品包）：平台只有成品时生成脚手架，成品放进
+///   `reference/<gameId>/`。
+///
+/// 阶段（渲染层状态条只显示这些真实发生过的阶段，不发假百分比）：
+/// 取回作品内容 → 校验摘要与字节 → 解压到项目 → 生成工程与来源记录。
+///
+/// 失败关闭点（按顺序）：
+/// 1. 没有平台登录态 → 直接给出可操作的登录提示，不发起任何请求；
+/// 2. 取件元数据/下载失败（404 / 409 / 403 / 401）→ 原样返回可区分的错误，不建目录；
+/// 3. 字节数或 SHA-256 与元数据不符 → 在解压**之前**失败，不落盘；
+/// 4. 建项或解压途中失败 → 删除半成品项目目录。
+#[tauri::command]
+pub(crate) async fn create_local_project_from_platform_game(
+    app: tauri::AppHandle,
+    game_id: String,
+    name: Option<String>,
+    planning: Option<bool>,
+    projects_root: Option<String>,
+) -> Result<InitLocalProjectResult, String> {
+    let analytics_context = crate::analytics::gui::capture_analytics_context();
+    let game_id = game_id.trim().to_string();
+    if game_id.is_empty() {
+        return Err("请先选择要开始共创的平台作品".to_string());
+    }
+    // 先冻结会话身份：取件与建项之间换号必须失败关闭，不能把 A 的取件结果落成 B 的项目。
+    let session = require_platform_session()?;
+    let identity = session.identity();
+    let projects_root = crate::resolve_game_project_creation_root(&app, projects_root.as_deref())?;
+    emit_fork_stage(&app, ForkSyncStage::Download);
+    let (source, package_bytes) = fetch_platform_game_fork_source(&game_id).await?;
+    emit_fork_stage(&app, ForkSyncStage::Verify);
+    verify_fork_source_bytes(&package_bytes, &source.sha256, source.bytes)?;
+    let stage_handle = app.clone();
+    let result = with_validated_platform_session_identity(&identity, || {
+        create_project_from_platform_fork_at(
+            &projects_root,
+            &source.game_id,
+            &source.version_id,
+            match source.source {
+                // 取件形态决定建项方式：工程源包解压即工程；成品包生成脚手架 + 参考副本。
+                GameDistributionForkSourceKind::Project => ProjectForkSourceKind::Project,
+                GameDistributionForkSourceKind::Package => ProjectForkSourceKind::Package,
+            },
+            &package_bytes,
+            name.as_deref(),
+            planning.unwrap_or(false),
+            &|stage| emit_fork_stage(&stage_handle, stage),
+        )
+    });
+    if let Ok(project) = &result {
+        crate::analytics::gui::created(
+            analytics_context,
+            Path::new(&project.project_path),
+            project.manifest.project_id.clone(),
+            crate::analytics::contract::CreationSource::PlatformGame,
+            // 平台作品 ID 作为来源标识：与模板链路的 `template_id` 位置同义（创建来源的稳定 ID）。
+            Some(source.game_id.clone()),
+        );
+    }
+    result
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs
index 679ed41f5..613ebea6d 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload.rs
@@ -15,8 +15,9 @@ use serde_json::Value;
 
 mod runtime;
 pub(crate) use runtime::{
-    game_package_upload_staging_dir, progress_event_payload, upload_staged_game_package,
-    GamePackageUploadOutcome, GamePackageUploadRequest, GAME_PACKAGE_UPLOAD_PROGRESS_EVENT,
+    game_package_upload_staging_dir, progress_event_payload, upload_staged_version_asset,
+    GamePackageUploadOutcome, GamePackageUploadRequest, PackageUploadAsset,
+    GAME_PACKAGE_UPLOAD_PROGRESS_EVENT,
 };
 
 /// 已暂存（归一化后）的发行包：内容寻址，重启后同一包复用同一个文件，续传才有意义。
@@ -104,10 +105,11 @@ fn next_chunk_plan(received: u64, total: u64, chunk_bytes: u64) -> Option<ChunkP
     })
 }
 
-fn upload_url(base_url: &str, version_id: &str, suffix: &str) -> String {
+fn upload_url(base_url: &str, version_id: &str, asset: PackageUploadAsset, suffix: &str) -> String {
     format!(
-        "{}/api/game-distribution/versions/{version_id}/package{suffix}",
-        base_url.trim_end_matches('/')
+        "{}/api/game-distribution/versions/{version_id}/{}{suffix}",
+        base_url.trim_end_matches('/'),
+        asset.url_segment()
     )
 }
 
@@ -189,6 +191,45 @@ mod tests {
         assert!(next_chunk_plan(0, total, 0).is_none());
     }
 
+    #[test]
+    fn upload_asset_routes_and_offset_codes_stay_apart() {
+        // 两条资产走同一段续传逻辑，URL 资源段与「偏移不符」错误码必须各自独立：
+        // 判错码会让偏移续传认不出服务端给的位置。
+        assert_eq!(
+            upload_url(
+                "https://dev.test/",
+                "version_1",
+                PackageUploadAsset::ReleasePackage,
+                "/chunk"
+            ),
+            "https://dev.test/api/game-distribution/versions/version_1/package/chunk"
+        );
+        assert_eq!(
+            upload_url(
+                "https://dev.test",
+                "version_1",
+                PackageUploadAsset::ProjectBundle,
+                "/upload-state"
+            ),
+            "https://dev.test/api/game-distribution/versions/version_1/project-bundle/upload-state"
+        );
+        assert_eq!(
+            PackageUploadAsset::ReleasePackage.offset_mismatch_code(),
+            "PACKAGE_UPLOAD_OFFSET_MISMATCH"
+        );
+        assert_eq!(
+            PackageUploadAsset::ProjectBundle.offset_mismatch_code(),
+            "PROJECT_BUNDLE_UPLOAD_OFFSET_MISMATCH"
+        );
+        // 只有发行包在创建版本时预登记了大小。
+        assert!(PackageUploadAsset::ReleasePackage.has_declared_bytes());
+        assert!(!PackageUploadAsset::ProjectBundle.has_declared_bytes());
+        // 文案必须能区分是哪条资产失败了（面板据此提示）。
+        assert!(PackageUploadAsset::ProjectBundle
+            .label()
+            .contains("工程源包"));
+    }
+
     #[test]
     fn offset_mismatch_response_yields_authoritative_position() {
         let body = r#"{"error":{"code":"PACKAGE_UPLOAD_OFFSET_MISMATCH","message":"偏移不一致","details":{"provider":"game-distribution","receivedBytes":16777216}}}"#;
@@ -209,11 +250,21 @@ mod tests {
     #[test]
     fn upload_url_joins_base_without_double_slash() {
         assert_eq!(
-            upload_url("https://dev.genarrative.world/", "ver-1", "/chunk"),
+            upload_url(
+                "https://dev.genarrative.world/",
+                "ver-1",
+                PackageUploadAsset::ReleasePackage,
+                "/chunk"
+            ),
             "https://dev.genarrative.world/api/game-distribution/versions/ver-1/package/chunk"
         );
         assert_eq!(
-            upload_url("http://127.0.0.1:10001", "ver 1", "/complete"),
+            upload_url(
+                "http://127.0.0.1:10001",
+                "ver 1",
+                PackageUploadAsset::ReleasePackage,
+                "/complete"
+            ),
             "http://127.0.0.1:10001/api/game-distribution/versions/ver 1/package/complete"
         );
     }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs
index ccaf75a95..c607545a2 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/game_package_upload/runtime.rs
@@ -27,6 +27,48 @@ pub(crate) struct GamePackageUploadOutcome {
     pub(crate) uploaded_bytes: u64,
 }
 
+/// 可续传上传的版本级资产：发行包与工程源包共用同一条分片续传链路，只有资源段与文案不同。
+///
+/// 两侧服务端路由同形，但**错误码不同**（`PACKAGE_UPLOAD_OFFSET_MISMATCH` /
+/// `PROJECT_BUNDLE_UPLOAD_OFFSET_MISMATCH`），偏移续传必须按资产判码，不能靠子串猜。
+#[derive(Clone, Copy, Debug, Eq, PartialEq, serde::Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) enum PackageUploadAsset {
+    ReleasePackage,
+    ProjectBundle,
+}
+
+impl PackageUploadAsset {
+    /// URL 里的资源段：`…/versions/{version_id}/<segment>`。
+    pub(super) fn url_segment(self) -> &'static str {
+        match self {
+            Self::ReleasePackage => "package",
+            Self::ProjectBundle => "project-bundle",
+        }
+    }
+
+    /// 面向用户的资产名。
+    pub(crate) fn label(self) -> &'static str {
+        match self {
+            Self::ReleasePackage => "发行包",
+            Self::ProjectBundle => "工程源包",
+        }
+    }
+
+    /// 服务端「偏移不符」错误码；偏移续传按它取权威偏移。
+    pub(super) fn offset_mismatch_code(self) -> &'static str {
+        match self {
+            Self::ReleasePackage => "PACKAGE_UPLOAD_OFFSET_MISMATCH",
+            Self::ProjectBundle => "PROJECT_BUNDLE_UPLOAD_OFFSET_MISMATCH",
+        }
+    }
+
+    /// 只有发行包在创建版本时预登记了大小；工程源包没有，因此不做「本地体积 vs 声明体积」校验。
+    pub(super) fn has_declared_bytes(self) -> bool {
+        matches!(self, Self::ReleasePackage)
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 struct PackageUploadState {
@@ -43,12 +85,16 @@ pub(crate) fn game_package_upload_staging_dir(app_data_dir: &Path) -> PathBuf {
     app_data_dir.join(UPLOAD_STAGING_DIR_NAME)
 }
 
-fn read_chunk(file: &mut File, plan: ChunkPlan) -> Result<Vec<u8>, String> {
+fn read_chunk(
+    file: &mut File,
+    plan: ChunkPlan,
+    asset: PackageUploadAsset,
+) -> Result<Vec<u8>, String> {
     file.seek(SeekFrom::Start(plan.offset))
-        .map_err(|error| format!("读取发行包失败：{error}"))?;
+        .map_err(|error| format!("读取{}失败：{error}", asset.label()))?;
     let mut buffer = vec![0_u8; usize::try_from(plan.length).unwrap_or(0)];
     file.read_exact(&mut buffer)
-        .map_err(|error| format!("读取发行包失败：{error}"))?;
+        .map_err(|error| format!("读取{}失败：{error}", asset.label()))?;
     Ok(buffer)
 }
 
@@ -80,52 +126,57 @@ pub(crate) enum GamePackageUploadStep {
 }
 
 impl GamePackageUploadStep {
-    fn label(self) -> &'static str {
+    fn label(self, asset: PackageUploadAsset) -> String {
         match self {
-            Self::ReadUploadState => "读取上传状态失败",
-            Self::UploadChunk => "发行包分片上传失败",
-            Self::CompleteUpload => "完成发行包上传失败",
+            Self::ReadUploadState => format!("读取{}上传状态失败", asset.label()),
+            Self::UploadChunk => format!("{}分片上传失败", asset.label()),
+            Self::CompleteUpload => format!("完成{}上传失败", asset.label()),
         }
     }
 }
 
-/// 发行包上传失败：`step` 说明是哪一步，`detail` 是这一步的原始事实（服务端 message / code /
-/// `HTTP {status}`）。
+/// 上传失败：`asset` + `step` 说明是哪条资产的哪一步，`detail` 是这一步的原始事实
+/// （服务端 message / code / `HTTP {status}`）。
 #[derive(Clone, Debug, serde::Serialize)]
 pub(crate) struct GamePackageUploadError {
+    pub(crate) asset: PackageUploadAsset,
     pub(crate) step: GamePackageUploadStep,
     pub(crate) detail: String,
 }
 
 impl GamePackageUploadError {
-    fn read_upload_state(detail: impl Into<String>) -> Self {
+    fn new(
+        asset: PackageUploadAsset,
+        step: GamePackageUploadStep,
+        detail: impl Into<String>,
+    ) -> Self {
         Self {
-            step: GamePackageUploadStep::ReadUploadState,
+            asset,
+            step,
             detail: detail.into(),
         }
     }
 
-    fn upload_chunk(detail: impl Into<String>) -> Self {
-        Self {
-            step: GamePackageUploadStep::UploadChunk,
-            detail: detail.into(),
-        }
+    fn read_upload_state(asset: PackageUploadAsset, detail: impl Into<String>) -> Self {
+        Self::new(asset, GamePackageUploadStep::ReadUploadState, detail)
     }
 
-    fn complete_upload(detail: impl Into<String>) -> Self {
-        Self {
-            step: GamePackageUploadStep::CompleteUpload,
-            detail: detail.into(),
-        }
+    fn upload_chunk(asset: PackageUploadAsset, detail: impl Into<String>) -> Self {
+        Self::new(asset, GamePackageUploadStep::UploadChunk, detail)
+    }
+
+    fn complete_upload(asset: PackageUploadAsset, detail: impl Into<String>) -> Self {
+        Self::new(asset, GamePackageUploadStep::CompleteUpload, detail)
     }
 
     /// 给用户/模型的那句：步骤 + 事实。步骤来自 `step` 枚举，不从调用点硬拼。
     pub(crate) fn to_user_msg(&self) -> String {
+        let label = self.step.label(self.asset);
         let detail = self.detail.trim();
         if detail.is_empty() {
-            self.step.label().to_string()
+            label
         } else {
-            format!("{}：{detail}", self.step.label())
+            format!("{label}：{detail}")
         }
     }
 }
@@ -142,36 +193,38 @@ async fn read_upload_state(
     base_url: &str,
     version_id: &str,
     access_token: &str,
+    asset: PackageUploadAsset,
 ) -> Result<PackageUploadState, GamePackageUploadError> {
     let response = platform_request(
         client,
         access_token,
         reqwest::Method::GET,
-        &upload_url(base_url, version_id, "/upload-state"),
+        &upload_url(base_url, version_id, asset, "/upload-state"),
     )
     .send()
     .await
     .map_err(|error| {
-        GamePackageUploadError::read_upload_state(format!(
-            "无法连接登录服务，请确认配套后端或 API 代理已启动后重试：{error}"
-        ))
+        GamePackageUploadError::read_upload_state(
+            asset,
+            format!("无法连接登录服务，请确认配套后端或 API 代理已启动后重试：{error}"),
+        )
     })?;
     let status = response.status().as_u16();
     let body = response
         .text()
         .await
-        .map_err(|error| GamePackageUploadError::read_upload_state(format!("{error}")))?;
+        .map_err(|error| GamePackageUploadError::read_upload_state(asset, format!("{error}")))?;
     if status >= 400 {
         let (code, message) = parse_server_error(status, &body);
         let detail = server_error_detail(code, message, || format!("HTTP {status}"));
-        return Err(GamePackageUploadError::read_upload_state(detail));
+        return Err(GamePackageUploadError::read_upload_state(asset, detail));
     }
     let parsed: Value = serde_json::from_str(&body).map_err(|error| {
-        GamePackageUploadError::read_upload_state(format!("响应不是合法 JSON：{error}"))
+        GamePackageUploadError::read_upload_state(asset, format!("响应不是合法 JSON：{error}"))
     })?;
     let payload = parsed.get("data").unwrap_or(&parsed);
     serde_json::from_value(payload.clone()).map_err(|error| {
-        GamePackageUploadError::read_upload_state(format!("响应缺少字段：{error}"))
+        GamePackageUploadError::read_upload_state(asset, format!("响应缺少字段：{error}"))
     })
 }
 
@@ -182,6 +235,7 @@ async fn upload_chunk(
     version_id: &str,
     access_token: &str,
     idempotency_key: &str,
+    asset: PackageUploadAsset,
     plan: ChunkPlan,
     body: Vec<u8>,
 ) -> Result<u64, ChunkUploadError> {
@@ -189,7 +243,7 @@ async fn upload_chunk(
         client,
         access_token,
         reqwest::Method::PUT,
-        &upload_url(base_url, version_id, "/chunk"),
+        &upload_url(base_url, version_id, asset, "/chunk"),
     )
     .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
     .header(UPLOAD_OFFSET_HEADER, plan.offset.to_string())
@@ -198,19 +252,24 @@ async fn upload_chunk(
     .send()
     .await
     .map_err(|error| {
-        ChunkUploadError::Retryable(GamePackageUploadError::upload_chunk(format!(
-            "请求未送达：{error}"
-        )))
+        ChunkUploadError::Retryable(GamePackageUploadError::upload_chunk(
+            asset,
+            format!("请求未送达：{error}"),
+        ))
     })?;
     let status = response.status().as_u16();
     let text = response.text().await.map_err(|error| {
-        ChunkUploadError::Retryable(GamePackageUploadError::upload_chunk(format!("{error}")))
+        ChunkUploadError::Retryable(GamePackageUploadError::upload_chunk(
+            asset,
+            format!("{error}"),
+        ))
     })?;
     if status == 409 {
         let (code, message) = parse_server_error(status, &text);
-        if code.as_deref() == Some("PACKAGE_UPLOAD_OFFSET_MISMATCH") {
+        if code.as_deref() == Some(asset.offset_mismatch_code()) {
             let received = parse_received_bytes(&text).ok_or_else(|| {
                 ChunkUploadError::Fatal(GamePackageUploadError::upload_chunk(
+                    asset,
                     "分片偏移不一致，但服务端未返回权威偏移",
                 ))
             })?;
@@ -218,27 +277,28 @@ async fn upload_chunk(
         }
         let detail = server_error_detail(code, message, || format!("HTTP {status}"));
         return Err(ChunkUploadError::Fatal(
-            GamePackageUploadError::upload_chunk(detail),
+            GamePackageUploadError::upload_chunk(asset, detail),
         ));
     }
     if status >= 500 || status == 408 || status == 429 {
         let (code, message) = parse_server_error(status, &text);
         let detail = server_error_detail(code, message, || format!("HTTP {status}"));
         return Err(ChunkUploadError::Retryable(
-            GamePackageUploadError::upload_chunk(detail),
+            GamePackageUploadError::upload_chunk(asset, detail),
         ));
     }
     if status >= 400 {
         let (code, message) = parse_server_error(status, &text);
         let detail = server_error_detail(code, message, || format!("HTTP {status}"));
         return Err(ChunkUploadError::Fatal(
-            GamePackageUploadError::upload_chunk(detail),
+            GamePackageUploadError::upload_chunk(asset, detail),
         ));
     }
     let parsed: Value = serde_json::from_str(&text).map_err(|error| {
-        ChunkUploadError::Retryable(GamePackageUploadError::upload_chunk(format!(
-            "响应不是合法 JSON：{error}"
-        )))
+        ChunkUploadError::Retryable(GamePackageUploadError::upload_chunk(
+            asset,
+            format!("响应不是合法 JSON：{error}"),
+        ))
     })?;
     let payload = parsed.get("data").unwrap_or(&parsed);
     payload
@@ -246,6 +306,7 @@ async fn upload_chunk(
         .and_then(Value::as_u64)
         .ok_or_else(|| {
             ChunkUploadError::Fatal(GamePackageUploadError::upload_chunk(
+                asset,
                 "响应缺少 receivedBytes",
             ))
         })
@@ -262,29 +323,32 @@ async fn complete_upload(
     version_id: &str,
     access_token: &str,
     idempotency_key: &str,
+    asset: PackageUploadAsset,
 ) -> Result<GamePackageUploadOutcome, GamePackageUploadError> {
     let response = platform_request(
         client,
         access_token,
         reqwest::Method::POST,
-        &upload_url(base_url, version_id, "/complete"),
+        &upload_url(base_url, version_id, asset, "/complete"),
     )
     .header("Idempotency-Key", format!("{idempotency_key}:complete"))
     .send()
     .await
-    .map_err(|error| GamePackageUploadError::complete_upload(format!("请求未送达：{error}")))?;
+    .map_err(|error| {
+        GamePackageUploadError::complete_upload(asset, format!("请求未送达：{error}"))
+    })?;
     let status = response.status().as_u16();
     let text = response
         .text()
         .await
-        .map_err(|error| GamePackageUploadError::complete_upload(format!("{error}")))?;
+        .map_err(|error| GamePackageUploadError::complete_upload(asset, format!("{error}")))?;
     if status >= 400 {
         let (code, message) = parse_server_error(status, &text);
         let detail = server_error_detail(code, message, || format!("HTTP {status}"));
-        return Err(GamePackageUploadError::complete_upload(detail));
+        return Err(GamePackageUploadError::complete_upload(asset, detail));
     }
     let parsed: Value = serde_json::from_str(&text).map_err(|error| {
-        GamePackageUploadError::complete_upload(format!("响应不是合法 JSON：{error}"))
+        GamePackageUploadError::complete_upload(asset, format!("响应不是合法 JSON：{error}"))
     })?;
     let payload = parsed.get("data").unwrap_or(&parsed);
     Ok(GamePackageUploadOutcome {
@@ -303,6 +367,7 @@ async fn complete_upload(
 }
 
 pub(crate) struct GamePackageUploadRequest<'a> {
+    pub(crate) asset: PackageUploadAsset,
     pub(crate) staging_path: &'a Path,
     pub(crate) version_id: &'a str,
     pub(crate) api_base_url: &'a str,
@@ -325,17 +390,22 @@ impl<'a> GamePackageUploadRequest<'a> {
 }
 
 /// 分片续传主循环：权威偏移来自服务端，失败按可重试分类退避，偏移不符立即按权威偏移继续。
-pub(crate) async fn upload_staged_game_package(
+///
+/// 发行包与工程源包共用这一段：差异全部收在 `request.asset`（URL 资源段、文案、偏移错误码、
+/// 是否有预登记大小）。
+pub(crate) async fn upload_staged_version_asset(
     client: &reqwest::Client,
     request: GamePackageUploadRequest<'_>,
     mut on_progress: impl FnMut(u64, u64),
     mut on_verify: impl FnMut(),
 ) -> Result<GamePackageUploadOutcome, String> {
+    let asset = request.asset;
+    let label = asset.label();
     let total_bytes = fs::metadata(request.staging_path)
-        .map_err(|error| format!("读取发行包暂存文件失败：{error}"))?
+        .map_err(|error| format!("读取{label}暂存文件失败：{error}"))?
         .len();
     if total_bytes == 0 {
-        return Err("发行包暂存文件为空，请重新导出试玩包".to_string());
+        return Err(format!("{label}暂存文件为空，请重新导出后再发布"));
     }
     let access_token = request.current_access_token()?;
     let state = read_upload_state(
@@ -343,11 +413,16 @@ pub(crate) async fn upload_staged_game_package(
         request.api_base_url,
         request.version_id,
         &access_token,
+        asset,
     )
     .await?;
-    if state.declared_package_bytes != 0 && state.declared_package_bytes != total_bytes {
+    // 只有发行包在创建版本时预登记了大小；工程源包的体积由 complete 时的整包校验确定。
+    if asset.has_declared_bytes()
+        && state.declared_package_bytes != 0
+        && state.declared_package_bytes != total_bytes
+    {
         return Err(format!(
-            "本地发行包与版本声明的体积不一致（本地 {} 字节，声明 {} 字节），请重新导出后再发布",
+            "本地{label}与版本声明的体积不一致（本地 {} 字节，声明 {} 字节），请重新导出后再发布",
             total_bytes, state.declared_package_bytes
         ));
     }
@@ -359,9 +434,9 @@ pub(crate) async fn upload_staged_game_package(
     let mut received = state.received_bytes.min(total_bytes);
     on_progress(received, total_bytes);
     let mut file = File::open(request.staging_path)
-        .map_err(|error| format!("打开发行包暂存文件失败：{error}"))?;
+        .map_err(|error| format!("打开{label}暂存文件失败：{error}"))?;
     while let Some(plan) = next_chunk_plan(received, total_bytes, chunk_bytes) {
-        let body = read_chunk(&mut file, plan)?;
+        let body = read_chunk(&mut file, plan, asset)?;
         let mut attempt = 1_usize;
         loop {
             let access_token = request.current_access_token()?;
@@ -371,6 +446,7 @@ pub(crate) async fn upload_staged_game_package(
                 request.version_id,
                 &access_token,
                 request.idempotency_key,
+                asset,
                 plan,
                 body.clone(),
             )
@@ -401,6 +477,7 @@ pub(crate) async fn upload_staged_game_package(
             request.api_base_url,
             request.version_id,
             &access_token,
+            asset,
         )
         .await?;
         received = authoritative.received_bytes.min(total_bytes);
@@ -414,6 +491,7 @@ pub(crate) async fn upload_staged_game_package(
         request.version_id,
         &access_token,
         request.idempotency_key,
+        asset,
     )
     .await?;
     outcome.uploaded_bytes = total_bytes;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/main.rs b/apps/ai-game-creator-shell/src-tauri/src/main.rs
index 15e5d4973..cbfa0a0c8 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/main.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/main.rs
@@ -103,6 +103,7 @@ mod editor_adapters;
 mod environment_check;
 pub mod error_report;
 mod game_distribution_publish;
+mod game_fork;
 mod game_package_upload;
 mod game_publish_attempt;
 mod git_inspect;
@@ -119,6 +120,7 @@ mod process_identity;
 mod process_session;
 mod process_session_bridge;
 mod project;
+mod project_bundle;
 mod project_snapshot;
 mod repository_context;
 mod resource_inspect;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project.rs b/apps/ai-game-creator-shell/src-tauri/src/project.rs
index 793d06b0b..0895067f8 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project.rs
@@ -11,6 +11,7 @@ mod checkpoint;
 mod conversation;
 mod external_editor_bindings;
 mod filesystem;
+mod fork_source;
 mod manifest;
 mod memory;
 mod model_usage;
@@ -30,6 +31,7 @@ pub(crate) use checkpoint::*;
 pub(crate) use conversation::*;
 pub(crate) use external_editor_bindings::*;
 pub(crate) use filesystem::*;
+pub(crate) use fork_source::*;
 pub(crate) use manifest::*;
 pub(crate) use memory::*;
 pub(crate) use model_usage::*;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/fork_source.rs b/apps/ai-game-creator-shell/src-tauri/src/project/fork_source.rs
new file mode 100644
index 000000000..11dff5b99
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/fork_source.rs
@@ -0,0 +1,245 @@
+//! 项目 Fork 来源记录：`.agent/fork-source.json`。
+//!
+//! 承载「本项目 Fork 自平台作品 X」这一事实：由「从平台作品 Fork」在取件校验通过、
+//! 建项完成之后写入，由发布链路的首次发布读取并并入创建作品请求的 `fork` 声明。
+//!
+//! 落点选择（与 `docs/【技术方案】游戏共创与作品Fork-2026-10-03.md` §3.5.1 一致）：
+//! - `.agent/**` 随项目快照上云、随用户整目录拷贝，是唯一既「随行」又不干扰游戏产物的位置；
+//! - 导出包（`exports/playtest-package-*.zip`）**不**透传 `.agent/`：这是已知取舍——
+//!   血缘不需要随试玩包分发，平台侧的血缘在创建作品时一次性写入；
+//! - 不改 `manifest.json`：它是 `deny_unknown_fields` 且只接受 v1，加顶层字段等于改契约。
+//!
+//! 读取必须是「可选项语义」：文件缺失、损坏、字段不合法或路径不合格一律按「没有来源记录」
+//! 处理（返回 `None`），绝不能让一个可选元数据文件把发布整体拖失败。
+
+use super::*;
+
+/// 当前写入的记录格式版本。
+///
+/// v2 起多带 `source`（取件形态），v1 记录**仍必须能读**：老项目里已有 v1 文件，
+/// 读不回来就等于把「改编自哪个作品」这条事实丢了。
+pub(crate) const FORK_SOURCE_SCHEMA_VERSION: &str = "agc-fork-source.v2";
+/// 仍接受的旧版本：v1 没有 `source`，按「成品包」解释（当时只有这一条取件通道）。
+pub(crate) const FORK_SOURCE_SCHEMA_VERSION_V1: &str = "agc-fork-source.v1";
+
+/// 取件形态：工程源包（作者的工程）还是已构建成品包。
+#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub(crate) enum ProjectForkSourceKind {
+    /// 已构建的成品包：AGC 侧生成脚手架，并把成品放进 `reference/<gameId>/`。
+    #[default]
+    Package,
+    /// 工程源包：解压即得作者的工程，不需要再生成脚手架。
+    Project,
+}
+
+/// 相对项目根的位置：`.agent` 是项目身份与 Agent 状态的权威目录，整目录随项目同步。
+pub(crate) const FORK_SOURCE_RELATIVE_PATH: &str = ".agent/fork-source.json";
+
+const FORK_SOURCE_LABEL: &str = "项目 Fork 来源记录";
+
+/// 「本项目 Fork 自平台作品」的本地记录。
+///
+/// `schema_version` 必填；`game_id` / `version_id` 是平台侧的作品身份与建立血缘时锁定的父版本，
+/// 发布时原样并入创建作品请求的 `fork` 字段。`source` 从 v2 起记录取件形态；v1 记录没有该字段，
+/// 读回来按「成品包」（当时只有这一条通道），因此老项目仍能正确声明 Fork 来源。
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub(crate) struct ProjectForkSourceRecord {
+    pub(crate) schema_version: String,
+    pub(crate) game_id: String,
+    pub(crate) version_id: String,
+    /// 取件形态；v1 记录缺省 → 成品包。
+    #[serde(default)]
+    pub(crate) source: ProjectForkSourceKind,
+    /// 建项成功的时刻（epoch 毫秒），只作本地审计，不参与任何上传。
+    pub(crate) adopted_at_millis: u64,
+}
+
+impl ProjectForkSourceRecord {
+    /// 新建一条来源记录；时间戳由本模块统一生成，调用方不自己造时间。
+    pub(crate) fn new(game_id: &str, version_id: &str, source: ProjectForkSourceKind) -> Self {
+        Self {
+            schema_version: FORK_SOURCE_SCHEMA_VERSION.to_string(),
+            game_id: game_id.to_string(),
+            version_id: version_id.to_string(),
+            source,
+            adopted_at_millis: now_millis(),
+        }
+    }
+}
+
+fn now_millis() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_millis() as u64)
+        .unwrap_or_default()
+}
+
+/// 来源记录在本项目里的绝对路径。
+pub(crate) fn fork_source_record_path(project_root: &Path) -> PathBuf {
+    project_root.join(FORK_SOURCE_RELATIVE_PATH)
+}
+
+/// 解析来源记录正文：格式版本不认识、字段缺失或标识为空都按「没有来源记录」处理。
+///
+/// 抽成纯函数是为了让「损坏不 panic」这条规则可以被单测钉住，而不是散在读取路径里。
+pub(crate) fn parse_project_fork_source(bytes: &[u8]) -> Option<ProjectForkSourceRecord> {
+    let record: ProjectForkSourceRecord = serde_json::from_slice(bytes).ok()?;
+    // v1 与 v2 都接受：v1 缺 `source`，serde 默认填成品包（见结构体注释）。
+    if record.schema_version != FORK_SOURCE_SCHEMA_VERSION
+        && record.schema_version != FORK_SOURCE_SCHEMA_VERSION_V1
+    {
+        return None;
+    }
+    if record.game_id.trim().is_empty() || record.version_id.trim().is_empty() {
+        return None;
+    }
+    Some(record)
+}
+
+/// 读取来源记录：缺失、损坏、异形一律 `None`，不返回错误、不 panic。
+pub(crate) fn read_project_fork_source(project_root: &Path) -> Option<ProjectForkSourceRecord> {
+    let path = fork_source_record_path(project_root);
+    // 复用私有路径门禁：链接、非普通文件或权限不达标的记录都不读，失败即当作「没有记录」。
+    if !prepare_game_creator_private_path_for_read(&path, false, FORK_SOURCE_LABEL).ok()? {
+        return None;
+    }
+    let bytes = fs::read(&path).ok()?;
+    parse_project_fork_source(&bytes)
+}
+
+/// 写入来源记录：走 AGC 管理文件的统一入口（校验父目录策略、临时 inode 原子安装）。
+pub(crate) fn write_project_fork_source(
+    project_root: &Path,
+    record: &ProjectForkSourceRecord,
+) -> Result<(), String> {
+    let body = serde_json::to_vec_pretty(record)
+        .map_err(|error| format!("序列化 {FORK_SOURCE_LABEL}失败：{error}"))?;
+    write_game_creator_private_file(
+        &fork_source_record_path(project_root),
+        &body,
+        FORK_SOURCE_LABEL,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_root(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|elapsed| elapsed.as_nanos())
+            .unwrap_or_default();
+        let root = std::env::temp_dir().join(format!(
+            "agc-fork-source-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&root).expect("create temp project root");
+        root
+    }
+
+    #[test]
+    fn fork_source_record_round_trips_through_project_agent_directory() {
+        let root = test_root("round-trip");
+        let record = ProjectForkSourceRecord::new(
+            "game_parent_1",
+            "gamever_parent_1",
+            ProjectForkSourceKind::Project,
+        );
+        write_project_fork_source(&root, &record).expect("write fork source record");
+
+        // 落点固定：`.agent/fork-source.json`，不落在项目根，也不进 manifest。
+        assert!(fork_source_record_path(&root).is_file());
+        assert_eq!(
+            fork_source_record_path(&root),
+            root.join(".agent/fork-source.json")
+        );
+        let read = read_project_fork_source(&root).expect("read back");
+        assert_eq!(read, record);
+        assert_eq!(read.schema_version, FORK_SOURCE_SCHEMA_VERSION);
+        assert_eq!(read.source, ProjectForkSourceKind::Project);
+        assert_eq!(read.game_id, "game_parent_1");
+        assert_eq!(read.version_id, "gamever_parent_1");
+        assert!(read.adopted_at_millis > 0);
+
+        // 覆盖写：同一路径第二次写入必须替换而不是失败。
+        let updated = ProjectForkSourceRecord::new(
+            "game_parent_2",
+            "gamever_parent_2",
+            ProjectForkSourceKind::Package,
+        );
+        write_project_fork_source(&root, &updated).expect("overwrite fork source record");
+        assert_eq!(read_project_fork_source(&root), Some(updated));
+    }
+
+    /// v1 记录（M2a 写的，没有 `source`）必须仍能读：否则老项目会丢掉「改编自哪个作品」，
+    /// 发布时静默不带声明。
+    #[test]
+    fn v1_fork_source_record_still_reads_as_package_source() {
+        let root = test_root("v1-compat");
+        let path = fork_source_record_path(&root);
+        write_game_creator_private_file(
+            &path,
+            br#"{"schemaVersion":"agc-fork-source.v1","gameId":"game_legacy","versionId":"gamever_legacy","adoptedAtMillis":123}"#,
+            FORK_SOURCE_LABEL,
+        )
+        .expect("write v1 record");
+
+        let record = read_project_fork_source(&root).expect("v1 记录必须仍可读");
+        assert_eq!(record.schema_version, FORK_SOURCE_SCHEMA_VERSION_V1);
+        assert_eq!(record.game_id, "game_legacy");
+        assert_eq!(record.version_id, "gamever_legacy");
+        // v1 时代只有成品包通道，缺省按成品包解释。
+        assert_eq!(record.source, ProjectForkSourceKind::Package);
+    }
+
+    #[test]
+    fn missing_fork_source_record_reads_as_none() {
+        let root = test_root("missing");
+        assert_eq!(read_project_fork_source(&root), None);
+        // 连 `.agent` 目录都没有时同样只能是 None，不能报错。
+        assert!(!root.join(".agent").exists());
+    }
+
+    #[test]
+    fn corrupted_fork_source_record_reads_as_none_without_panicking() {
+        let root = test_root("corrupted");
+        let path = fork_source_record_path(&root);
+        for body in [
+            // 不是 JSON
+            b"not-json{".as_slice(),
+            // 不是对象
+            b"[]".as_slice(),
+            // 合法 JSON 但缺字段
+            br#"{"schemaVersion":"agc-fork-source.v1","gameId":"game_1"}"#.as_slice(),
+            // 未知顶层字段（deny_unknown_fields）
+            br#"{"schemaVersion":"agc-fork-source.v1","gameId":"game_1","versionId":"v1","adoptedAtMillis":1,"extra":true}"#.as_slice(),
+            // 完全不认识的格式版本（v1/v2 之外的都按「没有记录」）
+            br#"{"schemaVersion":"agc-fork-source.v9","gameId":"game_1","versionId":"v1","adoptedAtMillis":1}"#.as_slice(),
+            // 已知版本但 source 取值非法
+            br#"{"schemaVersion":"agc-fork-source.v2","gameId":"game_1","versionId":"v1","source":"remix","adoptedAtMillis":1}"#.as_slice(),
+            // 标识为空
+            br#"{"schemaVersion":"agc-fork-source.v1","gameId":"  ","versionId":"v1","adoptedAtMillis":1}"#.as_slice(),
+            // 空文件
+            b"".as_slice(),
+        ] {
+            write_game_creator_private_file(&path, body, FORK_SOURCE_LABEL)
+                .expect("write corrupted record");
+            assert_eq!(read_project_fork_source(&root), None, "{body:?}");
+        }
+        // 目录顶替文件：不是普通文件，同样只能得到 None。
+        fs::remove_file(&path).expect("remove file");
+        fs::create_dir(&path).expect("create directory in place of record");
+        assert_eq!(read_project_fork_source(&root), None);
+    }
+
+    #[test]
+    fn fork_source_parse_accepts_only_current_schema_and_non_empty_identifiers() {
+        let valid = br#"{"schemaVersion":"agc-fork-source.v1","gameId":"game_1","versionId":"gamever_1","adoptedAtMillis":7}"#;
+        let record = parse_project_fork_source(valid).expect("valid record");
+        assert_eq!(record.adopted_at_millis, 7);
+        assert!(parse_project_fork_source(b"null").is_none());
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project_bundle.rs b/apps/ai-game-creator-shell/src-tauri/src/project_bundle.rs
new file mode 100644
index 000000000..6f55748e3
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/project_bundle.rs
@@ -0,0 +1,1416 @@
+//! 工程源包（project bundle）：把当前项目打成**确定性 ZIP**，供 M2b「版本级工程源包」上传使用。
+//!
+//! 与 `project/export.rs` 的发行包是两条路：发行包只装构建产物（`dist` 树 + 根 `assets` +
+//! `exports/README.md`，见 `collect_project_export_package_files`），并且会做资源引用归一化；
+//! 工程源包要的是**作者本地的可编辑工程**（源码 + 配置 + 素材），因此**不改写任何一个字节**，
+//! 收到方解压后就是一份能继续改、能重新构建的工程（`docs/【技术方案】游戏共创与作品Fork-2026-10-03.md` §3.5.2）。
+//!
+//! **ZIP 根目录 == 项目根**（与模板包同一条合同）：条目名一律是**项目根相对**路径，与打包范围
+//! 无关；`ProjectBundleScope::GameDirectory` 只缩小内容范围（只收集 `game/` 下的内容），不改变
+//! 条目命名口径——因此收到方总是往项目根解。
+//!
+//! 复用了哪些既有能力（避免第二套真相）：
+//! - 条目路径门禁用解压侧同一个 `template_library::safe_archive_relative_path`（拒绝对路径、
+//!   `..`、盘符、反斜杠，并统一成 `/`），保证「打得出来就一定解得回去」；
+//! - 根相对路径用 `project::relative_project_path`；
+//! - 符号链接与 Windows 重解析点用 `image_inspect::metadata_is_windows_reparse_point`；
+//! - 确定性 ZIP 写法沿用 `project/export.rs` 归一化发行包那套（先排序再逐文件写入）。
+//!
+//! **未**复用 `collect_project_export_package_dir_files`：它没有「按排除规则剪枝」的钩子，会先
+//! 遍历整个 `node_modules` 再交给调用方过滤；而且它对非普通条目是静默忽略，本模块要求失败关闭。
+//!
+//! ## 排除规则（**以服务端校验器为权威**，两侧必须逐条覆盖）
+//!
+//! 规则集拆成下面这些 `const` 而不是散在 `matches!` 里：`scripts/check-project-bundle-policy-parity.mjs`
+//! 会逐 token 比对两侧，机器门禁靠的就是这些常量（改规则必须同时改两侧，否则红）。
+//!
+//! 服务端权威实现：`server-rs/crates/module-game-distribution/src/project_bundle.rs`
+//! （`reject_forbidden_path` / `is_sensitive_file_name` / `MAX_PROJECT_*`）。
+//!
+//! | 类别 | 规则 | 理由 |
+//! | --- | --- | --- |
+//! | 依赖与版本库 | 任意层级 `node_modules` / `.git` / `.svn` | 依赖可重装；版本库元数据泄漏提交历史与远端地址 |
+//! | AGC 平台保留名 | 任意层级 `.agent` | 项目身份 + Agent 运行数据 + 本机改编来源记录，见 `bundle_excludes_agc_owned_dir` |
+//! | 凭据目录 | 任意层级 `.aws` / `.ssh` / `.kube` / `.docker` / `.gnupg` / `.terraform` / `.secrets` | 长期凭据、集群与注册表配置、私钥环、Terraform 状态（可能含明文 secret） |
+//! | 构建产物 | 项目根首层 `dist` / `build` / `library` / `temp` / `local`（服务端权威）；**客户端额外**：`game/` 首层 `dist` / `build` | 产物可重建；AGC 网页脚手架的 vite `outDir` 就落在 `game/dist`，源码包不该带 |
+//! | IDE / 编辑器 | 项目根首层 `.idea` / `.vscode`（服务端权威）；**客户端额外** `.godot` | 编辑器缓存，模板包指南同样排除 |
+//! | 凭据与隐私 | 任意层级 前缀 `.env` / `credentials` / `id_rsa` / `id_ecdsa` / `id_dsa` / `id_ed25519` / `terraform.tfstate` / `service-account`、后缀 `.pem` / `.key` / `.p12` / `.pfx` / `.jks` / `.keystore` / `.ppk` / `.p8` / `.kdbx` / `.der` / `.map` / `.zip`、全名 `.npmrc` / `.netrc` / `.git-credentials` / `.htpasswd` / `.pgpass` | 凭据外发不可撤销；`.map` 可反推源码与内部路径；`.zip` 是嵌套压缩包，解包阶段不递归校验等于绕过整份清单 |
+//! | 嵌套压缩包 | 任意层级后缀并集 `.zip` / `.tar` / `.gz` / `.tgz` / `.7z` / `.rar` / `.jar` / `.whl` / `.nupkg`，并在打包每个文件前**嗅探头部字节**（改名成 `.dat` 也拒） | 解包阶段不递归校验包里的包 |
+//! | 凭据内容 | 文本型（白名单扩展名或无扩展名）且 ≤ 256 KiB 的条目做特征扫描：PEM 私钥块、AWS Access Key ID、GitHub / Slack token | 兜住「未知凭据文件名」；只做低误报强特征，命中即**报错**而不是静默跳过 |
+//! | AGC 生成物 | **客户端额外** 项目根首层 `exports` / `memory` | 见 `bundle_excludes_agc_owned_dir` |
+//!
+//! 路径形状（含结尾点 / 空格、`<>"\|\?*`、空段、`.`/`..` 段）由 `bundle_entry_path_shape_error`
+//! 按服务端 `normalize_archive_path` 的口径拒绝：**报错**而不是静默改名，否则作者会打出服务端
+//! 必然 422 的包。
+//!
+//! 规模上限**与服务端逐项相等**（服务端是安全边界）：压缩包 ≤ 200 MiB、展开总量 ≤ 500 MiB、
+//! 单文件 ≤ 64 MiB、条目 ≤ 10 000、单条目声明解压大小 ≤ 该条目压缩字节 × 100。超限**失败关闭**
+//! 并点名违规条目，不静默截断——客户端先拦，就不会出现「传到一半被服务端 422 拒掉」。
+//!
+//! 调用方：发布链路的 `game_distribution_publish::upload_project_bundle_for_version`（授权非
+//! 「禁止共创」且作者未取消时，随版本上传工程源包）；取件侧的摘要校验与它共用 `sha256_hex`。
+use super::*;
+use std::io::Write;
+
+/// 压缩包（zip）体积上限：与服务端 `MAX_PROJECT_BUNDLE_BYTES` 相等——反代放行量按 200 MiB 校准，
+/// 超过它的包根本到不了 api-server，客户端必须提前拦。
+pub(crate) const PROJECT_BUNDLE_MAX_ARCHIVE_BYTES: u64 = 200 * 1024 * 1024;
+/// 展开后总量上限：与服务端 `MAX_PROJECT_EXPANDED_BYTES` 相等。
+pub(crate) const PROJECT_BUNDLE_MAX_EXPANDED_BYTES: u64 = 500 * 1024 * 1024;
+/// 单文件（解压后）上限：与服务端 `MAX_PROJECT_FILE_BYTES` 相等。
+pub(crate) const PROJECT_BUNDLE_MAX_FILE_BYTES: u64 = 64 * 1024 * 1024;
+/// 条目数上限：与服务端 `MAX_PROJECT_FILE_COUNT` 相等。
+pub(crate) const PROJECT_BUNDLE_MAX_FILES: usize = 10_000;
+/// 单条目压缩比上限：与服务端 `MAX_PROJECT_COMPRESSION_RATIO` 相等。分母是**该条目自身
+/// 的压缩字节**（不是整包体积）：整包分母下，一个 10 MiB 的包单条可以声明 1 GiB 而不触发。
+pub(crate) const PROJECT_BUNDLE_MAX_COMPRESSION_RATIO: u64 = 100;
+
+/// 任意层级都排除的目录名（依赖、版本库元数据、平台保留名、凭据目录）。
+const BUNDLE_EXCLUDED_ANY_LEVEL_DIRS: &[&str] = &[
+    "node_modules",
+    ".git",
+    ".svn",
+    ".agent",
+    // 凭据目录：家庭目录里那些装长期凭据 / 集群配置 / 私钥环 / Terraform 状态的目录。
+    ".aws",
+    ".ssh",
+    ".kube",
+    ".docker",
+    ".gnupg",
+    ".terraform",
+    ".secrets",
+];
+/// 项目根首层排除的构建产物目录（服务端权威口径）。
+const BUNDLE_EXCLUDED_ROOT_BUILD_DIRS: &[&str] = &["dist", "build", "library", "temp", "local"];
+/// 项目根首层排除的 IDE / 编辑器目录（`.godot` 是客户端额外项）。
+const BUNDLE_EXCLUDED_ROOT_IDE_DIRS: &[&str] = &[".idea", ".vscode", ".godot"];
+/// **客户端额外项**：`game/` 首层排除的构建产物（AGC 网页脚手架 vite `outDir` 落点）。
+const BUNDLE_EXCLUDED_GAME_BUILD_DIRS: &[&str] = &["dist", "build"];
+/// **客户端额外项**：项目根首层排除的 AGC 生成目录（`exports` 试玩包、`memory` Agent 记忆）。
+const BUNDLE_EXCLUDED_ROOT_AGC_DIRS: &[&str] = &["exports", "memory"];
+/// 任意层级按**前缀**排除的文件名（`.env*`、SSH 私钥名、云凭据文件名）。
+const BUNDLE_EXCLUDED_FILE_PREFIXES: &[&str] = &[
+    ".env",
+    "credentials",
+    "id_rsa",
+    "id_ecdsa",
+    "id_dsa",
+    "id_ed25519",
+    "terraform.tfstate",
+    "service-account",
+];
+/// 任意层级按**后缀**排除的文件名：凭据、源码映射、嵌套压缩包（扩展名并集）。
+const BUNDLE_EXCLUDED_FILE_SUFFIXES: &[&str] = &[
+    ".pem",
+    ".key",
+    ".p12",
+    ".pfx",
+    ".jks",
+    ".keystore",
+    ".ppk",
+    ".p8",
+    ".kdbx",
+    ".der",
+    ".map",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".tgz",
+    ".7z",
+    ".rar",
+    ".jar",
+    ".whl",
+    ".nupkg",
+];
+/// 任意层级按**全名**排除的文件名。
+const BUNDLE_EXCLUDED_FILE_NAMES: &[&str] = &[
+    ".npmrc",
+    ".netrc",
+    ".git-credentials",
+    ".htpasswd",
+    ".pgpass",
+];
+
+/// 与服务端 `normalize_archive_path` 逐字符对齐：路径段里出现任一字符即拒。
+///
+/// 含 `\`：服务端在路径层就拒反斜杠（`path.contains('\\')`），一致门禁把该字面量并入
+/// 「禁止字符」集比对，所以这里也列出来；函数里另有显式的反斜杠分支先拦（语义不变）。
+pub(crate) const BUNDLE_FORBIDDEN_PATH_CHARS: &[char] = &[':', '<', '>', '"', '|', '?', '*', '\\'];
+/// 路径段以任一字符结尾即拒（服务端同口径）。
+pub(crate) const BUNDLE_FORBIDDEN_PATH_SUFFIX_CHARS: &[char] = &[' ', '.'];
+/// 不允许出现的路径段（服务端同口径）。
+pub(crate) const BUNDLE_FORBIDDEN_PATH_SEGMENTS: &[&str] = &[".", ".."];
+
+/// 嵌套压缩包头部嗅探读取的字节数（与服务端同名同值）。
+const NESTED_ARCHIVE_SNIFF_BYTES: usize = 512;
+
+/// 内容嗅探的文本白名单扩展名（不含点、小写比较）：只对文本型条目做凭据特征扫描。
+///
+/// 刻意不做更宽的前缀启发（例如把 `sk-` 也当密钥）：误报会直接阻断作者发布，
+/// 而 `sk-` 同时也是无害字符串的常见前缀，收益与代价不成比例。宁可漏报未知命名，
+/// 也不让作者为一个正常文件反复试错。
+const SECRET_CONTENT_TEXT_EXTENSIONS: &[&str] = &[
+    "txt", "md", "json", "yml", "yaml", "toml", "ini", "cfg", "conf", "js", "ts", "tsx", "jsx",
+    "py", "rs", "go", "java", "sh", "ps1", "bat", "env",
+];
+/// 内容嗅探的条目大小上限：与服务端同名同值。
+const SECRET_CONTENT_MAX_SNIFF_BYTES: u64 = 256 * 1024;
+/// 简单子串特征：命中任一即判定疑似凭据（GitHub / Slack token）。
+const SECRET_CONTENT_SIGNATURES: &[&str] = &["ghp_", "github_pat_", "xoxa-", "xoxb-", "xoxp-"];
+/// AWS Access Key ID 的固定前缀：后面必须紧跟 16 位大写字母 / 数字才算命中。
+const SECRET_AWS_ACCESS_KEY_PREFIX: &str = "AKIA";
+/// PEM 私钥块的行首标记：必须与 `PEM_PRIVATE_KEY_MARKER` 出现在同一行才判定。
+const PEM_PRIVATE_KEY_LINE_PREFIX: &str = "-----BEGIN ";
+/// PEM 私钥块的类型标记。
+const PEM_PRIVATE_KEY_MARKER: &str = "PRIVATE KEY-----";
+
+/// ZIP 里给每个条目写的固定时间戳：ZIP 能表示的最早时刻（1980-01-01 00:00:00）。
+/// 同内容必须得到同一份字节，所以绝不写「打包时刻」。
+const PROJECT_BUNDLE_FIXED_ZIP_SECONDS: (u16, u8, u8, u8, u8, u8) = (1980, 1, 1, 0, 0, 0);
+/// ZIP 里给每个条目写的固定权限位：普通文件 0o644，不受本机 umask 与可执行位影响。
+const PROJECT_BUNDLE_FILE_MODE: u32 = 0o644;
+
+/// 打包范围：只决定**收集哪些内容**，不改变条目命名（条目始终相对项目根）。
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ProjectBundleScope {
+    /// 整个项目（源码 + 配置 + 素材）；发布链路的工程源包上传用这一档。
+    WholeProject,
+    /// 只收集 `game/` 下的内容（`game/index.html` 这类源码入口及其同级文件）。
+    ///
+    /// **目前只有测试在用**：发布链路一律上传整个项目——收到方要能直接打开并重新构建，
+    /// 只带 `game/` 会丢掉根 `assets/`。保留这一档是因为「打包范围」仍是打包器的对外入参，
+    /// 且这一档的剪枝与「没有 game/ 目录」失败关闭已被两条用例覆盖；真有生产调用方时去掉
+    /// `#[cfg(test)]`。
+    #[cfg(test)]
+    GameDirectory,
+}
+
+/// 规模上限。默认值就是合同常量（与服务端逐项相等）；测试用小上限跑同一段逻辑，不另写检查路径。
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct ProjectBundleLimits {
+    pub(crate) max_files: usize,
+    pub(crate) max_file_bytes: u64,
+    pub(crate) max_expanded_bytes: u64,
+    pub(crate) max_archive_bytes: u64,
+    pub(crate) max_compression_ratio: u64,
+}
+
+impl Default for ProjectBundleLimits {
+    fn default() -> Self {
+        Self {
+            max_files: PROJECT_BUNDLE_MAX_FILES,
+            max_file_bytes: PROJECT_BUNDLE_MAX_FILE_BYTES,
+            max_expanded_bytes: PROJECT_BUNDLE_MAX_EXPANDED_BYTES,
+            max_archive_bytes: PROJECT_BUNDLE_MAX_ARCHIVE_BYTES,
+            max_compression_ratio: PROJECT_BUNDLE_MAX_COMPRESSION_RATIO,
+        }
+    }
+}
+
+/// 打好的工程源包。
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct ProjectBundle {
+    pub(crate) bytes: Vec<u8>,
+    pub(crate) sha256: String,
+    pub(crate) file_count: usize,
+    /// 与 ZIP 条目一一对应（项目根相对、`/` 分隔、已排序）。
+    pub(crate) entry_paths: Vec<String>,
+}
+
+/// 打包器与服务端摘要、Fork 取件校验共用的同一个十六进制摘要实现。
+pub(crate) fn sha256_hex(bytes: &[u8]) -> String {
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(bytes);
+    format!("{:x}", hasher.finalize())
+}
+
+/// 把项目打成确定性工程源包（按合同上限）。
+pub(crate) fn build_project_bundle(
+    root: &Path,
+    scope: ProjectBundleScope,
+) -> Result<ProjectBundle, String> {
+    build_project_bundle_with_limits(root, scope, ProjectBundleLimits::default())
+}
+
+/// 同上，但上限可注入：只给测试用小上限跑同一段检查逻辑用。
+pub(crate) fn build_project_bundle_with_limits(
+    root: &Path,
+    scope: ProjectBundleScope,
+    limits: ProjectBundleLimits,
+) -> Result<ProjectBundle, String> {
+    if root.as_os_str().is_empty() || !root.is_absolute() {
+        return Err("工程源包打包需要项目根的绝对路径".to_string());
+    }
+    let root_metadata = fs::symlink_metadata(root)
+        .map_err(|error| format!("读取项目根失败：{}: {error}", root.display()))?;
+    if root_metadata.file_type().is_symlink() || !root_metadata.is_dir() {
+        return Err("工程源包的项目根必须是普通目录".to_string());
+    }
+    let walk_root = match scope {
+        ProjectBundleScope::WholeProject => root.to_path_buf(),
+        // 见 `ProjectBundleScope::GameDirectory` 的注释：这一档目前只有测试覆盖。
+        #[cfg(test)]
+        ProjectBundleScope::GameDirectory => {
+            let game_root = root.join("game");
+            if !game_root.is_dir() {
+                return Err("项目里没有 game/ 目录，无法只打包游戏目录".to_string());
+            }
+            game_root
+        }
+    };
+
+    let entries = collect_project_bundle_entries(root, &walk_root, &limits)?;
+    if entries.is_empty() {
+        return Err("工程源包里没有可打包的文件（内容都被排除规则挡掉了）".to_string());
+    }
+    let bytes = write_project_bundle_zip(&entries)?;
+    // 压缩包体积：服务端按反代放行量（200 MiB）卡这一条，客户端必须提前拦，否则白传一趟。
+    if bytes.len() as u64 > limits.max_archive_bytes {
+        return Err(format!(
+            "工程源包压缩后超过上限（{} > {} 字节）；请删掉不必要的大文件后重试",
+            bytes.len(),
+            limits.max_archive_bytes
+        ));
+    }
+    // 压缩比：与服务端同一判据——**单条目**声明解压大小 ≤ 该条目压缩字节 × 倍数。
+    // 直接回读刚产出的 zip 中央目录，拿到的就是服务端会读到的同一组数值。
+    // 分母不能用整包字节：那样一个几 MB 的包单条声明 1 GiB 也不触发，起不到防线作用；
+    // 整包维度由上面的包体积上限与收集阶段的单文件 / 累计展开量上限承担。
+    let mut produced = zip::ZipArchive::new(std::io::Cursor::new(bytes.as_slice()))
+        .map_err(|error| format!("工程源包自检失败：{error}"))?;
+    for index in 0..entries.len() {
+        let file = produced
+            .by_index(index)
+            .map_err(|error| format!("工程源包自检失败：{error}"))?;
+        if file.size()
+            > file
+                .compressed_size()
+                .saturating_mul(limits.max_compression_ratio)
+        {
+            return Err(format!(
+                "工程源包条目压缩比超过上限（{} 字节的解压内容 > 压缩后 {} 字节 × {}）：{}",
+                file.size(),
+                file.compressed_size(),
+                limits.max_compression_ratio,
+                file.name()
+            ));
+        }
+    }
+    Ok(ProjectBundle {
+        sha256: sha256_hex(&bytes),
+        bytes,
+        file_count: entries.len(),
+        entry_paths: entries.into_iter().map(|entry| entry.entry_path).collect(),
+    })
+}
+
+/// 单个待打包条目：`entry_path` 是项目根相对的 ZIP 条目名，`project_relative` 用于排除规则。
+struct ProjectBundleEntry {
+    entry_path: String,
+    project_relative: String,
+    absolute: PathBuf,
+    size: u64,
+}
+
+/// 递归收集（按排除规则剪枝），并按条目名排序——排序是确定性的一部分。
+fn collect_project_bundle_entries(
+    root: &Path,
+    walk_root: &Path,
+    limits: &ProjectBundleLimits,
+) -> Result<Vec<ProjectBundleEntry>, String> {
+    let mut entries = Vec::new();
+    let mut total_bytes: u64 = 0;
+    // 大小写折叠后的条目名：服务端拒绝折叠后重名的包（解包结果取决于文件系统大小写敏感度），
+    // 客户端提前失败关闭，不让作者传到一半才吃到 422。
+    let mut case_folded_entry_paths = std::collections::BTreeSet::new();
+    let mut directories = vec![walk_root.to_path_buf()];
+    while let Some(directory) = directories.pop() {
+        let mut children = fs::read_dir(&directory)
+            .map_err(|error| format!("读取项目目录失败：{}: {error}", directory.display()))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|error| format!("读取项目目录项失败：{}: {error}", directory.display()))?;
+        // 目录项顺序不稳定，先按名字排序，保证同一份内容每次都按同一顺序处理。
+        children.sort_by_key(|entry| entry.file_name());
+        for child in children {
+            let path = child.path();
+            let project_relative = crate::project::relative_project_path(root, &path)?;
+            if bundle_excludes_relative_path(&project_relative) {
+                continue;
+            }
+            let metadata = fs::symlink_metadata(&path)
+                .map_err(|error| format!("读取项目条目失败：{project_relative}: {error}"))?;
+            if metadata.file_type().is_symlink()
+                || crate::image_inspect::metadata_is_windows_reparse_point(&metadata)
+            {
+                return Err(format!(
+                    "工程源包不允许符号链接或重解析点：{project_relative}"
+                ));
+            }
+            if metadata.is_dir() {
+                directories.push(path);
+                continue;
+            }
+            if !metadata.is_file() {
+                return Err(format!("工程源包只接受普通文件与目录：{project_relative}"));
+            }
+            let size = metadata.len();
+            if size > limits.max_file_bytes {
+                return Err(format!(
+                    "工程源包单文件超过上限（{size} > {} 字节）：{project_relative}",
+                    limits.max_file_bytes
+                ));
+            }
+            total_bytes = total_bytes.saturating_add(size);
+            if total_bytes > limits.max_expanded_bytes {
+                return Err(format!(
+                    "工程源包解压后总量超过上限（>{} 字节，累计到 {project_relative}）",
+                    limits.max_expanded_bytes
+                ));
+            }
+            if entries.len() + 1 > limits.max_files {
+                return Err(format!(
+                    "工程源包条目数超过上限（>{} 条，累计到 {project_relative}）",
+                    limits.max_files
+                ));
+            }
+            // 条目名过一遍解压侧的同一道门禁，再统一成 `/` 分隔；两边只有一份路径规则。
+            let entry_path = crate::template_library::safe_archive_relative_path(&project_relative)
+                .map_err(|_| format!("工程源包条目路径无效：{project_relative}"))?;
+            let entry_path = entry_path.to_string_lossy().replace('\\', "/");
+            // 路径形状再按服务端 `normalize_archive_path` 逐字符核一遍：命中即**报错**，
+            // 不做 trim / 丢段那种静默改名（改名后作者不知道，服务端还会 422）。
+            if let Some(error) = bundle_entry_path_shape_error(&entry_path) {
+                return Err(error);
+            }
+            if !case_folded_entry_paths.insert(entry_path.to_ascii_lowercase()) {
+                return Err(format!(
+                    "工程源包里有大小写折叠后重名的条目（服务端会拒收）：{entry_path}"
+                ));
+            }
+            entries.push(ProjectBundleEntry {
+                entry_path,
+                project_relative,
+                absolute: path,
+                size,
+            });
+        }
+    }
+    entries.sort_by(|left, right| left.entry_path.cmp(&right.entry_path));
+    Ok(entries)
+}
+
+/// 写确定性 ZIP：条目顺序已排好，时间戳与权限位固定，压缩方式固定。
+///
+/// 只写**文件**条目，不写目录条目：解压侧会按需补父目录（`extract_template_archive` 的行为），
+/// 目录条目只会给 ZIP 引入额外的可变属性。
+fn write_project_bundle_zip(entries: &[ProjectBundleEntry]) -> Result<Vec<u8>, String> {
+    let modified = zip::DateTime::from_date_and_time(
+        PROJECT_BUNDLE_FIXED_ZIP_SECONDS.0,
+        PROJECT_BUNDLE_FIXED_ZIP_SECONDS.1,
+        PROJECT_BUNDLE_FIXED_ZIP_SECONDS.2,
+        PROJECT_BUNDLE_FIXED_ZIP_SECONDS.3,
+        PROJECT_BUNDLE_FIXED_ZIP_SECONDS.4,
+        PROJECT_BUNDLE_FIXED_ZIP_SECONDS.5,
+    )
+    .map_err(|error| format!("工程源包固定时间戳无效：{error}"))?;
+    let options = zip::write::SimpleFileOptions::default()
+        .compression_method(zip::CompressionMethod::Deflated)
+        .last_modified_time(modified)
+        .unix_permissions(PROJECT_BUNDLE_FILE_MODE);
+    let mut writer = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    for entry in entries {
+        let content = fs::read(&entry.absolute).map_err(|error| {
+            format!("读取工程源包文件失败：{}: {error}", entry.project_relative)
+        })?;
+        if content.len() as u64 != entry.size {
+            return Err(format!(
+                "工程源包条目在打包期间发生变化：{}",
+                entry.project_relative
+            ));
+        }
+        // 嵌套压缩包：扩展名并集已经在收集阶段排掉了，这里按**头部字节**兜住改名
+        // （`deps.dat` 里装的是 zip / 7z / rar / gzip / tar 一样拒），命中即报错点名路径。
+        if let Some(format) = nested_archive_format(&content) {
+            return Err(format!(
+                "工程源包不允许嵌套压缩包：{} 是 {format} 格式，请先在本地解开或删掉后再打包",
+                entry.project_relative
+            ));
+        }
+        // 凭据内容嗅探：只扫文本型且不大的条目，命中即报错并点名命中的特征。
+        if is_secret_content_candidate(&entry.entry_path, entry.size) {
+            if let Some(signature) = secret_content_signature(&content) {
+                return Err(format!(
+                    "工程源包条目疑似包含凭据（命中 {signature}），已阻断打包：{}",
+                    entry.project_relative
+                ));
+            }
+        }
+        writer
+            .start_file(entry.entry_path.as_str(), options)
+            .map_err(|error| format!("写入工程源包条目失败：{}: {error}", entry.entry_path))?;
+        writer
+            .write_all(&content)
+            .map_err(|error| format!("写入工程源包内容失败：{}: {error}", entry.entry_path))?;
+    }
+    let cursor = writer
+        .finish()
+        .map_err(|error| format!("完成工程源包失败：{error}"))?;
+    Ok(cursor.into_inner())
+}
+
+/// 是否排除某个**项目根相对**路径（`/` 分隔、已规范化、大小写不敏感比较）。
+///
+/// 规则集来自模块头部的 `const`（`BUNDLE_EXCLUDED_*`）：`scripts/check-project-bundle-policy-parity.mjs`
+/// 会与服务端校验器逐 token 比对，所以这里只做「查表」，不再内联字面量。
+fn bundle_excludes_relative_path(relative_path: &str) -> bool {
+    let components = relative_path.split('/').collect::<Vec<_>>();
+    let Some(file_name) = components.last().copied() else {
+        return false;
+    };
+    let first = components[0].to_ascii_lowercase();
+    let second = components.get(1).map(|value| value.to_ascii_lowercase());
+    // 依赖、版本库与平台保留名：任意层级命中即剪枝（`node_modules` 可能上万条，不能先收集再过滤）。
+    if components.iter().any(|component| {
+        BUNDLE_EXCLUDED_ANY_LEVEL_DIRS
+            .iter()
+            .any(|excluded| component.eq_ignore_ascii_case(excluded))
+    }) {
+        return true;
+    }
+    if BUNDLE_EXCLUDED_ROOT_BUILD_DIRS
+        .iter()
+        .chain(BUNDLE_EXCLUDED_ROOT_IDE_DIRS)
+        .chain(BUNDLE_EXCLUDED_ROOT_AGC_DIRS)
+        .any(|excluded| first == *excluded)
+    {
+        return true;
+    }
+    // 客户端额外项：AGC 网页脚手架的构建输出落在 `game/dist` / `game/build`。
+    if first == "game"
+        && second.as_deref().is_some_and(|value| {
+            BUNDLE_EXCLUDED_GAME_BUILD_DIRS
+                .iter()
+                .any(|excluded| value == *excluded)
+        })
+    {
+        return true;
+    }
+    bundle_excludes_sensitive_file_name(file_name)
+}
+
+/// 凭据、隐私与嵌套压缩包：按文件名判定，任意层级都要排除。
+///
+/// 与服务端 `is_sensitive_file_name` 逐条对应（前缀 / 后缀 / 全名三类），并额外覆盖 `.zip`
+/// ——服务端在 `reject_forbidden_path` 里以同样的后缀形式拒收嵌套压缩包。
+fn bundle_excludes_sensitive_file_name(file_name: &str) -> bool {
+    let name = file_name.to_ascii_lowercase();
+    BUNDLE_EXCLUDED_FILE_PREFIXES
+        .iter()
+        .any(|prefix| name.starts_with(prefix))
+        || BUNDLE_EXCLUDED_FILE_SUFFIXES
+            .iter()
+            .any(|suffix| name.ends_with(suffix))
+        || BUNDLE_EXCLUDED_FILE_NAMES
+            .iter()
+            .any(|excluded| name == *excluded)
+}
+
+/// 条目路径形状检查：与服务端 `normalize_archive_path` 逐字符对齐。
+///
+/// 返回 `Some(可读错误)` 表示该条目名会被服务端 422（`InvalidPath`），客户端必须提前
+/// **报错**——不做「整体 trim + 丢空段 / `.` 段」那种静默改名（改名后作者不知道，
+/// 服务端照样拒）。规则全部来自 `BUNDLE_FORBIDDEN_PATH_*` 常量，便于一致性门禁比对。
+fn bundle_entry_path_shape_error(entry_path: &str) -> Option<String> {
+    if entry_path.is_empty() {
+        return Some("工程源包条目路径为空".to_string());
+    }
+    if entry_path.contains('\\') {
+        return Some(format!("工程源包条目路径不能包含反斜杠：{entry_path}"));
+    }
+    if entry_path.starts_with('/') {
+        return Some(format!("工程源包条目路径不能以 / 开头：{entry_path}"));
+    }
+    for segment in entry_path.split('/') {
+        if segment.is_empty() {
+            return Some(format!(
+                "工程源包条目路径不能包含空段（连续的 /）：{entry_path}"
+            ));
+        }
+        if BUNDLE_FORBIDDEN_PATH_SEGMENTS.contains(&segment) {
+            return Some(format!(
+                "工程源包条目路径不能包含 {segment} 段：{entry_path}"
+            ));
+        }
+        if segment.ends_with(BUNDLE_FORBIDDEN_PATH_SUFFIX_CHARS) {
+            return Some(format!(
+                "工程源包条目路径段不能以空格或点结尾（服务端会拒收）：{entry_path}"
+            ));
+        }
+        if let Some(character) = segment
+            .chars()
+            .find(|character| BUNDLE_FORBIDDEN_PATH_CHARS.contains(character))
+        {
+            return Some(format!(
+                "工程源包条目路径不能包含字符 {character:?}（服务端会拒收）：{entry_path}"
+            ));
+        }
+    }
+    None
+}
+
+/// 嵌套压缩包头部嗅探：从头 512 字节判已知归档格式，返回格式名。
+///
+/// 判的是**内容**而不是文件名：改名成 `deps.dat` 的归档靠这里兜住。
+fn nested_archive_format(content: &[u8]) -> Option<&'static str> {
+    let head = &content[..content.len().min(NESTED_ARCHIVE_SNIFF_BYTES)];
+    if head.starts_with(b"PK\x03\x04") {
+        return Some("zip");
+    }
+    if head.starts_with(b"7z\xBC\xAF\x27\x1C") {
+        return Some("7z");
+    }
+    if head.starts_with(b"Rar!\x1A\x07") {
+        return Some("rar");
+    }
+    if head.starts_with(b"\x1F\x8B") {
+        return Some("gzip");
+    }
+    if head.len() >= 262 && &head[257..262] == b"ustar" {
+        return Some("tar");
+    }
+    None
+}
+
+/// 是否值得做凭据内容嗅探：非空、≤ 256 KiB，且扩展名属于文本白名单
+/// （**无扩展名也算文本**——`credentials`、`config` 这类凭据文件常常没有扩展名）。
+fn is_secret_content_candidate(entry_path: &str, size: u64) -> bool {
+    if size == 0 || size > SECRET_CONTENT_MAX_SNIFF_BYTES {
+        return false;
+    }
+    let name = entry_path.rsplit('/').next().unwrap_or(entry_path);
+    let extension = match name.rfind('.') {
+        Some(index) if index > 0 && index + 1 < name.len() => &name[index + 1..],
+        _ => return true,
+    };
+    SECRET_CONTENT_TEXT_EXTENSIONS
+        .iter()
+        .any(|allowed| extension.eq_ignore_ascii_case(allowed))
+}
+
+/// 凭据内容嗅探：命中任一已知强特征就返回特征说明（错误信息用它点名）。
+///
+/// 只做低误报的强特征；刻意不把 `sk-` 之类的前缀算进来（见 `SECRET_CONTENT_TEXT_EXTENSIONS`
+/// 的口径说明）——误报会直接阻断作者发布。
+fn secret_content_signature(content: &[u8]) -> Option<&'static str> {
+    if pem_private_key_detected(content) {
+        return Some("PEM 私钥块");
+    }
+    if aws_access_key_id_detected(content) {
+        return Some("AWS Access Key ID");
+    }
+    if SECRET_CONTENT_SIGNATURES
+        .iter()
+        .any(|signature| contains_bytes(content, signature.as_bytes()))
+    {
+        return Some("GitHub / Slack token");
+    }
+    None
+}
+
+/// PEM 私钥块：行首标记与私钥类型标记出现在**同一行**（证书块不会带 `PRIVATE KEY-----`）。
+fn pem_private_key_detected(content: &[u8]) -> bool {
+    content.split(|byte| *byte == b'\n').any(|line| {
+        contains_bytes(line, PEM_PRIVATE_KEY_LINE_PREFIX.as_bytes())
+            && contains_bytes(line, PEM_PRIVATE_KEY_MARKER.as_bytes())
+    })
+}
+
+/// AWS Access Key ID：`AKIA` 后紧跟 16 位大写字母或数字。
+fn aws_access_key_id_detected(content: &[u8]) -> bool {
+    let prefix = SECRET_AWS_ACCESS_KEY_PREFIX.as_bytes();
+    content
+        .windows(prefix.len())
+        .enumerate()
+        .any(|(index, window)| {
+            window == prefix
+                && content
+                    .get(index + prefix.len()..index + prefix.len() + 16)
+                    .is_some_and(|tail| {
+                        tail.iter()
+                            .all(|byte| byte.is_ascii_uppercase() || byte.is_ascii_digit())
+                    })
+        })
+}
+
+/// `haystack` 是否包含 `needle`（不引入正则依赖的等价实现）。
+fn contains_bytes(haystack: &[u8], needle: &[u8]) -> bool {
+    !needle.is_empty()
+        && haystack
+            .windows(needle.len())
+            .any(|window| window == needle)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeSet;
+
+    fn test_root(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map(|elapsed| elapsed.as_nanos())
+            .unwrap_or_default();
+        let root = std::env::temp_dir().join(format!(
+            "agc-project-bundle-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&root).expect("create temp root");
+        root
+    }
+
+    fn write_file(root: &Path, relative: &str, content: &[u8]) {
+        let path = root.join(relative);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).expect("create parent");
+        }
+        fs::write(&path, content).expect("write fixture file");
+    }
+
+    /// 变化内容的普通源码文本：压缩比远低于 100，用来证明默认倍数不会误拒正常工程。
+    fn varied_source_text(len: usize) -> Vec<u8> {
+        let mut output = Vec::with_capacity(len);
+        let mut counter = 0_u64;
+        while output.len() < len {
+            output.extend_from_slice(
+                format!("const value_{counter} = compute({counter}, \"{counter}\");\n").as_bytes(),
+            );
+            counter += 1;
+        }
+        output.truncate(len);
+        output
+    }
+
+    /// 一份典型 AGC 网页工程：`game/` 源码 + 根 `assets/` + 少量要排除的东西。
+    fn write_fixture_project(root: &Path) {
+        write_file(root, "game/index.html", b"<html></html>");
+        write_file(
+            root,
+            "game/package.json",
+            br#"{"dependencies":{"phaser":"4.2.1"}}"#,
+        );
+        write_file(root, "game/vite.config.js", b"export default {};");
+        write_file(root, "assets/hero.png", b"png-bytes");
+        write_file(root, ".gitignore", b"node_modules\n");
+    }
+
+    fn entry_set(bundle: &ProjectBundle) -> BTreeSet<String> {
+        bundle.entry_paths.iter().cloned().collect()
+    }
+
+    #[test]
+    fn bundle_excludes_dependency_and_vcs_directories_at_any_level() {
+        let root = test_root("vcs");
+        write_fixture_project(&root);
+        write_file(&root, "node_modules/phaser/package.json", b"{}");
+        write_file(
+            &root,
+            "game/node_modules/left-pad/index.js",
+            b"module.exports = 1;",
+        );
+        write_file(&root, ".git/config", b"[core]");
+        write_file(&root, "game/.git/HEAD", b"ref: refs/heads/main");
+        write_file(&root, "docs/.svn/entries", b"x");
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let entries = entry_set(&bundle);
+        assert!(entries.contains("game/index.html"));
+        assert!(entries.contains("assets/hero.png"));
+        assert!(entries.contains(".gitignore"));
+        for excluded in [
+            "node_modules/phaser/package.json",
+            "game/node_modules/left-pad/index.js",
+            ".git/config",
+            "game/.git/HEAD",
+            "docs/.svn/entries",
+        ] {
+            assert!(!entries.contains(excluded), "{excluded} 不应进包");
+        }
+    }
+
+    #[test]
+    fn bundle_excludes_root_build_and_editor_directories_and_game_build_output() {
+        let root = test_root("build");
+        write_fixture_project(&root);
+        for excluded in [
+            "dist/index.html",
+            "build/game.js",
+            "library/imports.json",
+            "temp/cache.bin",
+            "local/settings.json",
+            ".idea/workspace.xml",
+            ".vscode/settings.json",
+            ".godot/editor_state.cfg",
+            // AGC 网页脚手架的构建输出落在 game/ 下：产物可重建，不该随源码外发。
+            "game/dist/index.html",
+            "game/build/game.js",
+        ] {
+            write_file(&root, excluded, b"generated");
+        }
+        write_file(&root, "game/src/main.js", b"console.log('kept');");
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let entries = entry_set(&bundle);
+        assert!(entries.contains("game/src/main.js"));
+        for excluded in [
+            "dist/index.html",
+            "build/game.js",
+            "library/imports.json",
+            "temp/cache.bin",
+            "local/settings.json",
+            ".idea/workspace.xml",
+            ".vscode/settings.json",
+            ".godot/editor_state.cfg",
+            "game/dist/index.html",
+            "game/build/game.js",
+        ] {
+            assert!(!entries.contains(excluded), "{excluded} 不应进包");
+        }
+    }
+
+    #[test]
+    fn bundle_excludes_credentials_and_privacy_files_at_any_level() {
+        let root = test_root("credentials");
+        write_fixture_project(&root);
+        write_file(&root, ".env", b"TOKEN=1");
+        write_file(&root, ".env.local", b"TOKEN=2");
+        // 服务端用 `starts_with(".env")`，`.envrc` 这类同样落在前缀里，客户端必须一起排。
+        write_file(&root, ".envrc", b"export TOKEN=3");
+        write_file(&root, ".npmrc", b"//registry.test/:_authToken=x");
+        write_file(&root, ".netrc", b"machine x");
+        write_file(&root, ".git-credentials", b"https://user:token@host");
+        write_file(&root, "deploy/id_rsa", b"private key");
+        write_file(&root, "deploy/id_ed25519.pub", b"public key");
+        write_file(&root, "game/certs/dev.pem", b"pem");
+        write_file(&root, "game/certs/key.KEY", b"key");
+        write_file(&root, "assets/signing.p12", b"p12");
+        write_file(&root, "game/ios/export.pfx", b"pfx");
+        // 源码映射会暴露原始源码与内部路径，服务端按隐私类拒收。
+        write_file(&root, "game/dist/app.js.map", b"{\"version\":3}");
+        write_file(&root, "game/src/app.js.map", b"{\"version\":3}");
+        // P0-a：更多 SSH 私钥名、云凭据文件名、密钥库后缀。
+        write_file(&root, "deploy/id_ecdsa", b"private key");
+        write_file(&root, "deploy/id_dsa", b"private key");
+        write_file(&root, "deploy/credentials.json", b"{\"token\":\"x\"}");
+        write_file(
+            &root,
+            "ci/service-account.json",
+            b"{\"type\":\"service_account\"}",
+        );
+        write_file(&root, "infra/terraform.tfstate", b"{}");
+        write_file(&root, "certs/truststore.jks", b"jks");
+        write_file(&root, "certs/app.keystore", b"keystore");
+        write_file(&root, "deploy/key.ppk", b"ppk");
+        write_file(&root, "apple/AuthKey.p8", b"p8");
+        write_file(&root, "db/passwords.kdbx", b"kdbx");
+        write_file(&root, "certs/ca.der", b"der");
+        write_file(&root, ".htpasswd", b"user:hash");
+        write_file(&root, ".pgpass", b"host:5432:*:user:pass");
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let entries = entry_set(&bundle);
+        for excluded in [
+            ".env",
+            ".env.local",
+            ".envrc",
+            ".npmrc",
+            ".netrc",
+            ".git-credentials",
+            "deploy/id_rsa",
+            "deploy/id_ed25519.pub",
+            "game/certs/dev.pem",
+            "game/certs/key.KEY",
+            "assets/signing.p12",
+            "game/ios/export.pfx",
+            "game/dist/app.js.map",
+            "game/src/app.js.map",
+            "deploy/id_ecdsa",
+            "deploy/id_dsa",
+            "deploy/credentials.json",
+            "ci/service-account.json",
+            "infra/terraform.tfstate",
+            "certs/truststore.jks",
+            "certs/app.keystore",
+            "deploy/key.ppk",
+            "apple/AuthKey.p8",
+            "db/passwords.kdbx",
+            "certs/ca.der",
+            ".htpasswd",
+            ".pgpass",
+        ] {
+            assert!(!entries.contains(excluded), "{excluded} 不应进包");
+        }
+        assert!(entries.contains("game/index.html"));
+    }
+
+    /// 嵌套压缩包：解包阶段不会递归校验包里的包，服务端一律拒收，客户端必须一样排掉。
+    #[test]
+    fn bundle_excludes_nested_archives_at_any_level() {
+        let root = test_root("nested-archive");
+        write_fixture_project(&root);
+        write_file(&root, "assets/sprites.zip", b"PK\x03\x04");
+        write_file(&root, "game/vendor/tool.ZIP", b"PK\x03\x04");
+        write_file(&root, "game/levels/pack.zip", b"PK\x03\x04");
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let entries = entry_set(&bundle);
+        for excluded in [
+            "assets/sprites.zip",
+            "game/vendor/tool.ZIP",
+            "game/levels/pack.zip",
+        ] {
+            assert!(!entries.contains(excluded), "{excluded} 不应进包");
+        }
+        assert!(entries.contains("assets/hero.png"));
+    }
+
+    /// P0-c：扩展名并集逐条排除（`.tar.gz` 由 `.gz` 覆盖）。
+    #[test]
+    fn bundle_excludes_every_nested_archive_extension() {
+        let root = test_root("nested-extension-union");
+        write_fixture_project(&root);
+        let excluded = [
+            "assets/vendor.zip",
+            "assets/vendor.tar",
+            "assets/vendor.tar.gz",
+            "assets/vendor.gz",
+            "assets/vendor.tgz",
+            "assets/vendor.7z",
+            "assets/vendor.rar",
+            "assets/vendor.jar",
+            "assets/vendor.whl",
+            "assets/vendor.nupkg",
+        ];
+        for path in excluded {
+            write_file(&root, path, b"payload");
+        }
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let entries = entry_set(&bundle);
+        for path in excluded {
+            assert!(!entries.contains(path), "{path} 不应进包");
+        }
+        assert!(entries.contains("assets/hero.png"));
+    }
+
+    /// P0-c：改名成 `.dat` 装归档格式 → **报错**（不是静默跳过），错误要点名路径与格式。
+    #[test]
+    fn bundle_rejects_renamed_nested_archives_by_magic_bytes() {
+        let root = test_root("nested-magic");
+        write_fixture_project(&root);
+        write_file(&root, "game/vendor/deps.dat", b"PK\x03\x04payload");
+        let error = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect_err("改名后的 zip 必须报错");
+        assert!(
+            error.contains("game/vendor/deps.dat") && error.contains("zip"),
+            "错误必须点名路径与格式：{error}"
+        );
+
+        write_file(&root, "game/vendor/deps.dat", b"\x1F\x8B\x08\x00payload");
+        let error = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect_err("改名后的 gzip 必须报错");
+        assert!(
+            error.contains("game/vendor/deps.dat") && error.contains("gzip"),
+            "错误必须点名路径与格式：{error}"
+        );
+
+        // 正常二进制文件不误报。
+        write_file(&root, "game/vendor/deps.dat", b"\x89PNG\r\n\x1a\nrest");
+        assert!(build_project_bundle(&root, ProjectBundleScope::WholeProject).is_ok());
+    }
+
+    /// P0-a：凭据目录任意层级排除；名字只是前缀的普通目录 / 文件必须保留。
+    #[test]
+    fn bundle_excludes_credential_directories_at_any_level() {
+        let root = test_root("credential-dirs");
+        write_fixture_project(&root);
+        for excluded in [
+            ".aws/config",
+            ".ssh/known_hosts",
+            ".kube/config",
+            ".docker/config.json",
+            ".gnupg/pubring.kbx",
+            ".terraform/plugins.json",
+            ".secrets/vault.json",
+            "game/nested/.SSH/known_hosts",
+        ] {
+            write_file(&root, excluded, b"credential");
+        }
+        write_file(&root, "src/.sshrc", b"harmless");
+        write_file(&root, "docker/Dockerfile", b"FROM scratch");
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let entries = entry_set(&bundle);
+        for excluded in [
+            ".aws/config",
+            ".ssh/known_hosts",
+            ".kube/config",
+            ".docker/config.json",
+            ".gnupg/pubring.kbx",
+            ".terraform/plugins.json",
+            ".secrets/vault.json",
+            "game/nested/.SSH/known_hosts",
+        ] {
+            assert!(!entries.contains(excluded), "{excluded} 不应进包");
+        }
+        assert!(entries.contains("src/.sshrc"));
+        assert!(entries.contains("docker/Dockerfile"));
+    }
+
+    /// P0-a：文本型小文件命中凭据特征 → 报错点名特征；二进制与弱特征不误报。
+    #[test]
+    fn bundle_rejects_secret_content_in_small_text_files() {
+        let root = test_root("secret-content");
+        write_fixture_project(&root);
+        write_file(
+            &root,
+            "deploy/production-secret",
+            b"aws_access_key_id = AKIAIOSFODNN7EXAMPLE\n",
+        );
+        let error = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect_err("AWS Access Key ID 必须报错");
+        assert!(
+            error.contains("deploy/production-secret") && error.contains("AWS Access Key ID"),
+            "错误必须点名路径与特征：{error}"
+        );
+
+        fs::remove_file(root.join("deploy/production-secret")).expect("remove fixture");
+        write_file(
+            &root,
+            "config/pem.txt",
+            b"-----BEGIN OPENSSH PRIVATE KEY-----\nb3BlbnNzaC1rZXk=\n",
+        );
+        let error = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect_err("PEM 私钥块必须报错");
+        assert!(
+            error.contains("config/pem.txt") && error.contains("PEM"),
+            "错误必须点名路径与特征：{error}"
+        );
+
+        // 误报防线：证书块不是私钥、`AKIA` 长度不足、二进制扩展名不扫。
+        fs::remove_file(root.join("config/pem.txt")).expect("remove fixture");
+        write_file(
+            &root,
+            "docs/cert.txt",
+            b"-----BEGIN CERTIFICATE-----\nMIIB\n",
+        );
+        write_file(
+            &root,
+            "src/notes.md",
+            b"AKIA-SHORT\nBEGIN without the marker\n",
+        );
+        write_file(
+            &root,
+            "assets/logo.png",
+            b"\x89PNG\r\n\x1a\naws_access_key_id = AKIAIOSFODNN7EXAMPLE",
+        );
+        assert!(build_project_bundle(&root, ProjectBundleScope::WholeProject).is_ok());
+    }
+
+    /// P1-a：路径形状与服务端 `normalize_archive_path` 逐字符对齐，命中即报错。
+    #[test]
+    fn bundle_entry_path_shape_error_matches_the_server_rule() {
+        let rejects: &[(&str, &str)] = &[
+            ("src/a?.ts", "?"),
+            ("x.", "空格或点结尾"),
+            ("x ", "空格或点结尾"),
+            ("a//b", "空段"),
+            ("./x", "不能包含 . 段"),
+            ("foo/../bar", "不能包含 .. 段"),
+            ("C:/evil", "不能包含字符 ':'"),
+        ];
+        for (path, expected) in rejects {
+            let error =
+                bundle_entry_path_shape_error(path).unwrap_or_else(|| panic!("{path} 必须被拒"));
+            assert!(
+                error.contains(expected),
+                "{path} 的错误应包含 {expected}：{error}"
+            );
+        }
+        for path in ["game/src/main.ts", "assets/hero.png", ".gitignore"] {
+            assert_eq!(bundle_entry_path_shape_error(path), None, "{path} 应放行");
+        }
+    }
+
+    /// 用客户端依赖的 zip 直接造一个包：用来证明「服务端是独立把关的一侧」——
+    /// 客户端打包器按设计不会把这些条目放进包，所以只能手工构造给服务端校验器。
+    fn zip_with(entries: &[(&str, &[u8])]) -> Vec<u8> {
+        let mut writer = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+        for (path, content) in entries {
+            writer
+                .start_file(*path, zip::write::SimpleFileOptions::default())
+                .expect("zip entry");
+            writer.write_all(content).expect("zip content");
+        }
+        writer.finish().expect("finish zip").into_inner()
+    }
+
+    /// P1-b 执行级交叉证据：客户端打包器产出的**真实字节**必须被服务端校验器接受，
+    /// 且两份清单（路径 / 摘要 / 文件数）逐项一致——不是只靠文本级的一致性门禁。
+    #[test]
+    fn bundle_bytes_are_accepted_by_the_server_validator() {
+        let root = test_root("cross-validator");
+        write_fixture_project(&root);
+        write_file(&root, "game/src/main.js", b"console.log('hello');");
+        write_file(
+            &root,
+            "game/src/deep/nested/mod.js",
+            b"export const ok = true;",
+        );
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let manifest = module_game_distribution::validate_project_bundle_zip(&bundle.bytes)
+            .expect("客户端产物必须被服务端校验器接受");
+        assert_eq!(manifest.bundle_bytes, bundle.bytes.len() as u64);
+        assert_eq!(manifest.bundle_sha256, bundle.sha256);
+        assert_eq!(manifest.files.len(), bundle.file_count);
+        assert_eq!(
+            manifest
+                .files
+                .iter()
+                .map(|file| file.path.as_str())
+                .collect::<Vec<_>>(),
+            bundle
+                .entry_paths
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<_>>(),
+        );
+
+        // 反例：服务端是独立把关的一侧——含 `.env` / `node_modules` 的包必须被拒，
+        // 而不是「客户端拦了、服务端照收」。
+        let with_env = zip_with(&[("package.json", b"{}"), (".env", b"TOKEN=1")]);
+        assert_eq!(
+            module_game_distribution::validate_project_bundle_zip(&with_env),
+            Err(module_game_distribution::ProjectBundleError::SensitiveFileNotAllowed)
+        );
+        let with_dependencies =
+            zip_with(&[("package.json", b"{}"), ("node_modules/x/index.js", b"x")]);
+        assert_eq!(
+            module_game_distribution::validate_project_bundle_zip(&with_dependencies),
+            Err(module_game_distribution::ProjectBundleError::DependencyDirectoryNotAllowed)
+        );
+    }
+
+    #[test]
+    fn bundle_excludes_agent_state_playtest_packages_and_memory() {
+        let root = test_root("agc-owned");
+        write_fixture_project(&root);
+        write_file(&root, ".agent/manifest.json", br#"{"schemaVersion":"v1"}"#);
+        write_file(
+            &root,
+            ".agent/fork-source.json",
+            br#"{"gameId":"game_parent"}"#,
+        );
+        write_file(&root, ".agent/conversations/project.jsonl", b"{}\n");
+        // 平台保留名按「任意层级」对齐服务端：嵌套的项目状态同样不能外发。
+        write_file(&root, "game/.agent/state.json", b"{}");
+        write_file(&root, "exports/playtest-package-1.zip", b"PK\x03\x04");
+        write_file(&root, "exports/README.md", b"# playtest");
+        write_file(&root, "memory/agents/design.md", b"agent memory");
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let entries = entry_set(&bundle);
+        for excluded in [
+            ".agent/manifest.json",
+            ".agent/fork-source.json",
+            ".agent/conversations/project.jsonl",
+            "game/.agent/state.json",
+            "exports/playtest-package-1.zip",
+            "exports/README.md",
+            "memory/agents/design.md",
+        ] {
+            assert!(!entries.contains(excluded), "{excluded} 不应进包");
+        }
+        // 身份与来源记录都由收到方自己建项/取件时生成，不能从包里继承。
+        assert!(entries.iter().all(|entry| !entry.contains(".agent/")));
+    }
+
+    #[test]
+    fn bundle_is_deterministic_across_runs_and_creation_order() {
+        let first_root = test_root("deterministic-a");
+        write_fixture_project(&first_root);
+        write_file(&first_root, "game/src/a.js", b"a");
+        write_file(&first_root, "game/src/b.js", b"b");
+
+        // 同内容、不同创建顺序：条目必须按路径排序，摘要必须一致。
+        let second_root = test_root("deterministic-b");
+        write_file(&second_root, "game/src/b.js", b"b");
+        write_file(&second_root, "game/src/a.js", b"a");
+        write_file(&second_root, "game/index.html", b"<html></html>");
+        write_file(&second_root, "game/vite.config.js", b"export default {};");
+        write_file(
+            &second_root,
+            "game/package.json",
+            br#"{"dependencies":{"phaser":"4.2.1"}}"#,
+        );
+        write_file(&second_root, "assets/hero.png", b"png-bytes");
+        write_file(&second_root, ".gitignore", b"node_modules\n");
+
+        let first = build_project_bundle(&first_root, ProjectBundleScope::WholeProject)
+            .expect("first bundle");
+        let second = build_project_bundle(&second_root, ProjectBundleScope::WholeProject)
+            .expect("second bundle");
+        assert_eq!(first.sha256, second.sha256);
+        assert_eq!(first.bytes, second.bytes);
+        // 5 个基线文件 + 2 个 game/src 文件。
+        assert_eq!(first.file_count, 7);
+        assert_eq!(first.entry_paths, second.entry_paths);
+        let mut sorted = first.entry_paths.clone();
+        sorted.sort();
+        assert_eq!(first.entry_paths, sorted, "条目必须按路径排序");
+
+        // 同一份目录打两次也必须同摘要（时间戳与权限位固定，不写打包时刻）。
+        let again = build_project_bundle(&first_root, ProjectBundleScope::WholeProject)
+            .expect("repeat bundle");
+        assert_eq!(again.sha256, first.sha256);
+
+        // 改一个字节 → 摘要必须变，别把「确定性」做成「永远同一个摘要」。
+        write_file(&first_root, "game/src/a.js", b"changed");
+        let changed = build_project_bundle(&first_root, ProjectBundleScope::WholeProject)
+            .expect("changed bundle");
+        assert_ne!(changed.sha256, first.sha256);
+    }
+
+    #[test]
+    fn bundle_entries_stay_relative_and_forward_slashed() {
+        let root = test_root("entry-paths");
+        write_fixture_project(&root);
+        write_file(&root, "game/src/deep/nested/mod.js", b"x");
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        for entry in &bundle.entry_paths {
+            assert!(!entry.starts_with('/'), "{entry} 不能是绝对路径");
+            assert!(!entry.contains('\\'), "{entry} 必须用 / 分隔");
+            assert!(!entry.contains(".."), "{entry} 不能上跳");
+            assert!(
+                !entry.contains(':'),
+                "{entry} 不能带盘符或冒号（与解压侧门禁一致）"
+            );
+            // 解压侧同一道门禁必须原样接受这些条目名。
+            crate::template_library::safe_archive_relative_path(entry)
+                .unwrap_or_else(|error| panic!("{entry} 应被解压侧接受：{error}"));
+        }
+    }
+
+    #[test]
+    fn bundle_survives_the_existing_extractor_round_trip() {
+        let root = test_root("round-trip");
+        write_fixture_project(&root);
+        write_file(
+            &root,
+            "game/src/game-scene.js",
+            b"export const hello = 'world';",
+        );
+
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject).expect("bundle");
+        let destination = test_root("round-trip-out");
+        let written =
+            crate::template_library::extract_template_archive(&bundle.bytes, &destination)
+                .expect("工程源包必须能被既有解压器解开");
+        assert_eq!(written, bundle.file_count);
+        for entry in &bundle.entry_paths {
+            assert!(destination.join(entry).is_file(), "{entry} 解压后应存在");
+        }
+        assert_eq!(
+            fs::read(destination.join("game/src/game-scene.js")).unwrap(),
+            b"export const hello = 'world';"
+        );
+    }
+
+    #[test]
+    fn game_directory_scope_only_collects_game_content() {
+        let root = test_root("game-scope");
+        write_fixture_project(&root);
+        write_file(&root, "exports/README.md", b"# playtest");
+
+        let bundle =
+            build_project_bundle(&root, ProjectBundleScope::GameDirectory).expect("game bundle");
+        let entries = entry_set(&bundle);
+        assert!(entries.contains("game/index.html"));
+        assert!(entries.contains("game/package.json"));
+        assert!(!entries.iter().any(|entry| entry.starts_with("assets/")));
+        // 条目仍然相对项目根：收到方总是往项目根解。
+        assert!(entries.iter().all(|entry| entry.starts_with("game/")));
+        // game/ 下只有 index.html / package.json / vite.config.js 三个文件。
+        assert_eq!(bundle.file_count, 3);
+    }
+
+    #[test]
+    fn game_directory_scope_requires_a_game_directory() {
+        let root = test_root("no-game-dir");
+        write_file(&root, "assets/hero.png", b"png");
+        let error = build_project_bundle(&root, ProjectBundleScope::GameDirectory)
+            .expect_err("缺少 game/ 必须失败");
+        assert!(error.contains("game/"), "{error}");
+    }
+
+    #[test]
+    fn empty_bundle_fails_closed() {
+        let root = test_root("empty");
+        write_file(&root, "node_modules/only/index.js", b"x");
+        let error = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect_err("空包必须失败");
+        assert!(error.contains("没有可打包的文件"), "{error}");
+    }
+
+    #[test]
+    fn bundle_fails_closed_when_file_count_exceeds_limit() {
+        let root = test_root("limit-files");
+        write_file(&root, "game/index.html", b"0123456789");
+        write_file(&root, "game/extra.js", b"0123456789");
+        let error = build_project_bundle_with_limits(
+            &root,
+            ProjectBundleScope::WholeProject,
+            ProjectBundleLimits {
+                max_files: 1,
+                ..ProjectBundleLimits::default()
+            },
+        )
+        .expect_err("超出条目数必须失败");
+        assert!(error.contains("条目数超过上限"), "{error}");
+    }
+
+    #[test]
+    fn bundle_fails_closed_when_single_file_exceeds_limit() {
+        let root = test_root("limit-file-bytes");
+        write_file(&root, "game/index.html", b"0123456789");
+        let error = build_project_bundle_with_limits(
+            &root,
+            ProjectBundleScope::WholeProject,
+            ProjectBundleLimits {
+                max_file_bytes: 9,
+                ..ProjectBundleLimits::default()
+            },
+        )
+        .expect_err("超出单文件上限必须失败");
+        assert!(
+            error.contains("单文件超过上限") && error.contains("game/index.html"),
+            "错误必须点名违规条目：{error}"
+        );
+    }
+
+    #[test]
+    fn bundle_fails_closed_when_expanded_bytes_exceed_limit() {
+        let root = test_root("limit-expanded-bytes");
+        write_file(&root, "game/index.html", b"0123456789");
+        write_file(&root, "game/extra.js", b"0123456789");
+        let error = build_project_bundle_with_limits(
+            &root,
+            ProjectBundleScope::WholeProject,
+            ProjectBundleLimits {
+                max_expanded_bytes: 15,
+                ..ProjectBundleLimits::default()
+            },
+        )
+        .expect_err("超出总量上限必须失败");
+        assert!(error.contains("总量超过上限"), "{error}");
+        // 失败关闭而不是静默截断：这里必须真的报错，而不是给出一个被裁过的包。
+        assert!(build_project_bundle_with_limits(
+            &root,
+            ProjectBundleScope::WholeProject,
+            ProjectBundleLimits {
+                max_expanded_bytes: 20,
+                ..ProjectBundleLimits::default()
+            },
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn bundle_fails_closed_when_archive_bytes_exceed_limit() {
+        let root = test_root("limit-archive-bytes");
+        write_file(&root, "game/index.html", b"<html></html>");
+        let error = build_project_bundle_with_limits(
+            &root,
+            ProjectBundleScope::WholeProject,
+            ProjectBundleLimits {
+                max_archive_bytes: 16,
+                ..ProjectBundleLimits::default()
+            },
+        )
+        .expect_err("压缩包超过上限必须失败");
+        assert!(error.contains("压缩后超过上限"), "{error}");
+        // 上限给足时必须能打出来（证明上面那条是上限在拦，不是别的原因）。
+        assert!(build_project_bundle_with_limits(
+            &root,
+            ProjectBundleScope::WholeProject,
+            ProjectBundleLimits {
+                max_archive_bytes: 4 * 1024,
+                ..ProjectBundleLimits::default()
+            },
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn bundle_fails_closed_when_compression_ratio_exceeds_limit() {
+        let root = test_root("limit-compression-ratio");
+        // 4 KiB 的高度可压缩内容：压缩后几十字节，真实压缩比远大于 1。
+        write_file(&root, "game/levels/big.txt", &vec![b'a'; 4 * 1024]);
+        let error = build_project_bundle_with_limits(
+            &root,
+            ProjectBundleScope::WholeProject,
+            ProjectBundleLimits {
+                max_compression_ratio: 1,
+                ..ProjectBundleLimits::default()
+            },
+        )
+        .expect_err("压缩比超过上限必须失败");
+        assert!(error.contains("压缩比超过上限"), "{error}");
+
+        // 分母是**单条目的压缩字节**：4 KiB 全 'a' 的真实压缩比超过 100，
+        // 默认倍数下同样必须拒（旧实现用整包字节做分母，这里会误放行）。
+        let error = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect_err("单条目压缩比超标必须失败");
+        assert!(error.contains("压缩比超过上限"), "{error}");
+
+        // 正常源码内容压缩比远低于 100，默认倍数下必须能正常打包。
+        write_file(&root, "game/levels/big.txt", &varied_source_text(4 * 1024));
+        let bundle = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect("default ratio must accept ordinary source text");
+        assert_eq!(bundle.file_count, 1);
+    }
+
+    #[test]
+    fn contract_limits_match_the_server_validator_exactly() {
+        // 锚点：与服务端 `MAX_PROJECT_*` 逐项相等。这些值由
+        // `scripts/check-project-bundle-policy-parity.mjs` 机器比对，改数值必须是有意识的决定。
+        assert_eq!(PROJECT_BUNDLE_MAX_ARCHIVE_BYTES, 200 * 1024 * 1024);
+        assert_eq!(PROJECT_BUNDLE_MAX_EXPANDED_BYTES, 500 * 1024 * 1024);
+        assert_eq!(PROJECT_BUNDLE_MAX_FILE_BYTES, 64 * 1024 * 1024);
+        assert_eq!(PROJECT_BUNDLE_MAX_FILES, 10_000);
+        assert_eq!(PROJECT_BUNDLE_MAX_COMPRESSION_RATIO, 100);
+        let limits = ProjectBundleLimits::default();
+        assert_eq!(limits.max_archive_bytes, PROJECT_BUNDLE_MAX_ARCHIVE_BYTES);
+        assert_eq!(limits.max_expanded_bytes, PROJECT_BUNDLE_MAX_EXPANDED_BYTES);
+        assert_eq!(limits.max_file_bytes, PROJECT_BUNDLE_MAX_FILE_BYTES);
+        assert_eq!(limits.max_files, PROJECT_BUNDLE_MAX_FILES);
+        assert_eq!(
+            limits.max_compression_ratio,
+            PROJECT_BUNDLE_MAX_COMPRESSION_RATIO
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn bundle_rejects_symbolic_links() {
+        use std::os::unix::fs::symlink;
+        let root = test_root("symlink");
+        write_fixture_project(&root);
+        symlink(root.join("game/index.html"), root.join("game/linked.html"))
+            .expect("create symlink");
+        let error = build_project_bundle(&root, ProjectBundleScope::WholeProject)
+            .expect_err("符号链接必须失败关闭");
+        assert!(error.contains("符号链接"), "{error}");
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/template_library.rs b/apps/ai-game-creator-shell/src-tauri/src/template_library.rs
index 571a1e3da..92b906c1b 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/template_library.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/template_library.rs
@@ -639,7 +639,10 @@ pub(crate) fn safe_archive_relative_path(raw: &str) -> Result<PathBuf, String> {
     Ok(path)
 }
 
-fn extract_template_archive(bytes: &[u8], destination: &Path) -> Result<usize, String> {
+/// 解压模板归档到目标目录：条目数、单文件大小、符号链接与条目路径都走同一套门禁。
+///
+/// `pub(crate)`：Fork 取件（`game_fork`）复用同一套归档门禁，不另起一份解压实现。
+pub(crate) fn extract_template_archive(bytes: &[u8], destination: &Path) -> Result<usize, String> {
     let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes))
         .map_err(|error| format!("模板包不是有效 zip：{error}"))?;
     if archive.len() > TEMPLATE_ARCHIVE_MAX_FILES {
diff --git a/apps/ai-game-creator-shell/src-tauri/tauri.conf.json b/apps/ai-game-creator-shell/src-tauri/tauri.conf.json
index 63cd157e0..3db4fc244 100644
--- a/apps/ai-game-creator-shell/src-tauri/tauri.conf.json
+++ b/apps/ai-game-creator-shell/src-tauri/tauri.conf.json
@@ -60,6 +60,11 @@
     ]
   },
   "plugins": {
+    "deep-link": {
+      "desktop": {
+        "schemes": ["genarrative"]
+      }
+    },
     "updater": {
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDRFN0NFOEUzNDczNDg4Q0IKUldUTGlEUkg0K2g4VGpaQ3FiTXdoNnJTV0JDSWU4VjQrTkcrMkovS2RleFloUXVhdWZIVGpMOTYK",
       "endpoints": [
diff --git a/apps/ai-game-creator-shell/src/components/game-distribution/changeSummary.ts b/apps/ai-game-creator-shell/src/components/game-distribution/changeSummary.ts
new file mode 100644
index 000000000..2ba042eb3
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/components/game-distribution/changeSummary.ts
@@ -0,0 +1,38 @@
+/**
+ * 衍生作品「本次核心改动说明」的本地拦挡与错误文案。
+ *
+ * 长度区间与服务端 `GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS` / `_MAX_CHARS` 同值
+ * （`server-rs/crates/module-game-distribution/src/domain.rs:369,377`），按**字符数**计、
+ * 忽略首尾空白；唯一判据仍在服务端（`game_distribution_change_summary_violation`），
+ * 这里只负责「能不能提交」与可读提示，避免两套判据漂移。
+ */
+export const CHANGE_SUMMARY_MIN_CHARS = 20;
+export const CHANGE_SUMMARY_MAX_CHARS = 500;
+
+/** 衍生作品的核心改动说明校验：返回可读错误（空串 = 通过）。 */
+export function validateChangeSummary(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return '衍生作品发布新版本必须填写「本次核心改动说明」';
+  }
+  const length = Array.from(trimmed).length;
+  if (length < CHANGE_SUMMARY_MIN_CHARS || length > CHANGE_SUMMARY_MAX_CHARS) {
+    return `「本次核心改动说明」需为 ${CHANGE_SUMMARY_MIN_CHARS} 到 ${CHANGE_SUMMARY_MAX_CHARS} 个字符（当前 ${length}）`;
+  }
+  return '';
+}
+
+/**
+ * 发布失败的展示文案：**保留服务端稳定错误码**（客户端要能按码分支、排障也要看到码），
+ * 核心改动说明的两个码额外给一句可操作说明。
+ */
+export function describePublishFailure(error: unknown): string {
+  const text = error instanceof Error ? error.message : String(error);
+  if (text.includes('FORK_CHANGE_SUMMARY_REQUIRED')) {
+    return `FORK_CHANGE_SUMMARY_REQUIRED：衍生作品发布新版本必须填写「本次核心改动说明」（${CHANGE_SUMMARY_MIN_CHARS}–${CHANGE_SUMMARY_MAX_CHARS} 字）`;
+  }
+  if (text.includes('FORK_CHANGE_SUMMARY_INVALID')) {
+    return `FORK_CHANGE_SUMMARY_INVALID：本次核心改动说明需为 ${CHANGE_SUMMARY_MIN_CHARS} 到 ${CHANGE_SUMMARY_MAX_CHARS} 个字符（按字符计，忽略首尾空白）`;
+  }
+  return text;
+}
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx b/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
index d9b28f376..bef4625d3 100644
--- a/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
+++ b/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
@@ -21,6 +21,8 @@ import {
   canSubscribeTauriEvents,
   subscribeTauriEvent,
 } from '../../services/tauriEventSubscription';
+import CoCreationView from '../../view/co-creation';
+import ForkConfirmView from '../../view/fork-confirm';
 import HomeView from '../../view/home';
 import { type LauncherView, Sidebar } from '../../view/layout';
 import ProjectDevelopmentView from '../../view/project-development';
@@ -39,6 +41,11 @@ import {
 } from '../../view/project-development/projectResourceLiveUpdateModel';
 import TemplateLibraryView from '../../view/template-library';
 import { useDirectActiveTurns } from '../agent-runtime/directActiveTurns';
+import { useForkConfirmStore } from '../platform-fork/forkConfirmTarget';
+import {
+  subscribeForkDeepLink,
+  useForkDeepLinkStore,
+} from '../platform-fork/forkDeepLink';
 import { projectPathsMatchForInvalidation } from '../project-summary/projectPath';
 import { RuntimeConfigDialog } from '../runtime-config/RuntimeConfigDialog';
 import { useTemplateLibrary } from '../template-library/useTemplateLibrary';
@@ -659,6 +666,56 @@ export function WorkspaceLauncherShell({
     };
   }, [refreshActiveProjectManifestFromDisk]);
 
+  /**
+   * Fork 深链（`genarrative://fork?gameId=…`）。
+   *
+   * 原生侧收链后已经聚焦主窗口，这里只做两件事：把请求交给首页的 Fork 入口（预填输入框），
+   * 并在用户不处于项目工作区时切回首页，让那个入口可见。**不在这里触发下载**——预填之后需要
+   * 用户自己按「Fork 到我的项目」（工程源包是 200 MiB 级别）。
+   *
+   * 正停在项目工作区时不强行切走（那会把用户从正在进行的项目里踢出来）：请求留在 store 里，
+   * 用户回到首页时入口会自动预填。
+   */
+  useEffect(() => {
+    if (!canSubscribeTauriEvents()) {
+      return;
+    }
+    let disposed = false;
+    let unsubscribe: (() => void) | null = null;
+    void subscribeForkDeepLink((request) => {
+      useForkDeepLinkStore.getState().request(request);
+      if (request.gameId) {
+        // 带作品 ID 的深链直接落到确认页（需求：不需要用户再逛一遍列表）。
+        useForkConfirmStore.getState().open({
+          gameId: request.gameId,
+          game: null,
+          origin: 'deep-link',
+        });
+      }
+      setLauncherView((current) =>
+        current === 'project-development'
+          ? current
+          : request.gameId
+            ? 'fork-confirm'
+            : 'co-creation',
+      );
+    })
+      .then((release) => {
+        if (disposed) {
+          release();
+          return;
+        }
+        unsubscribe = release;
+      })
+      .catch(() => {
+        // 订阅不可用时深链静默失效：不影响应用其余功能，也不该弹错误打断用户。
+      });
+    return () => {
+      disposed = true;
+      unsubscribe?.();
+    };
+  }, []);
+
   const requestCurrentProjectPlay = useCallback((nextProjectPath: string) => {
     playRequestIdRef.current += 1;
     setPlayRequest({
@@ -815,12 +872,32 @@ export function WorkspaceLauncherShell({
             }
             templateLibraryError={templateLibrary.error}
             onTemplateLibraryOpen={() => setLauncherView('template-library')}
+            // 平台作品改编建出的项目与模板项目一样「原生已落盘」，复用同一条进项目通道；
+            // 项目来源事实（改编自哪个作品）由命令写入 .agent/fork-source.json，首页负责展示。
           />
         ) : launcherView === 'projects' ? (
           <ProjectsPage
             homeProject={homeProject}
             recentProjects={recentProjects}
           />
+        ) : launcherView === 'fork-confirm' ? (
+          <ForkConfirmView
+            onCancel={() => setLauncherView('co-creation')}
+            onProjectCreated={async (result, isCurrent, analytics) => {
+              await homeProject.enterCreatedTemplateProject(
+                result,
+                isCurrent,
+                analytics,
+              );
+            }}
+          />
+        ) : launcherView === 'co-creation' ? (
+          <CoCreationView
+            onOpenConfirm={(target) => {
+              useForkConfirmStore.getState().open(target);
+              setLauncherView('fork-confirm');
+            }}
+          />
         ) : launcherView === 'template-library' && templateLibrary.enabled ? (
           <TemplateLibraryView
             controller={templateLibrary}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/forkConfirmTarget.ts b/apps/ai-game-creator-shell/src/features/platform-fork/forkConfirmTarget.ts
new file mode 100644
index 000000000..251f8e27c
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/forkConfirmTarget.ts
@@ -0,0 +1,33 @@
+/**
+ * 「Fork 工程确认页」的进入目标：谁要 Fork 哪个作品。
+ *
+ * 两条入口共用同一个 store：
+ * - 共创列表卡片点「Fork」→ 打开确认页（带列表里已加载的作品，信息卡不必再等一次请求）；
+ * - 深链 `genarrative://fork?gameId=…` → 直接打开确认页（作品信息靠公开详情补）。
+ *
+ * 取消时回到进入前的落点（`origin`），这样「从列表进来」与「从深链进来」都能回到合理的位置。
+ */
+import { create } from 'zustand';
+
+import type { GameDistributionGame } from '../../../../../packages/shared/src/contracts/gameDistribution';
+
+export type ForkConfirmOrigin = 'co-creation' | 'deep-link';
+
+type ForkConfirmTarget = {
+  gameId: string;
+  /** 列表里已加载的作品（有则信息卡直接渲染，缺则确认页自己按 gameId 拉详情）。 */
+  game: GameDistributionGame | null;
+  origin: ForkConfirmOrigin;
+};
+
+type ForkConfirmStore = {
+  target: ForkConfirmTarget | null;
+  open: (target: ForkConfirmTarget) => void;
+  close: () => void;
+};
+
+export const useForkConfirmStore = create<ForkConfirmStore>((set) => ({
+  target: null,
+  open: (target) => set({ target }),
+  close: () => set({ target: null }),
+}));
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/forkDeepLink.ts b/apps/ai-game-creator-shell/src/features/platform-fork/forkDeepLink.ts
new file mode 100644
index 000000000..44b10de93
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/forkDeepLink.ts
@@ -0,0 +1,77 @@
+/**
+ * Fork 深链（`genarrative://fork?gameId=…`）在渲染层的落点。
+ *
+ * 原生侧收链后聚焦主窗口，并发 `game-fork-deep-link` 事件；这里把「要 Fork 哪个作品」存成一条
+ * **待处理请求**，由首页的 Fork 入口消费：预填输入并等用户按按钮，**绝不自动开始下载**
+ * （工程源包是 200 MiB 级别的下载，必须由用户确认）。
+ *
+ * 用模块级 store 而不是组件 props：链接到达时应用可能正停在项目工作区（首页没挂载），
+ * 请求要能留到用户回到首页时再生效。
+ */
+import { create } from 'zustand';
+
+import { subscribeTauriEvent } from '../../services/tauriEventSubscription';
+
+/** 与原生 `game_fork::desktop::FORK_DEEP_LINK_EVENT` 同名。 */
+export const FORK_DEEP_LINK_EVENT = 'game-fork-deep-link';
+
+export type ForkDeepLinkRequest = {
+  /** 解析出的作品 ID；链接不合法时为 null。 */
+  gameId: string | null;
+  /** 链接不合法的可读原因；合法时为 null。 */
+  message: string | null;
+};
+
+type ForkDeepLinkStore = {
+  pending: ForkDeepLinkRequest | null;
+  request: (request: ForkDeepLinkRequest) => void;
+  /** 取走并清空待处理请求：同一链接只生效一次。 */
+  consume: () => ForkDeepLinkRequest | null;
+};
+
+export const useForkDeepLinkStore = create<ForkDeepLinkStore>((set, get) => ({
+  pending: null,
+  request: (request) => set({ pending: request }),
+  consume: () => {
+    const pending = get().pending;
+    set({ pending: null });
+    return pending;
+  },
+}));
+
+/**
+ * 把原生事件载荷折成待处理请求；既没有 gameId 也没有 message 的载荷整条丢弃。
+ *
+ * 原生可能出现「带 gameId」与「带错误原因」两种形状二选一，这里都不丢信息地映射过去。
+ */
+export function forkDeepLinkRequestFromEvent(
+  payload: unknown,
+): ForkDeepLinkRequest | null {
+  if (typeof payload !== 'object' || payload === null) {
+    return null;
+  }
+  const gameId =
+    'gameId' in payload && typeof payload.gameId === 'string'
+      ? payload.gameId.trim()
+      : '';
+  const message =
+    'message' in payload && typeof payload.message === 'string'
+      ? payload.message.trim()
+      : '';
+  if (!gameId && !message) {
+    return null;
+  }
+  return { gameId: gameId || null, message: message || null };
+}
+
+/** 订阅原生 Fork 深链事件；返回注销函数（重复调用安全）。 */
+export function subscribeForkDeepLink(
+  onRequest: (request: ForkDeepLinkRequest) => void,
+): Promise<() => void> {
+  return subscribeTauriEvent<unknown>(FORK_DEEP_LINK_EVENT, (event) => {
+    const request = forkDeepLinkRequestFromEvent(event.payload);
+    if (request) {
+      onRequest(request);
+    }
+  });
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/forkNotice.ts b/apps/ai-game-creator-shell/src/features/platform-fork/forkNotice.ts
new file mode 100644
index 000000000..a5aef01b1
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/forkNotice.ts
@@ -0,0 +1,53 @@
+/**
+ * Fork 工程确认页的须知文案（可修改范围 / 商用权限说明 / 署名要求 / 溯源规则 / 违规后果说明）。
+ *
+ * 放在独立文件而不是页面里：页面只导出组件（`react-refresh/only-export-components`），而这份
+ * 文案要被测试逐条断言，也需要被独立阅读——它是这一页最该被审的代码。
+ *
+ * 口径（内部说明，不出现在用户可见文案里）：对外动作名统一叫「开始共创」（内部仍叫 fork）；语义 = 把整个工程复制一份到你的项目里继续改造，
+ * 设计意图与 git fork 同源——整份工程搬到你的项目里、副本独立；商用权限按父作品当前的授权档位
+ * 分档说明，不自行加码也不放宽。
+ */
+
+/** 强制阅读时长：底部「确认并进入编辑」在前 3 秒禁用。 */
+export const MANDATORY_READING_SECONDS = 3;
+
+export type ForkNoticeSection = {
+  key: string;
+  title: string;
+  body: string;
+};
+
+export function forkNoticeSections(
+  authorizationLabel: string,
+): readonly ForkNoticeSection[] {
+  const commercial =
+    authorizationLabel === '允许全开放共创'
+      ? '父作品授权是「允许全开放共创」：可以改编、商用、引流，也可以发布新版本。'
+      : authorizationLabel === '允许非商用共创'
+        ? '父作品授权是「允许非商用共创」：可以二次开发，但不得用于盈利——不能接入广告或任何盈利内容，只能公开分享。'
+        : '父作品授权是「禁止共创」：正常情况下不应走到这一步，请取消并回到作品详情页确认授权状态。';
+  return [
+    {
+      key: 'scope',
+      title: '可修改范围',
+      body: '开始共创会把该作者公开的整个工程复制一份到你的项目里继续改造：代码、素材与配置都可以按你的想法改。副本完全独立，你的修改只影响自己的作品，不会影响原作者。',
+    },
+    { key: 'commercial', title: '商用权限说明', body: commercial },
+    {
+      key: 'attribution',
+      title: '署名要求',
+      body: '按平台规则，你的二创作品会自带原作品溯源信息与原作者署名，不能删除、隐藏或改成别人的名字；平台也会在作品页展示历代改造者。',
+    },
+    {
+      key: 'lineage',
+      title: '溯源规则',
+      body: '平台会永久记录原作品 ID、复刻时间与你这个副本的迭代版本；你的二创作品会作为衍生版本出现在原作品的族谱里（发布后即为公开事实）。',
+    },
+    {
+      key: 'consequence',
+      title: '违规后果说明',
+      body: '违反上述授权、署名或溯源规则（例如删除署名、超范围商用、低改动度搬运）会被平台下架并要求整改；情节严重时限制账号的共创与发布权限。',
+    },
+  ];
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/forkPageStyles.ts b/apps/ai-game-creator-shell/src/features/platform-fork/forkPageStyles.ts
new file mode 100644
index 000000000..d84e5d00b
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/forkPageStyles.ts
@@ -0,0 +1,92 @@
+/**
+ * 共创相关页面（「共创」列表页 / Fork 工程确认页）共用的一套版式令牌。
+ *
+ * 目的：两个页面此前各写一套 Tailwind 串，间距（22/14/10px…）、状态文字形态（灰字当按钮看）、
+ * 卡片内标签列宽度都不一致。这里把**列宽、节奏、卡片、状态标签、按钮**收敛成一份：
+ *
+ * - 内容列：`min(860px, 100vw - 124px)`，正文再加 `72ch` 上限——正文不铺满整屏；
+ * - 节奏：一律 4/8 步进（`gap-2/3/6`、`p-3`、`py-2.5`）；
+ * - 色板：只用 `packages/shared/src/theme.css` 里既有的 `--platform-*` 变量，不新增颜色；
+ * - 状态与按钮**形态上必须可区分**：状态用 `rounded-full` 徽章（描边 + 浅底 + 短文案），
+ *   按钮用 `rounded-lg` 实心/描边 —— 之前「已可确认 / 确认后开始」是灰字，像被禁用的按钮。
+ *
+ * 这些都是**字面量**类名（Tailwind 扫描器按字面量收集，拼字符串会扫不到）。
+ */
+
+/** 页面内容列：居中、限宽、随窗口收窄。 */
+export const FORK_PAGE_COLUMN =
+  'mx-auto w-[min(860px,calc(100vw-124px))] max-[980px]:w-[min(100%,calc(100vw-64px))] max-[760px]:w-[min(100%,calc(100vw-40px))]';
+
+/**
+ * 页面根：顶部 80px 留白（与首页 `pt-20` 同值，给左上「正在运行的项目」浮层与顶边留出呼吸空间）
+ * + 纵向节奏 24px + 底部 32px。
+ *
+ * 留白加在**内容层**（页面根），不加在滚动容器 `.launcher-main` 上：滚动容器只负责滚，
+ * 页面自己决定与顶边的距离，滚动时页头跟着内容走（这是长页面的正常语义）。
+ */
+export const FORK_PAGE_ROOT =
+  'fork-page grid content-start gap-6 pt-20 pb-8 max-[760px]:pt-16';
+
+/** 区块内部：标题 / 说明 / 卡片之间 12px。 */
+export const FORK_SECTION = 'grid gap-3';
+
+/** 区块标题行：标题 + 右侧状态徽章（窄窗口换行，不挤压标题）。 */
+export const FORK_SECTION_HEAD =
+  'flex flex-wrap items-center justify-between gap-x-3 gap-y-2';
+
+export const FORK_PAGE_TITLE =
+  'm-0 text-[19px] font-semibold text-(--platform-text-strong)';
+
+export const FORK_SECTION_TITLE =
+  'm-0 text-[15px] font-semibold text-(--platform-text-strong)';
+
+/** 正文：12/20 行高 + 72 字符上限。 */
+export const FORK_BODY_TEXT =
+  'm-0 max-w-[72ch] text-[12px] leading-5 text-(--platform-text-soft)';
+
+/** 次要说明：11/16。 */
+export const FORK_META_TEXT =
+  'text-[11px] leading-4 text-(--platform-text-soft)';
+
+/** 卡片外壳：描边 + 浅底 + 既有阴影。 */
+export const FORK_CARD =
+  'rounded-xl border border-(--platform-surface-border) bg-(image:--platform-subpanel-fill) shadow-(--platform-panel-shadow)';
+
+/** 主按钮（实心）与次按钮（描边）；两者都与状态徽章形态不同。 */
+export const FORK_BUTTON_PRIMARY =
+  'cursor-pointer rounded-lg border-0 bg-(image:--platform-button-primary-fill) px-3.5 py-2 text-[12px] font-bold text-(--platform-button-primary-text) disabled:cursor-not-allowed disabled:opacity-55';
+export const FORK_BUTTON_SECONDARY =
+  'cursor-pointer rounded-lg border border-(--platform-surface-border) bg-(image:--platform-subpanel-fill) px-3.5 py-2 text-[12px] text-(--platform-text-strong) disabled:cursor-not-allowed disabled:opacity-55';
+
+/** 状态徽章：三种语义色，全部只读、不响应点击。 */
+const FORK_BADGE_BASE =
+  'inline-flex shrink-0 items-center gap-1 rounded-full border px-2.5 py-0.5 text-[11px] font-bold leading-4 tabular-nums';
+/** 进行中 / 需要注意（暖色）。 */
+export const FORK_BADGE_WARM =
+  FORK_BADGE_BASE +
+  ' border-(--platform-warm-border) bg-(--platform-warm-bg) text-(--platform-warm-text)';
+/** 中性事实（未开始 / 统计信息）。 */
+export const FORK_BADGE_NEUTRAL =
+  FORK_BADGE_BASE +
+  ' border-(--platform-neutral-border) bg-(--platform-neutral-bg) text-(--platform-neutral-text)';
+/** 完成（绿色）。 */
+export const FORK_BADGE_SUCCESS =
+  FORK_BADGE_BASE +
+  ' border-(--platform-success-border) bg-(--platform-success-bg) text-(--platform-success-text)';
+
+/** 吸附底部操作条：整屏宽、不透明底、上边框 + 顶部投影，内容区滚动时始终可见。 */
+export const FORK_STICKY_FOOTER =
+  'sticky bottom-0 z-10 mt-2 border-t border-(--platform-surface-border) bg-(image:--platform-subpanel-fill) py-3 backdrop-blur-[2px] shadow-[0_-8px_20px_rgb(31_24_16_/_7%)]';
+
+/** 卡片里的「标签 → 数值」两列表：标签列定宽 + 数值列等宽数字，避免换行跳动。 */
+export const FORK_META_GRID =
+  'grid grid-cols-[52px_minmax(0,1fr)] items-baseline gap-x-2 gap-y-1 text-[11px] leading-4';
+/**
+ * 同上一套，但行距收到 2px：给「四行信息」（作者 / 类型 / 游玩 / 创建时间）的列表卡片用，
+ * 让多出来的一行不至于把卡片撑高。字号与颜色与 `FORK_META_GRID` 完全一致。
+ */
+export const FORK_META_GRID_COMPACT =
+  'grid grid-cols-[52px_minmax(0,1fr)] items-baseline gap-x-2 gap-y-0.5 text-[11px] leading-4';
+export const FORK_META_LABEL = 'whitespace-nowrap text-(--platform-text-soft)';
+export const FORK_META_VALUE =
+  'min-w-0 truncate whitespace-nowrap tabular-nums text-(--platform-neutral-text)';
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/forkParentCard.ts b/apps/ai-game-creator-shell/src/features/platform-fork/forkParentCard.ts
new file mode 100644
index 000000000..e2dd38ab7
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/forkParentCard.ts
@@ -0,0 +1,80 @@
+/**
+ * 父作品信息（确认页信息卡的数据源）。
+ *
+ * 优先用列表已经加载过的那份；没有就按 gameId 走**既有的**公开详情接口（匿名单读，不新增平台接口）。
+ * 拿不到时返回 `null`，由调用方降级渲染（信息卡缺失字段不报错、不阻塞确认）。
+ */
+import type { GameDistributionGame } from '../../../../../packages/shared/src/contracts/gameDistribution';
+import { resolveTauriInvoke } from '../../app/tauri';
+
+const DETAIL_COMMAND = 'read_public_game_detail';
+
+/** 授权档位的中文标签（与共享契约的三态一一对应；缺省读作禁止共创）。 */
+export const FORK_AUTHORIZATION_LABELS: Record<string, string> = {
+  forbidden: '禁止共创',
+  nonCommercial: '允许非商用共创',
+  full: '允许全开放共创',
+};
+
+export function forkAuthorizationLabel(
+  value: string | null | undefined,
+): string {
+  return FORK_AUTHORIZATION_LABELS[value ?? 'forbidden'] ?? '禁止共创';
+}
+
+/** 信息卡要展示的四项：缺哪个都不报错，展示层逐项降级。 */
+export type ForkParentCard = {
+  gameId: string;
+  title: string;
+  authorName: string;
+  authorizationLabel: string;
+  coverObjectKey: string;
+  coverColor: string;
+};
+
+export function forkParentCardFromGame(
+  game: Pick<
+    GameDistributionGame,
+    | 'id'
+    | 'title'
+    | 'author'
+    | 'forkAuthorization'
+    | 'coverObjectKey'
+    | 'coverColor'
+  >,
+): ForkParentCard {
+  return {
+    gameId: game.id,
+    title: game.title?.trim() ?? '',
+    authorName: game.author?.name?.trim() ?? '',
+    authorizationLabel: forkAuthorizationLabel(game.forkAuthorization),
+    coverObjectKey: game.coverObjectKey?.trim() ?? '',
+    coverColor: game.coverColor?.trim() ?? '',
+  };
+}
+
+/**
+ * 读父作品详情：拿不到就 `null`（确认页仍可用，只是信息卡降级）。
+ *
+ * 失败不打日志噪音也不抛：这条只是「让用户看清楚自己在 Fork 什么」，缺了它不该挡住流程。
+ */
+export async function loadForkParentCard(
+  gameId: string,
+): Promise<ForkParentCard | null> {
+  const invoke = resolveTauriInvoke();
+  const normalized = gameId.trim();
+  if (!invoke || !normalized) {
+    return null;
+  }
+  try {
+    const game = await invoke<GameDistributionGame>(DETAIL_COMMAND, {
+      gameId: normalized,
+    });
+    if (!game || typeof game !== 'object' || !('id' in game)) {
+      return null;
+    }
+    return forkParentCardFromGame(game);
+  } catch {
+    return null;
+  }
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/forkProgress.ts b/apps/ai-game-creator-shell/src/features/platform-fork/forkProgress.ts
new file mode 100644
index 000000000..3b351b005
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/forkProgress.ts
@@ -0,0 +1,93 @@
+/**
+ * Fork 工程同步的真实阶段（与 Rust `ForkSyncStage` 一一对应）。
+ *
+ * **不造百分比**：这些阶段是原生侧真实发生的边界（取回 → 校验 → 解压 → 建项），事件到哪个阶段
+ * 就点亮哪个阶段；阶段内部是不可测量的（一次 HTTP 下载、一次解压），所以只做「进行中」指示。
+ *
+ * 与需求文档「源码 / 素材 / 场景 / 配置」的差异：文档假设按资产种类分别同步，而客户端这条链路是
+ * **整包取回**（一次下载、一次校验、一次解压、一次建项），没有按种类分开的可测量阶段，因此这里
+ * 如实降级成四个真实阶段并在页面上写明每个阶段在做什么。
+ */
+import { subscribeTauriEvent } from '../../services/tauriEventSubscription';
+
+/** 与原生 `game_fork::desktop::FORK_PROGRESS_EVENT` 同名。 */
+export const FORK_PROGRESS_EVENT = 'game-fork-progress';
+
+export const FORK_PROGRESS_STAGES = [
+  { key: 'download', label: '取回作品内容', detail: '读取件元数据并下载整包' },
+  {
+    key: 'verify',
+    label: '校验摘要与字节',
+    detail: '字节数与 SHA-256 必须与元数据一致',
+  },
+  {
+    key: 'extract',
+    label: '解压到项目',
+    detail: '解压内容到项目（成品包放进 reference 子目录）',
+  },
+  {
+    key: 'project',
+    label: '生成工程与来源记录',
+    detail: '生成工程、写入 .agent 身份与 .agent/fork-source.json',
+  },
+] as const;
+
+export type ForkProgressStageKey = (typeof FORK_PROGRESS_STAGES)[number]['key'];
+
+const STAGE_KEYS = FORK_PROGRESS_STAGES.map((stage) => stage.key);
+const STAGE_LABEL_BY_KEY = new Map(
+  FORK_PROGRESS_STAGES.map((stage) => [stage.key, stage.label]),
+);
+
+export function forkProgressStageLabel(key: ForkProgressStageKey): string {
+  return STAGE_LABEL_BY_KEY.get(key) ?? key;
+}
+
+/**
+ * 把原生事件载荷折成阶段键；未知/缺失整条丢弃（不把无法识别的阶段塞进状态条）。
+ */
+export function forkProgressStageFromEvent(
+  payload: unknown,
+): ForkProgressStageKey | null {
+  if (typeof payload !== 'object' || payload === null) {
+    return null;
+  }
+  const stage =
+    'stage' in payload && typeof payload.stage === 'string'
+      ? payload.stage
+      : '';
+  return STAGE_KEYS.includes(stage as ForkProgressStageKey)
+    ? (stage as ForkProgressStageKey)
+    : null;
+}
+
+/** 订阅原生 Fork 进度；返回注销函数（重复调用安全）。 */
+export function subscribeForkProgress(
+  onStage: (stage: ForkProgressStageKey) => void,
+): Promise<() => void> {
+  return subscribeTauriEvent<unknown>(FORK_PROGRESS_EVENT, (event) => {
+    const stage = forkProgressStageFromEvent(event.payload);
+    if (stage) {
+      onStage(stage);
+    }
+  });
+}
+
+/**
+ * 已发出的阶段集合（按真实到达顺序）。
+ *
+ * 状态条据此标记「已发生」；`current` 是最后一个到达的阶段（阶段内部仍在进行，所以是进行中）。
+ */
+export type ForkProgressSnapshot = {
+  current: ForkProgressStageKey | null;
+  reached: ForkProgressStageKey[];
+};
+
+export function forkProgressSnapshot(
+  reached: readonly ForkProgressStageKey[],
+): ForkProgressSnapshot {
+  return {
+    current: reached[reached.length - 1] ?? null,
+    reached: [...reached],
+  };
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/platformForkCatalog.ts b/apps/ai-game-creator-shell/src/features/platform-fork/platformForkCatalog.ts
new file mode 100644
index 000000000..9709cff71
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/platformForkCatalog.ts
@@ -0,0 +1,153 @@
+/**
+ * 「共创」页的数据源：平台公开作品目录 + 「只保留支持共创的」过滤。
+ *
+ * 平台侧没有「只列可 Fork 作品」的接口，因此这里从公开目录（新 → 旧）**顺序扫描**并按
+ * `forkAuthorization !== 'forbidden'` 过滤。推荐算法**留 TODO**：现在只按接口给的顺序取最新，
+ * 等平台出推荐/排序接口（或目录支持按 forkAuthorization 过滤）后，替换点就在
+ * `loadForkableGames` 里——UI 只消费它的返回值，不需要跟着改。
+ */
+import type { GameDistributionGame } from '../../../../../packages/shared/src/contracts/gameDistribution';
+
+/** 每页条数：用满服务端公开目录的上限，少发几次请求。 */
+export const FORK_CATALOG_PAGE_SIZE = 50;
+/**
+ * 最多向后扫几页。
+ *
+ * 理由：目录是新 → 旧的，而可 Fork 的作品可能很稀疏；扫太多页会让「打开页面」变成慢操作。
+ * 3 页（最多 150 条）在实测目录规模下足够填满一屏卡片，同时把最坏情况的请求数与耗时钉住。
+ */
+export const FORK_CATALOG_MAX_PAGES = 3;
+/** 够一屏卡片就不再往后扫（避免每次进来都打满 3 页）。 */
+export const FORK_CATALOG_ENOUGH = 12;
+
+export type ForkCatalogResult = {
+  /** 过滤后的可 Fork 作品（按接口顺序 = 最新在前）。 */
+  games: GameDistributionGame[];
+  /** 实际扫过的页数（用于报告「已检查多少条」）。 */
+  scannedPages: number;
+  /** 扫过的原始条数。 */
+  scannedGames: number;
+  /** 是否因为页数上限而停（此时可能还有更多可 Fork 的作品）。 */
+  cappedByPageLimit: boolean;
+};
+
+/**
+ * 卡片上的时间只能是**真实存在**的字段。
+ *
+ * 公开目录 payload 有 `createdAt`（RFC3339，服务端 `format_timestamp_micros` 产出）**没有**
+ * `updatedAt`，所以标签写「创建时间」；取不到就返回 `null`，由调用方整行不渲染——
+ * 不留一个恒为「—」的死行。数字型（微秒/毫秒时间戳）也认，返回本地时区的 `YYYY-MM-DD`。
+ */
+export function formatCatalogCreatedAt(value: unknown): string | null {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    // 微秒时间戳按 1e6 折算；毫秒时间戳照原样用。两者都远超合理下限，因此能稳定区分。
+    const millis = value > 1e14 ? Math.round(value / 1000) : value;
+    return formatLocalDate(new Date(millis));
+  }
+  if (typeof value !== 'string' || !value.trim()) {
+    return null;
+  }
+  const parsed = Date.parse(value.trim());
+  if (!Number.isFinite(parsed)) {
+    return null;
+  }
+  return formatLocalDate(new Date(parsed));
+}
+
+function formatLocalDate(date: Date): string | null {
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  const pad = (part: number) => String(part).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+/**
+ * 卡片上的游玩次数文案：只格式化**该作品自身**的 `playCount`（公开目录投影保证下发）。
+ *
+ * 为什么是自身值：客户端拿不到血缘树（要树得逐作品拉 `/lineage`，列表页不能这么打接口），
+ * 因此**刻意与网页侧不同**——网页侧能按子树合计，客户端只能给自身值。文案只写「N 次」，
+ * 不出现「含衍生」这类会被读成合计的措辞。
+ *
+ * 缺失/非法（旧响应或字段被裁）返回 `null`，由调用方整行不渲染，不留恒为「—」的死行。
+ */
+export function formatCatalogPlayCount(value: unknown): string | null {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return null;
+  }
+  return `${Math.max(0, Math.floor(value)).toLocaleString('zh-CN')} 次`;
+}
+
+/** 支持共创 = 授权不是「禁止共创」；字段缺省按 `forbidden` 处理（与契约一致）。 */
+export function isForkableGame(game: GameDistributionGame): boolean {
+  return (game.forkAuthorization ?? 'forbidden') !== 'forbidden';
+}
+
+export function forkableGames(
+  games: readonly GameDistributionGame[],
+): GameDistributionGame[] {
+  return games.filter(isForkableGame);
+}
+
+type CatalogPage = {
+  games?: GameDistributionGame[];
+  nextCursor?: string | null;
+};
+
+type CatalogInvoke = <T>(
+  command: string,
+  args?: Record<string, unknown>,
+) => Promise<T>;
+
+/**
+ * 顺序扫描公开目录，直到凑够一屏可 Fork 作品、没有下一页、或撞到页数上限。
+ *
+ * 只做只读请求（匿名目录接口），失败时把错误抛给调用方渲染失败态——不在这里吞掉。
+ */
+export async function loadForkableGames(
+  invoke: CatalogInvoke,
+  options: {
+    maxPages?: number;
+    enough?: number;
+    pageSize?: number;
+  } = {},
+): Promise<ForkCatalogResult> {
+  const maxPages = options.maxPages ?? FORK_CATALOG_MAX_PAGES;
+  const enough = options.enough ?? FORK_CATALOG_ENOUGH;
+  const pageSize = options.pageSize ?? FORK_CATALOG_PAGE_SIZE;
+  const games: GameDistributionGame[] = [];
+  let scannedPages = 0;
+  let scannedGames = 0;
+  let cursor: string | null = null;
+  let cappedByPageLimit = false;
+
+  while (scannedPages < maxPages) {
+    const page: CatalogPage = await invoke<CatalogPage>(
+      'list_platform_game_catalog',
+      {
+        limit: pageSize,
+        cursor,
+      },
+    );
+    scannedPages += 1;
+    const pageGames: GameDistributionGame[] = Array.isArray(page?.games)
+      ? page.games
+      : [];
+    scannedGames += pageGames.length;
+    games.push(...forkableGames(pageGames));
+    const nextCursor: string | null = page?.nextCursor ?? null;
+    if (!nextCursor) {
+      break;
+    }
+    if (games.length >= enough) {
+      break;
+    }
+    if (scannedPages >= maxPages) {
+      cappedByPageLimit = true;
+      break;
+    }
+    cursor = nextCursor;
+  }
+
+  return { games, scannedPages, scannedGames, cappedByPageLimit };
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/platformForkCover.ts b/apps/ai-game-creator-shell/src/features/platform-fork/platformForkCover.ts
new file mode 100644
index 000000000..e8184f880
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/platformForkCover.ts
@@ -0,0 +1,81 @@
+/**
+ * 公开作品封面：把 `coverObjectKey` 换成可显示的地址，带会话内缓存与失败短路。
+ *
+ * AGC 的约定是「渲染层不接触签名地址、不让 WebView 直连外部图片」（见 Rust 侧命令注释），因此
+ * 这里调用 `read_public_game_cover_preview` 拿**有界 data URL**——没有过期时间，也就不需要 TTL；
+ * 代价是每张封面要过一次 IPC，所以按对象键缓存：
+ * - **成功**：会话内一直复用（data URL 自身不会过期）；
+ * - **失败**：缓存 60 秒，避免同一张坏图在每个卡片上反复重试（沿用网页端同一条失败缓存窗口）；
+ * - **并发**：同一对象键的并发请求去重（列表一次渲染多张卡时只发一次）。
+ *
+ * 拿不到封面（没有对象键 / 请求失败 / 超限）时返回 `null`——调用方回落到首字占位 + `coverColor`。
+ */
+import type { GameDistributionGame } from '../../../../../packages/shared/src/contracts/gameDistribution';
+
+const COVER_COMMAND = 'read_public_game_cover_preview';
+const FAILURE_CACHE_WINDOW_MS = 60 * 1000;
+
+type CoverEntry = { url: string | null; at: number };
+
+const coverCache = new Map<string, CoverEntry>();
+const inflight = new Map<string, Promise<string | null>>();
+
+type CoverInvoke = <T>(
+  command: string,
+  args?: Record<string, unknown>,
+) => Promise<T>;
+
+/** 当前登录账号切换时清空缓存：换号后旧封面可能已无权访问。 */
+export function clearCoverPreviewCache() {
+  coverCache.clear();
+  inflight.clear();
+}
+
+function cacheKey(objectKey: string, accountScope: string) {
+  return `${accountScope}\u0000${objectKey}`;
+}
+
+/**
+ * 解析一张封面；失败一律 `null`（调用方保留占位），不抛给渲染层。
+ *
+ * `accountScope` 一般是当前账号 id：换号后同一对象键的结果不能复用。
+ */
+export async function resolveCoverPreview(
+  invoke: CoverInvoke,
+  game: Pick<GameDistributionGame, 'coverObjectKey'>,
+  accountScope = '',
+): Promise<string | null> {
+  const objectKey = (game.coverObjectKey ?? '').trim();
+  if (!objectKey) {
+    return null;
+  }
+  const key = cacheKey(objectKey, accountScope);
+  const cached = coverCache.get(key);
+  if (
+    cached &&
+    (cached.url !== null || Date.now() - cached.at < FAILURE_CACHE_WINDOW_MS)
+  ) {
+    return cached.url;
+  }
+  const pending = inflight.get(key);
+  if (pending) {
+    return pending;
+  }
+  const request = (async () => {
+    try {
+      const url = await invoke<string>(COVER_COMMAND, { objectKey });
+      const normalized =
+        typeof url === 'string' && url.startsWith('data:') ? url : null;
+      coverCache.set(key, { url: normalized, at: Date.now() });
+      return normalized;
+    } catch {
+      // 失败同样进缓存（短窗口）：列表里同一张坏图不重复打请求。
+      coverCache.set(key, { url: null, at: Date.now() });
+      return null;
+    } finally {
+      inflight.delete(key);
+    }
+  })();
+  inflight.set(key, request);
+  return request;
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/platformGameForkModel.ts b/apps/ai-game-creator-shell/src/features/platform-fork/platformGameForkModel.ts
new file mode 100644
index 000000000..03a2facf7
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/platformGameForkModel.ts
@@ -0,0 +1,53 @@
+/**
+ * 「从平台作品 Fork」的纯逻辑：取件失败分类。
+ *
+ * 作品标识的解析不在这里：深链的作品 ID 由原生解析（`game_fork::desktop`），列表页也不再提供
+ * 手动粘贴入口，因此渲染层只负责把原生失败文案折成可区分、可直接展示的结果。
+ * 作品的可见性、授权与存在性一律以服务端为准（原生命令的 404 / 409 / 403 / 401 已折成带稳定
+ * 前缀的文案，见 `classifyPlatformForkFailure`）。
+ */
+
+export type PlatformForkFailureKind =
+  /** 未登录 / 登录态过期：可操作提示是「重新登录」。 */
+  | 'auth'
+  /** 403：作者没有开放共创授权。 */
+  | 'forbidden'
+  /** 404：作品不存在或已被删除。 */
+  | 'notFound'
+  /** 409：作品未公开 / 已下架 / 没有公开版本。 */
+  | 'unavailable'
+  /** 其它失败（网络、超时、未预期状态）：原样展示原生文案。 */
+  | 'other';
+
+export type PlatformForkFailure = {
+  kind: PlatformForkFailureKind;
+  /** 去掉机器前缀后的用户可见文案。 */
+  message: string;
+};
+
+const FAILURE_PREFIXES: readonly [string, PlatformForkFailureKind][] = [
+  ['authentication-required:', 'auth'],
+  ['permission-denied:', 'forbidden'],
+  ['fork-source-not-found:', 'notFound'],
+  ['fork-source-not-available:', 'unavailable'],
+];
+
+/**
+ * 把原生取件失败折成「可区分 + 可直接展示」的两段式结果。
+ *
+ * 前缀是原生错误契约的一部分（`map_fork_source_http_error`），因此这里按前缀精确匹配，
+ * 绝不用文案子串猜测错误类型；未命中前缀的一律按 `other` 原样展示，不吞掉排障信息。
+ */
+export function classifyPlatformForkFailure(
+  error: unknown,
+): PlatformForkFailure {
+  const raw = error instanceof Error ? error.message : String(error);
+  const text = raw.trim();
+  for (const [prefix, kind] of FAILURE_PREFIXES) {
+    if (text.startsWith(prefix)) {
+      const message = text.slice(prefix.length).trim();
+      return { kind, message: message || raw.trim() };
+    }
+  }
+  return { kind: 'other', message: text };
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/usePlatformFork.ts b/apps/ai-game-creator-shell/src/features/platform-fork/usePlatformFork.ts
new file mode 100644
index 000000000..c984b0bd8
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/usePlatformFork.ts
@@ -0,0 +1,136 @@
+/**
+ * Fork 提交状态机：**卡片点击**与**粘贴作品 ID/链接**共用这一条路径。
+ *
+ * 两处入口只有「作品 ID 从哪来」不同，取件、失败分类、进项目与埋点完全一致——所以实现只留这一份。
+ * 取件、摘要校验、解压与来源记录都在原生命令里（`create_local_project_from_platform_game`），
+ * 渲染层只负责加载态、错误分类与建项后的进入动作。
+ */
+import { useCallback, useRef, useState } from 'react';
+
+import { resolveTauriInvoke } from '../../app/tauri';
+import type { InitLocalProjectResult } from '../../app/types';
+import {
+  beginProjectOpenAnalytics,
+  type ProjectOpenAnalytics,
+} from '../../services/clientAnalytics';
+import {
+  forkProgressSnapshot,
+  type ForkProgressStageKey,
+  subscribeForkProgress,
+} from './forkProgress';
+import { classifyPlatformForkFailure } from './platformGameForkModel';
+
+export type PlatformForkSuccess = {
+  gameId: string;
+  projectName: string;
+};
+
+type UsePlatformForkOptions = {
+  /**
+   * 建项成功后的进项目通道：与模板库共用同一条「原生已建好 → 登记最近项目并进入工作区」路径，
+   * 因此这里只透传结果、代次判据与项目打开埋点，不自己碰工作区状态。
+   */
+  onProjectCreated: (
+    result: InitLocalProjectResult,
+    isCurrent: () => boolean,
+    analytics: ProjectOpenAnalytics,
+  ) => Promise<void> | void;
+};
+
+export function usePlatformFork({ onProjectCreated }: UsePlatformForkOptions) {
+  const [busy, setBusy] = useState(false);
+  /** 当前正在 Fork 的作品 ID：列表卡片只让这一张进入加载态。 */
+  const [activeGameId, setActiveGameId] = useState<string | null>(null);
+  const [error, setError] = useState('');
+  const [notice, setNotice] = useState('');
+  const [success, setSuccess] = useState<PlatformForkSuccess | null>(null);
+  /** 原生侧真实发出的阶段（订阅在 invoke **之前**建立，否则会漏掉第一阶段）。 */
+  const [reachedStages, setReachedStages] = useState<ForkProgressStageKey[]>(
+    [],
+  );
+  /** 只认最后一次提交：迟到的结果不再改状态，也不进入项目。 */
+  const requestSequenceRef = useRef(0);
+  /** 同一 tick 内的重复提交靠 ref 拦截：`busy` 状态要等下一次渲染才生效。 */
+  const busyRef = useRef(false);
+  const onProjectCreatedRef = useRef(onProjectCreated);
+  onProjectCreatedRef.current = onProjectCreated;
+
+  const forkGame = useCallback(async (gameId: string) => {
+    const normalized = gameId.trim();
+    if (!normalized || busyRef.current) {
+      return;
+    }
+    const invoke = resolveTauriInvoke();
+    if (!invoke) {
+      setSuccess(null);
+      setError('需要在陶泥儿客户端内运行');
+      return;
+    }
+    const sequence = requestSequenceRef.current + 1;
+    requestSequenceRef.current = sequence;
+    const isCurrent = () => requestSequenceRef.current === sequence;
+    busyRef.current = true;
+    setBusy(true);
+    setActiveGameId(normalized);
+    setError('');
+    setNotice('');
+    setSuccess(null);
+    setReachedStages([]);
+    // 先订阅再下令：原生会在开始下载前就发第一阶段，晚订阅会漏掉它。
+    const reached: ForkProgressStageKey[] = [];
+    let releaseProgress: (() => void) | null = null;
+    try {
+      releaseProgress = await subscribeForkProgress((stage) => {
+        if (!isCurrent() || reached.includes(stage)) {
+          return;
+        }
+        reached.push(stage);
+        setReachedStages([...reached]);
+      });
+    } catch {
+      // 订阅不可用（非 Tauri 宿主/插件缺失）不影响 Fork 本身，只是没有阶段可显示。
+      releaseProgress = null;
+    }
+    const analytics = beginProjectOpenAnalytics(invoke, 'create');
+    try {
+      const result = await invoke<InitLocalProjectResult>(
+        'create_local_project_from_platform_game',
+        { gameId: normalized, name: null, planning: false },
+      );
+      if (!isCurrent()) {
+        return;
+      }
+      const projectName = result.manifest.name || normalized;
+      setSuccess({ gameId: normalized, projectName });
+      setNotice(
+        `已创建项目《${projectName}》，来自平台作品 ${normalized} 的共创`,
+      );
+      await onProjectCreatedRef.current(result, isCurrent, analytics);
+    } catch (nextError) {
+      if (!isCurrent()) {
+        return;
+      }
+      setError(classifyPlatformForkFailure(nextError).message);
+    } finally {
+      releaseProgress?.();
+      if (isCurrent()) {
+        busyRef.current = false;
+        setBusy(false);
+        setActiveGameId(null);
+      }
+    }
+  }, []);
+
+  return {
+    busy,
+    activeGameId,
+    error,
+    notice,
+    success,
+    /** 工程同步状态条用：只含真实到达过的阶段。 */
+    progress: forkProgressSnapshot(reachedStages),
+    forkGame,
+    setError,
+    setNotice,
+  };
+}
diff --git a/apps/ai-game-creator-shell/src/features/platform-fork/usePlatformForkCovers.ts b/apps/ai-game-creator-shell/src/features/platform-fork/usePlatformForkCovers.ts
new file mode 100644
index 000000000..3aba71142
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/platform-fork/usePlatformForkCovers.ts
@@ -0,0 +1,45 @@
+/**
+ * 列表封面：一次性解析当前列表里每张卡片的封面（有界 data URL），失败/缺封面就不返回该键。
+ *
+ * 解析本身走 `resolveCoverPreview` 的会话内缓存与并发去重，所以翻页、重渲染都不会重复拉同一张图。
+ */
+import { useEffect, useState } from 'react';
+
+import type { GameDistributionGame } from '../../../../../packages/shared/src/contracts/gameDistribution';
+import { resolveTauriInvoke } from '../../app/tauri';
+import { resolveCoverPreview } from './platformForkCover';
+
+export function usePlatformForkCovers(
+  games: readonly GameDistributionGame[],
+  accountScope = '',
+): Record<string, string> {
+  const [coverUrls, setCoverUrls] = useState<Record<string, string>>({});
+
+  useEffect(() => {
+    const invoke = resolveTauriInvoke();
+    if (!invoke || games.length === 0) {
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      const resolved: Record<string, string> = {};
+      await Promise.all(
+        games.map(async (game) => {
+          const url = await resolveCoverPreview(invoke, game, accountScope);
+          if (url) {
+            resolved[game.id] = url;
+          }
+        }),
+      );
+      if (cancelled) {
+        return;
+      }
+      setCoverUrls((current) => ({ ...current, ...resolved }));
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [games, accountScope]);
+
+  return coverUrls;
+}
diff --git a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
index 778bd3453..ac2e53882 100644
--- a/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
+++ b/apps/ai-game-creator-shell/src/services/gameDistributionPublish.ts
@@ -4,12 +4,14 @@ import {
   type GameCreationAppManifest,
   type GameCreationAppPublicationBinding,
 } from '../../../../packages/shared/src/contracts/gameCreationApp';
-import type {
-  GameDistributionCategory,
-  GameDistributionDeviceSupport,
-  GameDistributionInputMode,
-  GameDistributionOrientation,
-  GameMetadata,
+import {
+  GAME_DISTRIBUTION_DEFAULT_FORK_AUTHORIZATION,
+  type GameDistributionCategory,
+  type GameDistributionDeviceSupport,
+  type GameDistributionForkAuthorization,
+  type GameDistributionInputMode,
+  type GameDistributionOrientation,
+  type GameMetadata,
 } from '../../../../packages/shared/src/contracts/gameDistribution';
 import { resolveTauriInvoke } from '../app/tauri';
 import type { TauriInvoke } from '../app/types';
@@ -37,6 +39,15 @@ export type GameDistributionPublishMetadata = {
   };
   inputModes: GameDistributionInputMode[];
   orientation: GameDistributionOrientation;
+  /**
+   * 上架时的共创授权档位（三态单选，默认禁止共创）。只在**母版**的首次发布生效：母版创建后
+   * 只能通过网页端「我的作品」单向提升，更新版本不会改动它。
+   *
+   * 衍生作品（项目里有 `.agent/fork-source.json`）传了也会被服务端忽略——档位在创建时由父作品
+   * 快照继承，之后任何提升都被拒绝（`FORK_AUTHORIZATION_INHERITED`），所以面板对衍生作品根本
+   * 不渲染三态选择。这里保留字段只是为了母版链路不变。
+   */
+  forkAuthorization?: GameDistributionForkAuthorization;
 };
 
 /** 游戏截图上限与服务端 `MAX_GAME_SCREENSHOTS` 保持一致。 */
@@ -93,6 +104,12 @@ export type GameDistributionPublishResult = {
   /** 发布成功并回写绑定后的整份 manifest；渲染层据此同步工作台状态。 */
   manifest?: GameCreationAppManifest | null;
   publication?: GameCreationAppPublicationBinding | null;
+  /**
+   * 工程源包**未**随版本上传时的用户可见原因；`undefined`/`null` = 未尝试或已成功。
+   *
+   * 上传工程源包失败不阻断发布：作品照常可玩可发布，只是退化为「产物级改编」。
+   */
+  projectBundleWarning?: string | null;
 };
 
 /** 更新发布时默认回填的封面/截图；`objectKey` 缺失表示历史版本没有冻结素材，需重新选择。 */
@@ -234,6 +251,9 @@ function normalizeMetadata(
     },
     inputModes: metadata?.inputModes ?? ['keyboard', 'mouse', 'touch'],
     orientation: metadata?.orientation ?? 'responsive',
+    forkAuthorization:
+      metadata?.forkAuthorization ??
+      GAME_DISTRIBUTION_DEFAULT_FORK_AUTHORIZATION,
   };
 }
 
@@ -251,6 +271,14 @@ function toGameMetadata(
     deviceSupport: metadata.deviceSupport,
     inputModes: metadata.inputModes,
     orientation: metadata.orientation,
+    // 上架时的共创授权档位：渲染层只提交用户选择（或默认值），省略与显式传 `forbidden`
+    // 在服务端等价，因此这里始终显式提交，面板状态与请求体一一对应。
+    forkAuthorization:
+      metadata.forkAuthorization ??
+      GAME_DISTRIBUTION_DEFAULT_FORK_AUTHORIZATION,
+    // 改编来源声明**不**由渲染层提交：它必须来自项目内真实取过件的
+    // `.agent/fork-source.json`，由原生发布链路在首次发布时读取并并入请求体，
+    // 渲染层既拿不到也无法伪造。
   };
 }
 
@@ -301,6 +329,19 @@ export async function publishLocalProjectGame(args: {
    * 只有显式传入（测试或调用方已持有键）时才覆盖账本。
    */
   idempotencyKey?: string;
+  /**
+   * 是否随版本上传工程源包（面板「同时公开工程源码」勾选）。
+   *
+   * 缺省即「授权非禁止时上传」；`false` 表示作者主动取消——源码不外发，作品只能被产物级改编。
+   */
+  includeProjectBundle?: boolean;
+  /**
+   * 衍生作品的「本次核心改动说明」（母版不需要）。
+   *
+   * 服务端口径：衍生作品的版本必填，trim 后 20–500 个字符；这里原样透传，不做本地判据（校验只有
+   * 服务端那一份，客户端只负责采集与给可读提示）。
+   */
+  changeSummary?: string;
 }): Promise<GameDistributionPublishResult> {
   const projectPath = args.projectPath.trim();
   if (!projectPath) {
@@ -358,6 +399,15 @@ export async function publishLocalProjectGame(args: {
         ? { expectedPublicationRevision: args.expectedPublicationRevision }
         : {}),
       ...(rootKey ? { idempotencyKey: rootKey } : {}),
+      // 面板勾选：`false` 才是「作者取消」，因此只有显式 false 时才带这个字段，
+      // 其余情况交给原生按「授权非禁止即上传」判断。
+      ...(args.includeProjectBundle === false
+        ? { includeProjectBundle: false }
+        : {}),
+      // 衍生作品的核心改动说明：原样透传（服务端负责 trim、必填与长度判据）。
+      ...(typeof args.changeSummary === 'string' && args.changeSummary.trim()
+        ? { changeSummary: args.changeSummary.trim() }
+        : {}),
     },
   );
 }
diff --git a/apps/ai-game-creator-shell/src/styles.css b/apps/ai-game-creator-shell/src/styles.css
index 5b6343a4f..929a4861d 100644
--- a/apps/ai-game-creator-shell/src/styles.css
+++ b/apps/ai-game-creator-shell/src/styles.css
@@ -678,14 +678,6 @@ body {
   overflow: auto;
 }
 
-.window-chrome__content .launcher-main:has(.game-project-workbench) {
-  display: flex;
-  flex-direction: column;
-  height: 100%;
-  min-height: 0;
-  padding-bottom: 0;
-}
-
 .window-chrome__content .game-project-workbench {
   flex: 1 1 auto;
   height: auto;
@@ -1083,14 +1075,38 @@ textarea {
 
 .launcher-main {
   position: relative;
-  display: grid;
-  grid-template-columns: minmax(0, 1fr);
-  grid-template-rows: auto auto auto;
-  align-content: start;
+  /* 页面滚动就落在这里：**所有** launcher 视图（首页 / 项目 / 共创 / 确认页…）都是
+     `.launcher-main` 的直接子元素，因此滚动容器全应用只有一个，页面不用各自打补丁。
+
+     之前是 `display: grid; grid-template-rows: auto auto auto; align-content: start`：
+     行高是 `auto`，子元素撑多高行就多高，再叠加 `overflow: hidden` —— 内容一旦高于窗口就被
+     整块裁掉，既看不到也滚不到（截图里的「支持共创的作品」最后一行、确认页底部按钮够不到
+     都是这个原因）。改成 flex 列 + 纵向滚动：子元素保持自上而下排列，超出即滚。 */
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
   min-width: 0;
-  min-height: 100vh;
+  min-height: 0;
   padding: 0 0 42px;
-  overflow: hidden;
+  /* 纵向滚动 / 横向裁切：横向裁切必须保留，否则窄窗口下会被内容顶出横向滚动条。 */
+  overflow-x: hidden;
+  overflow-y: auto;
+}
+
+/*
+  视图本身是 `.launcher-main` 的 flex 子项：默认 `flex-shrink: 1` 会把「比窗口高的页面」
+  压扁到容器高度（内容溢出而不触发滚动）。这里统一 `flex: 0 0 auto`，让页面保持自然高度、
+  由 `.launcher-main` 滚动。需要占满高度的视图（工作台）在自己的规则里改回 `flex: 1 1 auto`。
+*/
+.launcher-main > * {
+  flex: 0 0 auto;
+}
+
+/* 共创相关页面的键盘聚焦：与 `.launcher-projects-page` 同一套描边口径。 */
+.fork-page
+  :where(button, a, input, textarea, [tabindex]):focus-visible {
+  outline: 3px solid var(--platform-warm-text);
+  outline-offset: 2px;
 }
 
 .launcher-runs-panel {
@@ -3647,6 +3663,118 @@ textarea {
   outline-offset: 1px;
 }
 
+/* 授权共创三态：与其它字段同宽同位，但 radio 不能套用上面那条「整行输入框」样式。 */
+.game-distribution-publish-panel__fork-authorization {
+  display: grid;
+  gap: 8px;
+  margin: 0;
+  padding: 0;
+  border: 0;
+  color: var(--platform-text-strong);
+  font-size: 12px;
+  font-weight: 700;
+}
+
+.game-distribution-publish-panel__fork-authorization legend {
+  padding: 0;
+}
+
+.game-distribution-publish-panel__fork-authorization.is-locked {
+  opacity: 0.6;
+}
+
+.game-distribution-publish-panel__fork-options {
+  display: grid;
+  gap: 6px;
+}
+
+.game-distribution-publish-panel__fields
+  .game-distribution-publish-panel__fork-options
+  label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--platform-text-strong);
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.game-distribution-publish-panel__fields
+  .game-distribution-publish-panel__fork-options
+  input[type='radio'] {
+  box-sizing: border-box;
+  width: auto;
+  min-width: 0;
+  margin: 0;
+  padding: 0;
+  accent-color: #a8663d;
+}
+
+.game-distribution-publish-panel__fork-hint {
+  margin: 0;
+  color: var(--platform-text-muted);
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 1.5;
+}
+
+/* 衍生作品的只读授权：徽章（档位）+ 说明两行，形态上明显不是可选控件。 */
+.game-distribution-publish-panel__fork-inherited {
+  display: grid;
+  gap: 6px;
+  margin: 0;
+  color: var(--platform-text-muted);
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 1.5;
+}
+
+.game-distribution-publish-panel__fork-inherited-badge {
+  display: inline-flex;
+  width: fit-content;
+  align-items: center;
+  gap: 6px;
+  padding: 2px 10px;
+  border: 1px solid var(--platform-warm-border);
+  border-radius: 999px;
+  background: var(--platform-warm-bg);
+  color: var(--platform-warm-text);
+  font-size: 11px;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+}
+
+/* 工程源码公开勾选：与上面的三态同宽同位，复选框不能套用「整行输入框」样式。 */
+.game-distribution-publish-panel__fields
+  .game-distribution-publish-panel__bundle-consent {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  color: var(--platform-text-soft);
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 1.5;
+}
+
+.game-distribution-publish-panel__fields
+  .game-distribution-publish-panel__bundle-consent
+  input[type='checkbox'] {
+  box-sizing: border-box;
+  width: auto;
+  min-width: 0;
+  margin: 2px 0 0;
+  padding: 0;
+  accent-color: #a8663d;
+}
+
+.game-distribution-publish-panel__bundle-warning {
+  margin: 0;
+  color: #b42318;
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 1.5;
+}
+
 .game-distribution-publish-panel__media {
   display: grid;
   gap: 14px;
diff --git a/apps/ai-game-creator-shell/src/view/co-creation/index.tsx b/apps/ai-game-creator-shell/src/view/co-creation/index.tsx
new file mode 100644
index 000000000..6cf9a1371
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/view/co-creation/index.tsx
@@ -0,0 +1,293 @@
+/**
+ * 「共创」页：列出支持共创（可 Fork）的平台作品。
+ *
+ * 对外口径只有一句（内部说明：设计意图与 git fork 同源，该类比不进用户可见文案）：
+ * **把平台上的作品整个工程复制到你的项目里继续改造。**
+ * 页面只有一条入口：卡片上的「开始共创」按钮 → 确认页（授权校验与工程同步都在那一页完成）。
+ * 对外动作名统一叫「开始共创」；内部标识仍用 fork（`fork-source`、`ForkConfirmView` 等不改）。
+ *
+ * 这里**没有**「直接 Fork 指定作品」输入块：深链 `genarrative://fork?gameId=…` 由 launcher 直接
+ * 落到确认页（见 `WorkspaceLauncher`），手动粘贴 ID 属于重复入口，已按需求移除。
+ */
+
+import { RefreshCcw } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+import type { GameDistributionGame } from '../../../../../packages/shared/src/contracts/gameDistribution';
+import { resolveTauriInvoke } from '../../app/tauri';
+import { useForkDeepLinkStore } from '../../features/platform-fork/forkDeepLink';
+import {
+  FORK_BADGE_NEUTRAL,
+  FORK_BODY_TEXT,
+  FORK_BUTTON_SECONDARY,
+  FORK_CARD,
+  FORK_META_GRID_COMPACT,
+  FORK_META_LABEL,
+  FORK_META_VALUE,
+  FORK_PAGE_COLUMN,
+  FORK_PAGE_ROOT,
+  FORK_PAGE_TITLE,
+  FORK_SECTION,
+  FORK_SECTION_HEAD,
+  FORK_SECTION_TITLE,
+} from '../../features/platform-fork/forkPageStyles';
+import {
+  FORK_CATALOG_MAX_PAGES,
+  type ForkCatalogResult,
+  formatCatalogCreatedAt,
+  formatCatalogPlayCount,
+  loadForkableGames,
+} from '../../features/platform-fork/platformForkCatalog';
+import { usePlatformForkCovers } from '../../features/platform-fork/usePlatformForkCovers';
+
+type CoCreationViewProps = {
+  /** 打开「开始共创」确认页（授权校验 + 工程同步都在那一页完成，这里只负责选作品）。 */
+  onOpenConfirm: (target: {
+    gameId: string;
+    game: GameDistributionGame | null;
+    origin: 'co-creation' | 'deep-link';
+  }) => void;
+};
+
+export default function CoCreationView({ onOpenConfirm }: CoCreationViewProps) {
+  const [catalog, setCatalog] = useState<ForkCatalogResult | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [catalogError, setCatalogError] = useState('');
+  const [deepLinkNotice, setDeepLinkNotice] = useState('');
+  const requestIdRef = useRef(0);
+
+  /**
+   * 深链只在这里**消费**（同一链接只生效一次）。
+   *
+   * 带 `gameId` 的链接在 launcher 里就已经切到确认页，本页通常根本不会挂载；万一挂载了
+   * （用户又从侧边栏点回列表），这里只把待处理请求清掉，不报错、也不留幽灵状态。
+   * 只有「链接解析失败」的 message 会显示成一条提示。
+   */
+  const pendingDeepLink = useForkDeepLinkStore((state) => state.pending);
+  const consumeDeepLink = useForkDeepLinkStore((state) => state.consume);
+
+  const reloadCatalog = useCallback(async () => {
+    const invoke = resolveTauriInvoke();
+    if (!invoke) {
+      setLoading(false);
+      setCatalogError('需要在陶泥儿客户端内运行');
+      return;
+    }
+    const requestId = requestIdRef.current + 1;
+    requestIdRef.current = requestId;
+    setLoading(true);
+    setCatalogError('');
+    try {
+      const result = await loadForkableGames(invoke);
+      if (requestIdRef.current !== requestId) {
+        return;
+      }
+      setCatalog(result);
+    } catch (error) {
+      if (requestIdRef.current !== requestId) {
+        return;
+      }
+      setCatalog(null);
+      setCatalogError(
+        error instanceof Error ? error.message : '读取共创目录失败',
+      );
+    } finally {
+      if (requestIdRef.current === requestId) {
+        setLoading(false);
+      }
+    }
+  }, []);
+
+  useEffect(() => {
+    void reloadCatalog();
+  }, [reloadCatalog]);
+
+  useEffect(() => {
+    if (!pendingDeepLink) {
+      return;
+    }
+    const request = consumeDeepLink();
+    if (!request) {
+      return;
+    }
+    setDeepLinkNotice(request.message ?? '');
+  }, [pendingDeepLink, consumeDeepLink]);
+
+  function forkFromCard(game: GameDistributionGame) {
+    onOpenConfirm({ gameId: game.id, game, origin: 'co-creation' });
+  }
+
+  const games = catalog?.games ?? [];
+  const coverUrls = usePlatformForkCovers(games);
+  const scannedHint = catalog
+    ? `已检查最新 ${catalog.scannedGames} 个作品（${catalog.scannedPages} 页${
+        catalog.cappedByPageLimit ? `，最多 ${FORK_CATALOG_MAX_PAGES} 页` : ''
+      }）`
+    : '';
+
+  return (
+    <div className={FORK_PAGE_ROOT}>
+      <header className={`${FORK_PAGE_COLUMN} grid gap-1`}>
+        <div className="flex flex-wrap items-center justify-between gap-x-3 gap-y-2">
+          <h1 className={FORK_PAGE_TITLE}>共创</h1>
+          <button
+            className={`${FORK_BUTTON_SECONDARY} shrink-0`}
+            type="button"
+            disabled={loading}
+            onClick={() => void reloadCatalog()}
+          >
+            <RefreshCcw
+              className="mr-1 inline-block align-[-2px]"
+              size={13}
+              aria-hidden="true"
+            />
+            刷新
+          </button>
+        </div>
+        <p className={`${FORK_BODY_TEXT} max-w-[56ch]`}>
+          把平台上的作品整个工程复制到你的项目里继续改造。
+        </p>
+      </header>
+
+      {deepLinkNotice ? (
+        <section className={FORK_PAGE_COLUMN} aria-label="共创链接提示">
+          <p className={FORK_BODY_TEXT} role="alert">
+            {deepLinkNotice}
+          </p>
+        </section>
+      ) : null}
+
+      <section
+        className={`${FORK_PAGE_COLUMN} ${FORK_SECTION}`}
+        aria-label="支持共创的作品"
+      >
+        <header className={FORK_SECTION_HEAD}>
+          <h2 className={FORK_SECTION_TITLE}>支持共创的作品</h2>
+          {scannedHint ? (
+            <small className={FORK_BADGE_NEUTRAL}>{scannedHint}</small>
+          ) : null}
+        </header>
+
+        {loading ? (
+          <p className={FORK_BODY_TEXT} role="status">
+            正在读取共创目录…
+          </p>
+        ) : null}
+
+        {!loading && catalogError ? (
+          <div className="grid justify-items-start gap-2.5">
+            <p
+              className="m-0 max-w-[72ch] text-[12px] leading-5 text-[#b42318]"
+              role="alert"
+            >
+              {catalogError}
+            </p>
+            <button
+              className={FORK_BUTTON_SECONDARY}
+              type="button"
+              onClick={() => void reloadCatalog()}
+            >
+              重试
+            </button>
+          </div>
+        ) : null}
+
+        {!loading && !catalogError && games.length === 0 ? (
+          <p className={FORK_BODY_TEXT}>
+            最新{scannedHint ? ` ${catalog?.scannedGames ?? 0} 个` : ''}
+            作品里还没有开放共创的；稍后再来看看，或请作品作者在网页端开启共创。
+          </p>
+        ) : null}
+
+        {!catalogError && games.length > 0 ? (
+          <div className="grid grid-cols-3 gap-4 max-[900px]:grid-cols-2 max-[760px]:grid-cols-1">
+            {games.map((game) => {
+              const coverUrl = coverUrls[game.id];
+              const createdAt = formatCatalogCreatedAt(game.createdAt);
+              const selfPlayCountLabel = formatCatalogPlayCount(game.playCount);
+              return (
+                <article className="grid min-w-0" key={game.id}>
+                  <div
+                    className={`${FORK_CARD} grid min-h-34 w-full grid-cols-[96px_minmax(0,1fr)] items-stretch gap-3 overflow-hidden p-2 text-left`}
+                  >
+                    <span
+                      className="grid min-h-29 place-items-center overflow-hidden rounded-lg text-[26px] font-bold text-white shadow-inner"
+                      style={{ backgroundColor: game.coverColor || '#c2653d' }}
+                    >
+                      {/*
+                        封面：优先用有界 data URL（AGC 不让渲染层直连签名地址）。没有封面、换签失败
+                        或超限时保持首字占位——**降级必须保留**，否则列表会出现破图。
+                      */}
+                      {coverUrl ? (
+                        <img
+                          className="h-full w-full object-cover"
+                          src={coverUrl}
+                          alt={`${game.title || game.id} 封面`}
+                        />
+                      ) : (
+                        <span aria-hidden="true">
+                          {(game.title || game.id).slice(0, 1)}
+                        </span>
+                      )}
+                    </span>
+                    <span className="grid min-w-0 content-start gap-1 py-0.5">
+                      <strong className="min-w-0 overflow-hidden text-ellipsis whitespace-nowrap text-[14px] font-semibold leading-5 text-(--platform-text-strong)">
+                        {game.title || '（无标题）'}
+                      </strong>
+                      <small className={FORK_META_GRID_COMPACT}>
+                        <span className={FORK_META_LABEL}>作者</span>
+                        <span className={FORK_META_VALUE}>
+                          {game.author?.name || '—'}
+                        </span>
+                        <span className={FORK_META_LABEL}>类型</span>
+                        <span className={FORK_META_VALUE}>
+                          {game.category || '—'}
+                        </span>
+                        {/*
+                          游玩次数：**只显示该作品自身的计数**（`game.playCount`），不叠加任何子代。
+                          客户端拿不到血缘树（要树得逐作品拉 `/lineage`，列表页不能这么打接口），
+                          所以这里与网页端**刻意不同**——网页侧能按子树合计，客户端只能给自身值。
+                          因此文案固定写「游玩 N 次」，**不写「含衍生」之类会被读成合计的措辞**：
+                          这不是漏了聚合，是客户端没有聚合所需的数据（别当成 bug 修）。
+                          字段由公开目录投影保证下发（api-server `public_game_payload` → `"playCount"`）；
+                          万一缺失/非法就整行不渲染，不留恒为「—」的死行。
+                        */}
+                        {selfPlayCountLabel ? (
+                          <>
+                            <span className={FORK_META_LABEL}>游玩</span>
+                            <span className={FORK_META_VALUE}>
+                              {selfPlayCountLabel}
+                            </span>
+                          </>
+                        ) : null}
+                        {/*
+                          公开目录没有 `updatedAt`，只有 `createdAt`：标签就写「创建时间」，
+                          取不到时整行不渲染（不留恒为「—」的死行）。
+                        */}
+                        {createdAt ? (
+                          <>
+                            <span className={FORK_META_LABEL}>创建时间</span>
+                            <span className={FORK_META_VALUE}>{createdAt}</span>
+                          </>
+                        ) : null}
+                      </small>
+                      <button
+                        className="w-fit cursor-pointer rounded-lg border-0 bg-(image:--platform-button-primary-fill) px-2.5 py-1 text-[11px] font-bold text-(--platform-button-primary-text) disabled:cursor-not-allowed disabled:opacity-55"
+                        type="button"
+                        // 无障碍名与可见文案一致，并带上作品名以便读屏定位到具体卡片。
+                        aria-label={`开始共创《${game.title || game.id}》`}
+                        onClick={() => void forkFromCard(game)}
+                      >
+                        开始共创
+                      </button>
+                    </span>
+                  </div>
+                </article>
+              );
+            })}
+          </div>
+        ) : null}
+      </section>
+    </div>
+  );
+}
diff --git a/apps/ai-game-creator-shell/src/view/fork-confirm/index.tsx b/apps/ai-game-creator-shell/src/view/fork-confirm/index.tsx
new file mode 100644
index 000000000..c5974149a
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/view/fork-confirm/index.tsx
@@ -0,0 +1,447 @@
+/**
+ * 「开始共创」确认页（创作用户端）：创作前的授权校验与工程同步环节。
+ *
+ * 对外动作名统一叫「开始共创」；内部标识仍用 fork（组件名 `ForkConfirmView`、`fork-source` 等不改）。
+ *
+ * 结构照需求文档「Fork 工程确认页（客户端）」：父作品信息卡 → 二次确认 + 授权须知 + 风险说明
+ * （**强制阅读 3 秒**）→ 工程同步状态条 → 底部吸附操作条「取消 / 确认并进入编辑」。
+ *
+ * 三条硬要求：
+ * 1. 须知**全文真实可见**（五条逐条写清、**不折叠也不自建内层滚动**，随页面一起滚）；
+ * 2. 强制阅读只靠**计时门禁**（底部按钮倒计时 + 顶部徽章），不要求「滚到底」；
+ * 3. 状态条只显示**原生真实发出的阶段**（`fork.progress`），阶段内部不可测量就只做进行中指示，
+ *    **不造百分比**。
+ *
+ * 滚动：页面滚动容器是外壳的 `.launcher-main`（见 `styles.css` 里那条注释），本页**不自建**
+ * 滚动容器；底部操作条用 `position: sticky` 吸附在滚动容器下沿，因此始终可见。
+ */
+
+import { RefreshCcw } from 'lucide-react';
+import { useEffect, useMemo, useState } from 'react';
+
+import { resolveTauriInvoke } from '../../app/tauri';
+import type { InitLocalProjectResult } from '../../app/types';
+import { useForkConfirmStore } from '../../features/platform-fork/forkConfirmTarget';
+import {
+  forkNoticeSections,
+  MANDATORY_READING_SECONDS,
+} from '../../features/platform-fork/forkNotice';
+import {
+  FORK_BADGE_NEUTRAL,
+  FORK_BADGE_SUCCESS,
+  FORK_BADGE_WARM,
+  FORK_BODY_TEXT,
+  FORK_BUTTON_PRIMARY,
+  FORK_BUTTON_SECONDARY,
+  FORK_CARD,
+  FORK_META_GRID,
+  FORK_META_LABEL,
+  FORK_META_VALUE,
+  FORK_PAGE_COLUMN,
+  FORK_PAGE_ROOT,
+  FORK_PAGE_TITLE,
+  FORK_SECTION,
+  FORK_SECTION_HEAD,
+  FORK_SECTION_TITLE,
+  FORK_STICKY_FOOTER,
+} from '../../features/platform-fork/forkPageStyles';
+import {
+  type ForkParentCard,
+  forkParentCardFromGame,
+  loadForkParentCard,
+} from '../../features/platform-fork/forkParentCard';
+import {
+  FORK_PROGRESS_STAGES,
+  forkProgressStageLabel,
+} from '../../features/platform-fork/forkProgress';
+import { resolveCoverPreview } from '../../features/platform-fork/platformForkCover';
+import { usePlatformFork } from '../../features/platform-fork/usePlatformFork';
+import type { ProjectOpenAnalytics } from '../../services/clientAnalytics';
+
+type ForkConfirmViewProps = {
+  /** 建项成功后的进项目通道：与模板库/共创页同一条「原生已建好 → 进入工作区」路径。 */
+  onProjectCreated: (
+    result: InitLocalProjectResult,
+    isCurrent: () => boolean,
+    analytics: ProjectOpenAnalytics,
+  ) => Promise<void> | void;
+  /** 取消：回到进入前的界面（列表/详情）。 */
+  onCancel: () => void;
+};
+
+export default function ForkConfirmView({
+  onProjectCreated,
+  onCancel,
+}: ForkConfirmViewProps) {
+  const target = useForkConfirmStore((state) => state.target);
+  const closeTarget = useForkConfirmStore((state) => state.close);
+  const fork = usePlatformFork({ onProjectCreated });
+  const [card, setCard] = useState<ForkParentCard | null>(() =>
+    target?.game ? forkParentCardFromGame(target.game) : null,
+  );
+  const [cardLoading, setCardLoading] = useState(false);
+  const [coverUrl, setCoverUrl] = useState('');
+  const [remainingSeconds, setRemainingSeconds] = useState(
+    MANDATORY_READING_SECONDS,
+  );
+
+  const gameId = target?.gameId ?? '';
+  const notices = useMemo(
+    () => forkNoticeSections(card?.authorizationLabel ?? '禁止共创'),
+    [card?.authorizationLabel],
+  );
+
+  // 信息卡：列表里带过来的先用，缺了再按 gameId 拉公开详情（拿不到就降级，不阻塞确认）。
+  useEffect(() => {
+    if (!gameId) {
+      setCard(null);
+      return;
+    }
+    if (target?.game) {
+      setCard(forkParentCardFromGame(target.game));
+      return;
+    }
+    let cancelled = false;
+    setCardLoading(true);
+    void loadForkParentCard(gameId)
+      .then((next) => {
+        if (!cancelled) {
+          setCard(next);
+        }
+      })
+      .finally(() => {
+        if (!cancelled) {
+          setCardLoading(false);
+        }
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [gameId, target?.game]);
+
+  // 封面：复用共创列表那套有界 data URL 链路；失败/没有封面就退回首字占位。
+  useEffect(() => {
+    const invoke = resolveTauriInvoke();
+    const objectKey = card?.coverObjectKey ?? '';
+    if (!invoke || !objectKey) {
+      setCoverUrl('');
+      return;
+    }
+    let cancelled = false;
+    void resolveCoverPreview(invoke, { coverObjectKey: objectKey }).then(
+      (url) => {
+        if (!cancelled) {
+          setCoverUrl(url ?? '');
+        }
+      },
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [card?.coverObjectKey]);
+
+  // 强制阅读：进入页面后倒计时 3 秒，其间确认按钮禁用（重新打开确认页会重新计时）。
+  // 门禁只与**时间**有关：须知随页面自然流动，不要求用户把某个内层容器滚到底。
+  useEffect(() => {
+    setRemainingSeconds(MANDATORY_READING_SECONDS);
+    const startedAt = Date.now();
+    const timer = window.setInterval(() => {
+      const elapsed = Math.floor((Date.now() - startedAt) / 1000);
+      const remaining = Math.max(0, MANDATORY_READING_SECONDS - elapsed);
+      setRemainingSeconds(remaining);
+      if (remaining === 0) {
+        window.clearInterval(timer);
+      }
+    }, 250);
+    return () => window.clearInterval(timer);
+  }, [gameId]);
+
+  const readingLocked = remainingSeconds > 0;
+  const readingProgress = Math.min(
+    1,
+    (MANDATORY_READING_SECONDS - remainingSeconds) / MANDATORY_READING_SECONDS,
+  );
+  const reachedStages = fork.progress.reached;
+  const activeStage = fork.progress.current;
+  const syncedCount = reachedStages.length;
+
+  async function confirmFork() {
+    if (!gameId || readingLocked || fork.busy) {
+      return;
+    }
+    await fork.forkGame(gameId);
+    // 成功时 `usePlatformFork` 已经把用户带进工作区（onProjectCreated）；这里只在失败后
+    // 需要清掉待确认目标时收尾，因此失败分支不关闭页面，让用户能重试或取消。
+    if (fork.error) {
+      return;
+    }
+  }
+
+  function cancelFork() {
+    if (fork.busy) {
+      return;
+    }
+    closeTarget();
+    onCancel();
+  }
+
+  if (!target) {
+    return (
+      <div className={FORK_PAGE_ROOT}>
+        <section
+          className={`${FORK_PAGE_COLUMN} ${FORK_SECTION}`}
+          aria-label="开始共创确认"
+        >
+          <p className={FORK_BODY_TEXT}>
+            没有待确认的共创作品；请回到「共创」页选择一个作品。
+          </p>
+          <button
+            className={`${FORK_BUTTON_SECONDARY} w-fit`}
+            type="button"
+            onClick={onCancel}
+          >
+            返回
+          </button>
+        </section>
+      </div>
+    );
+  }
+
+  return (
+    <div className={FORK_PAGE_ROOT}>
+      <header className={`${FORK_PAGE_COLUMN} grid gap-1`}>
+        <h1 className={FORK_PAGE_TITLE}>开始共创</h1>
+        <p className={`${FORK_BODY_TEXT} max-w-[64ch]`}>
+          确认授权边界后再开始。开始共创
+          会把整个工程复制一份到你的项目里继续改造，副本完全独立。
+        </p>
+      </header>
+
+      {/* 父作品信息卡：封面 / 标题 / 作者 / 当前授权类型（缺失逐项降级，不报错） */}
+      <section
+        className={`${FORK_PAGE_COLUMN} ${FORK_SECTION}`}
+        aria-label="父作品信息"
+      >
+        <div
+          className={`${FORK_CARD} grid grid-cols-[104px_minmax(0,1fr)] items-stretch gap-3.5 p-3 max-[760px]:grid-cols-[80px_minmax(0,1fr)]`}
+        >
+          <span
+            className="grid min-h-27 place-items-center overflow-hidden rounded-lg text-[26px] font-bold text-white shadow-inner"
+            style={{ backgroundColor: card?.coverColor || '#c2653d' }}
+          >
+            {coverUrl ? (
+              <img
+                className="h-full w-full object-cover"
+                src={coverUrl}
+                alt={`${card?.title || gameId} 封面`}
+              />
+            ) : (
+              <span aria-hidden="true">
+                {(card?.title || gameId || '？').slice(0, 1)}
+              </span>
+            )}
+          </span>
+          <span className="grid min-w-0 content-center gap-2">
+            <small className="text-[10px] leading-3.5 tracking-[0.08em] text-(--platform-text-soft)">
+              父作品
+            </small>
+            <strong className="min-w-0 overflow-hidden text-ellipsis whitespace-nowrap text-[15px] font-semibold leading-5 text-(--platform-text-strong)">
+              {card?.title?.trim() ||
+                (cardLoading ? '正在读取作品信息…' : '（未获取到标题）')}
+            </strong>
+            <small className={`${FORK_META_GRID} text-[11px]`}>
+              <span className={FORK_META_LABEL}>作者</span>
+              <span className={FORK_META_VALUE}>
+                {card?.authorName?.trim() || '—'}
+              </span>
+              <span className={FORK_META_LABEL}>授权类型</span>
+              <span className="min-w-0 truncate whitespace-nowrap text-(--platform-warm-text)">
+                {card ? card.authorizationLabel : '—'}
+              </span>
+              <span className={FORK_META_LABEL}>作品 ID</span>
+              <code className={FORK_META_VALUE}>{gameId}</code>
+            </small>
+          </span>
+        </div>
+      </section>
+
+      {/*
+        二次确认 + 授权须知 + 风险说明：全文随页面自然流动（**没有内层滚动**），
+        前 3 秒确认按钮禁用；顶部徽章给出倒计时，底部按钮同样带倒计时。
+      */}
+      <section
+        className={`${FORK_PAGE_COLUMN} ${FORK_SECTION}`}
+        aria-label="授权须知与风险说明"
+      >
+        <header className={FORK_SECTION_HEAD}>
+          <h2 className={FORK_SECTION_TITLE}>授权须知与风险说明</h2>
+          <small
+            className={readingLocked ? FORK_BADGE_WARM : FORK_BADGE_SUCCESS}
+          >
+            {readingLocked ? `${remainingSeconds}s 后可确认` : '已可确认'}
+          </small>
+        </header>
+        <div
+          className="h-1 w-full overflow-hidden rounded-full bg-(--platform-neutral-bg)"
+          role="progressbar"
+          aria-label="强制阅读进度"
+          aria-valuemin={0}
+          aria-valuemax={MANDATORY_READING_SECONDS}
+          aria-valuenow={MANDATORY_READING_SECONDS - remainingSeconds}
+        >
+          <span
+            className="block h-full rounded-full bg-(image:--platform-button-primary-fill) transition-[width] duration-250"
+            style={{ width: `${Math.round(readingProgress * 100)}%` }}
+          />
+        </div>
+        <div
+          className={`${FORK_CARD} grid gap-3 p-3.5`}
+          aria-label="授权须知全文"
+        >
+          {notices.map((notice, index) => (
+            <article
+              className="grid grid-cols-[22px_minmax(0,1fr)] items-start gap-2.5"
+              key={notice.key}
+            >
+              <span
+                className="mt-0.5 grid size-5 place-items-center rounded-full border border-(--platform-warm-border) bg-(--platform-warm-bg) text-[10px] font-bold text-(--platform-warm-text)"
+                aria-hidden="true"
+              >
+                {index + 1}
+              </span>
+              <span className="grid gap-1">
+                <strong className="text-[12px] font-bold leading-5 text-(--platform-text-strong)">
+                  {notice.title}
+                </strong>
+                <p className={FORK_BODY_TEXT}>{notice.body}</p>
+              </span>
+            </article>
+          ))}
+        </div>
+      </section>
+
+      {/* 工程同步状态条：只显示原生真实阶段，不造百分比 */}
+      <section
+        className={`${FORK_PAGE_COLUMN} ${FORK_SECTION}`}
+        aria-label="工程同步状态"
+      >
+        <header className={FORK_SECTION_HEAD}>
+          <h2 className={FORK_SECTION_TITLE}>工程同步</h2>
+          <small
+            className={
+              fork.busy
+                ? FORK_BADGE_WARM
+                : syncedCount > 0
+                  ? FORK_BADGE_SUCCESS
+                  : FORK_BADGE_NEUTRAL
+            }
+          >
+            {fork.busy
+              ? `正在：${activeStage ? forkProgressStageLabel(activeStage) : '准备中'}`
+              : syncedCount > 0
+                ? `已同步 ${syncedCount}/${FORK_PROGRESS_STAGES.length} 步`
+                : '确认后开始'}
+          </small>
+        </header>
+        <ol
+          className="m-0 grid list-none gap-2.5 p-0"
+          aria-label="工程同步阶段"
+        >
+          {FORK_PROGRESS_STAGES.map((stage, index) => {
+            const done =
+              reachedStages.includes(stage.key) &&
+              (!fork.busy || stage.key !== activeStage);
+            const active = fork.busy && stage.key === activeStage;
+            return (
+              <li
+                className="grid grid-cols-[18px_minmax(0,1fr)] items-start gap-2.5 text-[12px] leading-5"
+                key={stage.key}
+              >
+                <span
+                  className={
+                    'mt-0.5 grid size-4.5 place-items-center rounded-full border text-[9px] font-bold ' +
+                    (done
+                      ? 'border-(--platform-warm-text) bg-(image:--platform-button-primary-fill) text-(--platform-button-primary-text)'
+                      : active
+                        ? 'border-(--platform-warm-text) text-(--platform-warm-text)'
+                        : 'border-(--platform-surface-border) text-(--platform-text-soft)')
+                  }
+                  aria-hidden="true"
+                >
+                  {done ? '✓' : index + 1}
+                </span>
+                <span className="grid gap-0.5">
+                  <span
+                    className={
+                      done || active
+                        ? 'font-bold text-(--platform-text-strong)'
+                        : 'text-(--platform-text-soft)'
+                    }
+                  >
+                    {stage.label}
+                    {active ? '（进行中）' : ''}
+                  </span>
+                  <small className={FORK_BODY_TEXT}>{stage.detail}</small>
+                </span>
+              </li>
+            );
+          })}
+        </ol>
+        {fork.error ? (
+          <p
+            className="m-0 max-w-[72ch] text-[12px] leading-5 text-[#b42318]"
+            role="alert"
+          >
+            {fork.error}
+          </p>
+        ) : null}
+      </section>
+
+      {/*
+        吸附底部操作条：`sticky bottom-0` 挂在外壳滚动容器（`.launcher-main`）下沿，
+        长页面滚动时始终可见；状态说明也放在条内，避免它被顶到看不见的地方。
+      */}
+      <footer className={FORK_STICKY_FOOTER} aria-label="开始共创操作">
+        <div className={`${FORK_PAGE_COLUMN} grid gap-2`}>
+          <div className="flex flex-wrap items-center justify-end gap-2.5">
+            <button
+              className={FORK_BUTTON_SECONDARY}
+              type="button"
+              disabled={fork.busy}
+              onClick={cancelFork}
+            >
+              取消
+            </button>
+            <button
+              className={FORK_BUTTON_PRIMARY}
+              type="button"
+              disabled={readingLocked || fork.busy || !gameId}
+              onClick={() => void confirmFork()}
+            >
+              {fork.busy
+                ? '正在开始共创…'
+                : readingLocked
+                  ? `确认并进入编辑（${remainingSeconds}s）`
+                  : '确认并进入编辑'}
+            </button>
+          </div>
+          {fork.busy ? (
+            <p className={FORK_BODY_TEXT} role="status">
+              正在同步工程：内容较大时需要几分钟，请不要关闭客户端。同步期间不能取消。
+            </p>
+          ) : null}
+          {!fork.busy && reachedStages.length > 0 ? (
+            <p className={FORK_BODY_TEXT} role="status">
+              <RefreshCcw
+                className="mr-1 inline-block align-[-2px]"
+                size={11}
+                aria-hidden="true"
+              />
+              同步已完成，即将进入工作台。
+            </p>
+          ) : null}
+        </div>
+      </footer>
+    </div>
+  );
+}
diff --git a/apps/ai-game-creator-shell/src/view/layout.tsx b/apps/ai-game-creator-shell/src/view/layout.tsx
index 621c98708..79b85c129 100644
--- a/apps/ai-game-creator-shell/src/view/layout.tsx
+++ b/apps/ai-game-creator-shell/src/view/layout.tsx
@@ -2,6 +2,7 @@ import { openUrl } from '@tauri-apps/plugin-opener';
 import {
   CircleHelp,
   FolderKanban,
+  GitFork,
   Home,
   LayoutTemplate,
   Plus,
@@ -30,6 +31,8 @@ export type LauncherView =
   | 'guide'
   | 'contact'
   | 'news'
+  | 'co-creation'
+  | 'fork-confirm'
   | 'template-library'
   | 'project-development';
 
@@ -313,6 +316,19 @@ export function Sidebar({
         >
           <FolderKanban size={17} aria-hidden="true" />
         </button>
+        <button
+          type="button"
+          aria-label="共创"
+          title="共创"
+          className={cx(
+            sidebarIconButtonClass,
+            activeView === 'co-creation' &&
+              'border border-(--platform-nav-active-border) bg-(image:--platform-nav-active-fill) text-(--platform-nav-item-text-active) shadow-(--platform-nav-active-shadow)',
+          )}
+          onClick={() => changeView('co-creation')}
+        >
+          <GitFork size={17} aria-hidden="true" />
+        </button>
         {templateLibraryEnabled ? (
           <button
             type="button"
diff --git a/apps/ai-game-creator-shell/src/view/project-development/index.tsx b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
index 110945eed..701a7c09d 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/index.tsx
+++ b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
@@ -444,6 +444,7 @@ import {
   projectResourceSectionZoomFromWheel,
 } from './resourceSectionHeightModel';
 import { ResourceTypePanel } from './ResourceTypePanel';
+import { runUnavailableHintText } from './runUnavailableHint';
 import {
   describeProjectResourceCanvasLayoutRead,
   type ProjectResourceCanvasLayoutReadReport,
@@ -10152,7 +10153,7 @@ export default function ProjectDevelopmentView({
               className="game-run-unavailable"
               role="status"
             >
-              首个可运行原型尚未完成，运行视图暂不可用
+              {runUnavailableHintText(manifest)}
             </p>
           ) : null}
 
diff --git a/apps/ai-game-creator-shell/src/view/project-development/runUnavailableHint.ts b/apps/ai-game-creator-shell/src/view/project-development/runUnavailableHint.ts
new file mode 100644
index 000000000..288b4af79
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/view/project-development/runUnavailableHint.ts
@@ -0,0 +1,27 @@
+import type { GameCreationAppManifest } from '../../../../../packages/shared/src/contracts/gameCreationApp';
+
+/**
+ * 「运行」页签不可用（`run-unavailable-hint`）时给用户看的文案。
+ *
+ * 同一句话对两种情况并不都成立，所以按清单里已有的事实分叉，而不是套一句万能的空话：
+ *
+ * - **全新项目**（清单里还没有任何工程内部版本）：确实什么都还没产出，
+ *   「首个可运行原型尚未完成，运行视图暂不可用」是准确的，保持原样。
+ * - **已经有工程内容、但本机还没有可运行的构建产物**：典型是**从平台作品 Fork 来的工程源包
+ *   项目**——包里就是作者的完整工程，但工程源包按规则不含构建产物（`project_bundle.rs` 排除
+ *   `game/dist`），AGC 也不在 Fork 时自动构建（与「不自动安装外部工程依赖」的既有策略一致）。
+ *   这时原句会让人以为「什么都没有」，必须如实说清：内容已经在本地，只是还没有构建出可运行的
+ *   原型，让智能体完成可运行原型之后即可运行。
+ *
+ * 判据只用清单里已有的字段（`versions` 非空 = 这个项目已经有工程内部版本记录）。渲染层拿不到
+ * 「预览根有没有 index.html」这种文件事实（那是原生侧的门禁判据），所以这里不新造状态、也不
+ * 额外调 IPC——它只决定**措辞**，能不能运行仍由运行门禁与原生预览决定。
+ */
+export function runUnavailableHintText(
+  manifest: Pick<GameCreationAppManifest, 'versions'>,
+): string {
+  const hasProjectVersions = (manifest.versions?.length ?? 0) > 0;
+  return hasProjectVersions
+    ? '已有工程内容但还没有可运行的构建产物：让智能体完成可运行原型后即可运行'
+    : '首个可运行原型尚未完成，运行视图暂不可用';
+}
diff --git a/apps/ai-game-creator-shell/tests/appSurface.test.ts b/apps/ai-game-creator-shell/tests/appSurface.test.ts
index 53689b40e..92e5fc6ee 100644
--- a/apps/ai-game-creator-shell/tests/appSurface.test.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface.test.ts
@@ -7,6 +7,7 @@ import { registerDesignAgentSurfaceTests } from './appSurface/design-agent.suite
 import { describe } from './appSurface/harness';
 import {
   registerClientHomeTests,
+  registerCoCreationEntryTests,
   registerHomeProjectCreationTests,
   registerRecentProjectsTests,
 } from './appSurface/home.suite';
@@ -41,6 +42,7 @@ describe('AI 游戏创作 App 界面边界', () => {
   registerAuthTests();
   registerAgentStatusDerivationTests();
   registerClientHomeTests();
+  registerCoCreationEntryTests();
   registerHomeProjectCreationTests();
   registerRuntimeSettingsTests();
   registerRecentProjectsTests();
diff --git a/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
index c16b87c6c..ddbdd108b 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
@@ -10,6 +10,7 @@ import {
   parseStyleSheet,
   resolveDeclarations,
 } from '../styleCascade';
+import { createTauriEventFake } from '../tauriEventFake';
 import {
   act,
   App,
@@ -4191,3 +4192,98 @@ export function registerRecentProjectsTests() {
     });
   });
 }
+
+/** 共创入口从首页内联面板搬到侧边栏「共创」页之后的回归防线。 */
+export function registerCoCreationEntryTests() {
+  it('首页不再内联「从平台作品 Fork」面板', async () => {
+    const invoke = vi.fn(async (command: string) => {
+      if (command === 'list_platform_game_catalog') {
+        return { games: [], nextCursor: null };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    installTauriRuntime({ core: { invoke } });
+    renderLauncherAt('/?launcher');
+
+    // 首页该有的东西还在（否则这条断言会因为整页没渲染而假绿）。
+    expect(await screen.findByLabelText('创作想法')).not.toBeNull();
+    // 内联面板整体消失：标题、按钮都不得再出现在首页。
+    expect(screen.queryByText('从平台作品 Fork')).toBeNull();
+    expect(
+      screen.queryByRole('button', { name: 'Fork 到我的项目' }),
+    ).toBeNull();
+  });
+
+  it('深链带 gameId 时直接落到确认页并预填父作品', async () => {
+    const invoke = vi.fn(async (command: string) => {
+      if (command === 'read_public_game_detail') {
+        return {
+          id: 'game_from_link',
+          title: '链接带来的作品',
+          author: { id: 'user_1', name: '作者乙' },
+          forkAuthorization: 'nonCommercial',
+          coverColor: '#c2653d',
+        };
+      }
+      if (command === 'list_platform_game_catalog') {
+        return { games: [], nextCursor: null };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    installTauriRuntime({ core: { invoke } });
+    const eventFake = createTauriEventFake({ invoke });
+    eventFake.install();
+    renderLauncherAt('/?launcher');
+    await screen.findByLabelText('创作想法');
+    eventFake.flushRegistrationEvals();
+
+    eventFake.emit('game-fork-deep-link', {
+      gameId: 'game_from_link',
+      message: null,
+    });
+
+    // 落到确认页：父作品信息卡 + 强制阅读闸门。
+    expect(await screen.findByText('开始共创')).not.toBeNull();
+    const card = await screen.findByLabelText('父作品信息');
+    await waitFor(() => expect(card.textContent).toContain('链接带来的作品'));
+    expect(card.textContent).toContain('game_from_link');
+    expect(
+      screen.getByRole('button', { name: /确认并进入编辑/ }),
+    ).toHaveProperty('disabled', true);
+    eventFake.restore();
+  });
+
+  it('侧边栏「共创」入口可切换，并落在共创页上', async () => {
+    const invoke = vi.fn(async (command: string) => {
+      if (command === 'list_platform_game_catalog') {
+        return {
+          games: [
+            {
+              id: 'game_open',
+              title: '开放共创的作品',
+              category: '动作',
+              author: { id: 'user_1', name: '作者甲' },
+              coverColor: '#c2653d',
+              forkAuthorization: 'nonCommercial',
+              createdAt: '2026-10-01T08:00:00Z',
+            },
+          ],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    installTauriRuntime({ core: { invoke } });
+    renderLauncherAt('/?launcher');
+    await screen.findByLabelText('创作想法');
+
+    fireEvent.click(screen.getByRole('button', { name: '共创' }));
+
+    expect(await screen.findByText('支持共创的作品')).not.toBeNull();
+    expect(await screen.findByText('开放共创的作品')).not.toBeNull();
+    expect(invoke).toHaveBeenCalledWith('list_platform_game_catalog', {
+      limit: 50,
+      cursor: null,
+    });
+  });
+}
diff --git a/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
index fc37be1bc..4caa9bb13 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
@@ -531,6 +531,134 @@ export function registerProjectWorkbenchFoundationTests() {
     expect(screen.getByRole('article', { name: /发布 Agent/ })).not.toBeNull();
   });
 
+  /**
+   * Fork 建项之后运行视图必须直接可用。
+   *
+   * 原生侧（`game_fork.rs` 的 `register_forked_project_state_at`）在建项收口时登记「可运行
+   * 原型」：成品包形态把发行产物铺进预览根并置 `code-prototype = completed`，同时写一条
+   * `initial-1` 工程内部版本。这里钉的是渲染层的投影结果——那句「首个可运行原型尚未完成」
+   * 必须消失，运行页签可点并真的发出播放请求。
+   */
+  it('renders a forked package project as directly runnable with an initial version', () => {
+    const manifest = createGameCreationAppManifest(
+      'workbench-fork-package',
+      '共创项目（成品包）',
+    );
+    const codePrototype = manifest.tasks.find(
+      (task) => task.id === 'code-prototype',
+    );
+    if (!codePrototype) {
+      throw new Error('fixture 必须包含 code-prototype seed 任务');
+    }
+    codePrototype.status = 'completed';
+    manifest.versions = [
+      {
+        versionId: 'initial-1',
+        parentVersionId: null,
+        projectRevision: 1,
+        resourceBindings: [],
+        createdReason: 'initial',
+        createdAt: 1_791_271_678,
+      },
+    ];
+
+    const onPlay = vi.fn();
+    render(
+      React.createElement(ProjectDevelopmentView, {
+        projectName: '共创项目（成品包）',
+        projectPath: '/tmp/workbench-fork-package',
+        manifest,
+        attachments: [],
+        recentRunStatus: null,
+        recentRunStopReason: null,
+        chat: React.createElement(
+          'div',
+          { 'aria-label': '测试项目总控' },
+          '项目总控对话内容',
+        ),
+        onHomeOpen: vi.fn(),
+        onProjectsOpen: vi.fn(),
+        onPlay,
+      }),
+    );
+
+    // 提示必须消失，页签必须不再是「不可用」态。
+    expect(
+      screen.queryByText('首个可运行原型尚未完成，运行视图暂不可用'),
+    ).toBeNull();
+    expect(document.querySelector('#run-unavailable-hint')).toBeNull();
+    const runTab = screen.getByRole('tab', {
+      name: '运行',
+    }) as HTMLButtonElement;
+    expect(runTab.getAttribute('data-unavailable')).toBeNull();
+    expect(runTab.getAttribute('aria-describedby')).toBeNull();
+
+    // 点运行 = 切视图 + 发起播放请求（就是 fork 之后用户看到的「直接能跑」）。
+    fireEvent.click(runTab);
+    expect(runTab.getAttribute('aria-selected')).toBe('true');
+    expect(onPlay).toHaveBeenCalledTimes(1);
+  });
+
+  /**
+   * 工程源包 Fork 的如实表述：包里是作者的完整工程，但工程源包不含构建产物
+   * （`project_bundle.rs` 排除 `game/dist`），AGC 也不在 Fork 时自动构建，所以本机还没有
+   * 可运行的构建产物。此时不能再说「首个可运行原型尚未完成」（听着像什么都没有），
+   * 也不能谎称已经可运行。
+   */
+  it('tells the truth for a source-only fork that still needs a build', () => {
+    const manifest = createGameCreationAppManifest(
+      'workbench-fork-source',
+      '共创项目（工程源包）',
+    );
+    manifest.versions = [
+      {
+        versionId: 'initial-1',
+        parentVersionId: null,
+        projectRevision: 1,
+        resourceBindings: [],
+        createdReason: 'initial',
+        createdAt: 1_791_271_678,
+      },
+    ];
+
+    const onPlay = vi.fn();
+    render(
+      React.createElement(ProjectDevelopmentView, {
+        projectName: '共创项目（工程源包）',
+        projectPath: '/tmp/workbench-fork-source',
+        manifest,
+        attachments: [],
+        recentRunStatus: null,
+        recentRunStopReason: null,
+        chat: React.createElement(
+          'div',
+          { 'aria-label': '测试项目总控' },
+          '项目总控对话内容',
+        ),
+        onHomeOpen: vi.fn(),
+        onProjectsOpen: vi.fn(),
+        onPlay,
+      }),
+    );
+
+    expect(
+      screen.getByText(
+        '已有工程内容但还没有可运行的构建产物：让智能体完成可运行原型后即可运行',
+      ),
+    ).not.toBeNull();
+    expect(
+      screen.queryByText('首个可运行原型尚未完成，运行视图暂不可用'),
+    ).toBeNull();
+
+    const runTab = screen.getByRole('tab', {
+      name: '运行',
+    }) as HTMLButtonElement;
+    expect(runTab.getAttribute('data-unavailable')).toBe('true');
+    fireEvent.click(runTab);
+    expect(runTab.getAttribute('aria-selected')).toBe('false');
+    expect(onPlay).not.toHaveBeenCalled();
+  });
+
   it('keeps the approval-mode choices reachable in their own dialog surface', () => {
     // 审批模式原来是长在会话列头部按钮里的对话框；面板顶部精简之后它由设置浮层里的
     // 「操作权限」行打开，但选项与「不可用项给出说明」的语义必须完整保留。
diff --git a/apps/ai-game-creator-shell/tests/coCreation.test.tsx b/apps/ai-game-creator-shell/tests/coCreation.test.tsx
new file mode 100644
index 000000000..4ac1b1519
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/coCreation.test.tsx
@@ -0,0 +1,461 @@
+// @vitest-environment jsdom
+import { cleanup, fireEvent, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { InitLocalProjectResult } from '../src/app/types';
+import { useForkDeepLinkStore } from '../src/features/platform-fork/forkDeepLink';
+import {
+  forkableGames,
+  formatCatalogCreatedAt,
+  formatCatalogPlayCount,
+  isForkableGame,
+  loadForkableGames,
+} from '../src/features/platform-fork/platformForkCatalog';
+import CoCreationView from '../src/view/co-creation';
+
+const FORK_COMMAND = 'create_local_project_from_platform_game';
+const CATALOG_COMMAND = 'list_platform_game_catalog';
+
+const PROJECT_RESULT = {
+  projectPath: 'C:\\projects\\gameagent-fork-1',
+  manifestPath: 'C:\\projects\\gameagent-fork-1\\.agent\\manifest.json',
+  manifest: { name: '共创项目 1' },
+} as unknown as InitLocalProjectResult;
+
+type InvokeCall = { command: string; args?: Record<string, unknown> };
+
+function installInvoke(
+  implementation: (command: string, args?: Record<string, unknown>) => unknown,
+) {
+  const calls: InvokeCall[] = [];
+  const invoke = vi.fn(
+    async (command: string, args?: Record<string, unknown>) => {
+      calls.push({ command, args });
+      return implementation(command, args);
+    },
+  );
+  (window as unknown as { __TAURI__?: unknown }).__TAURI__ = {
+    core: { invoke },
+  };
+  return calls;
+}
+
+function catalogGame(
+  id: string,
+  title: string,
+  forkAuthorization: string,
+  playCount?: number,
+) {
+  return {
+    id,
+    title,
+    summary: '',
+    category: '动作',
+    author: { id: 'user_1', name: '作者甲' },
+    coverColor: '#c2653d',
+    forkAuthorization,
+    createdAt: '2026-10-01T08:00:00Z',
+    ...(typeof playCount === 'number' ? { playCount } : {}),
+  };
+}
+
+function renderPage() {
+  const onOpenConfirm = vi.fn();
+  const rendered = render(<CoCreationView onOpenConfirm={onOpenConfirm} />);
+  return { ...rendered, onOpenConfirm };
+}
+
+function forkCalls(calls: InvokeCall[]) {
+  return calls.filter((call) => call.command === FORK_COMMAND);
+}
+
+afterEach(() => {
+  cleanup();
+  delete (window as unknown as { __TAURI__?: unknown }).__TAURI__;
+  useForkDeepLinkStore.getState().consume();
+});
+
+describe('共创目录模型', () => {
+  it('只保留授权非 forbidden 的作品，字段缺省按 forbidden 处理', () => {
+    expect(isForkableGame(catalogGame('g1', 'A', 'forbidden') as never)).toBe(
+      false,
+    );
+    expect(
+      isForkableGame(catalogGame('g2', 'B', 'nonCommercial') as never),
+    ).toBe(true);
+    expect(isForkableGame(catalogGame('g3', 'C', 'full') as never)).toBe(true);
+    expect(isForkableGame({ id: 'g4' } as never)).toBe(false);
+    expect(
+      forkableGames([
+        catalogGame('g1', 'A', 'forbidden'),
+        catalogGame('g2', 'B', 'full'),
+      ] as never).map((game) => game.id),
+    ).toEqual(['g2']);
+  });
+
+  it('扫到足够可 Fork 的作品就停，不把页数打满', async () => {
+    const invoke = vi.fn(async () => ({
+      games: [catalogGame('g1', 'A', 'full'), catalogGame('g2', 'B', 'full')],
+      nextCursor: 'cursor-1',
+    }));
+    const result = await loadForkableGames(invoke as never, {
+      enough: 2,
+      maxPages: 3,
+    });
+    expect(result.games.map((game) => game.id)).toEqual(['g1', 'g2']);
+    expect(result.scannedPages).toBe(1);
+    expect(result.cappedByPageLimit).toBe(false);
+  });
+
+  it('一直没凑够就按页数上限停，并标记「被页数上限截断」', async () => {
+    let page = 0;
+    const invoke = vi.fn(async () => {
+      page += 1;
+      return {
+        games: [catalogGame(`g${page}`, 'A', 'forbidden')],
+        nextCursor: `cursor-${page}`,
+      };
+    });
+    const result = await loadForkableGames(invoke as never, {
+      enough: 5,
+      maxPages: 3,
+    });
+    expect(result.scannedPages).toBe(3);
+    expect(result.scannedGames).toBe(3);
+    expect(result.games).toEqual([]);
+    expect(result.cappedByPageLimit).toBe(true);
+  });
+});
+
+describe('共创页', () => {
+  it('列出可 Fork 的作品，过滤掉禁止共创的，并展示扫描范围', async () => {
+    const calls = installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [
+            catalogGame('game_open', '开放共创的作品', 'nonCommercial'),
+            catalogGame('game_locked', '禁止共创的作品', 'forbidden'),
+          ],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+
+    expect(await screen.findByText('开放共创的作品')).not.toBeNull();
+    expect(screen.queryByText('禁止共创的作品')).toBeNull();
+    expect(screen.getByText('作者甲')).not.toBeNull();
+    expect(screen.getByText('动作')).not.toBeNull();
+    expect(screen.getByText(/已检查最新 2 个作品（1 页）/)).not.toBeNull();
+    // 列表只读目录，不碰建项命令。
+    expect(forkCalls(calls)).toHaveLength(0);
+  });
+
+  it('点卡片只打开确认页，不直接建项', async () => {
+    const calls = installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [catalogGame('game_open', '开放共创的作品', 'full')],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    const { onOpenConfirm } = renderPage();
+    await screen.findByText('开放共创的作品');
+
+    const forkButton = screen.getByRole('button', {
+      name: '开始共创《开放共创的作品》',
+    });
+    fireEvent.click(forkButton);
+
+    // 卡片按钮：可见文案与无障碍名同一套词，且只剩「开始共创」一个动作名。
+    expect(forkButton.textContent).toBe('开始共创');
+    expect(document.querySelector('.fork-page')?.textContent).not.toMatch(
+      /\bFork\b/u,
+    );
+
+    // 建项与授权确认都搬到确认页；列表这一层一次 native 调用都不该发。
+    expect(forkCalls(calls)).toHaveLength(0);
+    expect(onOpenConfirm).toHaveBeenCalledTimes(1);
+    expect(onOpenConfirm.mock.calls[0]?.[0]).toMatchObject({
+      gameId: 'game_open',
+      origin: 'co-creation',
+    });
+  });
+
+  it('不再渲染「直接 Fork 指定作品」输入块（页面只留卡片入口）', async () => {
+    installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [catalogGame('game_open', '开放共创的作品', 'full')],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    const { container } = renderPage();
+    await screen.findByText('开放共创的作品');
+
+    // 整块连同它的标题、输入框、按钮一起消失。
+    expect(screen.queryByText('直接 Fork 指定作品')).toBeNull();
+    expect(screen.queryByLabelText('平台作品 ID 或链接')).toBeNull();
+    expect(screen.queryByRole('button', { name: '去确认并 Fork' })).toBeNull();
+    expect(screen.queryByPlaceholderText(/例如 game_ab12…/)).toBeNull();
+    // 卡片入口仍在（否则上面几条会因为整页没渲染而假绿）。
+    expect(
+      screen.getAllByRole('button', { name: /^开始共创《/ }).length,
+    ).toBeGreaterThan(0);
+
+    // 页面自己**不建**滚动容器：滚动落在外壳 `.launcher-main`（见 styles.css 契约测试）。
+    expect(container.querySelector('.fork-page')).not.toBeNull();
+    expect(container.querySelector('.fork-page .overflow-y-auto')).toBeNull();
+    expect(container.querySelector('.fork-page .overflow-scroll')).toBeNull();
+    // 顶部留白在内容层（页根），页头不贴顶；窄窗口仍保留留白。
+    const pageRoot = container.querySelector('.fork-page') as HTMLElement;
+    expect(pageRoot.classList.contains('pt-20')).toBe(true);
+    expect(pageRoot.getAttribute('class')).toContain('max-[760px]:pt-16');
+    // 用户可见文案不再出现「像 git fork」这类类比（口径只留在代码注释与文档里）。
+    expect(document.body.textContent ?? '').not.toMatch(/git\s*fork/iu);
+  });
+
+  it('卡片时间：公开目录只有 createdAt，就按「创建时间」渲染真实值', async () => {
+    installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [catalogGame('game_open', '开放共创的作品', 'full')],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+    await screen.findByText('开放共创的作品');
+
+    // 标签是「创建时间」而不是「更新时间」：目录 payload 没有 updatedAt，不拿 createdAt 冒充。
+    expect(screen.getByText('创建时间')).not.toBeNull();
+    expect(screen.queryByText('更新时间')).toBeNull();
+    expect(
+      screen.getByText(formatCatalogCreatedAt('2026-10-01T08:00:00Z')!),
+    ).not.toBeNull();
+  });
+
+  it('卡片时间：字段缺失或不可解析时整行不渲染，不留恒为「—」的死行', async () => {
+    installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [
+            {
+              ...catalogGame('game_open', '开放共创的作品', 'full'),
+              createdAt: '',
+            },
+            {
+              ...catalogGame('game_bad', '时间不可解析的作品', 'full'),
+              createdAt: '不是时间',
+            },
+          ],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+    await screen.findByText('开放共创的作品');
+
+    expect(screen.queryByText('创建时间')).toBeNull();
+    expect(screen.queryByText('更新时间')).toBeNull();
+    // 「作者 / 类型」两行照旧（确认不是整张卡没渲染）。
+    expect(screen.getAllByText('作者')).toHaveLength(2);
+    expect(screen.getAllByText('类型')).toHaveLength(2);
+  });
+
+  it('卡片显示作品自身的游玩次数，且不带会被读成合计的措辞', async () => {
+    installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [
+            catalogGame('game_played', '有游玩记录的作品', 'full', 7),
+            catalogGame('game_fresh', '没人玩过的作品', 'full', 0),
+          ],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+    await screen.findByText('有游玩记录的作品');
+
+    // 自身值：7 次 / 0 次都照实显示（0 是真实值，不是缺字段）。
+    expect(screen.getAllByText('游玩')).toHaveLength(2);
+    expect(screen.getByText('7 次')).not.toBeNull();
+    expect(screen.getByText('0 次')).not.toBeNull();
+    // 文案只讲自身，**不出现**任何合计/衍生口径（客户端没有树，聚合在网页端）。
+    const pageText = document.body.textContent ?? '';
+    expect(pageText).not.toMatch(/含衍生|子树|合计|衍生作品/u);
+    // 「含衍生」那条口径的反面证据：文案里就是「N 次」，前面不带别的词。
+    expect(
+      [...document.querySelectorAll('.fork-page article small span')].some(
+        (node) => node.textContent?.trim() === '游玩',
+      ),
+    ).toBe(true);
+  });
+
+  it('游玩次数字段缺失时整行不渲染（不留恒为「—」的死行）', async () => {
+    installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [catalogGame('game_no_plays', '旧响应没有该字段', 'full')],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+    await screen.findByText('旧响应没有该字段');
+
+    expect(screen.queryByText('游玩')).toBeNull();
+    // 其余信息行照旧（确认不是整张卡没渲染）。
+    expect(screen.getByText('作者')).not.toBeNull();
+    expect(screen.getByText('类型')).not.toBeNull();
+  });
+
+  it('游玩次数格式化：千分位、负数收敛到 0、非法值返回 null', () => {
+    expect(formatCatalogPlayCount(7)).toBe('7 次');
+    expect(formatCatalogPlayCount(12345)).toBe('12,345 次');
+    expect(formatCatalogPlayCount(0)).toBe('0 次');
+    expect(formatCatalogPlayCount(-3)).toBe('0 次');
+    expect(formatCatalogPlayCount(3.8)).toBe('3 次');
+    expect(formatCatalogPlayCount(undefined)).toBeNull();
+    expect(formatCatalogPlayCount(null)).toBeNull();
+    expect(formatCatalogPlayCount(Number.NaN)).toBeNull();
+    expect(formatCatalogPlayCount('7')).toBeNull();
+  });
+
+  it('时间格式化把微秒时间戳按本地日期折算', () => {
+    expect(formatCatalogCreatedAt('2026-10-01T08:00:00Z')).toMatch(
+      /^\d{4}-\d{2}-\d{2}$/,
+    );
+    // 微秒与毫秒两种写法必须落同一天：折算除数写错就会跑到几万年以外。
+    expect(formatCatalogCreatedAt(1_759_308_800_000_000)).toBe(
+      formatCatalogCreatedAt(1_759_308_800_000),
+    );
+    expect(formatCatalogCreatedAt('')).toBeNull();
+    expect(formatCatalogCreatedAt(undefined)).toBeNull();
+    expect(formatCatalogCreatedAt('不是时间')).toBeNull();
+  });
+
+  it('目录为空时给出明确空态，而不是空白', async () => {
+    installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [catalogGame('game_locked', '禁止共创', 'forbidden')],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+
+    expect(await screen.findByText(/作品里还没有开放共创的/)).not.toBeNull();
+  });
+
+  it('目录读取失败时给出失败态与重试', async () => {
+    let attempts = 0;
+    installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        attempts += 1;
+        if (attempts === 1) {
+          throw new Error('读取共创目录失败：请求超时，请稍后重试');
+        }
+        return {
+          games: [catalogGame('game_open', '开放共创的作品', 'full')],
+          nextCursor: null,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+
+    expect(
+      await screen.findByText('读取共创目录失败：请求超时，请稍后重试'),
+    ).not.toBeNull();
+    fireEvent.click(screen.getByRole('button', { name: '重试' }));
+    expect(await screen.findByText('开放共创的作品')).not.toBeNull();
+  });
+
+  it('有封面时用有界 data URL 渲染，换签失败或没有封面则保留首字占位', async () => {
+    const calls = installInvoke((command, args) => {
+      if (command === CATALOG_COMMAND) {
+        return {
+          games: [
+            {
+              ...catalogGame('game_with_cover', '有封面的作品', 'full'),
+              coverObjectKey: 'game-distribution/cover/open.png',
+            },
+            {
+              ...catalogGame('game_broken_cover', '换签失败的作品', 'full'),
+              coverObjectKey: 'game-distribution/cover/broken.png',
+            },
+            catalogGame('game_no_cover', '没有封面的作品', 'full'),
+          ],
+          nextCursor: null,
+        };
+      }
+      if (command === 'read_public_game_cover_preview') {
+        if ((args as { objectKey?: string })?.objectKey?.includes('broken')) {
+          throw new Error('换签失败');
+        }
+        return 'data:image/png;base64,AAAA';
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    const { container } = render(<CoCreationView onOpenConfirm={vi.fn()} />);
+
+    // 有封面的那张走 <img>，src 是命令返回的 data URL。
+    const image = await screen.findByRole('img', {
+      name: '有封面的作品 封面',
+    });
+    expect(image.getAttribute('src')).toBe('data:image/png;base64,AAAA');
+    // 失败与缺封面都保留首字占位：不出现破图（即没有第二张 <img>）。
+    expect(container.querySelectorAll('img')).toHaveLength(1);
+    expect(
+      screen.queryByRole('img', { name: '换签失败的作品 封面' }),
+    ).toBeNull();
+    expect(
+      screen.queryByRole('img', { name: '没有封面的作品 封面' }),
+    ).toBeNull();
+    // 没有对象键的那张根本不该发换签请求。
+    expect(
+      calls.filter(
+        (call) =>
+          call.command === 'read_public_game_cover_preview' &&
+          (call.args as { objectKey?: string })?.objectKey === undefined,
+      ),
+    ).toHaveLength(0);
+    expect(
+      calls.filter((call) => call.command === 'read_public_game_cover_preview'),
+    ).toHaveLength(2);
+  });
+
+  it('深链携带错误原因时如实展示，不预填也不请求', async () => {
+    const calls = installInvoke((command) => {
+      if (command === CATALOG_COMMAND) {
+        return { games: [], nextCursor: null };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+    await screen.findByText(/还没有开放共创的/);
+
+    useForkDeepLinkStore.getState().request({
+      gameId: null,
+      message: '链接里没有 gameId，无法确定要共创的作品',
+    });
+
+    expect((await screen.findByRole('alert')).textContent).toBe(
+      '链接里没有 gameId，无法确定要共创的作品',
+    );
+    expect(forkCalls(calls)).toHaveLength(0);
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/forkConfirm.test.tsx b/apps/ai-game-creator-shell/tests/forkConfirm.test.tsx
new file mode 100644
index 000000000..03c8a92b3
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/forkConfirm.test.tsx
@@ -0,0 +1,395 @@
+// @vitest-environment jsdom
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { InitLocalProjectResult } from '../src/app/types';
+import { useForkConfirmStore } from '../src/features/platform-fork/forkConfirmTarget';
+import { MANDATORY_READING_SECONDS } from '../src/features/platform-fork/forkNotice';
+import { FORK_PROGRESS_STAGES } from '../src/features/platform-fork/forkProgress';
+import ForkConfirmView from '../src/view/fork-confirm';
+import { createTauriEventFake, type TauriEventFake } from './tauriEventFake';
+
+const FORK_COMMAND = 'create_local_project_from_platform_game';
+
+const PROJECT_RESULT = {
+  projectPath: 'C:\\projects\\gameagent-fork-1',
+  manifestPath: 'C:\\projects\\gameagent-fork-1\\.agent\\manifest.json',
+  manifest: { name: '共创项目 1' },
+} as unknown as InitLocalProjectResult;
+
+const PARENT_GAME = {
+  id: 'game_parent_1',
+  title: '母版作品',
+  author: { id: 'user_1', name: '原作者甲' },
+  forkAuthorization: 'nonCommercial',
+  coverObjectKey: 'game-distribution/cover/parent.png',
+  coverColor: '#c2653d',
+};
+
+type InvokeCall = { command: string; args?: Record<string, unknown> };
+
+let eventFake: TauriEventFake | null = null;
+
+function installInvoke(
+  implementation: (command: string, args?: Record<string, unknown>) => unknown,
+) {
+  const calls: InvokeCall[] = [];
+  const invoke = vi.fn(
+    async (command: string, args?: Record<string, unknown>) => {
+      calls.push({ command, args });
+      return implementation(command, args);
+    },
+  );
+  (window as unknown as { __TAURI__?: unknown }).__TAURI__ = {
+    core: { invoke },
+  };
+  return calls;
+}
+
+function renderPage() {
+  const onProjectCreated = vi.fn();
+  const onCancel = vi.fn();
+  const rendered = render(
+    <ForkConfirmView onCancel={onCancel} onProjectCreated={onProjectCreated} />,
+  );
+  return { ...rendered, onProjectCreated, onCancel };
+}
+
+function confirmButton() {
+  return screen.getByRole('button', { name: /确认并进入编辑/ });
+}
+
+/** 跨过强制阅读窗口（真实计时器即可，3 秒内用假计时器更快）。 */
+function finishMandatoryReading() {
+  act(() => {
+    vi.advanceTimersByTime(MANDATORY_READING_SECONDS * 1000 + 300);
+  });
+}
+
+beforeEach(() => {
+  // 假计时器 + 允许真实时间推进：既能精确跨过 3 秒强制阅读窗口，又不会让
+  // `findBy*`/`waitFor` 这类依赖计时器的查询挂死。
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+  useForkConfirmStore.getState().open({
+    gameId: PARENT_GAME.id,
+    game: PARENT_GAME as never,
+    origin: 'co-creation',
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  vi.useRealTimers();
+  eventFake?.restore();
+  eventFake = null;
+  useForkConfirmStore.getState().close();
+  delete (window as unknown as { __TAURI__?: unknown }).__TAURI__;
+});
+
+describe('开始共创确认页', () => {
+  it('父作品信息卡展示标题 / 作者 / 授权类型 / 封面，缺失时降级不报错', async () => {
+    installInvoke((command) => {
+      if (command === 'read_public_game_cover_preview') {
+        return 'data:image/png;base64,AAAA';
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    renderPage();
+
+    const card = await screen.findByLabelText('父作品信息');
+    expect(card.textContent).toContain('母版作品');
+    expect(card.textContent).toContain('原作者甲');
+    expect(card.textContent).toContain('允许非商用共创');
+    expect(card.textContent).toContain('game_parent_1');
+    // 封面走有界 data URL 链路。
+    const cover = await screen.findByRole('img', { name: '母版作品 封面' });
+    expect(cover.getAttribute('src')).toBe('data:image/png;base64,AAAA');
+  });
+
+  it('信息卡缺字段时逐项降级：没有标题/作者/封面也不报错', async () => {
+    useForkConfirmStore.getState().close();
+    useForkConfirmStore.getState().open({
+      gameId: 'game_bare_1',
+      game: null,
+      origin: 'deep-link',
+    });
+    installInvoke((command) => {
+      if (command === 'read_public_game_detail') {
+        return { id: 'game_bare_1' };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    const { onProjectCreated } = renderPage();
+
+    const card = await screen.findByLabelText('父作品信息');
+    await waitFor(() => expect(card.textContent).toContain('（未获取到标题）'));
+    expect(card.textContent).toContain('game_bare_1');
+    // 缺授权类型读作「禁止共创」（契约缺省），缺封面不渲染 <img>。
+    expect(card.textContent).toContain('禁止共创');
+    expect(screen.queryByRole('img')).toBeNull();
+    // 仍然可以走完确认流程（缺信息不阻塞）。
+    finishMandatoryReading();
+    expect(confirmButton()).toHaveProperty('disabled', false);
+    expect(onProjectCreated).not.toHaveBeenCalled();
+  });
+
+  it('强制阅读：3 秒内按钮禁用且倒计时可见，3 秒后可点', async () => {
+    installInvoke(() => null);
+    renderPage();
+
+    expect(confirmButton()).toHaveProperty('disabled', true);
+    expect(confirmButton().textContent).toContain('3s');
+    const progress = screen.getByRole('progressbar', { name: '强制阅读进度' });
+    expect(progress.getAttribute('aria-valuenow')).toBe('0');
+
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    expect(confirmButton()).toHaveProperty('disabled', true);
+    expect(confirmButton().textContent).toContain('2s');
+    expect(progress.getAttribute('aria-valuenow')).toBe('1');
+
+    finishMandatoryReading();
+    expect(confirmButton()).toHaveProperty('disabled', false);
+    expect(confirmButton().textContent).not.toContain('s）');
+  });
+
+  it('五类须知全文真实渲染，不是一句话折叠', async () => {
+    installInvoke(() => null);
+    renderPage();
+
+    const notices = screen.getByLabelText('授权须知全文');
+    for (const title of [
+      '可修改范围',
+      '商用权限说明',
+      '署名要求',
+      '溯源规则',
+      '违规后果说明',
+    ]) {
+      expect(notices.textContent).toContain(title);
+    }
+    // 关键口径逐句落页：Fork 定义、非商用不得盈利、署名不可删、永久记录、违规后果。
+    expect(notices.textContent).toContain(
+      '整个工程复制一份到你的项目里继续改造',
+    );
+    expect(notices.textContent).toContain('不得用于盈利');
+    expect(notices.textContent).toContain('不能删除、隐藏或改成别人的名字');
+    expect(notices.textContent).toContain('永久记录原作品 ID');
+    expect(notices.textContent).toContain('会被平台下架并要求整改');
+  });
+
+  it('须知块不再自建内层滚动，页面只靠外壳滚动容器', async () => {
+    installInvoke(() => null);
+    const { container } = renderPage();
+
+    const root = container.querySelector('.fork-page');
+    expect(root).not.toBeNull();
+    // 顶部留白在内容层（页根），页头不贴顶；与列表页同值。
+    expect(root?.classList.contains('pt-20')).toBe(true);
+    // 用户可见文案不再出现「像 git fork / 与 git fork 同理」这类类比。
+    expect(document.body.textContent ?? '').not.toMatch(/git\s*fork/iu);
+    // 页面内不得出现任何纵向滚动容器：须知全文随页面自然流动。
+    expect(container.querySelector('.fork-page .overflow-y-auto')).toBeNull();
+    expect(container.querySelector('.fork-page .overflow-auto')).toBeNull();
+    expect(container.querySelector('.fork-page .overflow-scroll')).toBeNull();
+    const notices = screen.getByLabelText('授权须知全文');
+    for (const className of Array.from(notices.classList)) {
+      expect(className.startsWith('max-h-')).toBe(false);
+      expect(className.startsWith('overflow-y-')).toBe(false);
+    }
+    // 须知仍然是**全文**：五条正文都在这一个容器里逐条渲染。
+    expect(notices.querySelectorAll('article')).toHaveLength(5);
+  });
+
+  it('底部操作条是吸附页脚：停在滚动容器下沿，不随内容滚走', async () => {
+    installInvoke(() => null);
+    const { container } = renderPage();
+
+    const footer = container.querySelector(
+      '[aria-label="开始共创操作"]',
+    ) as HTMLElement;
+    expect(footer).not.toBeNull();
+    // `sticky bottom-0` 挂在页面根下（滚动容器是外壳的 `.launcher-main`）。
+    expect(footer.classList.contains('sticky')).toBe(true);
+    expect(footer.classList.contains('bottom-0')).toBe(true);
+    const pageRoot = container.querySelector('.fork-page') as HTMLElement;
+    expect(footer.parentElement).toBe(pageRoot);
+    expect(pageRoot.lastElementChild).toBe(footer);
+    expect(footer.className).toContain('border-t');
+    // 两个动作都在页脚里，长页面下也够得到。
+    expect(footer.textContent).toContain('取消');
+    expect(footer.textContent).toContain('确认并进入编辑');
+  });
+
+  it('状态是徽章形态，与按钮可区分（倒计时同时出现在徽章与按钮上）', async () => {
+    installInvoke(() => null);
+    renderPage();
+
+    const badge = screen.getByText(/^3s 后可确认$/);
+    // 徽章：圆角胶囊 + 描边，不是按钮。
+    expect(badge.tagName).toBe('SMALL');
+    expect(badge.className).toContain('rounded-full');
+    expect(badge.className).toContain('border');
+    expect(badge.closest('button')).toBeNull();
+    expect(screen.getByText('确认后开始').className).toContain('rounded-full');
+
+    finishMandatoryReading();
+    expect(await screen.findByText('已可确认')).not.toBeNull();
+  });
+
+  it('用户可见文案统一叫「开始共创」，不出现 Fork 动作名', async () => {
+    installInvoke(() => null);
+    renderPage();
+
+    // 标题就是统一后的动作名。
+    expect(screen.getByRole('heading', { level: 1 }).textContent).toBe(
+      '开始共创',
+    );
+    // 只检查**声明出来的用户可见节点**（不放全页 `not.toContain('Fork')`，
+    // 那样会误伤内部标识与 aria 说明里的机制描述）。
+    const visibleCopy = [
+      screen.getByRole('heading', { level: 1 }).textContent ?? '',
+      screen.getByLabelText('父作品信息').textContent ?? '',
+      screen.getByLabelText('授权须知全文').textContent ?? '',
+      screen.getByLabelText('工程同步状态').textContent ?? '',
+      screen.getByLabelText('开始共创操作').textContent ?? '',
+    ].join('\n');
+    expect(visibleCopy).not.toMatch(/Fork/u);
+    expect(visibleCopy).toContain('开始共创');
+  });
+
+  it('全开放授权时商用权限改写成可商用', async () => {
+    useForkConfirmStore.getState().close();
+    useForkConfirmStore.getState().open({
+      gameId: 'game_open_1',
+      game: {
+        ...PARENT_GAME,
+        id: 'game_open_1',
+        forkAuthorization: 'full',
+      } as never,
+      origin: 'co-creation',
+    });
+    installInvoke(() => null);
+    renderPage();
+
+    const notices = await screen.findByLabelText('授权须知全文');
+    expect(notices.textContent).toContain('允许全开放共创');
+    expect(notices.textContent).toContain('可以改编、商用、引流');
+  });
+
+  it('工程同步状态条按真实阶段渲染，事件到哪一步就点亮哪一步', async () => {
+    eventFake = createTauriEventFake();
+    eventFake.install();
+    // 让建项命令悬住：进度订阅在 forkGame 期间才在，命令立刻返回会先释放订阅。
+    // （`Promise.withResolvers` 需要 lib ES2024，本仓 AGC 走 ES2022，因此手写 deferred。）
+    let resolveFork: (value: unknown) => void = () => undefined;
+    installInvoke((command) => {
+      if (command === FORK_COMMAND) {
+        return new Promise((resolve) => {
+          resolveFork = resolve as (value: unknown) => void;
+        });
+      }
+      return null;
+    });
+    const { onProjectCreated } = renderPage();
+
+    // 未开始：四个真实阶段都在场，且没有任何一个被点亮。
+    for (const stage of FORK_PROGRESS_STAGES) {
+      expect(screen.getByText(stage.label)).not.toBeNull();
+    }
+    expect(screen.getByText('确认后开始')).not.toBeNull();
+
+    finishMandatoryReading();
+    fireEvent.click(confirmButton());
+    await waitFor(() =>
+      expect(
+        screen.getByRole('button', { name: '正在开始共创…' }),
+      ).toHaveProperty('disabled', true),
+    );
+
+    // 原生真实事件：只按到达顺序点亮，不预估、不填百分比。
+    eventFake.flushRegistrationEvals();
+    eventFake.emit('game-fork-progress', {
+      stage: 'download',
+      label: '取回作品内容',
+    });
+    expect(await screen.findByText(/正在：取回作品内容/)).not.toBeNull();
+
+    eventFake.emit('game-fork-progress', {
+      stage: 'verify',
+      label: '校验摘要与字节',
+    });
+    expect(await screen.findByText(/正在：校验摘要与字节/)).not.toBeNull();
+    // 未知阶段整条丢弃，不会污染状态条。
+    eventFake.emit('game-fork-progress', { stage: 'whatever' });
+    expect(screen.getByText(/正在：校验摘要与字节/)).not.toBeNull();
+
+    resolveFork(PROJECT_RESULT);
+    await waitFor(() => expect(onProjectCreated).toHaveBeenCalledTimes(1));
+  });
+
+  it('确认后调用原生 Fork 命令，成功后交给上层进入工作台', async () => {
+    const calls = installInvoke((command) =>
+      command === FORK_COMMAND ? PROJECT_RESULT : null,
+    );
+    const { onProjectCreated } = renderPage();
+
+    finishMandatoryReading();
+    fireEvent.click(confirmButton());
+
+    await waitFor(() =>
+      expect(
+        calls.filter((call) => call.command === FORK_COMMAND),
+      ).toHaveLength(1),
+    );
+    expect(
+      calls.find((call) => call.command === FORK_COMMAND)?.args,
+    ).toMatchObject({ gameId: 'game_parent_1', name: null, planning: false });
+    await waitFor(() => expect(onProjectCreated).toHaveBeenCalledTimes(1));
+  });
+
+  it('取件失败时如实展示可读原因，且不进入工作台', async () => {
+    installInvoke((command) => {
+      if (command === FORK_COMMAND) {
+        throw new Error(
+          'permission-denied: 作者没有开放这个作品的共创授权，无法开始共创',
+        );
+      }
+      return null;
+    });
+    const { onProjectCreated } = renderPage();
+
+    finishMandatoryReading();
+    fireEvent.click(confirmButton());
+
+    expect((await screen.findByRole('alert')).textContent).toBe(
+      '作者没有开放这个作品的共创授权，无法开始共创',
+    );
+    expect(onProjectCreated).not.toHaveBeenCalled();
+  });
+
+  it('取消回到进入前的界面，且同步进行中不允许取消', async () => {
+    installInvoke(() => null);
+    const { onCancel } = renderPage();
+
+    fireEvent.click(screen.getByRole('button', { name: '取消' }));
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(useForkConfirmStore.getState().target).toBeNull();
+  });
+
+  it('没有待确认目标时给出可读提示而不是空白', async () => {
+    useForkConfirmStore.getState().close();
+    const { onCancel } = renderPage();
+
+    expect(await screen.findByText(/没有待确认的共创作品/)).not.toBeNull();
+    fireEvent.click(screen.getByRole('button', { name: '返回' }));
+    expect(onCancel).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
index 87164c5c5..b136afa4f 100644
--- a/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
+++ b/apps/ai-game-creator-shell/tests/gameDistributionPublish.test.ts
@@ -79,6 +79,8 @@ describe('Rust 发布 facade', () => {
     expect(calls[0]?.command).toBe('publish_local_project_game');
     expect(calls[0]?.args).toMatchObject({
       projectPath: '/tmp/project',
+      // 身份字段在顶层：`gameMetadata` 不再重复携带 `projectKey`。
+      projectKey: 'local-proj-1',
       idempotencyKey: 'agc-publish-test',
       // 未传价格时按免费提交，保持旧调用方向后兼容。
       priceMudPoints: 0,
@@ -86,7 +88,6 @@ describe('Rust 发布 facade', () => {
       coverPath: '',
       screenshotPaths: [],
       metadata: {
-        projectKey: 'local-proj-1',
         coverObjectKey: 'generated/cover.png',
         screenshots: ['generated/shot-1.png', 'generated/shot-2.png'],
       },
@@ -138,7 +139,102 @@ describe('Rust 发布 facade', () => {
     expect(calls[0]?.args).not.toHaveProperty('idempotencyKey');
     expect(calls[0]?.args).toMatchObject({
       projectPath: '/tmp/project',
-      metadata: { projectKey: 'local-proj-1' },
+      // 身份锚在顶层：同一作者重复发布会确定性派生出同一 gameId。
+      projectKey: 'local-proj-1',
+    });
+  });
+
+  test('取消公开工程源码时显式传 includeProjectBundle=false', async () => {
+    const { invoke, calls } = installNativeInvoke(() => PUBLISH_RESULT);
+
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      manifest: MANIFEST,
+      metadata: { coverObjectKey: null },
+      // 首次发布（没有 gameId）：平台派发的下一个版本号就是 1；更新发布才是 max+1，
+      // 由平台回读的 `nextVersionNumber` 提供。这个文件的两个用例都是首次发布。
+      versionNumber: 1,
+      includeProjectBundle: false,
+    });
+    expect(calls[0]?.args).toMatchObject({
+      includeProjectBundle: false,
+      versionNumber: 1,
+    });
+
+    // 勾选（或未表态）时不带这个字段：默认由原生按「授权非禁止即上传」判断，
+    // 渲染层不重复实现同一套默认值。
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      manifest: MANIFEST,
+      metadata: { coverObjectKey: null },
+      versionNumber: 1,
+      includeProjectBundle: true,
+    });
+    expect(calls[1]?.args).not.toHaveProperty('includeProjectBundle');
+  });
+
+  test('衍生作品的核心改动说明 trim 后透传，母版留空不带字段', async () => {
+    const { invoke, calls } = installNativeInvoke(() => PUBLISH_RESULT);
+
+    // 衍生作品的必填与 20–500 字符判据都在服务端；渲染层只做 trim 透传。
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      manifest: MANIFEST,
+      metadata: { coverObjectKey: null },
+      versionNumber: 2,
+      changeSummary:
+        '  把跳台改成三段，并重画全部背景与手感，还新增了两个关卡  ',
+    });
+    expect(calls[0]?.args).toMatchObject({
+      changeSummary: '把跳台改成三段，并重画全部背景与手感，还新增了两个关卡',
+    });
+
+    // 空串/纯空白视为没写：不带字段（母版本来也不该带），由服务端对衍生作品回必填码。
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      manifest: MANIFEST,
+      metadata: { coverObjectKey: null },
+      versionNumber: 2,
+      changeSummary: '   ',
+    });
+    expect(calls[1]?.args).not.toHaveProperty('changeSummary');
+  });
+
+  test('共创授权档位随创建作品请求提交，改编声明不来自渲染层', async () => {
+    const { invoke, calls } = installNativeInvoke(() => PUBLISH_RESULT);
+
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      manifest: MANIFEST,
+      metadata: {
+        coverObjectKey: null,
+        forkAuthorization: 'nonCommercial',
+      },
+      // 同为首次发布：平台派发的下一个版本号是 1（见上一个用例的说明）。
+      versionNumber: 1,
+    });
+    expect(calls[0]?.args).toMatchObject({
+      metadata: { forkAuthorization: 'nonCommercial' },
+    });
+    // 改编声明只能来自项目内真实取过件的 `.agent/fork-source.json`：原生发布链路在首次
+    // 发布时读取并入请求体，渲染层既没有入口也伪造不了。
+    expect(calls[0]?.args?.metadata).not.toHaveProperty('fork');
+
+    // 未选择时按契约默认值「禁止共创」提交（与省略该字段在服务端等价）。
+    await publishLocalProjectGame({
+      invoke,
+      projectPath: '/tmp/project',
+      manifest: MANIFEST,
+      metadata: { coverObjectKey: null },
+      versionNumber: 1,
+    });
+    expect(calls[1]?.args).toMatchObject({
+      metadata: { forkAuthorization: 'forbidden' },
     });
   });
 
diff --git a/apps/ai-game-creator-shell/tests/launcherScrollContract.test.ts b/apps/ai-game-creator-shell/tests/launcherScrollContract.test.ts
new file mode 100644
index 000000000..c6beac413
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/launcherScrollContract.test.ts
@@ -0,0 +1,153 @@
+/**
+ * 外壳滚动链的**契约测试**（纯 CSS 断言，不需要浏览器）。
+ *
+ * 背景：`.launcher-main` 曾经是 `display: grid` + `grid-template-rows: auto …` + `overflow: hidden`，
+ * 视图一旦比窗口高就被整块裁掉——「共创」列表最后一行、开始共创确认页底部操作条都够不到。
+ * 修法是把 `.launcher-main` 变成**唯一的页面滚动容器**（flex 列 + `overflow-y: auto`），
+ * 视图保持自然高度（`flex: 0 0 auto`）。
+ *
+ * jsdom 没有布局，量不出 `scrollHeight > clientHeight`；这里钉住的是**样式契约**（哪一层负责
+ * 滚动、链路上的每一层都允许收缩），真实滚动行为由浏览器冒烟核对。
+ */
+import { readFileSync } from 'node:fs';
+
+import { describe, expect, it } from 'vitest';
+
+import { repoPath } from './repoPath';
+
+const stylesPath = repoPath('apps/ai-game-creator-shell/src/styles.css');
+const styles = readFileSync(stylesPath, 'utf8');
+
+/** 取某个选择器的第一条声明块（与 `workbenchThemeContrast.test.ts` 同一套解析口径）。 */
+function getCssBlock(source: string, selector: string) {
+  const selectorIndex = source.indexOf(selector);
+  expect(selectorIndex, `${selector} should exist`).toBeGreaterThanOrEqual(0);
+  const openBraceIndex = source.indexOf('{', selectorIndex);
+  let depth = 0;
+  for (let index = openBraceIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === '{') {
+      depth += 1;
+    } else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) {
+        return source.slice(openBraceIndex + 1, index);
+      }
+    }
+  }
+  throw new Error(`${selector} block is not closed`);
+}
+
+/** 去掉注释再断言：注释里会引用旧写法（例如「以前是 grid-template-rows…」）。 */
+function stripComments(block: string) {
+  return block.replace(/\/\*[\s\S]*?\*\//gu, '');
+}
+
+function declaration(block: string, property: string) {
+  const match = block.match(new RegExp(`(^|[;{\\s])${property}:\\s*([^;]+);`));
+  expect(match, `${property} should be declared`).not.toBeNull();
+  return (match?.[2] ?? '').replace(/\s+/gu, ' ').trim();
+}
+
+describe('launcher 滚动链', () => {
+  it('根与外壳层都给足高度，允许收缩', () => {
+    const root = getCssBlock(styles, '#root {');
+    expect(declaration(root, 'height')).toBe('100dvh');
+    expect(declaration(root, 'min-height')).toBe('0');
+
+    const chromeContent = getCssBlock(styles, '.window-chrome__content {');
+    expect(declaration(chromeContent, 'height')).toBe('100%');
+    expect(declaration(chromeContent, 'min-height')).toBe('0');
+    // 外壳内容区自己不能滚：滚动只发生在 `.launcher-main`。
+    expect(declaration(chromeContent, 'overflow')).toBe('hidden');
+
+    const launcherShell = getCssBlock(
+      styles,
+      '.window-chrome__content > .launcher-shell',
+    );
+    expect(declaration(launcherShell, 'height')).toBe('100%');
+    expect(declaration(launcherShell, 'min-height')).toBe('0');
+  });
+
+  it('`.launcher-main` 是唯一页面滚动容器（flex 列 + 纵向 auto）', () => {
+    const main = getCssBlock(styles, '\n.launcher-main {');
+    expect(declaration(main, 'display')).toBe('flex');
+    expect(declaration(main, 'flex-direction')).toBe('column');
+    // 纵向滚动 + 横向裁切：窄窗口不会被内容顶出横向滚动条。
+    expect(declaration(main, 'overflow-y')).toBe('auto');
+    expect(declaration(main, 'overflow-x')).toBe('hidden');
+    // 不允许再出现把内容整块裁掉的 `overflow: hidden`（横向那条是显式 overflow-x）。
+    expect(main).not.toMatch(/(^|[;\s])overflow:\s*hidden;/u);
+
+    const mainOverride = getCssBlock(
+      styles,
+      '.window-chrome__content > .launcher-shell .launcher-main {',
+    );
+    expect(declaration(mainOverride, 'height')).toBe('100%');
+    expect(declaration(mainOverride, 'min-height')).toBe('0');
+
+    // 视图保持自然高度：`flex-shrink: 1` 会把长页面压扁到容器高度。
+    const viewItem = getCssBlock(styles, '.launcher-main > * {');
+    expect(declaration(viewItem, 'flex')).toBe('0 0 auto');
+  });
+
+  it('旧的 grid 行高与裁切不再决定滚动', () => {
+    const main = stripComments(getCssBlock(styles, '\n.launcher-main {'));
+    expect(main).not.toMatch(/grid-template-rows/u);
+    expect(main).not.toMatch(/grid-template-columns/u);
+    expect(main).not.toMatch(/align-content/u);
+
+    // 工作台仍可特判自己占满高度，但不得再改滚动方式（滚动只有一处）。
+    const workbenchRule = getCssBlock(
+      styles,
+      '.launcher-main:has(.game-project-workbench) {',
+    );
+    expect(workbenchRule).not.toMatch(/overflow|display|height/u);
+  });
+
+  it('共创相关页面共享一套版式令牌，且正文不吃满整屏', () => {
+    const tokens = readFileSync(
+      repoPath(
+        'apps/ai-game-creator-shell/src/features/platform-fork/forkPageStyles.ts',
+      ),
+      'utf8',
+    );
+    const column = tokens.match(
+      /export const FORK_PAGE_COLUMN =\s*'[^']*min\((\d+)px/u,
+    );
+    expect(
+      column,
+      'FORK_PAGE_COLUMN should cap the column width',
+    ).not.toBeNull();
+    const width = Number(column?.[1]);
+    expect(width).toBeGreaterThanOrEqual(720);
+    expect(width).toBeLessThanOrEqual(880);
+    // 正文另有 72ch 上限：长文不铺满整个内容列。
+    expect(tokens).toContain('max-w-[72ch]');
+  });
+
+  it('页头顶部留白加在内容层（≥80px），不加在滚动容器上', () => {
+    const tokens = readFileSync(
+      repoPath(
+        'apps/ai-game-creator-shell/src/features/platform-fork/forkPageStyles.ts',
+      ),
+      'utf8',
+    );
+    const root = tokens.match(
+      /export const FORK_PAGE_ROOT =[\s\S]*?'([^']+)'/u,
+    );
+    expect(root, 'FORK_PAGE_ROOT should be declared').not.toBeNull();
+    const rootClass = root?.[1] ?? '';
+    // 80px = Tailwind 的 pt-20，与首页首屏的顶部留白同值。
+    expect(rootClass).toContain('pt-20');
+    const home = readFileSync(
+      repoPath('apps/ai-game-creator-shell/src/view/home/index.tsx'),
+      'utf8',
+    );
+    expect(home, '首页用同一个 pt-20 作为基准').toContain('pt-20');
+
+    // 滚动容器自己不加上内边距：留白属于内容层，滚动时页头跟着内容走。
+    const main = stripComments(getCssBlock(styles, '\n.launcher-main {'));
+    expect(main).not.toMatch(/padding-top/u);
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/platformForkDeepLink.test.tsx b/apps/ai-game-creator-shell/tests/platformForkDeepLink.test.tsx
new file mode 100644
index 000000000..f1c6bd257
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/platformForkDeepLink.test.tsx
@@ -0,0 +1,97 @@
+// @vitest-environment jsdom
+import { cleanup, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  FORK_DEEP_LINK_EVENT,
+  forkDeepLinkRequestFromEvent,
+  subscribeForkDeepLink,
+  useForkDeepLinkStore,
+} from '../src/features/platform-fork/forkDeepLink';
+import { createTauriEventFake, type TauriEventFake } from './tauriEventFake';
+
+/**
+ * 深链在渲染层的落点：原生事件 → 待处理请求 store。
+ *
+ * 「预填输入框、不自动下载」这条行为在共创页上（`coCreation.test.tsx`），这里只钉住事件解析与订阅，
+ * 免得同一件事在两个文件里各断言一遍。
+ */
+let eventFake: TauriEventFake | null = null;
+
+afterEach(() => {
+  cleanup();
+  eventFake?.restore();
+  eventFake = null;
+  useForkDeepLinkStore.getState().consume();
+});
+
+describe('Fork 深链载荷解析', () => {
+  it('接受 gameId 与错误原因两种形状，并丢掉空载荷', () => {
+    expect(
+      forkDeepLinkRequestFromEvent({ gameId: 'game_from_link', message: null }),
+    ).toEqual({ gameId: 'game_from_link', message: null });
+    expect(
+      forkDeepLinkRequestFromEvent({
+        gameId: null,
+        message: '链接里没有 gameId',
+      }),
+    ).toEqual({ gameId: null, message: '链接里没有 gameId' });
+    // 两端空白由渲染层收敛，避免把带空白的 ID 填进输入框。
+    expect(
+      forkDeepLinkRequestFromEvent({ gameId: '  game_x  ', message: '' }),
+    ).toEqual({ gameId: 'game_x', message: null });
+    for (const payload of [
+      null,
+      undefined,
+      'game_x',
+      42,
+      {},
+      { gameId: null, message: null },
+      { gameId: '   ', message: '   ' },
+    ]) {
+      expect(forkDeepLinkRequestFromEvent(payload)).toBeNull();
+    }
+  });
+
+  it('订阅原生事件后把载荷交给调用方（空载荷不产生请求）', async () => {
+    eventFake = createTauriEventFake();
+    eventFake.install();
+    const received: unknown[] = [];
+    const release = await subscribeForkDeepLink((request) => {
+      received.push(request);
+    });
+    eventFake.flushRegistrationEvals();
+
+    eventFake.emit(FORK_DEEP_LINK_EVENT, { gameId: 'game_from_link' });
+    expect(received).toEqual([{ gameId: 'game_from_link', message: null }]);
+
+    // 没有 gameId 也没有 message 的载荷不产生请求（避免用空链接清空用户输入）。
+    eventFake.emit(FORK_DEEP_LINK_EVENT, {});
+    await waitFor(() => expect(received).toHaveLength(1));
+    release();
+  });
+
+  it('待处理请求取走即清空，同一链接只生效一次', () => {
+    const store = useForkDeepLinkStore.getState();
+    store.request({ gameId: 'game_once', message: null });
+    expect(useForkDeepLinkStore.getState().consume()).toEqual({
+      gameId: 'game_once',
+      message: null,
+    });
+    expect(useForkDeepLinkStore.getState().consume()).toBeNull();
+  });
+});
+
+describe('深链订阅的清理', () => {
+  it('注销后事件不再进入回调', async () => {
+    eventFake = createTauriEventFake();
+    eventFake.install();
+    const handler = vi.fn();
+    const release = await subscribeForkDeepLink(handler);
+    eventFake.flushRegistrationEvals();
+    release();
+
+    eventFake.emit(FORK_DEEP_LINK_EVENT, { gameId: 'game_after_release' });
+    expect(handler).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/platformGameForkModel.test.ts b/apps/ai-game-creator-shell/tests/platformGameForkModel.test.ts
new file mode 100644
index 000000000..bdd4ca1d4
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/platformGameForkModel.test.ts
@@ -0,0 +1,47 @@
+// @vitest-environment jsdom
+import { describe, expect, it } from 'vitest';
+
+import { classifyPlatformForkFailure } from '../src/features/platform-fork/platformGameForkModel';
+describe('Fork 取件失败分类', () => {
+  it('按原生前缀分类失败，并去掉机器前缀后展示', () => {
+    expect(
+      classifyPlatformForkFailure(
+        new Error(
+          'authentication-required: 陶泥儿登录态已过期，请重新登录后重试',
+        ),
+      ),
+    ).toEqual({
+      kind: 'auth',
+      message: '陶泥儿登录态已过期，请重新登录后重试',
+    });
+    expect(
+      classifyPlatformForkFailure(
+        'permission-denied: 作者没有开放这个作品的共创授权，无法开始共创',
+      ),
+    ).toEqual({
+      kind: 'forbidden',
+      message: '作者没有开放这个作品的共创授权，无法开始共创',
+    });
+    expect(
+      classifyPlatformForkFailure(
+        'fork-source-not-found: 该作品不存在或已被删除，无法开始共创',
+      ),
+    ).toEqual({
+      kind: 'notFound',
+      message: '该作品不存在或已被删除，无法开始共创',
+    });
+    expect(
+      classifyPlatformForkFailure(
+        'fork-source-not-available: 该作品当前不能开始共创（未公开、已下架或没有公开版本）',
+      ),
+    ).toEqual({
+      kind: 'unavailable',
+      message: '该作品当前不能开始共创（未公开、已下架或没有公开版本）',
+    });
+    // 未命中前缀：原样展示，不吞掉排障信息。
+    expect(classifyPlatformForkFailure(new Error('网络不可用'))).toEqual({
+      kind: 'other',
+      message: '网络不可用',
+    });
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/runUnavailableHint.test.ts b/apps/ai-game-creator-shell/tests/runUnavailableHint.test.ts
new file mode 100644
index 000000000..bd3d8714e
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/runUnavailableHint.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+
+import { runUnavailableHintText } from '../src/view/project-development/runUnavailableHint';
+
+/**
+ * 「运行」页签不可用时的文案（`run-unavailable-hint`）。
+ *
+ * 为什么要有这条用例：同一句「首个可运行原型尚未完成」对**已有工程内容、只是本机还没构建出
+ * 可运行产物**的情况（典型是从平台作品 Fork 来的工程源包项目）是误导——内容明明已经在本地。
+ * 文案因此必须按清单事实分叉，而分叉判据只能是清单里已有的字段。
+ */
+describe('runUnavailableHintText', () => {
+  it('全新项目（清单里还没有工程内部版本）沿用原有措辞', () => {
+    expect(runUnavailableHintText({ versions: [] })).toBe(
+      '首个可运行原型尚未完成，运行视图暂不可用',
+    );
+  });
+
+  it('versions 字段整体缺失时按「没有版本」处理，不抛错', () => {
+    expect(runUnavailableHintText({} as { versions: [] })).toBe(
+      '首个可运行原型尚未完成，运行视图暂不可用',
+    );
+  });
+
+  it('已有工程内容但没有可运行的构建产物时如实说明需要先完成原型', () => {
+    const text = runUnavailableHintText({
+      versions: [
+        {
+          versionId: 'initial-1',
+          parentVersionId: null,
+          projectRevision: 1,
+          resourceBindings: [],
+          createdReason: 'initial',
+          createdAt: 1_791_271_678,
+        },
+      ],
+    });
+
+    expect(text).toBe(
+      '已有工程内容但还没有可运行的构建产物：让智能体完成可运行原型后即可运行',
+    );
+    // 不能再用「首个可运行原型尚未完成」那种"什么都还没有"的说法。
+    expect(text).not.toContain('首个可运行原型尚未完成');
+  });
+});
diff --git a/deploy/container/nginx.conf b/deploy/container/nginx.conf
index cfc24e607..69f1583b2 100644
--- a/deploy/container/nginx.conf
+++ b/deploy/container/nginx.conf
@@ -183,7 +183,7 @@ http {
             try_files /index.html =404;
         }
 
-        location ~* "^/(?:creation|editor/canvas|pay|profile|profile/payment|project|components|design-system|creators|creators/connections|games|games/detail|games/mine|games/play|games/publish)/?$" {
+        location ~* "^/(?:creation|editor/canvas|pay|profile|profile/payment|project|components|design-system|creators|creators/connections|games|games/compare|games/detail|games/lineage|games/mine|games/play|games/publish|games/theme|games/themes)/?$" {
             try_files $uri /index.html =404;
         }
 
diff --git a/deploy/nginx/genarrative-dev-http.conf b/deploy/nginx/genarrative-dev-http.conf
index 89b6ecd03..3d7593beb 100644
--- a/deploy/nginx/genarrative-dev-http.conf
+++ b/deploy/nginx/genarrative-dev-http.conf
@@ -240,7 +240,7 @@ server {
         try_files /index.html =404;
     }
 
-    location ~* "^/(?:creation|editor/canvas|pay|profile|profile/payment|project|components|design-system|creators|creators/connections|games|games/detail|games/mine|games/play|games/publish)/?$" {
+    location ~* "^/(?:creation|editor/canvas|pay|profile|profile/payment|project|components|design-system|creators|creators/connections|games|games/compare|games/detail|games/lineage|games/mine|games/play|games/publish|games/theme|games/themes)/?$" {
         error_page 503 /maintenance.html;
 
         if ($genarrative_maintenance) {
diff --git a/deploy/nginx/genarrative.conf b/deploy/nginx/genarrative.conf
index 987b5f9e1..2063cb350 100644
--- a/deploy/nginx/genarrative.conf
+++ b/deploy/nginx/genarrative.conf
@@ -268,7 +268,7 @@ server {
         try_files /index.html =404;
     }
 
-    location ~* "^/(?:creation|editor/canvas|pay|profile|profile/payment|project|components|design-system|creators|creators/connections|games|games/detail|games/mine|games/play|games/publish)/?$" {
+    location ~* "^/(?:creation|editor/canvas|pay|profile|profile/payment|project|components|design-system|creators|creators/connections|games|games/compare|games/detail|games/lineage|games/mine|games/play|games/publish|games/theme|games/themes)/?$" {
         error_page 503 /maintenance.html;
 
         if ($genarrative_maintenance) {
diff --git a/docs/README.md b/docs/README.md
index 13874f005..43b973947 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -22,13 +22,14 @@
 - [平台入口与玩法链路](./【玩法创作】平台入口与玩法链路-2026-05-15.md)：平台壳、图片画布、游戏分发与在线游玩合同；网站游戏评分与评价已实现并通过本地验证，待用户验收，未部署。
 - [网站游戏评分与评价里程碑](./project-memory/plans/【里程碑】网站游戏评分与评价-2026-09-30.md)：唯一评价、编辑预填、4000 字符、公共分页与平均分/人数的验收边界与本地证据。
 - [创作者主页与关注粉丝合同](./【玩法创作】平台入口与玩法链路-2026-05-15.md#创作者主页与关注粉丝合同)：前后端已实现并通过工程验证，用户已确认提交交付，未部署。第四项默认进入自己主页，他人的关注/粉丝列表统一只读并支持主页跳转。
-- [创作者主页与关注粉丝工程设计](./technical/【技术方案】创作者主页与关注粉丝工程设计-2026-10-05.md)：分层落点、关系表/DTO、授权、关系列表分页、组件状态、深链与验证边界；游戏列表沿用最多 48 项限制，不做额外分页改造。
+- [创作者主页与关注粉丝工程设计](./technical/【技术方案】创作者主页与关注粉丝工程设计-2026-10-05.md)：分层落点、关系表/DTO、授权、关系列表分页、组件状态、深链与验证边界；公开游戏目录原为最多 48 项且不分页，**2026-10-07 已补真游标分页**（缺省 48 / 上限 100 / 非法游标 400 `CATALOG_INVALID_CURSOR` / 末页 `nextCursor` 为 `null`），作者过滤沿用原排序但不再被 48 项截死。
 - [后台游戏评价管理合同](./【玩法创作】平台入口与玩法链路-2026-05-15.md#后台游戏评价管理合同)：查找、分页、隐藏/恢复/删除、必填原因、统计与个人状态联动；已实现并通过本地验证，待用户验收，未部署。
 - [后台游戏评价管理里程碑](./project-memory/plans/【里程碑】后台游戏评价管理-2026-10-01.md)与[实施计划](./project-memory/plans/【实施计划】后台游戏评价管理-2026-10-01.md)：单里程碑范围、接口/schema 边界及验收要求；本地证据已回写主规范。
 - [游戏广场评分展示合同](./【玩法创作】平台入口与玩法链路-2026-05-15.md#游戏广场评分展示合同)、[里程碑](./project-memory/plans/【里程碑】游戏广场评分展示-2026-10-01.md)与[实施计划](./project-memory/plans/【实施计划】游戏广场评分展示-2026-10-01.md)：已实现并通过本地定向验证，待用户验收，未部署；公开列表/详情携带真实摘要，卡片显示一位小数均分与人数，复用有效评价统计。
 - [游戏买断制泥点付费与播放鉴权合同](./【玩法创作】平台入口与玩法链路-2026-05-15.md#游戏买断制泥点付费与播放鉴权合同)与[里程碑](./project-memory/plans/【里程碑】游戏买断制泥点付费与播放鉴权-2026-10-05.md)：已实现，本机真实栈 E2E 由人工验收脚本 `check:game-distribution-purchase-e2e` 覆盖（最近一次人工运行 76 PASS / 0 FAIL / 1 WARN），该脚本不在 CI 自动门禁内；待用户验收，未部署；作者可选买断制泥点付费，购买后永久可玩，后台审核可见价格且审核员不限次试用；网页与 AGC 两个发布入口一致支持定价并共用 `packages/shared` 组件 `PlatformGamePricingField`，AGC 定价的前端用例与 Rust 预填单测已覆盖，AGC 真实栈发布未覆盖。
 - [游戏分发统一发布接口与版本号自然幂等合同](./【玩法创作】平台入口与玩法链路-2026-05-15.md#游戏分发统一发布接口与版本号自然幂等合同2026-10-07)、[里程碑](./project-memory/plans/【里程碑】游戏分发统一发布接口与版本号自然幂等-2026-10-07.md)与[实施计划](./project-memory/plans/【实施计划】游戏分发统一发布接口与版本号自然幂等-2026-10-07.md)：已定稿待实现；`POST /versions` 合并建作品与建首版，`versionNumber` 必填并作自然幂等键，首次发布媒体只上传一次。
 - [游戏游玩次数计数](./adr/【ADR】游戏游玩次数计数-2026-10-03.md)：点「开始游戏」前端上报一次游玩，api-server 纯内存聚合（5s flush、30min 去重、`IP+game` 限流、关停不强制 flush），批量 procedure 自增现有 `game_distribution_game.play_count`，不 bump `updated_at`。
+- [游戏共创与作品 Fork](./【技术方案】游戏共创与作品Fork-2026-10-03.md)：共创授权三态（只升不降）、作品级血缘与代际、成品包与工程源包两条改造路径、族谱树与溯源署名的产品设计与技术方案；同时作为该功能主规范，已评审通过，按 M1 逐里程碑实现。
 - [外部 OpenAPI 与 API Key 接入方案](./【后端架构】外部OpenAPI与APIKey接入方案-2026-06-19.md)
 - [外部 MCP 语义工具说明与参数设计](./technical/【技术方案】外部MCP语义工具说明与参数设计-2026-09-23.md)：15 个新增语义工具与全部原工具并存，复用现有 External API；包含工具说明、action、参数、幂等和兼容合同。
 - [External v1 OpenAPI](./openapi/genarrative-external-v1.openapi.json)：公开 HTTP 契约唯一机器可读来源。
diff --git a/docs/project-memory/plans/【实施计划】游戏共创授权与血缘-2026-10-04.md b/docs/project-memory/plans/【实施计划】游戏共创授权与血缘-2026-10-04.md
new file mode 100644
index 000000000..a196a3bea
--- /dev/null
+++ b/docs/project-memory/plans/【实施计划】游戏共创授权与血缘-2026-10-04.md
@@ -0,0 +1,98 @@
+# 【实施计划】游戏共创授权与血缘
+
+| 字段          | 值                                                                       |
+| ------------- | ------------------------------------------------------------------------ |
+| Version       | 1.0                                                                      |
+| Status        | implemented-local（代码与静态门禁已过；运行时端到端与浏览器验证待补）    |
+| Date          | 2026-10-04                                                               |
+| Parent Spec   | `docs/【技术方案】游戏共创与作品Fork-2026-10-03.md`                        |
+| Milestone     | `docs/project-memory/plans/【里程碑】游戏共创授权与血缘-2026-10-03.md`      |
+| 授权默认值    | `forbidden`（保守取值，与需求文档一致；如需改默认允许，改一个常量即可）      |
+| 分支 / 工作树 | `feat/game-fork` / `.worktrees/feat/game-fork`                            |
+
+## 修改边界（逐文件）
+
+### 1. `server-rs/crates/spacetime-module/src/game_distribution.rs`
+
+- `GameDistributionGame` 表尾追加 `fork_authorization: String`，`#[default("forbidden".to_string())]`。
+- 新增表 `GameDistributionLineage`（accessor `game_distribution_lineage`）：
+  - `game_id` PK；`owner_user_id` / `parent_game_id` / `root_game_id` 三个 btree 索引。
+  - 字段：`game_id, owner_user_id, parent_game_id, parent_version_id, root_game_id, generation, created_at`。
+- 新常量：`GAME_DISTRIBUTION_FORK_AUTHORIZATION_{FORBIDDEN,NON_COMMERCIAL,FULL}`、`GAME_DISTRIBUTION_ACTION_SET_FORK_AUTHORIZATION`。
+- `GameDistributionCreateGameInput` 追加 `forked_from_game_id: Option<String>`、`forked_from_version_id: Option<String>`。
+- 新增 `GameDistributionSetForkAuthorizationInput { game_id, owner_user_id, fork_authorization, expected_fork_authorization, idempotency_key, request_digest, now_micros }`。
+- `create_game_distribution_game_tx`：在「新建分支」写 game 之后、写收据之前校验并写血缘行（幂等回放分支与 `local_project_id` 复用分支都不写血缘；复用分支带血缘直接报错）。
+- 新增 `set_game_distribution_fork_authorization_tx` + procedure `set_game_distribution_fork_authorization_and_return`。
+- 快照：`GameDistributionGameSnapshot` 加 `fork_authorization`；公开快照加 `fork_authorization` / `fork_count` / `lineage`（父作品摘要 + 代际 + 根）；后台快照加 `fork_authorization` / `generation` / `forked_from_game_id` / `derived_count`。
+- 血缘校验函数 `validate_game_distribution_fork_declaration_tx(ctx, owner, parent_game_id, parent_version_id) -> Result<(root, generation, parent_owner), String>`。
+
+### 2. `server-rs/crates/spacetime-module/src/migration.rs`
+
+- 在 `game_distribution_game` 之后追加 `game_distribution_lineage`，并补一行注释说明它是业务事实、随迁移导出。
+
+### 3. `server-rs/crates/module-game-distribution/src/{domain,errors,lib}.rs`
+
+- 授权阶梯规则（只升不降）与错误：`FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED`、`FORK_AUTHORIZATION_UNKNOWN`、`FORK_NOT_AUTHORIZED`、`FORK_SOURCE_NOT_AVAILABLE`、`FORK_SOURCE_VERSION_MISMATCH`、`FORK_DECLARATION_ON_EXISTING_GAME`（展示文案中文，错误码进 details）。
+- 代际计算：`next_generation(parent_generation) = parent_generation + 1`；根判定。
+- 配套单测。
+
+### 4. `server-rs/crates/spacetime-client/src/**`
+
+- `game_distribution.rs`：创建输入 record 加血缘字段；新增 `set_game_distribution_fork_authorization`。
+- `active/mapper/game_distribution.rs`：`GameDistributionGameRecord` 加 `fork_authorization`；公开 record 加 `fork_count`/`lineage`；admin record 加 `generation`/`forked_from_game_id`/`derived_count`；新增血缘 record 与映射。
+- `module_bindings/**` 由 `npm run spacetime:generate` 生成，禁止手改。
+
+### 5. `server-rs/crates/shared-contracts/src/game_distribution.rs`
+
+- `GameDistributionCreateGameRequest` 追加 `fork: Option<GameDistributionForkDeclaration>`（`parentGameId` / `parentVersionId`）。
+- 新增 `GameDistributionSetForkAuthorizationRequest { expectedForkAuthorization, forkAuthorization }`。
+- 游戏响应加 `forkAuthorization`，公开响应加 `forkCount` / `lineage`。（原计划的 `forkSourceAvailable` 未实现，也不需要：改造入口的显隐依据 `forkAuthorization`，可复刻形态由 `/fork-source` 回答；若 M2b 要在详情页区分「可源码级改造 / 只能参考」，届时再加。）
+
+### 6. `server-rs/crates/api-server/src/modules/game_distribution.rs`
+
+- `protected` 路由新增 `PUT /api/game-distribution/games/{game_id}/fork-authorization`。
+- `create_game` 校验并传递血缘声明。
+- `public_game_payload` / `game_payload` / `admin_game_payload` 增量字段。
+- `map_spacetime_error` 增加血缘/授权关键字的映射分支（放在 `不匹配` 分支之前，避免子串碰撞）。
+- 定向测试（沿用 `app.rs` 里的分发测试 harness）。
+
+### 7. 网页端
+
+- `packages/shared/src/contracts/gameDistribution.ts`：`GameDistributionGame` / 创建请求 / 新授权请求类型。
+- `src/services/gameDistributionClient.ts`：`updateGameForkAuthorization`（照 `unpublishGame` 写）。
+- `src/components/game-distribution/GameDetailPage.tsx`：授权徽章、溯源卡、代际。
+- `src/components/game-distribution/MyGamesPage.tsx`：卡片内授权设置（行内两段式确认，复用现有 `PlatformActionButton` 视觉），只升不降。
+- 定向测试：`GameDistributionPages.test.tsx` / `MyGamesPage.test.tsx` 增量用例。
+
+### 8. 文档
+
+- 主规范 `<u>§5 验收证据</u>` 回填、里程碑验收勾选；`docs/README.md` 索引已登记。
+
+## 顺序
+
+1. schema（表 + 列 + 迁移登记）→ `npm run spacetime:generate` → `npm run check:spacetime-schema`。
+2. 领域规则与单测（`module-game-distribution`）。
+3. module tx/procedure + client facade + mapper。
+4. shared-contracts DTO + api-server handler/payload/错误映射 + 后端定向测试。
+5. 网页端类型、服务层、详情页、我的作品页 + 定向测试。
+6. 运行时 smoke：真实栈走「设置授权 → 提升 → 拒绝降级 → 声明血缘 → 详情页展示 → 父作品下架后新声明被拒」。
+
+## 验证命令
+
+```bash
+npm run spacetime:generate
+npm run check:spacetime-schema
+cargo test -p module-game-distribution
+cargo test -p api-server
+npx tsc --noEmit
+npx vitest run src/components/game-distribution
+npm run check:encoding
+git diff --check
+```
+
+## 风险与回滚点
+
+- **回滚点 1（schema）**：新列与新表只做追加，旧行默认 `forbidden`；回滚只需还原表定义并重新发布（新表直接删表定义）。
+- **风险**：`map_spacetime_error` 靠子串匹配，新错误文案若含「不匹配」「已存在」「状态」会被打成 409 —— 必须在映射表前面显式加分支。
+- **风险**：新增血缘校验若放在 `local_project_id` 复用分支之后，会放过「既有作品改判成衍生作品」；必须放在复用分支内判定。
+- **风险**：公开 payload 不得回传对象键；血缘只回传作品摘要与代际。
diff --git a/docs/project-memory/plans/【里程碑】作品工程源包与一键改造-2026-10-03.md b/docs/project-memory/plans/【里程碑】作品工程源包与一键改造-2026-10-03.md
new file mode 100644
index 000000000..6f5f0ded7
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】作品工程源包与一键改造-2026-10-03.md
@@ -0,0 +1,73 @@
+# 【里程碑】作品工程源包与一键改造
+
+| 字段        | 值                                                    |
+| ----------- | ----------------------------------------------------- |
+| Version     | 1.2                                                   |
+| Status      | implemented-local（**两端均已落地**：服务端三列 + 校验器 + 上行/下行路由族；AGC 侧打包器 + 上传 + 取件建项 + 来源记录 v2；端到端脚本 46/46、规则 parity 门禁 OK。未跑项见验收标准里的 ⏳） |
+| Date        | 2026-10-03（2026-10-04 标注为正解路径；2026-10-05 按实现更新范围与验收） |
+| Parent Spec | `docs/【技术方案】游戏共创与作品Fork-2026-10-03.md`（口径见 §2.5、§3.2.3、§3.4、§3.5.1、§3.5.2、§3.5.4） |
+
+> **定位（2026-10-04）**：只读侦察证明成品包路径只能试玩、不能重新发布（见「成品包改造闭环」里程碑的「事实依据」），因此**本里程碑是「一键复刻完整工程」的唯一正解路径**：只有拿到作者随版本上传的工程源包，用户才可能在不重写工程的前提下改核心逻辑并重新发布。技术方案 §3.5.4 的推荐是「路线 A（参考式改编）先行验证需求，路线 B（本里程碑）作为正解排后续」。
+>
+> **产品口径（2026-10-05 已拍板，§3.2.3/§3.5.4）**：**不做**独立的「源码可见性」开关——作品授权非 `forbidden` 时，工程源包与成品包走同一道取件鉴权；作者不想给源码就是**不上传**，「上传与否」本身就是开关。`nonCommercial` 的约束力是**平台规则层面**（源码被取走后无法从技术上阻止商用）。上传与发布/审核解耦：未上传不影响发布。
+
+## 目标
+
+作者在授权允许时，把工程源码作为该发行版本的可选伴随资产一起发布；其他用户拿到的是**源码级工程**，可以改核心逻辑、重跑构建并发布，改造质量与原作者体验一致。
+
+## 范围
+
+- 工程源包作为发行版本的可选伴随资产：上传（整包或分片续传）、确认、只读回读与对象存储生命周期。
+- 工程源包的内容门禁：服务端**独立恢复**（不信任客户端）——与发行包同级的体积/条目上限 + 源码场景项（凭据与隐私文件、依赖与 VCS 目录、根级构建产物与 IDE 目录、嵌套压缩包、符号链接、加密条目）。
+- 改造内容下发入口的来源优先级：同一版本同时存在工程源包与成品包时优先下发工程源包，并如实标注来源类型。
+- 客户端：源码工程确定性打包（条目排序 + 固定时间戳）→ 上传（含中断续传）；下载 → 校验摘要 → 解压 → 以源码工程形态建项。
+- 发布面板的工程包上传入口与后果说明：**上传与否是作者唯一的开关**（不做独立的「源码可见性」授权位）；未上传时如实提示「只能被他人试玩与参考」。
+
+## 不在范围内
+
+- 成品包路径的「试玩 + 素材参考」闭环（见「成品包改造闭环」里程碑；本里程碑复用其内容下发入口、血缘声明与建项基座）。
+- **已公开版本的补传（backfill）**：原方案曾设想「公开后可给当前公开版本补传一次工程包」，本期**不做**——上传阶段门与发行包确认一致（只允许 `awaiting_upload` / `upload_failed`），公开后不接受任何内容写入。若产品要这条，需要单独设计（它会是「版本不可变」的例外）。
+- 工程源包的版本回溯（历史版本没有工程包时不为它补做）。
+- 网页端上传工程源码包（首期只支持客户端）。
+- 相似度比对与低改动度判定、收益分成。
+
+## 依赖与前置条件
+
+- 「游戏共创授权与血缘」里程碑已通过验收。
+- 「成品包改造闭环」里程碑已通过验收（内容下发入口、客户端建项基座、发布携带来源、授权面板均在那一里程碑落地）。
+- **前置依赖 ①「工程包下载/授权」接口——已落地（2026-10-05）**：`GET /games/{gameId}/fork-source` 在有工程包时返回 `source: "project"`，本体的独立路径 `GET /games/{gameId}/fork-source/project` 与成品包共用同一套鉴权与校验函数（不重复实现），**不下发对象键**、只服务当前公开版本、`no-store`。读取复用现役 OSS 读路径，**缓存键含资产维度**（对象键 `…/{version_id}.project.zip` 与 `…/{version_id}.zip` 不同），两份资产不串味。
+- **前置依赖 ②包内禁项与规模上限——已定稿并已落地（2026-10-05）**：服务端 `module-game-distribution/src/project_bundle.rs` 的 `validate_project_bundle_zip` 独立复核，拒绝清单与上限见技术方案 §3.5.2。**512 MiB（客户端打包上限）与 200 MiB（服务端/反代放行量）的不对齐按下述口径收敛**：服务端上限与发行包逐项相等（200 MiB / 展开 500 MiB / 单文件 64 MiB / 条目 10 000 / 压缩比 100）。**客户端预检已完成**（原先属待办）：打包器在产出后即按 `limits.max_archive_bytes` 失败关闭（`apps/ai-game-creator-shell/src-tauri/src/project_bundle.rs` 的 `write_project_bundle_zip` 内 `bytes.len() > limits.max_archive_bytes` 分支），超限包在本地就被拦下，不会「上传到一半被拒」；单文件 / 累计展开 / 条目数更是在压缩前就检查。
+- 客户端已有的「从包安装并建项」基座与包内容门禁可直接复用；本里程碑不新建第二套解压或建项路径。
+- 决策：产品已同意引入工程源包，且**不设**独立的「源码可见性」授权位（口径见文首）。
+
+## 实现进展（2026-10-05）
+
+- 服务端：块 A `c6bd2c081`（三列 + 契约 + 绑定）、块 B `9403a47c0`（工程包校验器）、块 C+D `d061b2e37`（上行 5 条路由 + 下行优先 + 缓存资产维度）；文档块 E `3aa145d91`。
+- 客户端：`4d070dd1a`（规则对齐 + `check-project-bundle-policy-parity` 机器门禁）、`5dd9d1c5d`（发布时上传，失败不阻断）、`72f08c264`（取件按 `source` 分支建项 + 来源记录 v2 兼容 v1）、`da24dd5be`（取件提示按形态如实措辞）；`ff763abe5`（端到端验收脚本）。
+- 证据（按冻结点实测重数）：`npm run （本地夹具脚本，无 npm 条目）` **51 个 `check(` 调用点**；`npm run check-project-bundle-policy-parity` OK（服务端 51 条规则全被客户端覆盖 + 路径形状维度）；`cargo test -p module-game-distribution` **73 passed**（其中 `project_bundle::tests` **19 条**）；`cargo test -p api-server game_distribution` 60 passed；AGC `vitest` 1961 passed、客户端打包器 `cargo test -- project_bundle` **24 passed**（含 dev-dependency 执行级交叉测试）。
+- **未做（含原因）**：① 已公开版本的补传（backfill）——按产品口径不做，阶段门与发行包确认一致；② 真实 >200 MiB / 10 001 条目 / 极端半包续传边界——未测（成本高，靠常量单测钉住）；③ AGC 真机取件→建项链路——未跑（需要真机客户端窗口）；④ 结构化埋点事件——未接（待产品定事件口径）。
+- **已知留白（对抗性复核后如实登记，别当成已全覆盖）**：归档格式未纳入 `.bz2` / `.xz` / `.zst`；数据库转储 `*.db` / `*.sql` 未纳入；凭据目录未纳入 `.gcloud` / `.azure` / `.password-store`；zip 条目名的 CP437 解码与 `external_attributes == 0` 的条目未覆盖；「爆炸包峰值内存」只有机制级封顶 + 常量单测，未做真实量测；内容嗅探的误报率无实测数据（只做了「不误报」的反例：`.sshrc` / `Dockerfile` / 非私钥证书块 / `AKIA` 长度不足 / 二进制扩展名不扫）。
+
+## 验收标准
+
+> 标注：✅ = 已落地并有证据（单测 / 门禁 / 端到端脚本，本地）；⏳ = 仍待补（真机或极端边界）；⏭ = 明确不做。
+
+- [x] ✅ 工程包校验器拒绝清单齐备：绝对路径、`..`、盘符、反斜杠、通配符、符号链接、加密条目、**嵌套归档扩展名并集（`.zip`/`.tar`/`.gz`/`.tgz`/`.7z`/`.rar`/`.jar`/`.whl`/`.nupkg`）与 magic bytes 嗅探（改名也拦）**、完全重复/大小写折叠重复路径、任意层级 `node_modules` / `.git` / `.svn` / `.agent` / **`.aws` / `.ssh` / `.kube` / `.docker` / `.gnupg` / `.terraform` / `.secrets`**、根级 `dist` / `build` / `library` / `temp` / `local` / `.idea` / `.vscode`、凭据与隐私文件（`.env*`、`*.pem`、`*.key`、`*.p12`、`*.pfx`、`.npmrc`、`.netrc`、`.git-credentials`、`id_rsa*`、`id_ed25519*`、**`credentials*` / `id_ecdsa*` / `id_dsa*` / `terraform.tfstate*` / `service-account*` / `*.jks` / `*.keystore` / `*.ppk` / `*.p8` / `*.kdbx` / `*.der` / `.htpasswd` / `.pgpass` / `*.map`**）、**小体积文本条目的内容嗅探（PEM 私钥块 / `AKIA…` / `ghp_` / `github_pat_` / `xox*`）**、单文件/累计/压缩比超限；合法源码包（**不含** `index.html`）通过。证据：`module-game-distribution` **19 条校验器单测**（+ `package.rs` 6 条）与 `check-project-bundle-policy-parity`（客户端打包器与它逐项对齐）。
+- [x] ✅ 同一版本重复确认同一工程包不产生第二份对象（同内容幂等重放）；换内容重传按冲突拒绝（409 `同一版本已存在不同的工程源包`）。证据：模块事务 + 本地夹具脚本（工程源包）A4。
+- [x] ✅ 阶段门：只有 `awaiting_upload` / `upload_failed` 可写；已上传、验证中、待审核、已拒绝、已公开、已撤回、已取消一律拒绝。**顺序按实现**：「已存在工程包」先判（409 `PROJECT_BUNDLE_ALREADY_EXISTS`），故「已公开且已有工程包」返回 `ALREADY_EXISTS`；「已公开但无工程包」才返回 `UPLOAD_NOT_ALLOWED`。证据：e2e A5 / A5b + api-server 单测。
+- [x] ✅ 非作者上传 → **404**（按「版本不存在」处理，与发行包上行族同口径，不泄露版本存在性），未带 Bearer → 401。证据：e2e A6 + 路由级 401 单测。
+- [x] ✅ 上行整包 PUT（`application/octet-stream`）+ 服务端独立复核 + 失败 422 `PROJECT_BUNDLE_VALIDATION_FAILED` 且清理半包对象。证据：e2e（整包/校验失败/清理）+ 单测。
+- [x] ✅ 下行优先级：同一版本同时有两种资产时 `fork-source` 返回 `source: "project"` 且 `downloadPath` 指向 `/fork-source/project`；只有成品包时回落 `package`；「字节数 > 0 但摘要为空」的半写行回落 `package`（失败关闭）；两条下载路径共用同一个校验函数，请求 project 而实际没有工程包时 409 而非静默回落。
+- [x] ✅ 两种资产的读取缓存不串味（缓存键即对象键，键名分别以 `.zip` / `.project.zip` 结尾）。证据：api-server 单测（对象键互不相等 + `ReleasePackageCache` 双资产各自取回）。
+- [x] ✅ 未上传工程包不阻断发布与审核（上传是独立可选资产，不参与版本状态机）；无工程包的作品仍能拿到成品包；未上传时面板如实提示「只能被他人试玩与参考」。证据：客户端发布链路改动 + 面板文案测试（真机窗口仍未看，见下条）。
+- [ ] ⏳ 上传中断后按权威偏移续传的**真实**验证：分片路由与客户端续传逻辑均已落地，但未跑真实断点/乱序场景。
+- [ ] ⏳ AGC **真机**取件 → 建项链路：客户端按 `source` 分支建项与来源记录 v2 已落地并有单测，但未在真机窗口里跑过「取件 → 解压 → 建项 → 可编辑/可试玩/可发布」整链。
+- [ ] ⏳ 通过源码路径发布的作品，其来源、代际与根与成品包路径完全一致（服务端本就用同一套血缘，真机验证待做）。
+- [ ] ⏳ 真实极端边界：>200 MiB 压缩包、>10 001 条目、极端压缩比在**真实上传链路**上的表现（当前靠常量单测与门禁钉住，未在真实栈压测）。
+- [x] ⏭ 已公开版本的**补传（backfill）**：按产品口径**不做**（阶段门与发行包确认一致，公开后不接受内容写入）。原验收项已从本节移除，改为本行显式记录。
+
+## 证据要求
+
+- 自动化（已落地的命令）：`npm run （本地夹具脚本，无 npm 条目）`（**46/46**）、`npm run check-project-bundle-policy-parity`（两端规则一致）、`cargo test -p module-game-distribution`（69 passed，含校验器 16）、`cargo test -p api-server game_distribution`（60 passed）、AGC `npx vitest run apps/ai-game-creator-shell/tests`（1961 passed）与定向 `cargo test -- fork|project_bundle`（17 + 16 passed）、DTO parity 与 schema/编码/文档索引门禁。
+- 运行时：真实 api-server + 真实对象存储 + 真实客户端跑通「拿到源码 → 改核心逻辑 → 试玩 → 发布 → 溯源与代际正确」，附对比截图或录屏。**（取件 → 建项链路的真机窗口验证仍未跑，见验收标准 ⏳）**
+- 边界：越权下载、无授权下载、来源已下架、摘要不符、超限包、解压失败、上传中断续传、账号切换后的迟到响应、同版本双来源优先级。
diff --git a/docs/project-memory/plans/【里程碑】共创主题与作品树-2026-10-06.md b/docs/project-memory/plans/【里程碑】共创主题与作品树-2026-10-06.md
new file mode 100644
index 000000000..955d0b68c
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】共创主题与作品树-2026-10-06.md
@@ -0,0 +1,261 @@
+# 【里程碑】共创主题与作品树
+
+| 字段        | 值                                                                    |
+| ----------- | --------------------------------------------------------------------- |
+| Version     | 1.1                                                                   |
+| Status      | 服务端已实现（`2fa201e0d` 模型/纯函数/契约、`742723a58` 公开读、`033e3aa79` 后台写）；**公开前端（共创 Tab / 主题页 / 详情入口）与后台管理 UI 待做** |
+| Date        | 2026-10-06                                                            |
+| Parent Spec | `docs/【技术方案】游戏共创与作品Fork-2026-10-03.md`（§3.10 共创主题）  |
+| 已落地提交  | `063c04a1b`（设计定稿：技术方案 §3.10 + 本文件）、`2fa201e0d`（数据模型 / 领域纯函数 / 契约 / 数据契约表 94→96）、`742723a58`（公开读路径：3 个 procedure + client + 2 条公开路由 + 作品详情 `themes` 增量）、`033e3aa79`（后台写路径：5 条 admin 路由 + 事务 + 幂等 + `THEME_*` 错误码） |
+
+## 目标
+
+共创侧出现**由平台 / 运营命名**的「共创主题」：一个主题下挂若干**根作品**，点进去能看到这些根各自的**作品树**；作品在游戏 Tab 里仍作为独立作品展示，详情页能看到自己所属的主题并跳过去。
+
+一句话判据：**主题是运营叙事，树由血缘复用，作品归属是额外维度而不是替代品。**
+
+## 范围
+
+- 两张表：`game_distribution_theme`（主题）与 `game_distribution_theme_member`（成员，**只允许根**）；迁移白名单登记与生成绑定。
+- 领域纯函数：主题状态白名单、主题公开可见性、成员公开可见性、确定性成员主键、成员 / 主题的稳定排序与游标切页。
+- 公开读接口（匿名、`no-store`）：主题列表（游标分页）、主题详情（成员根清单 + 每根既有公开摘要）。
+- 作品详情增量：`themes: [{ themeId, name, badge }]`（先取该作品的**根**再反查）。
+- 后台写接口：创建主题、改名 / 简介 / 角标 / 排序 / 状态、增删成员（都幂等）、后台列表（含 `draft` / `archived`）；鉴权复用既有 `require_admin_auth` + `AuthenticatedAdmin`。
+- 公开前端：共创 Tab（主题列表）、主题页（成员根清单 + 逐根渲染 `lineage` 树）、详情页主题入口。
+- 契约同步：Rust / TS DTO、DTO parity 构建器登记、数据契约表随表落地补。
+
+## 不在范围内
+
+- **后台管理 UI**（本轮只做后台接口；运营页另行安排）。
+- 主题**封面图**（要接平台素材链路与公开授权口径，独立小需求；本轮用 `badge` + `name` 呈现）。
+- **slug / URL 别名**（公开 URL 直接用 `theme_id`，本轮不做 slug 与唯一性约束）。
+- **埋点 / 统计**（曝光、点击、成员转化等 UI 上线后按数据定口径）。
+- 主题内「**跳到某一代节点**」高亮（UI 层能力，族谱页已有 `from` 参数）。
+- **批量树端点**（本轮接受前端 N 次 `/games/{id}/lineage`）。
+- 主题级联下架 / 归档时的成员清理（不做：归档即「不再公开」，成员行按同一口径保留）。
+- 收益分成、流量回馈、相似度反洗稿校验、关注 / 粉丝。
+
+## 依赖与前置条件
+
+- M1（授权与血缘骨架）已落地：`game_distribution_lineage` 表与根解析（`game_distribution_lineage().game_id().find(...).map(root_game_id).unwrap_or(game_id)`）是本里程碑「成员只允许根」与「详情页按根反查」的前置。
+- M3（族谱与衍生列表）已落地：主题页的树**直接复用** `/games/{id}/lineage`，本里程碑不重建任何树查询或树整形。
+- 公开目录同一份 `public_game_payload` 投影已存在于 api-server（主题详情与成员卡片都复用它）。
+- 游标分页惯例已由 `/my-collections`（2026-10-06）落地：默认 20 / 上限 50 / 游标 `"{micros}:{id}"` / 非法游标 400 / 末页 `nextCursor: null`。
+- 设计已由技术方案 §3.10 定稿（含四条留白）。**待产品确认的只剩一条**：①「主题级排序口径」；② 主题详情 `roots` 的 **50 上限**行为**已于 2026-10-06 定口径**（`memberCount` 报真实可见成员数 + 新增 `rootsTruncated` 截断信号，见文末「待确认项」）。
+
+## 实施清单（执行结果）
+
+A–F 已落地（服务端）；G 前端与后台 UI 未做。
+
+### A. 数据模型与迁移
+
+**已落地（`2fa201e0d`）。**
+
+1. 在 `server-rs/crates/spacetime-module/src/game_distribution.rs` 追加两张表（列、索引、注释按技术方案 §3.10.1 的表声明逐字落地）：
+   - `game_distribution_theme`：`theme_id`（PK，`theme-*`）、`name`、`summary`、`badge`、`sort_order: i64`、`status: String`、`created_by_user_id`、`created_at`、`updated_at`；具名索引 `by_game_distribution_theme_created_at`（btree `created_at`）。
+   - `game_distribution_theme_member`：`member_id`（PK，`"{theme_id}:{root_game_id}"`）、`theme_id`、`root_game_id`、`sort_order: i64`、`created_at`；**两条具名 btree 索引** `by_game_distribution_theme_member_theme_id`、`by_game_distribution_theme_member_root_game_id`。
+2. 在 `server-rs/crates/spacetime-module/src/migration.rs` 的 `migration_tables!` 白名单登记两表，注释写明「主题与成员是运营业务事实，随迁移导出/导入；归档 / 下架不删除成员行」。
+3. 生成绑定：`npm run spacetime:generate`；**只保留**与本次 schema 相关的 `module_bindings/game_distribution*` 与 `module_bindings/module_bindings.rs`，其余 rustfmt 漂移 `git checkout --` 还原（与 §5.1 同处理）。
+4. 新增 procedure 的 Result/Input `SpacetimeType`（`SpacetimeType` 派生，字段用 `snake_case`，与既有 `GameDistributionCollection*` 系列同形），放在既有结果类型附近。
+
+### B. 领域纯函数（`server-rs/crates/module-game-distribution/src/theme.rs`，新文件，不碰 `ReducerContext`）
+
+**已落地（`2fa201e0d`；`033e3aa79` 补充后台 `status` 过滤白名单与文本上限校验）。**
+
+| 函数 / 常量 | 职责 | 关键约束 |
+| --- | --- | --- |
+| `GAME_DISTRIBUTION_THEME_STATUSES: [&str; 3]` | `["draft", "published", "archived"]` | 三处共用同一个白名单（可见性、后台列表过滤、DTO 校验），不复制字面量 |
+| `game_distribution_theme_status_valid(status: &str) -> bool` | 状态合法性 | 非法值由 api-server 映射 400，不落到 axum 422 |
+| `game_distribution_theme_public_visible(status: &str) -> bool` | 主题公开可见性 | 等价于 `status == "published"`；`draft` / `archived` 一律不可见 |
+| `game_distribution_theme_member_id(theme_id: &str, root_game_id: &str) -> String` | 确定性主键 | `format!("{theme_id}:{root_game_id}")`；两个 ID 都不含 `:`（`theme-*` / `game-*`），组合单射 |
+| `game_distribution_theme_member_visible(is_deleted: bool, is_published: bool, has_public_version: bool) -> bool` | 成员公开可见性 | **委托**既有 `game_distribution_collection_visible`（同一条「未删 + 已公开 + 有公开版本」口径），不新写第二个同义判定 |
+| `game_distribution_theme_root_acceptable(has_lineage_row: bool) -> bool` | 成员只允许根 | `has_lineage_row == true`（非根）→ 拒绝；由调用方用血缘点查给出事实 |
+| `GAME_DISTRIBUTION_THEME_PAGE_LIMIT_DEFAULT = 20` / `_MAX = 50` / `game_distribution_theme_page_limit(limit: u32) -> usize` | 公开列表页大小归一化 | 与 `/my-collections` 同一数值与「超界截断而非报错」口径；归一化在模块侧定义一次，日志与切页共用同一函数 |
+| `encode_game_distribution_theme_cursor(created_at_micros: i64, theme_id: &str) -> String` / `parse_game_distribution_theme_cursor(value: &str) -> Result<(i64, String), String>` | 游标编解码 | 格式 `"{micros}:{themeId}"`，解析只切**第一个**冒号；解析失败返回 `Err`（api-server 映射 400） |
+| `sort_public_themes(...)` + `page_public_themes(items, cursor, limit) -> (page, next_cursor)` | 主题公开列表排序与切页 | 排序键 `created_at` **倒序** + `theme_id` **升序**兜底（全序，翻页不重不漏）；**先过滤可见性、再排序切页** |
+| `sort_theme_members(...)` + `page_theme_members(items, limit) -> Vec<...>` | 主题内成员排序 | `sort_order` **升序** + `member_id` **升序**兜底（`sort_order` 允许重复） |
+| `game_distribution_theme_member_visibility(game_row_present, is_deleted, game_visibility) -> String` | 后台成员行的**细粒度**状态（只给后台） | `missing`（游戏行不存在）**优先于** `deleted`（软删除），否则原样透传游戏行的 `visibility`。与 `game_distribution_theme_member_visible` **刻意独立**：前者答「为什么」，后者答「此刻公开侧会不会出现」 |
+| `encode_game_distribution_theme_member_cursor(sort_order, member_id)` / `parse_game_distribution_theme_member_cursor(value)` | 后台成员名单游标编解码 | `"{sort_order}:{member_id}"`；解析**只委托** `parse_game_distribution_theme_cursor`（**共用同一个可达的 `THEME_INVALID_CURSOR`**，不复制第二份解析） |
+| `page_admin_theme_members(items, cursor, limit) -> (page, next_cursor)` | 后台成员名单切页 | 复用**同一份** `sort_theme_members`（全序，翻页不重不漏）；`limit` 归一化复用 `game_distribution_theme_page_limit`；调用方**不**做可见性过滤（后台看全部行） |
+| `game_distribution_theme_roots_truncated(visible_member_count: usize, returned_root_count: usize) -> bool` | 详情 `roots` 是否被响应体积上限截断 | 仅 `returned_root_count < visible_member_count` 为 `true`；相等（不足上限，全发）与「回传多于可见」（两组数字不同源，防御性）都是 `false`。与族谱 `truncated` 同约定 |
+
+复用 `collection.rs` 里 `GameDistributionCollectionPageItem<T>` 那种「排序键与负载绑定」的写法，避免「按 A 排序、按 B 切页」的错位。
+
+### C. 事务与 procedure（`server-rs/crates/spacetime-module/src/game_distribution.rs`）
+
+**已落地（读：`742723a58`；写：`033e3aa79`；后台成员名单读：本条）。**
+
+命名沿用既有：**写** = `*_and_return`，**读** = `list_*` / `get_*`。
+
+| procedure | 事务职责 |
+| --- | --- |
+| `create_game_distribution_theme_and_return` | 服务端生成 `theme_id`（`theme-` + 唯一后缀，不接受客户端传入）；写 `created_by_user_id`（= admin 会话主体）、`created_at` = `updated_at` = now；返回主题行 + `replayed` |
+| `update_game_distribution_theme_and_return` | 按 `theme_id` 改名 / 简介 / 角标 / 排序 / 状态；`theme_id` 不存在 → `THEME_NOT_FOUND`；生效时刷新 `updated_at`；幂等收据键与既有写接口同族（绑定请求摘要，摘要不一致 → `THEME_IDEMPOTENCY_CONFLICT`） |
+| `upsert_game_distribution_theme_member_and_return` | 按确定性主键写成员（不存在则插入，存在则更新 `sort_order`）；**先判主题存在**，再判作品存在，再按血缘点查判「是否根」（非根 → `THEME_MEMBER_NOT_ROOT`）；重复调用不产生第二行，`created_at` 首次写入后不再变 |
+| `remove_game_distribution_theme_member_and_return` | 按确定性主键删除；不存在也算成功（无「重放 vs 新意图」差异，不需要幂等键）；主题不存在 → `THEME_NOT_FOUND` |
+| `list_game_distribution_admin_themes` | 后台列表：支持 `status` 过滤（`all` / `draft` / `published` / `archived`），`limit` 缺省与上限与后台作品列表同口径（200），按 `created_at` 倒序 + `theme_id` 升序 |
+| `list_admin_game_distribution_theme_members` | 后台成员**名单**：**不套**公开可见性过滤、**不要求主题已发布**（`draft` / `archived` 照常可读），返回全部成员行（每行 `visible` / `visibility`）+ **行总数**（不受分页影响）+ 下一页游标；排序复用 `sort_theme_members`、切页走 `page_admin_theme_members`；主题不存在 → `THEME_NOT_FOUND` |
+| `list_game_distribution_public_themes` | 公开列表：只取 `published`，**先过滤再排序切页**，返回 `(themes, next_cursor)`；每条的 `member_count` = 该主题当前可见成员数（同一可见性判定） |
+| `get_game_distribution_theme_detail` | 公开详情：主题不存在 / 非 `published` → `found = false`（api-server 映射 404）；命中时返回主题行 + 可见成员根（按 `sort_order` + `member_id` 排序），成员卡片信息按 `public_game_payload` 所需事实取（游戏行 + 当前公开版本 + 评分摘要） |
+| `list_game_distribution_theme_refs_for_root` | 按 `root_game_id` 走 `by_game_distribution_theme_member_root_game_id`，联主题行，只保留 `published`，按主题公开列表同一比较器排序；供作品详情 `themes` 增量使用 |
+| （内部辅助）`game_distribution_theme_root_of(ctx, game_id) -> String` | 血缘点查取根，无血缘行返回自身；**必须复用** `game_distribution_lineage_entries` 用的同一写法，不复制第二份根解析 |
+
+事务级不变量（必须有定向断言）：① 同一主题内同一根只可能有一行（主键结构）；② 非根作品不能成为成员；③ 同一根可以同时存在于多个主题（跨主题各有独立行）；④ 成员行**不因作品下架 / 软删除而删除**；⑤ 归档主题的行仍在表里（只是不在公开投影里）。
+
+### D. api-server 路由（`server-rs/crates/api-server/src/modules/game_distribution.rs`）
+
+**已落地（公开族：`742723a58`；后台族：`033e3aa79`；后台成员名单读：本条）。**
+
+公开族（挂 `public_games` 那一支，带 `add_no_store_response_headers`）：
+
+| 方法 / 路径 | handler | 响应 | 错误 |
+| --- | --- | --- | --- |
+| `GET /api/game-distribution/themes?limit=&cursor=` | `list_public_themes` | `{ themes: [{ themeId, name, summary, badge, memberCount }], nextCursor }`（`memberCount` = 真实可见成员数，不截断） | 非法游标 → 400（平台信封） |
+| `GET /api/game-distribution/themes/{theme_id}` | `get_public_theme` | `{ themeId, name, summary, badge, memberCount, roots: [...], rootsTruncated }`（`memberCount` 不截断；`rootsTruncated` = 这份 `roots` 被 50 上限截断） | 不存在 / 未发布 → 404（不返回空壳） |
+| `GET /api/game-distribution/games/{game_id}`（**既有，响应增量**） | `get_game` | 追加 `themes: [{ themeId, name, badge }]` | 沿用既有 404 |
+
+后台族（挂 `admin` 那一支的 `route_layer(middleware::from_fn_with_state(state, require_admin_auth))`）：
+
+| 方法 / 路径 | 语义 | 幂等 |
+| --- | --- | --- |
+| `POST /admin/api/game-distribution/themes` | 创建（`name` 必填非空；`status` 缺省 `draft`） | 要求 `Idempotency-Key` |
+| `PUT /admin/api/game-distribution/themes/{theme_id}` | 改名 / 简介 / 角标 / 排序 / 状态 | 要求 `Idempotency-Key` |
+| `GET /admin/api/game-distribution/themes?limit=&status=` | 后台列表（含 `draft` / `archived`） | 只读 |
+| `PUT /admin/api/game-distribution/themes/{theme_id}/members/{root_game_id}` | 增 / 改成员（body 可带 `sortOrder`） | 确定性主键保证幂等 |
+| `DELETE /admin/api/game-distribution/themes/{theme_id}/members/{root_game_id}` | 移除成员（不存在也算成功） | 不需要幂等键 |
+| `GET /admin/api/game-distribution/themes/{theme_id}/members?limit=&cursor=` | 读取成员**名单**：**全部成员行**（含当前不可见的）+ 每行 `visible` / `visibility`；**含 `draft` / `archived` 主题**（原缺口：借公开投影时草稿 / 归档主题列不出成员） | 只读（`limit` 缺省 20 / 上限 50；游标 `"{sortOrder}:{memberId}"`，末页 `null`） |
+
+### E. 错误码映射（api-server 集中映射，沿用 `FORK_*` 那套「前缀字符串 → 状态码」写法）
+
+**已落地（6 个 `THEME_*` 码：`742723a58`；领域错误类型：`033e3aa79`）。** 未登记的码兜底 **400 `THEME_ERROR`**（不落 axum 默认 422 纯文本）。
+
+| 领域码 | HTTP | 触发 |
+| --- | --- | --- |
+| `THEME_NOT_FOUND` | 404 | 后台按 `theme_id` 找不到主题（公开侧「不存在 / 未发布」一律 404 且不带该码） |
+| `THEME_BAD_REQUEST` | 400 | `name` 空 / 非法 `status` / 非法 `status` 过滤值 |
+| `THEME_INVALID_CURSOR` | 400 | 游标格式非法（也可直接复用既有 `bad_request` 文案，二选一并在脚本里钉住实际值） |
+| `THEME_IDEMPOTENCY_CONFLICT` | 409 | 同 `Idempotency-Key` 不同请求摘要 |
+| `THEME_MEMBER_NOT_ROOT` | 409 | 目标作品有血缘行（非根） |
+| `THEME_MEMBER_GAME_NOT_FOUND` | 404 | 目标作品不存在 |
+| （框架）未带 admin 会话 | 401 | 由 `require_admin_auth` 给出 |
+
+### F. 契约与 DTO 同步
+
+**已落地（类型与数据契约表：`2fa201e0d`；公开构建器登记：`742723a58`；后台 payload 登记：`4a3339782`；成员名单读接口的两个构建器：本条）。** DTO parity 现为 **58 组类型 / 17 个手拼响应构建器 / 15 个手拼响应类型**。
+
+- Rust DTO：`server-rs/crates/shared-contracts/src/game_distribution.rs`（主题列表 / 详情 / 后台写请求的私有类型；**不下发**任何对象键或内部计数）。
+- TS DTO：`packages/shared/src/contracts/gameDistribution.ts`——后台成员名单新增 `GameDistributionAdminThemeMemberRow` / `GameDistributionAdminThemeMemberListResponse` / `GameDistributionAdminThemeMemberVisibility`（服务端同样是逐字段手拼 JSON，因此走 `TS_ONLY_TYPES` 登记）。
+- `scripts/check-game-distribution-dto-parity.mjs`：登记新响应构建器（`public_themes_payload` / `public_theme_detail_payload` / 详情 `themes` 增量构建器 / 后台主题一族，以及本条的两个：`admin_theme_members_payload`（列表）与 `admin_theme_member_row_payload`（单条行）），证明这些路径确实会发出新键——列表与单条各登记一条，让「条目到底发哪几个键」有独立证据。
+- `docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md`：**已随表落地补齐**（`2fa201e0d`，两张表小节；`check:spacetime-schema` 现为 **96** tables）。
+
+### G. 前端（公开侧；后台 UI 不在本轮）
+
+**未做（待前端里程碑）。** 下表是待执行的改动清单：
+
+| 文件 | 改动 |
+| --- | --- |
+| `src/routing/activeAppPageRoutes.ts` | 新增 `['game-themes', '/games/themes']`、`['game-theme', '/games/theme']`（详情用 `?id=<themeId>`，与 `/games/lineage?id=` 同款）；同步 `SelectionStage` 类型 |
+| `src/components/platform-entry/PlatformEntryActiveFlowShell.tsx` | 新 stage 的渲染分支（与 `game-lineage` 同形） |
+| `src/components/game-distribution/GameGalleryPage.tsx` | 新增「共创」Tab（切到 `/games/themes`），分类 Tab 结构复用既有 `game-category-tabs` |
+| `src/components/game-distribution/GameThemesPage.tsx`（新） | 主题列表：卡片显示 `name` / `summary` / `badge` / `memberCount`；游标「加载更多」；空态与失败态复用既有平台错误组件 |
+| `src/components/game-distribution/GameThemePage.tsx`（新） | 主题详情：成员根清单 + **逐根**调 `/games/{id}/lineage` 渲染多棵树（N+1 是已接受的取舍）；已发布但无可见成员 → 明确空态（**不是**错误）；成员作品不可用时按族谱页既有降级展示 |
+| `src/components/game-distribution/GameDetailPage.tsx` | 用 `GameDetailDisplay` 的槽位渲染 `themes` 入口链（`/games/theme?id=`）；无主题时不渲染空容器 |
+| `src/services/gameDistributionClient.ts` | 新增 `listThemes` / `getTheme`；`getGame` 类型增量 `themes` |
+
+新增 SPA 路由后必须同步 `npm run check:nginx-spa-routes` 与 `npm run check:pingora-route-parity` 的静态路由清单（`/games/themes` 是静态前缀；`/games/theme` 若走查询串则不需要动态段放行）。
+
+### H. 测试清单
+
+**已落地**：纯函数（`module-game-distribution`，含 `033e3aa79` 补的 status 过滤 / 文本校验）、事务结构断言（`spacetime-module`）、api-server 路由与错误码定向测试、契约 parity。**未做**：前端 vitest、真实 dev 栈 e2e。**2026-10-07 更新**：真实栈 e2e 已写好并跑通（71/71，运行在隔离实例上），但它是**本地验收脚本、未入库**（只在本地工作树，路径见本地 `info/exclude`）。
+
+| 层 | 用例 |
+| --- | --- |
+| 纯函数（`module-game-distribution`） | 状态白名单（合法三态 / 未知值）；主题公开可见性（`draft` / `archived` false）；成员可见性四组合 + 「未删已公开但无当前公开版本」必须 false；`member_id` 确定性（同输入同输出、不同主题不同行）；成员只允许根（`has_lineage_row` true → 拒绝）；游标编解码往返 + 非法游标（缺冒号 / 非数字 / 空 ID）+ 解析只切第一个冒号；页大小归一化（缺省 20 / 0 取默认 / 超界截断到 50）；`rootsTruncated` 三态（相等 / 截断 / 防御性「回传多于可见」）；**过滤后切页不重不漏**（可见性过滤位置在排序之前）；排序兜底（`sort_order` 相同按 `member_id` 升序；`created_at` 相同按 `theme_id` 升序）；**后台成员短名单**：细粒度状态三态（`missing` 优先于 `deleted`、否则原样透传）+ 与 `visible` 的组合（`visibility=published` 且无公开版本 ⇒ `visible=false`）、成员游标委托主题游标解析（共用可达稳定码、只切第一个冒号）、后台成员全序翻页不重不漏 / 末页游标 `None` / `limit=0` 取默认 / 超界截断、以及「切页复用 `sort_theme_members` + 同一归一化函数」的源码断言 |
+| 事务（`spacetime-module`） | 同主题同根重复 upsert 只有一行且 `created_at` 不变；跨主题同根两行并存；非根入成员被拒；成员作品下架 / 软删除后**行还在**、公开投影不含它、重新公开后自动回来；归档主题不出现在公开列表；`theme_id` 服务端生成且形如 `theme-*`；`created_by_user_id` 取自 admin 会话主体；`updated_at` 每次更新刷新；**后台成员名单**：不套公开可见性过滤 / 不要求主题已发布 / 复用共享排序切页纯函数 / 不 `.delete(`，且 `totalMembers` 在切页**之前**取（结构断言）；行快照复用 `game_distribution_theme_member_visible` 并把 `visibility` 交给模块侧纯函数，作品行缺失不跳过 |
+| api-server 路由 | 公开列表 200 / 匿名可读 / 非法游标 400 / 末页 `nextCursor === null`；公开详情 404（不存在、`draft`、`archived`）与 200 空 `roots`；作品详情 `themes` 增量（只含公开主题；**第 N 代作品按其根查到所属主题**）；两条公开路径都带 `Cache-Control: no-store`；后台**六条**路由未带 admin 会话一律 401、非 admin 令牌 403；后台写：空 `name` / 非法 `status` 400、未知 `theme_id` 404、作品不存在 404、非根 409、同键重放 `replayed: true`、同键不同请求 409、`DELETE` 重复调用 200；后台成员名单：非法游标 400 `THEME_INVALID_CURSOR`、主题不存在 404 `THEME_NOT_FOUND`、响应键集合（列表 4 键 / 单条行 6 键）与 `title` / `nextCursor` 的 `null` 语义 |
+| 契约 | DTO parity 含新构建器（`public_theme_detail_payload` 的 `mustEmit` 含 `rootsTruncated`；后台 `admin_theme_members_payload` / `admin_theme_member_row_payload` 分别钉住列表与单条行）；TS 类型与 Rust DTO 逐键一致 |
+| 前端 | 主题列表（渲染 / 空态 / 失败态 / 加载更多）；主题页多棵树（mock 两个根各自 `lineage`）与「已发布但空成员」空态；详情页 `themes` 链到主题页、无主题时不渲染；窄屏布局不撑破 |
+
+### I. 门禁命令与证据
+
+```bash
+# 文档与工作树（本里程碑设计产出）
+npm run check:doc-index && npm run check:encoding && git diff --check
+
+# Rust 侧
+cargo test -p module-game-distribution
+cargo test -p api-server game_distribution
+cargo check --all-targets --manifest-path server-rs/Cargo.toml
+npm run check:server-rs-ddd
+
+# schema 与生成物
+npm run spacetime:generate
+npm run check:generated-bindings
+npm run check:spacetime-schema
+
+# 契约
+npm run check:game-distribution-dto-parity
+
+# 前端
+npx vitest run src/components/game-distribution src/services/gameDistributionClient.test.ts
+npm run typecheck && npm run lint:eslint
+npm run check:nginx-spa-routes && npm run check:pingora-route-parity
+
+# 真实栈端到端（本地夹具脚本，未入库；形状照同族的收藏夹具脚本：
+# 起本地完整隔离实例 + 管理员账号，走真实 HTTP，逐条 check(...) 断言，失败非零退出）
+E2E_ADMIN_USER=<管理员> E2E_ADMIN_PASSWORD=<密码> node <本地夹具脚本路径>
+```
+
+真实栈端到端**没有新增 npm script**：夹具脚本本身未入库（只在本地工作树，路径见本地 `info/exclude`），所以 `npm run` 列表里不会出现指向未入库文件的条目。
+
+**执行状态**：已跑门禁 —— `check:spacetime-schema`（**96** tables）、`check:game-distribution-dto-parity`（**58 组 / 10 构建器**）、`check:encoding`、`check:doc-index`、`git diff --check`、`cargo test`（见下「验收标准」的勾选与「证据要求」的现状）。**未跑**：前端 vitest / typecheck / lint、`check:nginx-spa-routes`、`check:pingora-route-parity`（前端未动，且未新增 SPA 路由）、以及真实栈 e2e（当时本地夹具脚本尚未写上；后续已补并在隔离实例上跑通，脚本未入库）。
+
+## 验收标准
+
+- [x] 两张表与两条成员索引落地；schema 检查通过（96 tables）；生成绑定随 `2fa201e0d` 提交。
+- [x] `theme_id` 由服务端生成、形如 `theme-*`；`member_id` 为 `"{theme_id}:{root_game_id}"`，重复添加同一 (主题, 根) 不产生第二行。
+- [x] 成员只允许根：目标作品有血缘行（非根）时写入被拒绝且不写库（纯函数 `game_distribution_theme_root_acceptable` 单测 + 事务结构断言）；无血缘行的作品可入成员。
+- [x] 同一根可同时属于多个主题，各主题各有独立成员行；作品详情的 `themes` 返回**多值**（DTO 为数组 + parity 钉住）。
+- [x] 公开侧只出现 `status == published` 的主题；`draft` / `archived` 主题的详情与列表均不可见（纯函数单测 + 事务分别断言列表与详情两条路径）。
+- [x] 成员只出现「公开未删且存在当前公开版本」的根；成员作品下架 / 软删除后从投影中跳过但**行不删除**，重新公开后自动回到主题页（可见性委托收藏口径，逐格单测 + `member_row_survives_unpublish_and_returns_after_republish` + 事务「不删行」结构断言）。
+- [x] 主题不存在或未发布时详情返回 404，不返回空壳；已发布但可见成员为空时返回 200 + 空成员列表。
+- [x] 公开主题列表分页沿用既有游标惯例：默认 20、上限 50、超界截断；非法游标 400；`nextCursor` 为真实值且末页为 `null`；排序为 `created_at` 倒序 + `theme_id` 升序兜底，翻页不重不漏。
+- [x] 主题详情的 `roots` 按 `sort_order` 升序 + `member_id` 升序稳定排序，逐条为既有公开作品投影（不泄露对象键、不泄露未公开作品信息）。
+- [x] 作品详情新增 `themes`：**第 N 代作品**（非根）也能看到并跳到其所属公开主题（按根反查），且只含公开主题。
+- [x] 主题列表与详情的 `memberCount` 是**真实可见成员数**（不截断，不含草稿 / 已下架成员）；详情另有 `rootsTruncated` 表示这份 `roots` 被 50 上限截断（`roots` 少于 `memberCount` 时为 `true`，与族谱 `truncated` 同约定）。**注意：`memberCount == roots.length` 不再是不变式**（可见成员 > 50 时故意不等，见「待确认项」的已定口径）。
+- [x] 两条公开主题路径匿名可读且带 `Cache-Control: no-store`。
+- [x] 后台五条路由未带 admin 会话一律 401；鉴权复用既有 `require_admin_auth` + `AuthenticatedAdmin`，不自造。
+- [x] 后台写接口错误码可区分：空名 / 非法状态 400、未知主题 404、作品不存在 404、非根 409、同键不同请求 409；同键重放如实回报幂等重放（错误码映射单测 + 领域错误类型单测；**经真实库存的 404 / 409 等 dev 栈 e2e**）。
+- [x] 后台 `DELETE` 成员重复调用结果相同且成功（幂等），成员不存在不是错误（事务结构断言：响应不含「之前存不存在」）。
+- [x] 后台列表含 `draft` / `archived` 主题；非法 `status` 过滤值返回 400。
+- [x] 后台能读到成员**名单**（`GET …/themes/{theme_id}/members`）：**草稿 / 归档主题也能读**（事务不套 `game_distribution_theme_public_visible`，结构断言），且**含当前不可见的成员**（未公开 / 软删除 / 无公开版本三类都原样返回，不套公开可见性过滤）。主题不存在才是 404 `THEME_NOT_FOUND`。
+- [x] 名单每行 `visible` 与 `visibility` 的组合正确且**不许互相推导**：`visibility` 为 `deleted` / `missing` / 原样透传游戏行可见性，`visible` 复用 `game_distribution_theme_member_visible`；`visibility == "published"` 且**无**当前公开版本时 `visible == false`（刻意的组合，纯函数与事务结构两处钉住）。
+- [x] `totalMembers` 是**成员行总数**（含不可见、**不受分页影响**，事务在切页之前取）；排序稳定（`sort_order` 升序 + 成员主键升序兜底，**复用公开侧同一比较器**）；翻页不重不漏、**末页 `nextCursor: null`**；`limit` 缺省 20 / 上限 50 / `0` 取默认 / 超界截断；**非法游标 → 400 `THEME_INVALID_CURSOR`**（可达的稳定码，用模块真实产出的文案钉住）。
+- [x] 后台成员名单未带 admin 会话 → 401（同码同形），**非 admin 令牌 → 403**（复用既有 `require_admin_auth`，不自造）；响应键集合由 DTO parity 两个构建器分别钉住（列表 4 键 / 单条行 6 键），`title` 与 `nextCursor` 的 `null` **必须发出键**。
+- [ ] 公开前端：共创 Tab 能列出主题并进入主题页；主题页按成员根渲染**多棵树**（复用 `/games/{id}/lineage`）；已发布空主题显示空态；详情页 `themes` 能跳到主题页。**等前端**
+- [ ] 新增路由在桌面与窄屏可用，且 `check:nginx-spa-routes` / `check:pingora-route-parity` 通过。**等前端**
+- [x] 契约同步：DTO parity 通过（58 组 / 17 构建器 / 15 手拼类型）；数据契约表文档随表落地补齐（`2fa201e0d`）。
+
+**已落地（本条补）**：后台成员**名单读**接口——原缺口「后台要成员名单只能借道**公开投影**（`GET /api/game-distribution/themes/{theme_id}`），而公开投影只服务 `published` 主题，于是**草稿 / 归档主题在后台看不到成员**」已随 `GET /admin/api/game-distribution/themes/{theme_id}/members?limit=&cursor=` 补掉：不套公开可见性过滤、含当前不可见成员、每行带 `visible` / `visibility` 两个独立口径，`draft` / `archived` 照常可读。技术方案侧同步写在 §3.4 后台表与 §3.10.8。
+
+**勾选口径**：勾选项由已落地的纯函数单测 / 事务结构断言 / api-server 定向测试 / DTO parity / schema 门禁证实；**未跑真实 dev 栈的端到端整链**（本地夹具脚本（共创主题） 未创建），所以凡依赖真实库存的运行时分支（未知主题 404、作品不存在 404、同键换请求 409、下架→重公开自动回归等）目前只到单元 / 结构 / 映射层。第 17 / 18 条（前端）**等前端**。
+
+## 证据要求
+
+**现状**：自动化已覆盖纯函数 / 事务结构 / api-server 定向 / 契约 / schema；**运行时**（真实本地栈整链、浏览器桌面与窄屏）**未跑**，本地夹具脚本（共创主题） **未创建**——「证据要求」的运行时与脚本两项仍缺。
+
+- 自动化：`module-game-distribution` 纯函数单测（可见性 / 排序 / 游标 / 根约束）、`spacetime-module` 事务断言、api-server 路由与错误码定向测试、DTO parity、schema 与生成绑定检查、前端 vitest、`check:encoding` / `check:doc-index` / `git diff --check`。
+- 运行时：真实本地栈上完成「建主题（draft）→ 加两个根成员 → 发布 → 匿名读列表与详情 → 作品详情看到主题 → 把一个成员下架（从投影消失、行仍在）→ 重新公开（自动回来）→ 归档主题（公开侧不可见、行仍在）→ 后台列表仍可见」整链；浏览器在桌面与窄屏走一遍共创 Tab 与主题页。
+- 边界：已发布但零可见成员、非根作品入成员、跨主题同根、非法游标、末页游标、未知主题 404、未带 admin 会话 401、重复成员写入、`DELETE` 不存在成员。
+- 脚本：本地夹具脚本（共创主题） 的 `check(...)` 计数与失败项；脚本头部按既有惯例列出「契约来源」与「与工单描述不一致、按实现断言」的条目。
+
+## 待确认项（需用户 / 产品拍板）
+
+- **主题级排序口径**：本方案按「沿用既有游标惯例」把公开列表排在 `created_at`（倒序）+ `theme_id`（升序兜底）上，`sort_order` 只用于**主题内成员排序**与后台列表。若产品要求共创 Tab 按运营 `sort_order` 展示，需要把游标改成 `(sort_order, theme_id)` 双键并同步前端——**这会改一次接口契约**（已按现状实现，改需另开一轮）。
+- **主题详情 `roots` 的 50 上限行为（已定口径，2026-10-06）**：原「三个备选」里采纳 ③：`roots` **保留** 50 上限（`get_game_distribution_theme_detail_tx` 里走 `GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX`），**但 `memberCount` 改为报真实可见成员数**（不再取截断后的 `roots.len()`，列表与详情都走 `game_distribution_theme_member_count`），并新增布尔信号 `rootsTruncated`：仅当 `roots` 少于 `memberCount` 时为 `true`（纯函数 `game_distribution_theme_roots_truncated`），与族谱响应的 `truncated` 同约定，客户端可据此提示「仅显示前 50 个」。未采纳 ①（去上限：一次性放大响应体积）与 ②（成员独立游标：契约从「一次拿全」改成翻页、须配套成员游标）。同步写在技术方案 §3.4 / §3.10.6 / §3.10.9。
+
+## 已知留白
+
+主题封面图、slug / URL 别名、埋点与统计、主题内「跳到某一代节点」高亮、批量树端点、主题级联归档时的成员清理、后台管理 UI。理由与将来接法见技术方案 §3.10.9 与本文件「不在范围内」。
+
+（原缺口「后台要成员名单只能借公开投影 ⇒ 草稿 / 归档主题看不到成员」**已落地**为后台成员名单读接口，见上文 §C / §D / §F 与「验收标准」；后台**管理 UI** 仍是留白。）
diff --git a/docs/project-memory/plans/【里程碑】创作族谱与衍生列表-2026-10-03.md b/docs/project-memory/plans/【里程碑】创作族谱与衍生列表-2026-10-03.md
new file mode 100644
index 000000000..ef58bccfb
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】创作族谱与衍生列表-2026-10-03.md
@@ -0,0 +1,48 @@
+# 【里程碑】创作族谱与衍生列表
+
+| 字段        | 值                                                    |
+| ----------- | ----------------------------------------------------- |
+| Version     | 1.0                                                   |
+| Status      | proposed                                              |
+| Date        | 2026-10-03                                            |
+| Parent Spec | `docs/【技术方案】游戏共创与作品Fork-2026-10-03.md` |
+
+## 目标
+
+任意作品的读者都能看到以母版为顶的创作族谱树，并从任一节点进入对应作品；作者能在自己的作品页看到「被改编」的直接衍生作品列表。
+
+## 范围
+
+- 族谱读取：以某个作品的根为顶，返回各代节点（标题、作者、代际、父作品、公开状态、游玩数），按代际与创建时间稳定排序，超出上限截断并如实标注。
+- 网页新增族谱页面与路由，含根节点、分支、当前作品高亮、节点跳转、空态与失败态。
+- 作品详情页的族谱入口。
+- 我的作品页的「被改编」入口与直接衍生作品列表弹层。
+- 来源作品已下架或封禁时节点的降级展示。
+
+## 不在范围内
+
+- 共创主题（平台命名的归组实体）与广场共创分区。
+- 族谱的排序算法、热度权重、推荐位。
+- 树的可视化交互增强（缩放、拖拽、导出图片）。
+- 收益或流量回馈的任何计算。
+
+## 依赖与前置条件
+
+- 「游戏共创授权与血缘」里程碑已通过验收。
+- 「成品包改造闭环」里程碑产生的真实数据用于端到端验证（仅展示层不依赖它，但真实链路验证需要）。
+
+## 验收标准
+
+- [ ] 三层链路作品打开族谱页，根节点为母版，各节点代际与父作品关系正确，点击任意节点进入对应详情页。
+- [ ] 未登录用户可以浏览族谱页，不触发登录门禁；已下架但仍有血缘的节点保留在树上并标注原作品不可用，不出现空白或断链。
+- [ ] 超出节点上限时如实标注已截断，不静默丢弃；空族谱（无任何衍生）给出明确空态而不是报错。
+- [ ] 我的作品页「被改编」列表只包含直接衍生作品，数量与族谱树中该作品的子节点一致。
+- [ ] 族谱与衍生列表的公开数据不泄露未公开作品、被隐藏内容或对象键；**锚点（URL 里点名的作品）必须公开可读**——未公开、已软删除或不存在的作品，两个接口一律返回 404，不得用「空标题占位节点」或空树代替 404（那等于确认该作品存在、其代际与血缘位置）。
+- [ ] 灰度未命中时族谱入口不渲染，直接访问路由给出与现役未知路径一致的降级行为。
+- [ ] 桌面与移动端布局可用，长标题与较大数字不撑破容器。
+
+## 证据要求
+
+- 自动化：族谱与衍生列表的排序、截断、可见性过滤定向测试；路由与前端组件定向测试；DTO 一致性与编码、文档索引检查。
+- 运行时：真实数据上打开族谱页与「被改编」列表，包含一条来源已下架的链路；桌面与窄屏浏览器验证跳转与布局。
+- 边界：无衍生作品的空族谱、超上限截断、来源下架、未公开子作品不出现在树中、未公开/已软删除锚点返回 404、未登录访问。
diff --git a/docs/project-memory/plans/【里程碑】成品包改造闭环-2026-10-03.md b/docs/project-memory/plans/【里程碑】成品包改造闭环-2026-10-03.md
new file mode 100644
index 000000000..a3fc7aceb
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】成品包改造闭环-2026-10-03.md
@@ -0,0 +1,77 @@
+# 【里程碑】成品包改造闭环
+
+| 字段        | 值                                                    |
+| ----------- | ----------------------------------------------------- |
+| Version     | 1.1                                                   |
+| Status      | proposed（**未拍板前不得实现**，见下方前置决策）      |
+| Date        | 2026-10-03（2026-10-04 按只读侦察的事实重写）          |
+| Parent Spec | `docs/【技术方案】游戏共创与作品Fork-2026-10-03.md`（口径见 §2.5、§3.5.1、§3.5.4） |
+
+> **改名说明**：本里程碑原名「成品包改造闭环」，其「改造」隐含「改完能再发布」。2026-10-04 的只读侦察证明成品包路径**只能试玩、不能重新发布**（事实见下），因此本里程碑的对外名称为**「参考式改编（只试玩 + 素材 + 血缘，不含重新发布）」**；文件名保持不变以免断链。
+
+## 前置决策（未拍板前不得实现）
+
+1. **对外表述**：是否接受「只能试玩 + 素材复用，不能一键复刻工程」？建议接受并同步改文案（AGC 侧注释 `apps/ai-game-creator-shell/src-tauri/src/project/export.rs:407-408` 已把无 `package.json` 的静态项目排除在发布合同外）。
+2. **血缘承载位**：血缘只作为客户端本地注释（项目内独立文件），还是要平台可查询（服务端新增字段）或随工程包传输（manifest 升 v2）？建议先本地，等工程源包里程碑落地再上平台字段。
+3. **是否立刻做工程源包（M2b）**：它是「一键复刻完整工程」的唯一正解路径，但需要新增「工程包下载/授权接口」（当前不存在）。建议先做本里程碑验证需求。
+4. **唤起方式**：AGC 内手工输入 gameId / 平台取件码 / deep link（当前 `tauri.conf.json` 未注册 scheme、无 `tauri-plugin-deep-link` 与单实例插件，需动安装器与升级链路）？建议手工输入起步。
+5. **是否允许「伪工程」兼容存量**：补一个声明 phaser 4 + vite 的 `package.json` 让成品包过检——产出不可再构建，建议不允许。
+
+## 目标
+
+用户能在作品详情页把别人的已公开作品拿到本地，**对照试玩、复用其中素材**，并在**自己新建的合规工程**里完成改编与发布；发布后溯源、代际与署自动正确。整条链路**复用平台已存在的成品包**，作者侧不需要任何新增上传动作。
+
+> 目标里没有「把成品包改完直接发布」这一句——它不成立（见「事实依据」第 2、3 条）。
+
+## 事实依据（本里程碑的能力边界由这四条钉死）
+
+1. **试玩成立**：客户端 `validate_project_game_entry`（`apps/ai-game-creator-shell/src-tauri/src/project/verification.rs:49-66`）只要求入口是 HTML 文档、引用可解析（`:68-100`），与 `package.json`、构建脚本无关。
+2. **发布不成立**：导出/发布的唯一入口 `export_local_project_package`（`src-tauri/src/commands/desktop.rs:1148-1156`）→ `export_local_project_package_for_publish_at`（`export.rs:259-306`），其中「已有可玩入口」的静态入口分支（`export.rs:262-265`）**仍然无条件调用 `ensure_publish_project_stack(root)`**（实检 `export.rs:413-459`，调用点 `export.rs:463-468`）：`package.json` 必须声明 phaser 主版本 4（`:440-453`）且声明 vite 依赖或存在 `vite.config.*`（`:398-410`、`:454-458`）。注释与反例测试见 `export.rs:407-408`、`:1239-1243`。该分支**不要求 build 脚本**（`resolve_publish_build_plan` 只在「无入口」分支调用，`export.rs:266-273`）。
+3. **成品包里没有工程**：`collect_project_export_package_files`（`export.rs:770-804`）只收 `dist` 树 + 根 `assets/` + `exports/README.md`，**不含 `package.json` 与源码**（发布前归一化还会剥掉 `game/` 前缀并要求包根 `index.html`，`export.rs:527-534`、`:582-584`）。
+4. **平台没有包下载通道**：作者侧路由只有 create/upload/chunk/complete/reset/submit/get_owner_version/cancel，作者侧 payload 不回对象键或下载地址（`server-rs/crates/api-server/src/modules/game_distribution.rs:3029-3041`）；对外只有公开发行网关**逐文件**读取，且只服务**当前已公开版本**（`:395-421`、`:800-863`），扩展名受限（`server-rs/crates/module-game-distribution/src/release.rs:36-64`）。
+
+⇒ 三条合起来：**把成品包铺成项目只能试玩，发布必然被拦，也无法从包里补出合规工程声明**。
+
+## 范围
+
+- 受鉴权的内容下发入口（只服务成品包）：只对满足授权与公开性条件的请求开放，不下发可直接匿名访问的对象地址。
+- 客户端：下载 → 摘要校验 → 解压 → 以「可玩参考」形态在本机建成副本（可试玩、可提取素材）→ 项目内记录来源并在界面展示。
+- 客户端：为用户提供**新建合规工程**的路径，并在其中带上血缘（来源声明随发布写入），使「在自建工程里改编后发布」能留下正确溯源。
+- 从平台作品唤起客户端的入口。
+- 发布链路自动携带来源声明，不要求用户手填。
+- 客户端发布面板的共创授权选择与相应提示。
+- 能力边界的如实告知：界面必须写明「成品包只能试玩与提取素材，**不能直接重新发布**」，不能让用户以为拿到了可发布工程。
+
+## 不在范围内
+
+- 把成品包补成可发布的工程（补声明 `package.json` 的「伪工程」路线已否决；见前置决策第 5 条）。
+- 工程源包的上传、下载与源码形态建项（见「作品工程源包与一键改造」里程碑）。
+- 网页端手填来源声明。
+- 创作族谱页面（见「创作族谱与衍生列表」里程碑）。
+- 相似度比对、收益分成、游玩次数上报。
+
+## 依赖与前置条件
+
+- 「游戏共创授权与血缘」里程碑已通过验收（授权与血缘的数据合同、状态机、灰度入口）。
+- **新增**「按版本读取/下发成品包」的受鉴权接口——当前不存在（事实依据第 4 条），需连同大小与内存策略一并设计（服务端读包整包进内存 + 进程内缓存上限 4 条 / 256 MiB，`api-server/src/modules/game_distribution.rs:926-958`、`:101-104`；客户端 `fetch_limited_bytes` 整包进内存、上限 512 MiB、无 Range 无续传，`src-tauri/src/template_library.rs:564-591`；分片能力只有上传侧，`src-tauri/src/game_package_upload.rs:96-105`、`game_package_upload/runtime.rs:353-363`）。
+- 客户端现有的「从包安装并建项」基座、解压路径门禁可直接复用，不新建第二套解压路径；但**建项形态必须区分**：先铺成品包文件与先建空工程在现有 `create_npm_scaffold` 判据下互斥（`src-tauri/src/project/manifest.rs:609-613`），两条都要就得由 fork 流程自己写 `package.json` / `vite.config.*`（既有做法可参照 `src-tauri/src/template_library.rs:816-905` 的「先复制模板文件、再调标准初始化」）。
+- 决策：前置决策 5 项拍板通过。
+
+## 验收标准
+
+- [ ] 授权为「禁止共创」的作品不出现改编入口；绕过界面直接请求内容入口同样被拒绝。
+- [ ] 未登录、无授权、来源作品未公开或已下架时，内容入口全部拒绝，且不泄露摘要与地址。
+- [ ] 客户端在真实环境中完成「详情页 → 唤起客户端 → 下载 → 建项」：摘要校验失败时不留半成品目录，成功时新副本**可直接试玩**。
+- [ ] 界面明确告知该副本**不能直接重新发布**（不得出现「改完即可发布」类文案），并给出「新建合规工程」的可用路径。
+- [ ] 在自建合规工程里改编后发布的作品，详情页显示正确的来源、代际与衍生关系；代际与根由服务端计算，客户端无法伪造或覆盖。
+- [ ] 未携带来源声明的发布路径（旧客户端、网页端）不产生血缘，也不因此报错。
+- [ ] 账号切换或退出后，迟到的下载与建项响应不得写入任何本地项目或项目来源信息。
+- [ ] 移动端不出现需要桌面端才能完成的改编动作，或明确给出桌面端提示。
+- [ ] 灰度未命中时改编入口不渲染，写接口返回服务不可用。
+
+## 证据要求
+
+- 自动化：内容入口鉴权与可用性拒绝用例、客户端下载/摘要校验/解压门禁/建项的定向测试、发布链路携带来源的用例、DTO 一致性与编码、文档索引检查。
+- 运行时：真实 api-server + 真实对象存储 + 真实客户端跑通「看别人的已公开作品 → 本地试玩并提取素材 → 在自建工程里改编 → 试玩 → 发布 → 溯源与代际正确」，附对比截图或录屏。
+- 文案：核对产品与技术文档、AGC 界面、网页入口三处都不出现「成品包可直接发布 / 一键复刻完整工程」的表述。
+- 边界：越权下载、无授权下载、来源已下架、摘要不符、解压失败、账号切换后的迟到响应、旧客户端发布不产生血缘。
diff --git a/docs/project-memory/plans/【里程碑】游戏共创授权与血缘-2026-10-03.md b/docs/project-memory/plans/【里程碑】游戏共创授权与血缘-2026-10-03.md
new file mode 100644
index 000000000..5ad60aa8c
--- /dev/null
+++ b/docs/project-memory/plans/【里程碑】游戏共创授权与血缘-2026-10-03.md
@@ -0,0 +1,63 @@
+# 【里程碑】游戏共创授权与血缘
+
+| 字段        | 值                                                    |
+| ----------- | ----------------------------------------------------- |
+| Version     | 1.0                                                   |
+| Status      | implemented-local（本地实现完成；已 rebase 到含 #565 的新 master 并收敛软删除语义；运行时端到端与浏览器验证待补） |
+| Date        | 2026-10-03                                            |
+| Parent Spec | `docs/【技术方案】游戏共创与作品Fork-2026-10-03.md` |
+
+## 目标
+
+作者可以对自己的作品设置「共创授权」，之后只能单向提升；所有浏览者能在作品详情页看到授权状态、代际与溯源信息；公开页展示真实作者署名。
+
+## 范围
+
+- 作品级共创授权三态（禁止共创 / 允许非商用共创 / 允许全开放共创）的持久化、默认值与单向提升规则。
+- 作品级血缘关系（父作品、来源版本快照、根作品、代际）的持久化与查询，创建作品时对来源的完整校验。
+- 详情页：授权徽章、溯源卡（改编自《X》· 由 Y 制作）、代际与衍生数量。
+- 我的作品页：授权三态设置（仅允许提升，终态只读）。
+- 后台游戏管理：授权与代际的只读展示。
+- 公开页作者署名取真实账号资料，不再落到兜底文案。
+- 端到端灰度开关与前端入口联动。
+
+## 不在范围内
+
+- 改造内容的下发与客户端建项（成品包路径见「成品包改造闭环」里程碑，源码路径见「作品工程源包与一键改造」里程碑）。
+- 创作族谱页面与衍生作品列表（见「创作族谱与衍生列表」里程碑）。
+- 共创主题（平台命名的归组实体）。
+- 收益分成、流量回馈、相似度反洗稿校验。
+- 游玩次数上报。
+
+## 依赖与前置条件
+
+- 主规范 §3 的数据模型与状态机已评审通过。
+- 决策（2026-10-06 已拍板，取代原待拍板项）：授权默认值——**母版**创建缺省仍为「禁止共创」；**衍生作品**在创建时**继承父作品当时的档位**（不接受客户端另选，也不做收窄）。其余合同不变，见技术方案 §2.3 / §3.9 补充。
+- 决策：是否引入共创主题实体需产品拍板；本里程碑不依赖该实体。
+
+## 验收标准
+
+- [x] 新建作品的初始授权为拍板结果：**母版**取请求值（缺省「禁止共创」）、**衍生作品**继承父作品当时的档位（创建时快照）；迁移前已存在的作品在升级后仍按其行上的原值解释，无需人工回填。
+- [x] 同一次授权变更里，合法提升（含跳级）成功、任何降级被拒绝且不写库。
+- [x] 非作品作者不能变更授权；基于旧值的并发请求按期望值冲突拒绝。
+- [x] 重复提交同一授权变更请求不产生第二次副作用，如实回报为幂等重放。
+- [x] 声明血缘时：来源作品不存在、未公开、已被封禁、**已被软删除**（#565 的 `deleted_at`）、授权为禁止、来源版本不等于来源作品当前公开版本，各类情形全部失败关闭且给出可区分的原因（已删除与未公开统一返回 `FORK_SOURCE_NOT_AVAILABLE`，不用错误码区分删除事实）。
+- [x] 代际与根作品由服务端计算：三层链路（A→B→C）得到 B 为第 1 代、C 为第 2 代，且 B、C 的根作品都是 A。
+- [x] 血缘不可变：同一作品第二次声明血缘被拒绝；既有作品复用身份的场景不接受血缘声明。
+- [x] 来源作品下架、封禁或**软删除**后，既有衍生作品保持公开，新的血缘声明被拒绝；衍生数量只统计未软删除且已公开的子作品。
+- [x] 详情页展示的授权、代际、溯源与衍生数量与后端一致；来源作品不可读（含已软删除）时该节点降级为「原作品已不可用」，不空白、不回显被删作品标题。
+- [ ] 公开详情与广场展示真实作者名与头像（读时联账号表），兜底文案不再出现在可正常读取账号的场景；现役公开 DTO 未暴露陶泥号，如需展示须另加字段。（实现已落地：`useGameAuthorDisplayName` 按作者 ID 补查昵称，公开 DTO 未加陶泥号字段；暂无专用断言，故不勾选。）
+- [x] 公开响应不泄露对象键、未公开作品或未公开来源信息（含：父/根作品被软删除后不再输出其标题与作者名）。
+- [ ] 发布开关收紧时，共创授权写入返回 `503 GAME_DISTRIBUTION_PUBLISH_DISABLED`；开关状态读取失败按关闭处理。（M1 复用现役 `game-distribution:publish` 开关，不新增独立灰度键。）（路由已接 `ensure_publish_enabled`，含读开关失败按关闭；暂无 503 断言用例，故不勾选。）
+
+## 证据要求
+
+- 自动化：领域规则单测（授权状态机、代际与根计算、血缘校验）、发行模块与 BFF 定向测试、共享 DTO 一致性检查、生成绑定与 schema 检查、编码与文档索引检查。
+- 运行时：真实 api-server + 本地数据库上完成「设置授权 → 提升 → 声明血缘 → 详情页展示 → 父作品下架后新声明被拒」整链 smoke；浏览器在桌面与窄屏检查详情页与我的作品页。
+- 边界：未登录、非作者、期望值不匹配、重复请求、来源作品六种不可用情形（不存在 / 未公开 / 已被封禁 / 已被软删除 / 授权禁止 / 来源版本不匹配）、父作品下架与软删除前后对比。
+
+## 实施记录
+
+- 2026-10-04：rebase 到含 #565（作品管理与 Phaser4 客户端发布）的新 master，9 个冲突文件按「两侧业务逻辑都保留」解完；详情页按 #565 的新结构改用共享 `GameDetailDisplay`，共创卡改由 `infoCards` 槽位渲染；并按 #565 的软删除语义收敛三处（来源校验 / 衍生计数 / 溯源摘要）。冲突解法与具体落点见技术方案 §3.9.1–§3.9.2，门禁与验收证据见 §5.1。
+- 2026-10-06：按产品拍板收敛「授权继承」口径（取代「衍生作品落默认 `forbidden`、作者自己提升」）：创建游戏事务在带血缘声明时取**父行当时的档位**写入新行（`resolve_game_distribution_fork_declaration_tx` 把父档位一并返回，新增纯函数 `resolve_game_distribution_creation_fork_authorization` 承载「衍生继承 / 母版按请求值」的裁决），客户端传值一律忽略且不报错；**收窄入口不做**；`PUT …/fork-authorization` 的只升不降语义当时**未改**（同日第二笔收紧，见下一条）。口径与落点见技术方案 §2.3 / §3.9 补充，证据见 §5.3。既有按旧语义写的两个 e2e 脚本（本地夹具脚本（族谱/血缘） 富树段、`scripts/capture-game-lineage-visual.mjs`）需要按新语义改成「创建后不再从 `forbidden` 提升」，本轮未改（不属本工作树权限），见 §5.3 的遗留项。
+- 2026-10-06（同日第二笔）：**衍生作品的授权档位收敛为「终态」**。上一笔只改了创建（继承父档位），但 `PUT …/fork-authorization` 仍对任意作品开放「只升不降」，作者可把继承来的 `nonCommercial` 再提成 `full`，得到比祖先更宽的子作品，把父作品在非商用授权下公开的工程内容变成可用商用。现在：**存在血缘行（衍生作品）→ 任何 PUT 一律拒绝**（含传同值），新稳定码 `FORK_AUTHORIZATION_INHERITED` → 409；判定在 `set_game_distribution_fork_authorization_tx` 里**先于 CAS**，规则抽成纯函数 `module_game_distribution::resolve_fork_authorization_promotion`（衍生终态 → CAS → 只升不降）；母版语义完全不变。验收标准里「授权状态机」一项据此理解为「母版单向提升 + 衍生作品不可改」。口径见技术方案 §2.3 / §3.4 / §3.9 第二条补充，证据见 §5.5，决策理由见 `decision-log.md` 同日条目。
diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index 285ffe921..02da06b3c 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -15,6 +15,67 @@
 - 影响范围：`server-rs/crates/api-server/src/modules/game_distribution.rs`（`game_media_object_key_belongs_to_game`、`ensure_owner_media_object_key` 及其单测）；权威说明同步到后端数据契约、玩法链路与技术方案。
 - 验证方式：`cargo test --manifest-path server-rs/Cargo.toml -p api-server modules::game_distribution`（58 passed，含新增 `owner_media_object_key_is_authorized_by_game_namespace_not_current_row`）、`cargo fmt --all --manifest-path server-rs/Cargo.toml -- --check`。
 
+## 2026-10-07 共创页「被共创 N 次」指标、图谱下清单改响应式网格、总览图标、详情页两个主动作改名
+
+同一轮四小件（用户逐条口径，均已落地并真机取证）：
+
+1. **共创页卡片指标位 = 「被共创 N 次」（不是游玩次数）**。用户原话：「并非游玩次数，而是共创次数」（截图圈的是卡片标题行右侧那处）。做法：共享卡 `GameCard` 新增**可选 `metric` 槽**（不传 = 原来的「N 次游玩」，默认行为一字不改），只有 `scope="forkable"` 的共创页传；**封面角标「共创 N」删除**（同一张卡只留一处计数）。文案选**被动式「被共创 N 次」**：避免「共创 N 次」读成主动语态，且平台已有「累计被共创次数」词汇；`aria-label` 同名。突出方式：`--platform-accent-strong`（实测 `rgb(199,101,61)`）+ `700` + `0.72rem`（默认指标 `0.66rem` / `--platform-text-soft`）+ `Sparkles` 12.8px 图标 + `tabular-nums`。**0 要显示**（「被共创 0 次」= 还没人接着做）；只有两个字段都缺省才退回默认游玩数、不伪造 0。取值 `coCreationCount ?? forkCount`（服务端 `ffd751014` 已上线该键，实测 45/45 条带键，分布 0/1/2/3/5/7；「富树分支 B1」`forkCount=1` 而 `coCreationCount=2` ⇒ 两键口径确实不同）。
+2. **图谱下方「父代 / 子代」清单改响应式多列网格**。用户原话：「一行一个太奢侈了，你整小一点，响应式布局」。根因：两段清单用了两套容器——父代是 `grid`、子代是 `flex column + 54rem`，后者一张卡占满一行、16:9 封面被拉到 ~850×480。现在两段共用 `.lineage-relation__grid`（`repeat(auto-fill, minmax(10rem, 1fr))` + 容器 `max-width: 54rem`），实测 1440 **5 列** / 1024 **5 列** / 390 窄屏 **2 列**；卡宽 160–200px（比画布卡 212/148 窄一档，仍**同一个** `GameCard`，差异只由 `.lineage-relation__item` wrapper 表达）；卡内标题单行省略、留白与字号收紧；封面仍 16:9 `object-fit: cover`。删掉随之失效的 `.lineage-relation__list` / `__row` / `__main`。
+3. **「总览」图标换成向内收拢**。用户原话：「改成向中间的箭头，因为现在这个就是起到这个作用的」。原用 lucide `Expand`（四角向外）与动作 `fitToView(true)`（缩小到装得下整棵树）**方向相反**；换成同一对反向图标里的 **`Minimize`**（箭头指向中间）。文案 / `aria-label` / `title` 保持「总览」不变（描述结果而非动作）。同栏逐个核对：缩小 `Minus` ✅、读数 `NNN%` ✅、放大 `Plus` ✅、刷新 `RefreshCcw` ✅、无搜索（`ZoomIn/ZoomOut` 已被测试钉住不得回归）；测试新增 `Minimize` 必在 / `Expand` 不得回归的源码级断言。
+4. **详情页主操作行两个按钮定名**：`立即玩` → **`开始游戏`**（与游玩页启动按钮同一词表）、`一键开始共创` → **`开始共创`**（与玩家侧同一词表，两侧差别只在样式：共创者侧实心 lg / 玩家侧次要小按钮）；未登录侧 `登录后开始共创` 不变。两个按钮都没有单独 `aria-label`，无障碍名 = 可见文本，因此随之自动一致。**已改（2026-10-07 用户拍板）**：共创广场 hero 的「立即试玩」→ **「浏览作品」**（它的动作是滚动到列表、不启动作品；两个 scope（游戏广场 / 共创广场）共用同一个按钮）。
+
+- 影响面：`packages/shared/src/components/GameCard/index.tsx`（新增 `metric` 槽）、`src/components/game-distribution/{GameGalleryPage,LineageRelationLists,GameLineagePage,GameDetailPage}.tsx`、`src/components/game-distribution/gameDistribution.css`、`packages/shared/src/components/GameDetailDisplay/index.tsx`（注释）、`GameDistributionPages.test.tsx`、`docs/【技术方案】游戏共创与作品Fork-2026-10-03.md`、`docs/【玩法创作】平台入口与玩法链路-2026-05-15.md`。
+- 验证方式：`npx vitest run src/components/game-distribution src/components/platform-entry src/components/creator src/routing src/components/creation-home`、`npm run typecheck`、全仓 `npx eslint . --ext .ts,.tsx,.js,.mjs,.cjs --max-warnings 0`、`npm run check:encoding`、`git diff --check`；真机（只读 `127.0.0.1:8082` + 独立端口 Vite）：共创页 5 张不同值卡（0/1/2/3/5）的文本+颜色+字重、游戏页同作品仍是「N 次游玩」、清单在 1440/1024/390 三档的列数/卡宽/封面比例/溢出、控件栏改前后截图、详情页共创者侧与玩家侧的可见文本与无障碍名。
+
+## 2026-10-07 「共创」从游戏页子页签升为侧边栏顶层入口；共创页卡片显示「共创 N」次数
+
+- 用户口径（原话）：「共创页不应该是游戏页里的子标签，而应该是**侧边栏里的大标签**」；「共创页里的游戏卡片要突出一个**共创次数**（即它有多少个子项目）」。
+- 决策（入口）：桌面侧边栏一级入口改为 `创作 / 项目 / 游戏 / **共创** / 创作者主页 / 我的`（「共创」紧挨「游戏」、同一套 `ActiveRailButton`），窄屏底部 dock 改为 `游戏 / **共创** / 创作者主页 / 我的`（4 列）。两侧都指向**同一个** `GameGalleryPage`（`scope="forkable"`，`/games/co-creation`，请求带 `forkable=1`），**不新建页面、不新建路由**。
+- 决策（子页签删除）：`GameGalleryPage` 与 `GameThemesPage` 里那段「游戏 / 共创」子页签**整段删除**（它只为这个切换而存在）；随之删掉 `GameGalleryPage` 的 `onOpenGallery` / `onOpenThemes` 两个 prop（调用点一并清理，不留兼容壳）。**主题列表页与主题详情路由保留**，入口改为「作品详情 → 所属主题」或直接 URL。
+- 决策（高亮互斥）：`isGamesStage`（游戏区，含共创，决定搜索口语/面板滚动）与**导航高亮**拆开——新增 `isCoCreationStage`，导航用 `isGamesNavActive = isGamesStage && !isCoCreationStage`，保证进共创时高亮「共创」而不是「游戏」。
+- 决策（老链接）：子页签从来只有 `setSelectionStage('game-co-creation', { path: '/games/co-creation' })`，没有自己的路径，因此 **`/games/co-creation` 深链语义不变**、无需重定向；路由表/stage 枚举/标题表本来就有这一项。
+- 决策（共创次数角标）：在**共创页**卡片封面左上（复用共享卡 `GameCard` 的 `badges` 槽 + `pointer-events: none`）显示实心强调色角标「共创 N」，**只在共创页出现**（广场/游戏页不传 `badges`，默认表现零改动）。取值 `resolveCoCreationBadgeCount(game) = game.coCreationCount ?? game.forkCount`，`<=0` 或缺省**不渲染**（不显示「共创 0」）。
+- 口径（2026-10-07 服务端已定稿并落地）：`coCreationCount` = **该作品子树里公开可见的全部后代数（不含自己）**，`forkCount` = **直接子代数量**；两者并存、互不推导（同一张卡上前者 ≥ 后者）。可见性规则与 `forkCount` 同一份（未软删除 + 已公开），已删 / 未公开的后代不进任何一层计数；血缘环 / 自引用按 `visited` 去重，自己永不计数。**公开投影（公开目录 / 公开详情 / 我的收藏 / 主题成员）恒发 `coCreationCount`（没有后代时是 `0`，不是缺键）**，`scripts/check-game-distribution-dto-parity.mjs` 已把它与 `forkCount` 一起钉成 `public_game_payload` 的 `mustEmit`；**作者侧同形响应不发**该键，因此读取方仍按 `coCreationCount ?? forkCount` 取值。计数由 spacetime 在**只读事务里现算**：一次建 `module_game_distribution::PublicDerivativeIndex`（父 → 直接子代血缘边 + 可见性集合）+ 每行一次 BFS 子树计数，不新增表 / 列 / 索引、不落物化计数，api-server 只发键不遍历。前端（`resolveCoCreationBadgeCount`）无需改动。
+- 影响面（本轮，只动 `src/**` + `packages/shared/**` 可加扩展 + `docs/**`）：`src/components/platform-entry/PlatformEntryActiveFlowShell.tsx`（rail + dock + stage 标志）、`PlatformEntryActiveFlowShell.test.tsx`、`src/components/game-distribution/GameGalleryPage.tsx`（删子页签、加角标）、`GameThemesPage.tsx`（删同一行子页签）、`GameDistributionPages.test.tsx`、`src/components/game-distribution/gameDistribution.css`（角标样式，新增块）、`packages/shared/src/contracts/gameDistribution.ts`（可加字段 `coCreationCount?`）、`docs/【技术方案】游戏共创与作品Fork-2026-10-03.md`（§3.4 / §3.6.1 / §3.10）、`docs/【玩法创作】平台入口与玩法链路-2026-05-15.md`（导航基线）。
+- 验证方式：`npx vitest run src/components/game-distribution src/components/platform-entry src/components/creator src/routing src/components/creation-home`、`npm run typecheck`、全仓 `npx eslint . --ext .ts,.tsx,.js,.mjs,.cjs --max-warnings 0`、`npm run check:encoding`、`git diff --check`；真机（只读用户栈 `127.0.0.1:8082` + 独立端口 Vite）：桌面「侧边栏点共创 → 列表（含共创次数角标）→ 点卡进详情 → 返回」、窄屏底部导航一遍、深链 `/games/co-creation` 直达、游戏页（子页签移除后）无死路。
+
+## 2026-10-07 Fork 建项收口：成品包铺进预览根、登记可运行原型与初始工程版本
+
+- 背景（真 bug，用户实测）：用户在 AGC 里 Fork 了一个只发布过成品包的作品（`source: package`），项目建出来之后**运行页签不可用**——只显示「首个可运行原型尚未完成，运行视图暂不可用」，点击无反应，发布也被同一判据拦下。实物证据：`%APPDATA%/world.genarrative.ai-game-creator/projects/gameagent-a74aa1d9`（2026-10-06 15:27:58 建项）的 manifest **16 个 seed 任务全 `pending`（含 `code-prototype`）、没有 `versions[]`、没有 `preview`**，小到一个 296 B 的默认占位 `game/index.html`；父作品那套真实可玩产物（`index.html` + `assets/index-*.js` + 素材）被解到 `reference/<gameId>/` —— 该目录**不在预览根**，`preview::project_game_root()` 与服务预览的 `resolve_preview_path()` 都走不到，AGC 界面也没有任何入口能播它。
+- 根因：Fork 建项（`game_fork.rs` 的 `create_project_from_platform_fork_at`）只做「解压 → `init_local_game_project_at`（脚手架 + 全新 manifest）→ 写 `.agent/fork-source.json`」，**没有**像 AI 直连回合收口那样登记「本项目已有可运行原型」与工程内部版本；而运行视图与发布导出读的恰恰就是 `manifest.tasks[code-prototype] == completed`（或存在运行中的预览）这一条事实（前端 `view/project-development/index.tsx` 的 `runAvailable`、后端 `project/export.rs` 的 `project_has_runnable_prototype`）。用户自己那个正常项目 `gameagent-c3af9c7e` 恰是 `code-prototype: completed` + `versions: [initial-10]` 这一对——两者对比即根因。
+- 决策（D1 口径，产品 2026-10-07 拍板）：**成品包 fork 之后允许零改动直接发布**，语义就是「fork 完即可用」——把父作品成品铺进**预览根**并在**同一次收口**里登记可运行原型，用户点运行/发布应立刻可用。同步更正 §3.5.1 / §2.5 里「成品包只能试玩、不能发布」的旧结论（那是按 M2a 落点假设写的，已过期）：真正的能力边界只剩「取到的成品里没有源码，核心逻辑要在自建工程里重做」。
+- 决策（落点）：成品包整包解到 **`fork_playable_root` = `preview::project_game_root(root)`（本形态即 `game/dist`）**，**不再写 `reference/<gameId>/` 副本**。理由：运行视图只服务预览根，铺在别处的副本用户既看不到也播不了；两份副本会让「哪份是事实源」含糊并白占磁盘；来源与形态事实由 `.agent/fork-source.json`（v2）承担。安全性：平台发行包契约保证入口固定在包根 `index.html`（服务端 `validate_release_zip` + api-server 的 `package_entry_path` + AGC 发布侧归一化三处一致），解到预览根后就是 `<预览根>/index.html`；`game/dist` 同时被工程源包排除清单覆盖（`project_bundle.rs`），**不会**把父作品产物当成作者源码重新上传。
+- 决策（收口，照既有模式、不另发明）：`game_fork.rs` 新增 `register_forked_project_state_at(root)`，在 fork 已持有的项目写锁内按既有顺序写入——`update_manifest_task_status_at("code-prototype", Completed)`（**仅当预览根确有 `index.html`**）→ `advance_agent_runtime_project_revision_locked` → `append_agent_game_iteration_version_at`（首条即 `initial-1`）→ `emit_game_creator_manifest_invalidated(root, "game-fork.project")`，最后重读 manifest 返回（避免把过期快照交给进项目通道）。与 `agent/direct_runtime/mod.rs:4181-4194` 同一套模式；不使用无守卫的 `set_task_status`（`pitfalls.md` 记过它有两条竞争写入路径）。
+- 决策（D2 工程源包形态，产品 2026-10-07 拍板）：**不在 fork 时自动构建**——与既有「不自动安装或覆盖导入/用户修改过的工程」策略一致（源码包本身也不含 `game/dist`）。因此该形态**如实不标记完成**：只写 `versions == [initial-1]`，`code-prototype` 保持 `pending`；**文案诚实化**：运行页签不可用时按清单事实分叉（`src/view/project-development/runUnavailableHint.ts`）——已有工程内部版本时说「已有工程内容但还没有可运行的构建产物：让智能体完成可运行原型后即可运行」，全新项目保留原句「首个可运行原型尚未完成，运行视图暂不可用」。
+- 决策（D3 既有数据，产品 2026-10-07 拍板）：**不做一次性迁移**（不写补丁代码）。修复只对新 Fork 生效；既有 fork 项目（含上面那个实物）请**重新 Fork 一次**。
+- 不做：不新增 manifest 字段（manifest 是 `deny_unknown_fields` 的 v1 契约；改编来源仍只写 `.agent/fork-source.json`）；不引入「本项目自己的构建已发生」这条新判据（D1 允许零改动发布，故不需要把运行门禁与发布门禁拆成两套事实）；不改平台契约、`server-rs/**`、`src/**`、`scripts/**`。
+- 影响面（AGC 客户端 + 文档）：`apps/ai-game-creator-shell/src-tauri/src/game_fork.rs`（落点、收口、来源校验、用例）、`src-tauri/src/project/export.rs`（`project_has_runnable_prototype` 提升为 `pub(crate)` 供断言）、`src/view/project-development/runUnavailableHint.ts`（新）+ `index.tsx`（一行接线）、`apps/ai-game-creator-shell/tests/runUnavailableHint.test.ts`（新）、`tests/appSurface/project-development.suite.ts`（两条 fork 形态投影用例）、`docs/【技术方案】游戏共创与作品Fork-2026-10-03.md`（§2.5 / §3.5 头注 / §3.5.1 / §3.5.2 下载与建项 / §3.5.4 / §5 验收矩阵 / §5.8 / §6 M2a 行）。
+- 验证方式：`cargo test --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml -- game_fork`（成品包形态断言 `game/dist/index.html` == 包内入口、`code-prototype == Completed`、`versions == [initial-1]`、`project_has_runnable_prototype == true`、无 `reference/`；工程源包形态断言 `code-prototype == Pending`、`versions == [initial-1]`、无 `game/dist`）、`cargo check --tests`、`cargo fmt --check`、AGC 两个 tsconfig `typecheck`、`npx vitest run apps/ai-game-creator-shell/tests`、全仓 eslint、`npm run check:encoding`、`git diff --check`。真机留档（截图/录屏）待客户端重建后执行：Fork 一个无工程源包的已公开作品 → 运行看到父作品画面 → 改源码 → build → 发布 → 详情页出现溯源。
+
+## 2026-10-06 衍生作品的共创授权档位是终态：禁止 PUT 修改（新码 `FORK_AUTHORIZATION_INHERITED` → 409）
+
+- 背景（真漏洞）：上一轮「创建时继承父作品档位」只堵住了创建，`PUT /api/game-distribution/games/{gameId}/fork-authorization` 仍是「任意作品、只限方向不限对象」。继承是「创建时快照等值」，于是一个继承到 `nonCommercial` 的衍生作品可以被作者再提成 `full`——得到一个**比祖先更宽**的子作品，把父作品在非商用授权下公开的工程内容变成可用商用。
+- 决策：**衍生作品的档位是终态**，只由继承决定。判定 = 「该作品**存在血缘行**」（有父即衍生，不接受客户端自称）→ 直接拒绝，稳定错误码 **`FORK_AUTHORIZATION_INHERITED`** → **409 CONFLICT**（与既有 `FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED` 同为 409，码不同），文案「衍生作品的共创授权由父作品继承，不能自行修改」。
+- 口径（照此实现）：**衍生作品的任何 PUT 都拒绝**，含「传同值」这种幂等重试——客户端因此不会遇到「有时成功有时失败」的随机性。母版（无血缘行）语义**一律不变**：只升不降（可跳级）+ `expectedForkAuthorization` CAS + 幂等重放。
+- 判定落点（一个事务的一步）：`server-rs/crates/spacetime-module/src/game_distribution.rs` 的 `set_game_distribution_fork_authorization_tx`——**幂等重放分支之后、CAS 之前**查 `game_distribution_lineage().game_id().find(&game_id)`，把 `has_lineage_row` 连同 `current` / `expected_fork_authorization` / `target` 交给新增纯函数 `module_game_distribution::resolve_fork_authorization_promotion` 一次裁决（顺序：**衍生终态 → CAS → 只升不降**，失败都不写库）。衍生判定放在 CAS 之前是有意的：同一个衍生作品不会因为载荷不同（传同值 / 传新值 / 期望值过期）而回不同的码。判据只有这一份实现（事务里不再出现 `can_promote_to`，也不自己比 CAS 期望值）。
+- 错误码可达性三件套：模块 `Display` 产出 `"{CODE}: 中文"`（码常量 `GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE`，Display 插值它）；api-server 的 `FORK_` 映射表登记该码（409）；纳入既有「FORK 码由模块真实文案可达」枚举测试（并保留「未登记码退化成 `FORK_ERROR`/409」的反证）。
+- 测试改动：**没有既有 Rust 用例断言过「衍生作品 PUT 提升会成功」**——Rust 侧此前对该路径只有「未知档位 → 400 信封」与「路由未带 Bearer → 401」两条用例。故本轮的测试是**新增**：`module-game-distribution` 的 `derivative_put_is_rejected_even_with_the_same_or_stale_value`（同值 / 再提一级 / 期望值过期都回同码）、`master_put_still_promotes_with_unchanged_cas_semantics`（母版提升照旧 + 同级 / 降级 / CAS 不符语义未变）、`errors.rs` 的前缀断言，`spacetime-module` 的结构断言 `set_fork_authorization_tx_rejects_derivatives_before_cas`（血缘行先于裁决、裁决先于写库），api-server 的可达性枚举 + 常量字面量断言。断言旧语义的是 本地夹具脚本（族谱/血缘） / `scripts/capture-game-lineage-visual.mjs`（不属本工作树权限，见「遗留」）。
+- 契约与形状：**无列 / 表 / 索引 / DTO 形状变更**，只新增一个错误码常量与错误变体；`GameDistributionSetForkAuthorizationRequest` 的 serde 形状未动（幂等摘要不变）。
+- 文档：技术方案 §2.3（授权模式 + 状态机）、§2.4（`/games/mine`、`/games/publish`、`/games/lineage`）、§2.6 时序图、§3.3 状态表、§3.4（`PUT` 行、`POST /games` 行、公开详情行、`/lineage` 行）、§3.9 新补充、§5.3 遗留、§7 第 2 条；数据契约文档的 `fork_authorization` 条目；里程碑日志。
+- 顺带写清的三条口径（无代码）：① `/lineage` 的**累计世代数由前端自算**——本作品子树的深度 = 子树最大代际 − 本作品代际（根作品若有 3 层后代则为 3），服务端不提供该字段；② 改动说明**已在版本摘要 payload 上**（公开详情 `currentVersion.changeSummary`，衍生为字符串、母版 `null`），族谱页右侧面板只对**选中节点**请求一次公开详情即可拿到——**不做 N+1、不给 `LineageNode` 贴该字段**；③ **衍生作品不会继承到 `forbidden`**：父作品为 `forbidden` 时不允许共创（`403 FORK_NOT_AUTHORIZED`），根本产生不出衍生作品。
+- 遗留（不在本次工作树权限内）：两个 e2e 脚本里对衍生作品的 PUT 现在**一律**回 409 `FORK_AUTHORIZATION_INHERITED`（不再只是 CAS 不符），需改成「按新继承档位断言 / 只对母版提升」——由 `scripts/**` owner 并行改写。前端侧已接：`MyGamesPage` 对衍生作品隐藏提升入口、改为只读展示（`4f888d8c9`），AGC 发布面板同轮改为只读展示「授权继承自父作品」；`/lineage` 世代数按子树深度自算、面板读版本摘要层（`bd73acfcc`）。
+- 验证方式：`.worktrees/feat/game-fork` 上自跑 12 条门禁全部 exit 0（wasm build、`cargo check --all-targets`、`cargo test -p module-game-distribution`、`cargo test -p api-server game_distribution`、`cargo test -p spacetime-module`、`cargo test -p spacetime-client`、`check-game-distribution-dto-parity`、`check-project-bundle-policy-parity`、`SPACETIME_SCHEMA_BASE_REF=9f4c7d76 npm run check:spacetime-schema`、`npm run check:encoding`、`cargo fmt --check`、`git diff --check`），逐条 exit 见技术方案 §5.5。
+
+## 2026-10-06 衍生作品的共创授权改为「创建时继承父作品当时的档位」
+
+- 背景：需求文档（rev 1554「发布设置页 → 授权设置区」）要求「**自动继承父作品授权**」，并划掉了「可选择收窄授权，不可放宽」——连收窄也不做。改前的实现是衍生作品创建时落默认 `forbidden`、再由作者自己 PUT 提升，与文档不一致；旧客户端在创建衍生作品时惯常带自己的默认档位。
+- 决策：创建游戏事务的新建分支里，带 `forked_from_game_id` / `forked_from_version_id` 时新行的 `fork_authorization` 取**父行当时的档位**（血缘解析 `resolve_game_distribution_fork_declaration_tx` 现在把父行档位一并返回，它的既有校验「父必须允许共创」不变，因此继承到的档位只会是 `nonCommercial` / `full`）；客户端在请求里传的值**一律被忽略且不报错**。母版维持按请求值（缺省 `forbidden`，未知档位失败关闭）。裁决抽成纯函数 `resolve_game_distribution_creation_fork_authorization(parent, requested)`，让口径可被单测直接钉住（事务需要 `ReducerContext`，起不了真库）。
+- 语义边界：继承是**创建时快照**——父作品之后提升档位不会回溯改写既有子作品的行；因此它与「只升不降」作用在同一行数据上不冲突（提升只改被提升的那一行）。**不做收窄入口**（产品决定 2026-10-06）。
+- 契约与形状：`GameDistributionCreateGameRequest.forkAuthorization` 字段保留、serde 形状（非 `Option` + `#[serde(default)]`）不变——改了会让创建请求的幂等摘要漂移；不新增/删除列，无 schema 迁移。
+- 未改（后被同日「档位终态」决策收紧，见上一条；「原样保留」现在只对**母版**成立）：`PUT /api/game-distribution/games/{gameId}/fork-authorization` 的语义（只升不降、`expectedForkAuthorization` CAS、幂等重放）原样保留；它继续服务「提升」。
+- 影响面：`server-rs/crates/spacetime-module/src/game_distribution.rs`（血缘解析返回值、创建事务、纯函数与测试）、`server-rs/crates/api-server/src/modules/game_distribution.rs`（创建 handler 注释）、`server-rs/crates/shared-contracts/src/game_distribution.rs` 与 `server-rs/crates/spacetime-client/src/game_distribution.rs` 与 `packages/shared/src/contracts/gameDistribution.ts`（字段注释）、技术方案 §2.3 / §3.2.1 / §3.4 / §3.9 / §7、数据契约文档、里程碑文档。
+- 遗留（不在本次工作树权限内）：本地夹具脚本（族谱/血缘） 与 `scripts/capture-game-lineage-visual.mjs` 仍按旧语义「创建衍生作品（落 `forbidden`）→ 再 PUT 从 `forbidden` 提升」，H 段富树还刻意让一个衍生节点保持 `forbidden`；改口径后那些 PUT 会因 CAS 不符返回 409。两脚本在工作树划分里属其它 owner，未改。
+- 验证方式：新增/改写 3 条 `spacetime-module` 用例（继承矩阵 / 母版按请求值 + 未知失败关闭 / 创建事务取父行档位的结构断言），`cargo test -p spacetime-module` 301 passed / 1 ignored；`cargo test -p module-game-distribution` 119 passed；`cargo test -p api-server game_distribution` 104 passed（既有「缺省 `forbidden` 且幂等摘要不变」用例继续通过）；`cargo test -p spacetime-client` 43 passed；wasm build、`cargo check --all-targets`、`check-game-distribution-dto-parity`、`check-project-bundle-policy-parity`、`SPACETIME_SCHEMA_BASE_REF=9f4c7d76 npm run check:spacetime-schema`、`npm run check:encoding`、`cargo fmt --check`、`git diff --check` 全部 exit 0。**没有改动任何 Rust 既有断言**（Rust 侧原本没有断言「衍生作品默认 `forbidden`」的用例；断言旧语义的是上面两个 e2e 脚本）。
 ## 2026-10-07 AGC 命令沙箱原生支持 fnm/nvm：只读挂载窄叶安装前缀，npm 改走 node + npm-cli.js
 
 - 背景：开发构建里 AGC 让命令沙箱执行 `npm run build` / `npm install` 时，宿主 Node 由 fnm 托管，`node` / `npm` 实际是随 shell 会话变化的 fnm multishell 目录里的 shim；bwrap `--tmpfs /run` 会抹掉该路径，而只按单文件挂载 `<前缀>/bin/npm`（它软链到 `lib/node_modules/npm/bin/npm-cli.js`）会因 `Cannot find module '../lib/cli.js'` 失败。此前把宿主 `node` / `npm` / `npx` shim 指到 `/usr/bin/*` 是错误取舍：系统 Node 26 默认启用实验性 Web Storage，会顶掉 vitest 0.34 jsdom 的 localStorage，使 AGC 测试套件在 HEAD 即失败（见 `pitfalls.md` 2026-10-03 条）。
@@ -9953,3 +10014,12 @@ CI 上 `background_agent_runtime_recovers_stale_running_before_pending_task` 在
 - 槽位三态：封面槽位是「空 = 沿用上一版本 / 线上 objectKey = 沿用该键 / 其余 = 本地图带二进制」；截图槽位是「线上 objectKey 或本地路径」。草稿被回写成键后，下一次发布按沿用处理、不重复上传；宿主与前端都按 `GAME_DISTRIBUTION_MEDIA_PREFIX` 前缀先认出键，读文件前分流（AGC `is_game_distribution_media_object_key` + `buildTaonierPublishMetadata` 封面分支）。
 - 预览口径：当前槽位与「上一版本」槽位都按 OSS 同一来源 `object-contain` 显示（本地图走 `IconPreview` 的 `size-24 object-contain`），不再 `object-cover` 裁剪，作者能逐张对照比例；封面草稿是键时按同一 key 从上一版本列表取换签地址，取不到预览时显示「已上传封面」而不是伪装成没有封面。
 - 验证：AGC 单测 `resolve_publish_media_treats_a_rewritten_cover_object_key_as_reuse_not_a_local_file` 与既有 `resolve_publish_media_*`；`taonierExport.test.tsx` 覆盖封面/截图回写、已为键时不重复改写、`buildTaonierPublishMetadata` 封面键分支。
+
+## 2026-10-07：合并 origin/master「游戏共创（作品 Fork）」后的发布链路冲突处理
+
+- 背景：`style/polish-taonier-publish`（统一发布接口）合并 `origin/master`（PR #622 游戏共创 / 作品 Fork，merge-base `b1c89fbb`），17 个文件两侧都改了同一批发布链路。结论是**保留两支能力**：统一 `POST /api/game-distribution/versions` 与旧两步 `POST /games` + `POST /games/{gameId}/versions` 并存。
+- 契约：`GameMetadata` 保留 master 的 `forkAuthorization` / `fork`（ts-rs 手写类型；`fork` 标为可选，渲染层不提交，改由原生链路从 `.agent/fork-source.json` 读取）；`NewGameVersionRequest` 增加可选 `changeSummary`；恢复旧 `GameDistributionCreateGameRequest` / `GameDistributionCreateVersionRequest` 与 `From<&...> for GameMetadata`，并登记 DTO parity。
+- 领域 / 事务：`resolve_version_number` 恢复两参 `(max_existing, requested)` 与 `VersionNumberExhausted`；`spacetime-module` 同时保留统一 `publish_game_distribution_version_tx` 与旧 `create_game_distribution_game_tx` / `create_game_distribution_version_tx`，两条路径复用同一份 `ensure_game_distribution_change_summary`。
+- 修复的功能缺口：统一发布事务此前不处理 `changeSummary`。现按血缘行判定衍生、对衍生作品失败关闭并落库，母版忽略；网页 `gamePublishSubmission` 与 AGC 原生发布都把该字段透传到 `POST /versions`。
+- schema：`local_project_id` → `project_key` 是模块未上线前的硬切改名，继续按 `SPACETIME_SCHEMA_GUARD_ALLOW_BREAKING=1` 走窗口；rollback 为回退 M1/M2 提交。
+- 验证：`cargo check --workspace --all-targets`；`cargo test -p module-game-distribution` / `-p spacetime-module game_distribution` / `-p api-server game_distribution`；AGC `cargo test -- game_fork`；`check:generated-bindings`、`check:game-distribution-dto-parity`、`check:spacetime-schema`、`check:encoding`、`git diff --check`、网页与 AGC 定向 vitest 全绿。
diff --git a/docs/project-memory/shared-memory/pitfalls.md b/docs/project-memory/shared-memory/pitfalls.md
index c14026bc0..347e04bcf 100644
--- a/docs/project-memory/shared-memory/pitfalls.md
+++ b/docs/project-memory/shared-memory/pitfalls.md
@@ -6587,6 +6587,15 @@ Cocos Creator 根目录由 `package.json.creator.version` 与普通 `assets/` 
 - **验证**：`cargo test -p api-server --bin api-server -- game_distribution`（新增 ETag 作用域、`If-None-Match` 列表/弱校验命中、`gzip;q=0` 拒绝、文本压缩与二进制/小文件不压、304 无正文、`*` 对包内缺失路径仍 404 等用例）；`npx vitest run packages/shared/src/components/PlatformGameLoadingSurface.test.tsx`、`src/components/game-distribution/GameDistributionPages.test.tsx`、`apps/admin-web/src/pages/AdminGameDistributionReviewPage.test.tsx`；`npm run check:game-distribution-ops-rollback-e2e` 47 项通过（含压缩/Vary/ETag/304/不接受 gzip 四条新断言）。真实栈同链路复跑：`phaser.min.js` 1,375,976 B → 353,336 B（gzip，4 Mbps 下 2724 ms → 774 ms），用户端游戏画面 3298 ms → 1543 ms、后台试玩 4587 ms → 2694 ms。
 - **关联**：`packages/shared/src/components/PlatformGameLoadingSurface.tsx`、`src/components/game-distribution/GamePlayPage.tsx`、`apps/admin-web/src/pages/AdminGameDistributionReviewPage.tsx`、`server-rs/crates/api-server/src/modules/game_distribution.rs`、`deploy/nginx/README.md`。
 
+## 2026-10-06 合并 master 后 schema guard 的基线盲区：本地全绿、CI 红（表字段相对顺序）
+
+- **现象**：合并 master（merge 提交 `eeb101458`，PR base `9f4c7d76`）后本地整套门禁全绿，CI 的 **Backend tests** 与 **Repository checks** 却都在 `check:spacetime-schema` 红：`表 game_distribution_game 的第 26 个字段从 price_mud_points 变为 fork_authorization，疑似字段顺序被调整`。
+- **原因**：schema guard 对**表的字段相对顺序**是按 index 逐位比对的（`baseTable.fields[index]` vs `currentTable.fields[index]`）；而**不显式给基线时它取 `git merge-base HEAD origin/master`**——merge 提交还没建时那还是**旧 merge-base**，于是「两侧各自在表尾追加」被并成「我们的列插到了 master 的列前面」这件事本地完全看不见；merge 提交一建，基线变成 PR base，CI 立刻红。
+- **处理（现行口径）**：合并 master 后**先建 merge 提交**，再用 PR base 复跑 `SPACETIME_SCHEMA_BASE_REF=<PR base> npm run check:spacetime-schema`。列顺序规则：**master 先追加的列保持原 index，我们的追加排它之后**（`price_mud_points` 第 26 位、`fork_authorization` 表尾）；对应的 `SpacetimeType` 快照（`GameDistributionGameSnapshot`）按同一条纪律排，避免只改表不改快照。
+- **别踩**：`migration.rs` 白名单、DTO parity 成员、nginx SPA 路由、Pingora 路由清单都是**集合/无序**判定（各脚本内部 `Set`/`difference`），只有 **SpacetimeDB 表字段顺序**（以及同步生成的 `module_bindings/*` 里的 wire 顺序）对相对顺序敏感；改列序后必须重跑 `spacetime generate` 并只回写受影响文件。
+- **判据/取证**：`SPACETIME_SCHEMA_BASE_REF=9f4c7d76 npm run check:spacetime-schema`（exit 0）、`cargo check --all-targets` 0、`cargo test -p api-server game_distribution`（101 passed）、`cargo test -p spacetime-module`（294 passed）。
+- **关联**：`server-rs/crates/spacetime-module/src/game_distribution.rs`（game 表与 game 快照的列序注释）、`server-rs/crates/spacetime-client/src/module_bindings/game_distribution_game_{type,snapshot_type}.rs`、`scripts/check-spacetime-schema-guard.mjs`、`scripts/check-repository-ci.sh`（CI 侧基线传法）。
+
 ## 2026-10-07 cc 会话恢复只活在进程内存里，「离开项目再进入」就看不到历史对话
 
 - **现象**：用户反馈「离开后再进入项目，cc 那边看不到历史对话」——聊天面板里的历史还在（`.agent/conversations/project.jsonl` 是 UI 的事实源），但模型完全不知道之前说过什么。
diff --git a/docs/technical/【技术方案】创作者主页与关注粉丝工程设计-2026-10-05.md b/docs/technical/【技术方案】创作者主页与关注粉丝工程设计-2026-10-05.md
index a10d7b7e9..bef890bf4 100644
--- a/docs/technical/【技术方案】创作者主页与关注粉丝工程设计-2026-10-05.md
+++ b/docs/technical/【技术方案】创作者主页与关注粉丝工程设计-2026-10-05.md
@@ -26,7 +26,7 @@
 
 以上新增文件是拟定落点，实施时可按相邻模块组织拆分，但不得建立第二套身份、作品或数据访问系统。不涉及 AGC 桌面客户端、外部 OpenAPI、后台管理页或游戏运行态。
 
-源码已确认：公开游戏列表和“我的游戏”一次最多取 48 项，公开列表 `nextCursor` 固定为 null，前端 `listGames` 只返回数组；游戏广场的设备过滤发生在这份数组上。用户明确本次不额外改造这些现状。创作者主页只增加服务端作者过滤，沿用最多 48 项和原排序，不增加游戏分页、加载更多或新的筛选控件。
+源码已确认（2026-10-05 基线）：公开游戏列表和“我的游戏”一次最多取 48 项，公开列表 `nextCursor` 固定为 null，前端 `listGames` 只返回数组；游戏广场的设备过滤发生在这份数组上。**2026-10-07 变更**：公开游戏目录 `GET /api/game-distribution/games` 已补**真游标分页**（`limit` 缺省 48——即为保持这条既有首屏语义、上限 100、超界截断；`cursor` = `"{createdAtMicros}:{gameId}"`；非法游标 400 `CATALOG_INVALID_CURSOR`；末页 `nextCursor` 为 `null`）。**前端尚未消费该游标**（`src/services/gameDistributionClient.ts` 的 `listGames` 仍只返回数组，属前端跟进的留白）。`/my-games`（“我的游戏”）仍是一次最多 48 项、不分页。创作者主页的作者过滤不变（服务端精确 owner 过滤 + 同一排序），只是过滤后的结果不再被 48 项截死，可继续翻页。
 
 ## 关系模型和授权
 
@@ -98,7 +98,7 @@ type CreatorRelationshipResponse = {
 
 先排除不存在的对端，再计算 total 和分页；读取 limit+1 判断是否还有下一页。同时间多行不漏读，游标主人或类型不匹配返回 400。并发增删不保证多页构成冻结快照，按 userId 去重，刷新从首批开始；不引入跨请求数据库快照或游标持久化表。
 
-作者游戏只扩展现有 `GET /api/game-distribution/games` 的 `authorId`：未传保持原行为，显式空值返回 400；先按稳定 owner ID 和既有公开条件过滤，再排序、截取最多 48 项。现有条件包含 published、未删除及有效公开版本。前端 `GameListQuery` 增加可选 authorId，仍返回现有游戏数组；不修改游戏表结构或引入新的游戏列表系统。
+作者游戏只扩展现有 `GET /api/game-distribution/games` 的 `authorId`：未传保持原行为，显式空值返回 400；先按稳定 owner ID 和既有公开条件过滤，再排序切页（2026-10-07 起该端点自带游标分页，缺省 48 / 上限 100 / 末页 `nextCursor` 为 `null`），不再截死 48 项。现有条件包含 published、未删除及有效公开版本。前端 `GameListQuery` 增加可选 authorId；TS 客户端 `listGames` 目前仍只取数组（未消费 `nextCursor`，留给前端跟进）；不修改游戏表结构或引入新的游戏列表系统。
 
 ## 前端状态与组件责任
 
diff --git a/docs/technical/【技术方案】客户端本地埋点与主站入库契约-2026-09-21.md b/docs/technical/【技术方案】客户端本地埋点与主站入库契约-2026-09-21.md
index 6cc64acbd..ddb65a81d 100644
--- a/docs/technical/【技术方案】客户端本地埋点与主站入库契约-2026-09-21.md
+++ b/docs/technical/【技术方案】客户端本地埋点与主站入库契约-2026-09-21.md
@@ -210,7 +210,7 @@ Direct 的自动登录刷新重试仍属同一个 run。原生单次调用结束
 
 - 触发：新项目初始化完成，manifest 已持久化且稳定 project_id 已确认；覆盖自动创建与用户选目录创建。
 - 公共字段：status=success；project_id 必填；source=editor；任务/run/turn ID 均 null。
-- properties：creation_source=home_game / home_design / template / selected_directory；project_template_id 可选，仅填真实模板稳定 ID。
+- properties：creation_source=home_game / home_design / template / selected_directory / platform_game；project_template_id 可选，仅填真实模板稳定 ID。
 - 打开已有项目、幂等初始化不记创建；文件夹刚建立但后续失败不记成功。
 - 去重事实键：project_id + 本次创建操作 ID + event_name，沿用业务操作身份，不读取路径当项目 ID。
 - 只有成功事件，不能计算创建成功率；创建尝试数不在本版范围。
diff --git a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
index 154ddab81..b887f4a66 100644
--- a/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
+++ b/docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md
@@ -501,6 +501,8 @@ Responses 的终态载荷既是工具调用的恢复源，也是正文的恢复
 - 复用规则：末尾可空列 `project_key` 保存发布方本地项目标识（AGC 的 `manifest.projectId`）。同一 `owner_user_id` 再次以相同 `project_key` 创建游戏时复用既有 `game_id` 并只新增版本，避免“更新”被实现成新建游戏；该字段只是复用提示，不构成所有权或路径凭证，也不能用于跨账号匹配。已软删除的游戏不参与复用：删除后重新发布同一本地项目应得到新的游戏身份。
 - 软删除：游戏行末尾追加可空 `deleted_at`（2026-10-01）。非空表示作者已删除该作品：`delete_game_distribution_game_and_return` 只写该时间戳并把公开投影下线（可见性回到 `unpublished`、撤销当前公开版本、递增 `publication_revision`），版本行、发行包与其冻结资料一律不改写。软删行不进入作者列表（`list_owner_game_distribution_games_and_return`）、公开目录（`list_public_game_distribution_games_and_return`）、公开详情（`get_public_game_distribution_game_and_return`）、公开媒体读取判定（`get_game_distribution_media_read_access_and_return`）与审核队列；后台默认视图同样排除，只有显式 `status=deleted` 才会读到。作者侧版本回读对软删作品返回空（404），因此上传、确认与送审入口一并关闭。
 - 资料编辑：`update_game_distribution_game_metadata_and_return` 覆盖游戏行上的展示字段（标题/简介/详介/分类/标签/封面/截图/设备/输入模式/方向）并立即生效，要求 `expected_publication_revision` CAS；版本行与冻结资料不变，下一次审核通过仍会用新版本的冻结资料覆盖游戏行。**资料编辑不得直接改公开价格**：调价必须走新版本审核。
+- 共创授权：游戏行末尾追加 `fork_authorization: String` 并设置 `#[default("forbidden")]`，取值 `forbidden` / `nonCommercial` / `full`（2026-10-04）。它表达作者对「这部作品能否被改编」的策略，与血缘正交：**母版**只能单向提升（`forbidden → nonCommercial → full`），降级与未知档位失败关闭；旧行按 `forbidden` 解释，旧客户端缺字段同样按禁止共创兜底。**创建时的档位来源分两种（2026-10-06）**：母版按请求值（缺省 `forbidden`）；带 `forked_from_game_id` / `forked_from_version_id` 的**衍生作品继承父作品当时的档位**（创建时快照，父作品之后提升不会回溯改写既有子作品的行），请求里的 `forkAuthorization` 一律被忽略且不报错（旧客户端惯常带默认值），父作品为禁止共创时在血缘解析里就以 `FORK_NOT_AUTHORIZED` 失败，因此继承到的档位只会是 `nonCommercial` / `full`；「收窄授权」不实现（产品决定 2026-10-06）。**衍生作品的档位是终态（2026-10-06）**：存在血缘行时任何 PUT 都被拒——**409 `FORK_AUTHORIZATION_INHERITED`**（与降级同为 409、码不同），含「传同值」这种幂等重试；判定取血缘行且**先于 CAS**（同一衍生作品不因载荷不同而回不同的码），母版的只升不降 + CAS 语义不变。写入只发生在创建游戏（`create_game_distribution_game_and_return` 的 `GameDistributionCreateGameInput`）与提升 procedure `set_game_distribution_fork_authorization_and_return`（输入 `GameDistributionSetForkAuthorizationInput { game_id, owner_user_id, fork_authorization, expected_fork_authorization, idempotency_key, request_digest, now_micros }`）发生：只允许 owner 本人，`expected_fork_authorization` 不符返回 409，同 key 重放走 `game_distribution_idempotency_receipt`（action = `set_fork_authorization`；衍生作品永远写不了这条收据，因此重放分支只服务母版）。`api-server` 把实现值映射为 HTTP 码（`FORK_AUTHORIZATION_UNKNOWN` 400、降级与继承终态各 409、非本人 403、未登录 401），路由 `PUT /api/game-distribution/games/{gameId}/fork-authorization` 受发布灰度开关约束（收紧时 503，读接口不受影响）。
+- 共创授权与软删除的交叉口径：已软删除的作品（`deleted_at` 非空）不再是可用的改编来源——`resolve_game_distribution_fork_declaration_tx` 先判 `deleted_at`，命中即按 `FORK_SOURCE_NOT_AVAILABLE` 失败（HTTP 409，与「未公开」同一错误码，不用错误码区分删除事实）；既有子作品与血缘行不受影响，父作品的删除不会连带下线子作品。衍生计数（`game_distribution_public_fork_count`）只统计 `deleted_at` 为空且 `visibility = published` 的子作品，作者删除子作品后父作品的「已被改编 N 次」随之下降。
 - 买断制定价（2026-10-05）：游戏行末尾追加 `price_mud_points: u64` 并设置 `#[default(0u64)]`；`0` 表示免费，上限 `1_000_000`（复用 `module-game-distribution::normalize_game_price_mud_points` 校验）。价格是版本冻结资料的一部分：作者在 `GameDistributionCreateVersionRequest.priceMudPoints` 提交，写入版本冻结 `metadata_json.priceMudPoints`，只有 `approve_game_distribution_version_and_return` 通过审核时才随资料整体生效到本行；未通过审核或资料编辑都不会改变当前公开价格。公开投影（`get_public_game_distribution_game_and_return` 等）在游戏快照上带出 `priceMudPoints`。
 - 索引：`by_game_distribution_game_owner_user_id` 用于作者私有游戏列表；`game_id` 为主键。公开目录只返回 `visibility = published`、`deleted_at` 为空且活动版本存在、状态为 `published`（有效 `active_version_id`）的投影。
 - 购买与播放鉴权 HTTP（2026-10-05）：`POST /api/game-distribution/games/{gameId}/purchase`（`require_bearer_auth` + 必填 `Idempotency-Key`，请求体 `{ expectedPriceMudPoints }`）经 facade 调 `purchase_game_distribution_game_and_return`，返回 `{ purchase, walletBalance, replayed }`；余额不足 400 `INSUFFICIENT_MUD_POINTS`、价格已变化 409、免费游戏 400、作者本人自购 400 `GAME_PURCHASE_OWNER_EXEMPT`（作者免购买，绝不扣费）、管理员令牌 403 `GAME_PURCHASE_ADMIN_NOT_ALLOWED`（购买只接受普通用户 bearer）、游戏不可见 404、缺幂等键 400、未登录 401。`POST /api/game-distribution/games/{gameId}/play-session` 对免费作品直接回既有公开入口 `/games/{gameId}/`；付费作品同时接受管理员令牌（按现有 admin 鉴权）与用户令牌，已购买 / 作者本人 / 管理员才签发绑定 `gameId + userId`、2 小时有效期的进程内会话，令牌为内存态，进程重启即失效。网关 `GET /api/game-distribution/play-sessions/{token}[/{assetPath}]` 不挂登录中间件、凭令牌读取当前公开版本包，能解析出平台刷新会话 Cookie 时 403，令牌过期 / 不存在、游戏下架 / 封禁或没有有效公开版本一律 404，全部 `no-store`。公开详情 `GET /api/game-distribution/games/{gameId}` 可选鉴权读取查看者：`purchased` 只反映真实购买记录，付费作品对未购买且非作者 / 非管理员把 `currentVersion.entryUrl` 置 `null`（资料与价格仍可见）；`GET /api/game-distribution/releases/{gameId}[/{assetPath}]` 在当前公开版本 `price_mud_points > 0` 时同样 404，付费作品只能经播放会话路径播放。
@@ -510,6 +512,47 @@ Responses 的终态载荷既是工具调用的恢复源，也是正文的恢复
 
 - 统一发布接口与版本号自然幂等（2026-10-07）：`POST /api/game-distribution/versions` 取代 `POST /games` 与 `POST /games/{gameId}/versions`；`metadata` 增加必填 `versionNumber`，删掉 `resolve_game_distribution_version_number` 的 `None => max_existing + 1` 自增分支。无 `gameId` 时以 `projectKey` 为身份锚，`gameId` 由 `(ownerUserId, projectKey)` 确定性派生；新 procedure 在一次 `try_with_tx` 内 get-or-create 游戏行、写入版本行并落一张 `create_version` 收据（`idempotency_key = "{anchor}:v{versionNumber}"`，同键同摘要重放、不同摘要 409，不要求 `Idempotency-Key`）。删掉「同号 pending 被新提交取消替换」逻辑；`request_digest` 口径不变；媒体只解析一次，同一批 objectKey 同时用于游戏行 bootstrap 与版本冻结资料。消费方：AGC `publish_local_project_game` 合并为一次调用；网页 `GamePublishPage` 新建固定 `versionNumber=1` 并持久化生成的 `projectKey`，更新读作者中心 max+1 后冻结。软删后同身份重发成功：模块按确定性 `gameId` 命中已软删行时，就地把它复活覆盖为全新作品（清 `deleted_at`、回到未公开、`publication_revision=0`、清空 `active_version_id` 与 `play_count`/`price_mud_points`、用本次资料覆盖作品级字段），并删除该作品旧的 `create_version` 收据，旧版本号可在新身份里重新发布而不被当作重放或摘要冲突；api-server 仅在显式 `gameId` 恰好等于该 `projectKey` 的确定性身份时进入复活路径，其余不存在 / 非本身份的 `gameId` 仍 404。沿用封面/截图按「当前行媒体 **或** `{GAME_DISTRIBUTION_MEDIA_PREFIX}{gameId}/` 命名空间内的历史媒体」放行，软删后 `current` 为空也能沿用旧 objectKey。详见玩法链路的「游戏分发统一发布接口与版本号自然幂等合同（2026-10-07）」。
 
+### `game_distribution_lineage`
+
+- Rust 结构体：`GameDistributionLineage`，源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`；2026-10-04 新增。
+- 用途：作品之间的改编（Fork）血缘。`game_id` 为主键（子作品），因此「一个作品最多有一个父」由主键本身保证；`owner_user_id`（子作品作者，冗余用于「我改编过的作品」查询，不参与授权判定）、`parent_game_id`、`parent_version_id`（建立血缘时父作品的当前公开版本，不可变事实）、`root_game_id`（0 代母版；根作品自身不写行）、`generation: u32`（直接改编母版为 1）、`created_at`。
+- 写入时机：只在创建游戏时（`GameDistributionCreateGameInput` 携带 `forked_from_game_id` / `forked_from_version_id`，`api-server` 由创作入口的 `fork` 声明映射）与游戏行同事务写入，一次落定后不可变更；同一作品的第二次血缘声明失败关闭（`FORK_DECLARATION_ON_EXISTING_GAME` 409），`local_project_id` 复用既有身份的场景拒绝携带血缘。来源校验全部失败关闭：来源不存在 → `FORK_SOURCE_NOT_FOUND`（404），来源已软删除 / 未公开 / 无有效公开版本 → `FORK_SOURCE_NOT_AVAILABLE`（409），来源授权为禁止共创 → `FORK_NOT_AUTHORIZED`（403），来源版本不等于来源作品当前公开版本 → `FORK_SOURCE_VERSION_MISMATCH`（409）。
+- 索引：`by_game_distribution_lineage_parent_game_id`（衍生计数与今后的衍生列表）、`by_game_distribution_lineage_root_game_id`、`by_game_distribution_lineage_owner_user_id`。
+- 读取口径：公开详情/公开目录的投影增量是 `forkAuthorization`、`forkCount`（按 `parent_game_id` 实时统计未软删除且已公开的**直接**子作品，不维护物化计数）、`coCreationCount`（2026-10-07 新增：**公开可见的全部后代数**，不含自己——同一条可见性规则 `counts_as_public_derivative`，深度不同；在只读事务里**建一次** `module_game_distribution::PublicDerivativeIndex`（父 → 直接子代血缘边 + 可见性集合）后对本页每行做 BFS 子树计数，事务内不落表 / 不新增索引，api-server 只发键）与 `lineage` 摘要快照（`generation` / `rootGameId` / `rootTitle` / `parentGameId` / `parentTitle` / `parentAuthorName`）；母版或旧数据为 `null`/缺省。父作品下架或封禁只影响新的血缘声明，既有摘要照常返回。
+- 溯源摘要与软删除：父（或根）作品被软删除时不再输出它的标题与父作者名——`game_distribution_lineage_snapshot` 把 `parent_title` / `root_title` 置为 `None`、`parent_author_name` 一并清空，`api-server` 原样发 `null`，前端降级为「原作品已不可用」；只保留不透明的 ID 与代际。理由：公开目录/详情既已下线被删作品，若还能从别人的溯源卡里读到它的标题与作者，删除语义就被血缘绕过。表结构同 `migration.rs` 的迁移导入导出白名单（血缘是业务事实，随迁移导入导出）。
+- 迁移：新表初始为空，不需要回填；根作品的「0 代」由「无血缘行」表达。`migration_tables!` 已登记该表。
+
+### `game_distribution_collection`
+
+- Rust 结构体：`GameDistributionCollection`，源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`；2026-10-06 新增。私有表，仅通过受信 API 服务身份的 procedure 与 BFF 提供用户态投影。
+- 用途：登录用户对公开作品的**收藏（收录）**事实——真实服务端投影，不是前端本地状态（既有发行合同禁止虚构收藏状态）。字段：`collection_id: String`（主键）、`user_id`、`game_id`、`created_at: Timestamp`。
+- 防重：主键是确定性构造的 `{user_id}:{game_id}`（`module_game_distribution::game_distribution_collection_id`，与 `profile_save_archive.archive_id` 同一写法），同一 (用户, 作品) 在结构上不可能出现第二行——去重由主键约束本身承担，而不是「事务里先查后写」（那种写法只在单写者假设下成立，分片 / 并发时两个事务都可能先查到「不存在」再各写一行）。因此**不需要**额外的 `(user_id, game_id)` 唯一索引。
+- 索引：`by_game_distribution_collection_user_id`（「我的收藏」按用户读取）、`by_game_distribution_collection_game_id`（按作品维度读取）。
+- 写入时机：`set_game_distribution_collection_and_return`（`PUT /api/game-distribution/games/{gameId}/collection`，要求 `Idempotency-Key`，命中同键收据回 `replayed = true`；主键已存在则跳过写入但仍算成功）与 `unset_game_distribution_collection_and_return`（`DELETE` 同路径，按确定性主键删除，不存在也算成功，天然幂等因此不要求幂等键）。收藏的前置失败关闭：作品不存在 → 404，未公开 / 已软删除 / 没有当前公开版本 → 409（文案 `作品状态不允许收藏（未公开或已软删除）`，`shared_contracts::game_distribution::GAME_DISTRIBUTION_COLLECTION_STATE_CONFLICT` 与 api-server 的 `状态` 子串映射共用同一常量）。取消**不**要求作品仍公开（否则下架后会留下用户清理不掉的脏行）。
+- 读取口径：`list_game_distribution_collections_and_return` 按 `user_id` 索引取行、按 `created_at` 倒序（同刻按 `game_id` 升序）稳定排序，逐条用**既有** `public_game_distribution_snapshot` 投影，只返回当前公开可读的作品（`module_game_distribution::game_distribution_collection_visible`）。下架 / 软删除的行在**投影时被跳过但不删除**，作品重新公开后自动回到列表。公开详情的 `collected` 由 `is_game_distribution_collected_and_return` 单独查询，不改动既有公开快照契约（`api-server` 在登录时把它并入公开详情负载，匿名不发该键）。
+- 迁移：随迁移导入导出（用户态事实），作品下架不删除行。`migration_tables!` 已登记该表。
+
+### `game_distribution_theme`
+
+- Rust 结构体：`GameDistributionTheme`，源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`；2026-10-06 新增。私有表，仅通过受信 API 服务身份的 procedure 与 BFF 提供投影。
+- 用途：平台 / 运营**命名**的「共创主题」——一棵（或一组）作品树的归组实体。主题不是作品的属性，而是运营叙事：作品在游戏 Tab 里仍作为独立作品展示，主题只是额外的归组维度。字段：`theme_id: String`（主键，形如 `theme-*`，由服务端签发、不接受客户端指定）、`name`（运营命名，不是根作品标题的派生）、`summary`、`badge`（角标短文本，本轮与 `name` 共同承担「封面」呈现职责，无封面图列）、`sort_order: i64`（成员排序权重）、`status: String`、`created_by_user_id: String`（创建者审计，不参与鉴权判定）、`created_at: Timestamp`、`updated_at: Timestamp`。
+- 状态口径：`status` 三态白名单 `draft` / `published` / `archived`（`module_game_distribution::GAME_DISTRIBUTION_THEME_STATUSES`）；只有 `published` 进入公开投影（`game_distribution_theme_public_visible`），`draft` 与 `archived` 在公开列表 / 公开详情 / 作品详情 `themes` 里都不可见，后台仍可见全量。归档**不是删除**：行与成员行都保留，语义可逆。
+- 索引：`by_game_distribution_theme_created_at`。公开列表按创建时间倒序 + `theme_id` 升序兜底翻页（游标 `"{created_at_micros}:{theme_id}"`，默认 20 / 上限 50 / 超界截断 / 非法游标 400）；`sort_order` 只用于主题内成员排序与后台列表展示，不参与公开列表排序。
+- 迁移：随迁移导出/导入（运营业务事实）；归档只改变公开投影，不删除行。`migration_tables!` 已登记该表。
+- 读写路径（均已落地，2026-10-06）：公开读列表 `list_game_distribution_themes_and_return`（事务 `list_game_distribution_themes_tx`）、公开详情 `get_game_distribution_theme_detail_and_return`（`get_game_distribution_theme_detail_tx`）；后台写 `create_game_distribution_theme_and_return` / `update_game_distribution_theme_and_return`（`create_game_distribution_theme_tx` / `update_game_distribution_theme_tx`）与后台列表 `list_admin_game_distribution_themes_and_return`（`list_admin_game_distribution_themes_tx`）。私有表，只经 api-server 的受信服务身份调用，不经连接订阅 cache 或前端本地状态伪造。
+
+### `game_distribution_theme_member`
+
+- Rust 结构体：`GameDistributionThemeMember`，源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`；2026-10-06 新增。私有表。
+- 用途：「主题 ↔ 根作品」的运营归组事实。字段：`member_id: String`（主键）、`theme_id`、`root_game_id`、`sort_order: i64`、`created_at: Timestamp`。
+- 只允许**根作品**：根 = 该作品没有血缘行（第 0 代）。判定事实由调用方用血缘点查给出（`game_distribution_lineage().game_id().find(&game_id)` 命中即有行 ⇒ 非根），规则由纯函数 `game_distribution_theme_root_acceptable` 表达；非根写入被拒（`THEME_MEMBER_NOT_ROOT` 409）。理由：主题页呈现的作品树由 `/games/{id}/lineage` **按根**聚合，若允许子作品也入主题，同一棵树会在主题页里出现多次。
+- 防重：主键是确定性构造的 `{theme_id}:{root_game_id}`（`module_game_distribution::game_distribution_theme_member_id`），同一 (主题, 根) 在结构上不可能出现第二行——去重由主键约束本身承担，而不是「事务里先查后写」。因此**不需要**额外的 `(theme_id, root_game_id)` 唯一索引。跨主题的同一根会有**多行**（每主题一行），这是预期行为而不是重复数据。
+- 索引：`by_game_distribution_theme_member_theme_id`（主题页按主题取成员）、`by_game_distribution_theme_member_root_game_id`（作品详情按根反查所属公开主题，因此第 N 代作品也能看到自己的主题）。
+- 可见性：成员只出现在「作品公开未删且存在当前公开版本」时——判定**委托**收藏的同一条口径 `module_game_distribution::game_distribution_theme_member_visible`（内部即 `game_distribution_collection_visible`），不新写第二个同义判定。作品下架 / 软删除时该成员在**投影里跳过但不删除行**，作品重新公开后自动回到主题页；主题详情的 `roots` 与列表 / 详情的 `memberCount` 用**同一判定**（因此成员口径永不漂移），但**两个数在可见成员超过详情响应体积上限 50 时故意不相等**：`memberCount` 报真实可见成员数，`roots` 只回前 50 条，差额由详情响应的 `rootsTruncated` 表达（纯函数 `module_game_distribution::game_distribution_theme_roots_truncated`，与族谱 `truncated` 同约定）。
+- 排序：主题内成员按 `sort_order` 升序 + `member_id` 升序兜底（`sort_order` 允许重复，兜底键保证全序、翻页/渲染不重不漏）；可见性过滤必须发生在排序切页之前。
+- 迁移：随迁移导出/导入（运营业务事实）；归档主题与下架作品都不删除成员行。`migration_tables!` 已登记该表。
+- 读写路径（均已落地，2026-10-06）：公开详情 `get_game_distribution_theme_detail_and_return`（成员投影在 `get_game_distribution_theme_detail_tx` 内按 `by_game_distribution_theme_member_theme_id` 取行）、作品详情 `themes` 增量 `list_game_distribution_theme_refs_for_root_and_return`（`list_game_distribution_theme_refs_for_root_tx`，按 `by_game_distribution_theme_member_root_game_id` 反查）；后台写 `upsert_game_distribution_theme_member_and_return` / `remove_game_distribution_theme_member_and_return`（`upsert_game_distribution_theme_member_tx` / `remove_game_distribution_theme_member_tx`）。私有表，只经 api-server 的受信服务身份调用。
+
 ### `game_distribution_review`
 
 - Rust 结构体：`GameDistributionReview`，源码：`server-rs/crates/spacetime-module/src/game_distribution.rs`；私有表，仅通过受信 API 服务身份的 procedure 与 BFF 提供评价投影。
@@ -545,6 +588,8 @@ Responses 的终态载荷既是工具调用的恢复源，也是正文的恢复
 - 冻结资料：版本表末尾追加可空 `metadata_json`，保存创建版本时由 api-server 校验（标题/简介/分类/标签/设备/方向/必需封面/≤6 张截图/买断制价格 `priceMudPoints`）并从创建请求确定 `coverObjectKey` / 截图 objectKey 后的资料快照；`approve_game_distribution_version_and_return` 通过审核时把该快照整体生效到游戏行，因此公开投影展示的始终是“已随版本审核通过”的资料与价格，旧版本（无快照）保持原值。**价格口径统一为「冻结资料缺 `priceMudPoints` 即免费（0）」**：待审列表、审核详情的版本价与审核通过后生效的游戏行价格都按 `0` 处理，不会回退到游戏行旧价。<code>parse_game_distribution_frozen_metadata</code> 会用 <code>normalize_game_price_mud_points</code> 校验价格上限，越界快照在审核时失败关闭。
 - 作者回读投影：版本回读（作者本人）与审核回读（管理员）在版本 payload 上追加 `frozenMetadata`（冻结快照原样 JSON，历史版本为 `null`）。冻结资料只含 `coverObjectKey` 与截图 objectKey 数组，作者续发时直接把这些 objectKey 放进 `metadata` 的沿用槽位，不需要为了沿用封面或截图重新上传；公开投影仍只暴露 objectKey，不含任何素材 ID。
 - 撤回与回读：`cancel_game_distribution_version_and_return` 只允许把未参与当前公开投影的版本推进到 `cancelled`，并要求 `expected_publication_revision` 与游戏公开修订号一致；`get_game_distribution_version_and_return` 供管理员按版本 ID 直读。客户端看到的 `recoveryAction` 由 `api-server` 按 `status` 派生，不落表。
+- 工程源包（M2b，2026-10-05）：版本行末尾追加三个可空/零默认列 `project_bundle_object_key: Option<String>`、`project_bundle_bytes: u64`（`0` = 未上传）、`project_bundle_sha256: Option<String>`，保存作者**可选**上传的工程源码包（与发行包并列的第二份私有资产）。三列由 `confirm_game_distribution_project_bundle_and_return` 一次性写入（`upload_project_bundle` 幂等动作），只在版本尚未公开（`awaiting_upload` / `upload_failed`）时接受；同一版本已确认工程包后换内容按冲突拒绝，同内容按幂等重放。作品授权非 `forbidden` 时，工程包与发行包走同一道取件鉴权与校验，**平台不设独立的「源码可见性」开关**——作者不传即退化产物级改编。对象键只在服务端使用（投影里只回 `projectBundleBytes` / `projectBundleSha256`），且键名与发行包不同（`.project.zip`），避免同 (作品, 版本) 的两份资产互相覆盖或串缓存。
+- 核心改动说明（2026-10-06）：版本行末尾再追加可空列 `change_summary: Option<String>`（`#[default(None::<String>)]`），保存**衍生作品**发布新版本时必填的「本次核心改动说明」（0 代母版恒为 `NULL`——传了也不校验、不落库）。它是**版本级**事实：同一作品的不同代版本各有各的说明，随版本冻结不可改。由 `create_game_distribution_version_and_return` 在**写库前**校验（失败关闭，不在库里留下没有说明的衍生版本），判据是**血缘行**（不接受客户端自称派生）；长度按 trim 后的**字符**数计、区间 `20–500`（常量 `GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS` / `_MAX_CHARS`），违规走 `FORK_CHANGE_SUMMARY_REQUIRED` / `FORK_CHANGE_SUMMARY_INVALID`（均 400）。公开投影只多下发 `changeSummary`（衍生必有、母版 `null`），不含任何私有字段。
 
 ### 后台游戏管理读模型与恢复动作（2026-09-23）
 
diff --git a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
index ab4f9d5ce..af96c3dbd 100644
--- a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
+++ b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
@@ -100,12 +100,27 @@ npm run dev
 npm run dev:all
 ```
 
-`npm run dev:all` 保持 `npm run dev` 的主站完整栈语义不变，使用 AGC 当前配套后端的数据库 `genarrative-game-creator-dev` 与 data dir `server-rs/.spacetimedb/ai-game-creator/data` 启动一份 SpacetimeDB、BgFilter worker、api-server、主站 Vite 和后台 Vite；待这五个服务就绪后，再启动 AGC Vite 与 Tauri。AGC 通过匹配的 `.app/dev-stack.json` 复用这份后端，且设置 `AGC_DEV_ADMIN_WEB=0`，因此一键入口只保留一份管理后台。该入口不接受覆盖 database 或 SpacetimeDB data dir 的参数；需要独立数据库时分别使用 `npm run dev` / `npm run agc`。
+`npm run dev:all` 保持 `npm run dev` 的主站完整栈语义不变，使用 AGC 当前配套后端的数据库 `genarrative-game-creator-dev` 与 data dir `server-rs/.spacetimedb/ai-game-creator/data` 启动一份 SpacetimeDB、BgFilter worker、api-server、主站 Vite 和后台 Vite；待这五个服务就绪后，再启动 AGC Vite 与 Tauri。AGC 通过匹配的 `.app/dev-stack.json` 复用这份后端，且设置 `AGC_DEV_ADMIN_WEB=0`，因此一键入口只保留一份管理后台。该入口不接受覆盖 database 或 SpacetimeDB data dir 的参数；需要独立数据库时分别使用 `npm run dev` / `npm run agc`。默认会**保留**这个本地库（等价于给根栈传 `--preserve-database`），因此当库内 schema 与源码不一致（SpacetimeDB 报 `needs manual migration` / `Reordering table …`）时 publish 会被拒、根栈随之退出——此时终端会补一段可操作提示（说明是本地 schema 冲突、打印目标库与 data dir），按提示用 `npm run dev:all -- --clear-database` 清掉该本地库重建，或先跑一次不带 `--preserve-database` 的 `npm run dev -- --database genarrative-game-creator-dev --spacetime-data-dir server-rs/.spacetimedb/ai-game-creator/data`；两种做法都会丢弃该本地库里的数据（仅本地开发数据）。
 
 一键入口由自身负责收束根 dev 栈与 AGC 客户端的进程树。AGC Vite marker 可访问后，终端会打印包含 SpacetimeDB、BgFilter worker、api-server、主站、后台、AGC Vite 和 Tauri 窗口的实际地址表；任一子进程异常退出都应停止另一侧并返回非零退出码。端口漂移和运行态地址仍以启动日志及 `.app/dev-stack.json` 为准。
 
 通过 `nohup` 在仓库根目录启动 dev 栈且未显式重定向 stdout / stderr 时，默认 `nohup.out` 会持续收集 SpacetimeDB、api-server、bgfilter-worker、主站 Vite 和后台 Vite 的整套 dev 栈输出；该文件已被主站 Vite watcher 和 Git 忽略，避免日志追加触发页面刷新循环，重启主站 Vite 后生效。若把输出显式重定向到其它仓库内文件（例如 `> dev.out`），该自定义文件不会自动获得同样的 watcher 保护，应改为写到 Vite root 之外，或同步配置精确的忽略规则。
 
+### 本地 e2e / 夹具必须用隔离实例（2026-10-07）
+
+**背景（实际事故）**：夹具类 e2e 脚本过去缺省跟着 `.app/dev-stack.json` 打**用户正在用的开发栈**，而「换端口」并不等于「换库」——`npm run dev` 与早期 pinned 端口那套都指向同一个 `genarrative-game-creator-dev` + 同一份 data dir。结果是跑几轮 e2e 就把夹具写进用户的库：实测盘点时该库有 **105 条作品 = 13 条演示 + 92 条夹具**（族谱 4 轮×9、主题 1 轮×54、收藏 2、工程源包 2、共创授权 2），而公开目录一次只出最新 48 条，用户的共创页几乎被夹具占满。
+
+**要求（这些是纪律，不是建议；本地夹具工具的路径不入库，团队按下面的做法自己准备工具即可）**：
+
+1. **缺省隔离**：任何会往库里写测试数据的脚本，未显式给目标地址时**必须**指向**隔离实例**（专用端口 + 专用库名 + 临时 data-dir），不得回落到 `.app/dev-stack.json` 里用户正在用的那套。
+2. **硬护栏**：脚本在启动阶段就要判定目标——解析出的 api-server 与 `.app/dev-stack.json` 记录的**同地址或同端口**即视为「用户开发栈」，**直接拒绝启动**（非零退出），除非调用方显式越权（`E2E_ALLOW_DEV_STACK=1` 之类）并在提示里写清后果。护栏只管**会写夹具**的脚本；只读工具可以照常读开发栈。
+3. **隔离实例的组成**：专用端口组（api / bgfilter / spacetime / admin-web / web 各一份）、**专用库名**（例如 `*-e2e`，与 `genarrative-game-creator-dev` 区分开）、**临时 data-dir**（跑完删除，另留 `--keep-*` 逃生口）。隔离实例还必须把自己的 dev-stack 标记写到临时目录（`GENARRATIVE_DEV_STACK_STATE_PATH`），**绝不覆盖仓库根的 `.app/dev-stack.json`**，也**不做**「按 exe 路径清旧 api-server」的兜底清扫——两者都会把用户正在跑的那套栈踢下线（2026-10-07 实测踩到并已修）。
+4. **夹具必须可辨识**：统一标题前缀（本仓口径 `E2E·`）+ 统一 tag，盘点/清理不依赖随机后缀；**演示数据**另有自己的前缀（`共创演示·`），两者不得混用。
+5. **跑批后自清理**：脚本正常结束时用本轮 owner 身份把自己造的作品逐条**软删**（owner 维度 `DELETE /api/game-distribution/my-games/{id}?expectedPublicationRevision=…`），并打印删除条数；清理失败或脚本中断时，必须打印**残留清单**（owner + gameId + 标题）便于人工补删。**跑完不留残留**是交付判据之一。
+6. **例外**：演示数据灌装工具**有意**写开发栈（它的用途就是把演示数据放进 dev 栈，且幂等、判重不绑账号），不受护栏约束；要写到别处请显式给目标地址。
+
+**软删的语义**：`DELETE …/my-games/{id}` 只是软删（撤销当前公开版本 + 写 `deleted_at`），公开目录、族谱树、`my-games` 立刻都看不到，但**行仍在库里**、可由后台恢复；已软删的行不会出现在任何列表接口里，所以「清理后列表为空」不等于「行被物理删除」。
+
 单独启动主站前端：
 
 ```bash
diff --git a/docs/【技术方案】游戏共创与作品Fork-2026-10-03.md b/docs/【技术方案】游戏共创与作品Fork-2026-10-03.md
new file mode 100644
index 000000000..a3d6fc96d
--- /dev/null
+++ b/docs/【技术方案】游戏共创与作品Fork-2026-10-03.md
@@ -0,0 +1,1214 @@
+# 【技术方案】游戏共创与作品 Fork
+
+更新时间：`2026-10-03`
+
+> 状态：`draft`（待评审）。评审通过前不写业务代码。
+> 本文件同时作为「游戏共创」的主规范与技术方案；行为合同部分不得绑定类名、文件名和实现算法。
+
+## 0. 结论摘要
+
+1. **Fork 关系挂在 `game`，不挂在 `version`。** `game` 是稳定作品身份，`version` 是不可变内容快照；血缘是「作品 ↔ 作品」关系。唯一留在版本级的是**被复刻的内容本身**（已存在的成品包与新增的工程源包都属于版本资产），因为内容随版本演进。
+2. **现状不存在任何 fork/remix/来源/父作品字段或表。** 旧的「作品改造 / Remix」在网页端已整体退役（`vite.config.ts:16-18,20-59,126-140,170-173` 把退役固化成构建门禁），后端只剩 `#[cfg(any())]` 死码（`module-runtime/src/domain.rs:137`、`api-server/src/state.rs:1317`、`shared-contracts/src/runtime.rs:879-880`）与 CSS 死类名。本功能是**从零建**，没有历史包袱，也不复活 Remix 命名。
+3. **必须区分两种 Fork，它们是两层能力而不是一个开关**：
+   - **成品包 Fork（零新增资产，但它只到「可玩参考」）**：每个已发布版本本来就存着构建产物 ZIP（`game_distribution_version.package_object_key`，`:797`），拿它铺成本地项目可以**试玩**、可以**提取素材**；但**不能重新发布**——包里没有 `package.json` 也没有源码，而 AGC 的导出/发布入口对「已有可玩入口」的项目同样强制 Phaser 4 + Vite 声明（`apps/ai-game-creator-shell/src-tauri/src/project/export.rs:262-265` → `:405-470`，注释与反例测试见 `:407-408`、`:1239-1243`）。详见 §3.5.1。
+   - **工程源包 Fork（真·复刻工程，也是唯一能直接发布的路径）**：成品包是 Vite 构建产物——模板工程 `vite.config.js` 只配了 `build: { outDir: 'dist' }`，**未关压缩也未开 sourcemap**，且平台发行校验明确拒收 `*.map`（`server-rs/crates/module-game-distribution/src/package.rs:171-175`）。所以 AI 在成品包上改核心逻辑不可靠；要让「改造完成后可发布」成立，必须有版本级可选资产**工程源包**。
+   - 两者共用同一套血缘模型；成品包路径是工程源包缺失时（网页端发布、作者不愿公开源码）的天然**降级路径，降级到「试玩 + 素材」，不含发布**。
+4. **工程源包有现成规范与现成客户端链路可复用**：排除规则见 `docs/【模板规范】AGC模板包组织指南-2026-09-21.md`；下载→校验 SHA-256→解压→建项全链路已存在于 `apps/ai-game-creator-shell/src-tauri/src/template_library.rs`（`create_project_from_installed_template_at` `:816`）。
+5. **本期只做贡献归集与归因计算（§3.11），不含资金 / 分成结算**（口径留待产品决定；仓库无收益 / 分成 / 结算表，`docs/【技术方案】外部产品支付服务接入-2026-10-03.md:200` 明确人工结算）；**反洗稿（相似度校验）产品已决定搁置（2026-10-06，见 §2.2 与 §7）**；**不上链**。
+6. **顺带必修的相关缺口（已在 M1 修复）**：公开 `author.name` 长期落到兜底文案（创建游戏时 `author_name` 写死 `None`，`api-server/src/modules/game_distribution.rs:1001-1003`；公开 payload 兜底「创作者」）。修法：公开快照改为读时联 `user_account`，账号改名/换头像立即跟随，与后台游戏管理页同口径。
+
+---
+
+## 1. 现状事实（设计依据）
+
+### 1.1 现役「作品」只有一套：游戏分发
+
+| 形态 | 表 | 状态 |
+| --- | --- | --- |
+| 游戏分发（游戏广场） | `game_distribution_game` / `_version` / `_review` / `_review_moderation_log` / `_idempotency_receipt` | 现役 |
+| 编辑器精选素材 | `editor_showcase_asset` / `_like` | 现役，与作品 Fork 无关 |
+| 公开玩法作品（custom-world / puzzle / 大鱼 …） | `public_work_like` / `public_work_play_daily_stat` / `profile_played_world` + 各玩法源表 | **写入路径全部 `#[cfg(any())]` 死码**，前端路由与组件已删除 |
+
+现役路由唯一真相 `src/routing/activeAppPageRoutes.ts:7-18`，作品相关只有：
+
+```
+/games          游戏广场          src/components/game-distribution/GameGalleryPage.tsx
+/games/detail   作品详情          GameDetailPage.tsx
+/games/play     游玩（iframe）    GamePlayPage.tsx
+/games/mine     我的作品          MyGamesPage.tsx
+/games/publish  发布 / 发布新版本 GamePublishPage.tsx
+```
+
+导航：桌面 rail 创作 / 项目 / 游戏 / 我的（`PlatformEntryActiveFlowShell.tsx:653-682`），移动 dock 游戏 / 我的（`:198-207`）。
+
+### 1.2 游戏 - 版本模型
+
+- `game_distribution_game`（`server-rs/crates/spacetime-module/src/game_distribution.rs:718-764`）：`game_id` PK、`owner_user_id`、资料（标题/简介/分类/标签/封面/截图/设备/输入/朝向）、`publication_revision`（公开修订号 CAS）、`active_version_id`（当前公开版本指针）、`visibility`（`unpublished` / `published` / `suspended`）、`play_count`、`local_project_id`（同作者同本地项目复用身份，**不构成所有权证明**）、`cover_object_key`、`screenshots_json`。
+- `game_distribution_version`（`:766-821`）：`version_id` PK、`game_id` 索引、`owner_user_id` 索引、`version_number`、包摘要（`package_sha256` / `package_bytes` / `package_file_count` / `package_entry_path`）、`status`、`package_object_key`、`package_manifest_json`、`entry_url`、审核人/阶段时间、`metadata_json`（该版本冻结的作者资料快照，审核通过时整体生效到 game）。
+- 版本状态：`awaiting_upload → uploaded → pending_review → published`，失败终态 `upload_failed / validation_failed / rejected / cancelled / revoked`（常量 `:868-877`，枚举 `module-game-distribution/src/domain.rs:42-53`）。
+- 公开性唯一口径：`visibility == published` 且 `active_version_id` 指向 `status == published` 的版本（`:3335-3346`）。
+- 公开读只有 3 条无鉴权路径：列表、详情、发行网关 `/api/game-distribution/releases/{gameId}[/{*asset}]`（`api-server/src/modules/game_distribution.rs:344-363`）。
+- 写操作全部经受信服务身份 procedure；幂等收据 30 天；所有公开切换走 `publication_revision` CAS。
+
+### 1.3 与 Fork 相关的既有能力与缺口
+
+| 项 | 现状 | 证据 |
+| --- | --- | --- |
+| 「能否被 fork」 | **不存在**（旧的 `remixEnabled` 是玩法级死配置） | `module-runtime/src/domain.rs:137`（`#[cfg(any())]`） |
+| 「fork 自谁」 | **不存在**。最近似的只有 `local_project_id` 身份复用，语义是同一作者自己的本地项目 | `game_distribution.rs:1700-1727` |
+| fork 计数 | **不存在**（`remixCount` 是 `#[cfg(any())]` 退役契约里的死字段，零消费方） | `shared-contracts/src/runtime.rs:922,950` |
+| 作者署名 | 字段存在但创建时写死 `None`，公开页兜底「创作者」 | `api-server/.../game_distribution.rs:1001-1003`、`:2390` |
+| 作者主页 / 关注 / 粉丝 | **不存在**（无任何社交关系表） | `migration.rs:149-200` 无相关表 |
+| 收藏 / 收录 | **已落地**（2026-10-06）：`game_distribution_collection` 表 + `PUT/DELETE /api/game-distribution/games/{gameId}/collection`、`GET /api/game-distribution/my-collections`、公开详情 `collected` 字段，是**服务端真实投影**而非前端本地状态（`server-rs/crates/spacetime-module/src/game_distribution.rs`、`server-rs/crates/api-server/src/modules/game_distribution.rs`） | `docs/【玩法创作】平台入口与玩法链路-2026-05-15.md:74` 的「不要虚构收藏状态」条款照旧成立 |
+| 播放次数 | 本分支上 `play_count` 仍**从无递增路径**却被前端展示；PR #565 已新增游玩计数上报 procedure，合并后以 master 结果为准。**显示口径见 §3.6.3**：公开字段仍是自身值，界面上的「游玩次数」按子树合计显示（前端用已有树算，服务端零改动） | `game_distribution.rs:1759`（仅初值）；`GameDetailPage.tsx:292` |
+| 收益 / 分成 | **不存在**；`PuzzleAuthorIncentiveClaim` 有枚举无写入方 | `module-runtime/src/domain.rs:1147` |
+| 从包建项（客户端） | **存在且完整**：下载→SHA-256 校验→解压（拒绝绝对路径/`..`/盘符/反斜杠/符号链接，条目 ≤4096、单文件 ≤256 MiB）→建项→失败删半成品 | `template_library.rs`、`:815-850`、`:240-342` |
+| 工程包排除规则 | **存在**：禁止 `.agent` / `.git` / `.svn` / `node_modules` 段与根 `dist` / `build` / `library` / `temp` / `local` / `.idea` / `.vscode` | `docs/technical/【技术方案】AGC模板库与模板建项-2026-09-17.md`（后台模板上传章节）、`docs/【模板规范】AGC模板包组织指南-2026-09-21.md` |
+| 发行包下载通道（按版本取 ZIP） | **不存在**：作者侧只有 create/upload/chunk/complete/reset/submit/get_owner_version/cancel，作者侧 payload 不回对象键或下载地址；对外只有公开发行网关**逐文件**读取，且只服务**当前已公开版本**、扩展名受限 | `api-server/.../game_distribution.rs:3029-3041`、`:395-421`、`:800-863`；`module-game-distribution/src/release.rs:36-64` |
+| 导出/发布的工程栈前置 | **强制**：唯一导出入口对「已有可玩入口」的项目同样调用 `ensure_publish_project_stack`，要求 `package.json` 声明 phaser 主版本 4 且声明 vite 依赖或存在 `vite.config.*`（不要求 build 脚本）；注释与反例测试均确认无 `package.json` 的静态项目不在发布合同内 | `apps/ai-game-creator-shell/src-tauri/src/project/export.rs:262-265`、`:405-470`、`:407-408`、`:1239-1243` |
+| 发行包内容 | **只含运行产物**：`dist` 树（条目改名 `game/...`）+ 根 `assets/` 兜底 + `exports/README.md`；**不含** `package.json` 与源码 | `apps/ai-game-creator-shell/src-tauri/src/project/export.rs:770-804` |
+
+---
+
+## 2. 产品设计
+
+### 2.1 目标
+
+让平台上的游戏可以被他人**合法地继续改造**，并让改造形成的世代链路可展示、可追溯、原作者可署名。
+
+### 2.2 非目标
+
+- **本期只做贡献归集与归因计算**（§3.11：递归「子代所有的都算父代的」+ 按代际 / 直接子代归因分解），**不做**资金 / 分成 / 版税结算与算力成本核算——无账本、无结算周期、无金额口径，属独立议题；资金与分成口径留待产品决定。
+- **反洗稿（相似度校验）产品已决定搁置（2026-10-06）**：不是没想到，是明确不做——无判定标准，且判定只能基于工程源包做结构化比对，属独立议题；本方案只保证**来源声明不可伪造**（声明只能来自真实取件，见 §3.5.3）。
+- 不做上链；「永久溯源」实现为**不可变的父子链 + 平台持久化事实**。
+- 不做跨作品类型 Fork（现役只有一种作品：游戏分发）。
+- 不做关注 / 粉丝。收藏（收录）原先也在这个「不做」列表里，但**已纳入并落地**（2026-10-06，见 §2.4 / §3.4）：它是服务端真实用户态投影（`game_distribution_collection`），不是前端本地状态，因此仍满足「不要虚构收藏状态」这条既有发行合同。
+
+### 2.3 授权模式（作者侧，作品级）
+
+档位**只写在作品行上**，两种作品的规则不同：
+
+- **母版（0 代作品，没有血缘行）**：作者上架时可选，之后**只能单向提升开放度**（可跳级），请求必须带 `expectedForkAuthorization`（CAS）；降级一律拒绝。
+- **衍生作品（有血缘行）**：档位在创建时**继承父作品当时的档位**，是**终态**——作者既不能收窄（入口整体不做），也不能提升：任何 `PUT …/fork-authorization`（含传同值这种幂等重试）一律 **409 `FORK_AUTHORIZATION_INHERITED`**。若放行，作者就能把继承来的 `nonCommercial` 提成 `full`，得到一个**比祖先更宽**的子作品，父作品在非商用授权下公开的工程内容会因此变成可用商用。
+
+| 值 | 用户可见文案 | 含义 |
+| --- | --- | --- |
+| `forbidden`（母版默认） | 禁止共创 | 仅可游玩，不可复刻改编 |
+| `nonCommercial` | 允许非商用共创 | 可二次开发，禁止盈利，仅可公开分享 |
+| `full` | 允许全开放共创 | 可改编、可商用、可引流、可发布新版本 |
+
+状态机（唯一合法迁移；**提升只发生在母版行上**，衍生作品行一旦由创建写入即不再变化）：
+
+```mermaid
+stateDiagram-v2
+  [*] --> forbidden : 母版创建（请求缺省）
+  [*] --> nonCommercial : 衍生作品继承父档位（终态）
+  [*] --> full : 衍生作品继承父档位（终态）
+  forbidden --> nonCommercial : 母版作者提升
+  forbidden --> full : 母版作者跳级提升
+  nonCommercial --> full : 母版作者提升
+  full --> [*] : 终态（不可降级）
+```
+
+约束：
+- **衍生作品的档位 = 创建时快照的父作品档位**（2026-10-06 产品决定）：创建请求里的 `forkAuthorization` 对衍生作品**一律被忽略且不报错**（旧客户端会惯常带自己的默认档位）；父作品之后提升档位**不会回溯**改写既有子作品的行（提升只改被提升的那一行）。
+- **衍生作品之下没有第二条迁移**（2026-10-06 产品决定，取代「继承的行上还能再提升」的读法）：档位是终态，`PUT` 一律 409 `FORK_AUTHORIZATION_INHERITED`；判定取**血缘行**（有父即衍生），不接受客户端自称，且**先于 CAS**——同一个衍生作品不会因为载荷不同（传同值 / 传新值 / 期望值过期）而回不同的码。母版（无血缘行）的语义完全不变。
+- **衍生作品不会继承到 `forbidden`**：父作品为 `forbidden` 时根本不允许共创（`403 FORK_NOT_AUTHORIZED`），建立不了血缘，因此**产生不出**衍生作品；继承到的档位只可能是 `nonCommercial` 或 `full`。
+- **不做收窄入口**：衍生作品不能选择比父作品更窄的授权（产品决定 2026-10-06，「可选择收窄授权」已从需求中划掉）——「收窄」这条路径整体不实现。
+- 只有 `owner_user_id` 可以变更（非作者 403）；**母版**的提升请求必须带 `expectedForkAuthorization`（CAS），不匹配返回 `409`。
+- **母版**的任何降级请求一律 `409 FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED`，不写库。
+- 已按旧授权完成的 Fork **不受后续提升影响**（授权在建立血缘时已兑现）。
+- **提升与源码的时序**：工程源包只能在版本**尚未公开**时随版本上传（阶段门与发行包确认一致）；作品公开后**不接受**补传（本期不做 backfill），因此「先禁止共创、后提升授权」的作品在其当前公开版本上不会被源码级改造，只能走「试玩 + 素材参考」。提升界面对此如实提示，不作为提升的前置条件。
+
+### 2.4 用户视角入口矩阵
+
+**玩家 / 未登录**
+
+| 位置 | 内容 |
+| --- | --- |
+| `/games` 广场卡片 | `forkedFrom` 存在时显示「改编」角标；不做父子聚合，卡片仍独立展示 |
+| `/games/detail` 详情页 | ① 授权徽章（禁止共创 / 允许非商用共创 / 允许全开放共创）；② 有父作品时显示溯源卡「改编自《X》· 由 Y 制作」+ 可点进父作品；③ 显示「第 N 代作品」与「N 个衍生作品」；④ `forkAuthorization != forbidden` 时显示主行动作「改造这个作品」（未登录点击走既有登录门禁） |
+| `/games/detail` 族谱入口 | 「查看创作族谱」→ `/games/lineage?id=<rootGameId>` |
+| `/games/lineage`（新页面） | 以根作品为顶的树：根节点、各代分支、每代作品卡（封面 / 标题 / 作者 / 第 N 代 / 游玩数），点击进入详情；父作品已下架时该节点显示「原作品已下架」但仍可点；空态与加载失败按现有平台错误组件。**累计世代数（「这棵树往下还有几代」）由前端自算**：本作品子树的深度 = 子树最大代际 − 本作品代际（根作品若有 3 层后代则为 3），服务端**不提供**该字段，前端从同一次 `/lineage` 响应自算，不额外发请求。右侧面板展示选中节点的「本次核心改动说明」时，**只对选中节点请求一次公开详情**取 `currentVersion.changeSummary`（衍生作品为字符串、母版为 `null`）——不做 N+1、不给族谱节点贴该字段（详见 §3.4 的 `/lineage` 行）。两条前端口径均已落地（`bd73acfcc`：世代数按子树深度计算、面板读版本摘要层） |
+
+**作者 / 已登录**
+
+| 位置 | 内容 |
+| --- | --- |
+| `/games/mine` 每张作品卡 | 新增「共创授权」三态设置（**只有母版**有该入口：仅允许提升，终态 `full` 时只读；**衍生作品的档位由父作品继承、是终态**，不提供该入口——入口隐藏已落地（`4f888d8c9`：网页端改为只读展示「继承自父作品」），服务端即使收到 `PUT` 也一律 409 `FORK_AUTHORIZATION_INHERITED`）；新增「被改编 N」入口，弹层列出直接子代（标题 / 作者 / 代际 / 状态）；提升授权后若当前公开版本没有工程源包，行内提示「上传工程源码以支持源码级改造」（上传在桌面端客户端完成，网页端只做引导） |
+| `/games/publish`、AGC 发布面板 | 新增「授权共创」三态单选（默认「禁止共创」，页面提示：开启后可被他人复刻改编，开启后不可撤销）；**上架时随创建请求一起提交**（`forkAuthorization`），不必事后补一次提升；从父作品 Fork 而来时显示只读的「改编自《X》」**且档位由服务端继承父作品当时的档位**——该场景下客户端所选档位不生效（不报错，见 §2.3），且**该作品从此没有「修改授权」入口**（终态）；AGC 发布面板同样只读展示「授权继承自父作品」（同轮改动） |
+| AGC 客户端 | ① 侧边栏「共创」页列出公开目录里 `forkAuthorization != forbidden` 的作品（卡片：封面 / 标题 / 作者 / 类型 / 创建时间），点卡片「开始共创」→ 确认页（标题即「开始共创」）；② `genarrative://fork?gameId=<id>` deep link **已注册**（原生解析 + 聚焦主窗口），带 `gameId` 时**直接落到确认页**、不带时回到「共创」页并如实展示链接原因；③ 手动粘贴作品 ID 的输入块已**移除**（重复入口，口径与理由见 §3.6.2） |
+| `/games/detail` 详情页 | 新增「收藏」按钮（收藏 / 已收藏两态）。初始态取自公开详情的 `collected`（登录才有该字段）；点击后 `PUT` / `DELETE /api/game-distribution/games/{gameId}/collection`，按钮态改用**响应里的权威投影值**（不写本地乐观状态——前端本地状态正是本功能要消灭的东西）。未公开 / 已软删除的作品返回 409，按钮按失败态提示 |
+| `/games/mine`（或「我的」入口）| 新增「我的收藏（收录）」列表：`GET /api/game-distribution/my-collections`，形状与广场一致（封面 / 标题 / 作者 / 游玩数），点击进详情。列表只含**当前公开可读**的作品；已下架作品的收藏行保留，作品重新公开后自动回来（不需要用户重新收藏） |
+
+**后台**
+
+| 位置 | 内容 |
+| --- | --- |
+| `#game-management` 游戏管理 | 列表新增「授权」「代际」列；版本历史弹层不变；不做强制改授权（避免平台替作者背授权责任） |
+| `#game-distribution` 审核队列 | 允许共创的作品审核通过时，若作者未提供工程源包，标注「仅成品包可玩参考，不能直接发布」（不影响发布与审核；口径依据 §3.5.1） |
+
+### 2.5 两个层级的改造能力（必须让作者和用户都看懂）
+
+已公开的作品**总是**有成品包，所以「改造这个作品」按钮对所有开放授权的作品都可用；区别不只是「能改到什么程度」，还包括**改完能不能再发布**——这一点在 2026-10-04 的只读侦察里被否证过一次，必须按事实写：
+
+| 情形 | 用户拿到什么 | 能不能再发布 | 用户可见文案 |
+| --- | --- | --- | --- |
+| 父作品有**工程源包**（AGC 发布且作者选择公开源码） | **源码级复刻**：AGC 下载工程 → 解压为新项目 → 可改源码、可重跑构建、可发布 | 能（前提是源包本身是 Phaser 4 + Vite 工程） | 「改造这个作品」 |
+| 父作品只有**成品包**（网页端发布，或作者未上传工程源包） | **可玩参考 + 素材来源 + 合规工程骨架**：AGC 先把该发行版本的成品包铺进项目**预览根**（`game/dist`），fork 完即可运行，并可提取包内素材（受发行网关扩展名白名单限制，见 §3.5.1） | **能**（2026-10-07 起）：AGC 建项同时生成 Phaser 4 + Vite 合规脚手架并登记「可运行原型」，因此发布入口的「已有可玩入口」分支成立；发布内容是当前预览根——**作者没改就是取到的那份成品产物**（平台仍要求衍生作品填「本次核心改动说明」）。**不能**的是「在取到的成品上重建核心逻辑」：包里没有源码（`export.rs:770-804`） | 「试玩并参考改编」；面板如实写明「本作品只提供已构建成品，**没有源码**：可直接运行与发布，但核心逻辑要在自建工程里重做」 |
+
+两条路径在**用户自建合规工程**里发布时写入**完全相同**的血缘与溯源；不设「作者必须开源才能被改造」的前置条件。
+
+**被否证与被更正的旧表述（保留以便对照）**：原方案写的是「成品包路径 = 产物级改造，项目无需构建步骤即可试玩与发布」、「这条形态 AGC 本来就支持」。2026-10-04 的只读侦察把「发布」判成不成立——依据是当时假设的落点（成品铺在项目里、项目没有 `package.json`，过不了 `ensure_publish_project_stack`）。2026-10-07 落地的 M2b 建项改成「**先建合规脚手架、再把成品铺进预览根**」，同时把「可运行原型」登记进 manifest，于是「试玩」与「发布」**都**成立（事实依据见 §3.5.1「AGC 建项」小节与 §5.8 证据）。真正的能力边界只剩一条：成品包里没有源码，核心逻辑要在自建工程里重做。
+
+### 2.6 关键流程
+
+**A. 作者发起共创**
+
+```mermaid
+sequenceDiagram
+  participant A as 作者(AGC/网页)
+  participant API as api-server
+  A->>API: 发布游戏/版本，携带 forkAuthorization
+  API->>API: 母版：校验三态合法并写入 game.fork_authorization；衍生作品：忽略该值，继承父作品当时的档位
+  A->>API: （AGC 且授权非 forbidden）上传工程源包
+  API->>API: 校验 zip（复用模板包门禁）→ OSS → version.project_bundle_*
+  Note over A,API: 审核通过后作品公开，且可被改造
+  A->>API: 后续修改授权（PUT /games/{gameId}/fork-authorization，仅母版、只升不降；衍生作品一律 409）
+```
+
+**B. 用户一键改造（目标形态；成品包分支只到「试玩 + 素材」）**
+
+```mermaid
+sequenceDiagram
+  participant U as 用户(浏览器)
+  participant AGC as AGC 客户端
+  participant API as api-server
+  U->>U: 详情页点「改造这个作品」
+  U->>AGC: 唤起客户端（方式待拍板：手工输入 / 取件码 / deep link）
+  AGC->>API: GET /api/game-distribution/games/X/fork-source (Bearer)
+  API-->>AGC: {versionId, bundleSha256, bundleBytes, downloadPath}
+  Note over API: 图中的字段名是 M2b 目标形状；M2a 已实现的形状见 §3.4「登录用户」表
+  AGC->>AGC: 下载 → 校验 SHA-256 → 解压（同模板安装门禁）→ 新建项目
+  AGC->>AGC: manifest 写入 forkedFrom{gameId, versionId, rootGameId, generation}
+  Note over AGC: 工程源包可改源码/重跑构建/发布；只有成品包则只能试玩与提取素材（§3.5.1）
+  AGC->>API: POST /games（携带 forkedFromGameId/VersionId）
+  API->>API: 校验授权/来源版本/计算 generation 与 root → 写 lineage
+```
+
+> 说明：本图是**目标形态**。唤起方式已定：**deep link `genarrative://fork?gameId=<id>` 已注册并落地**（原生解析 + 单实例聚焦，带 `gameId` 直接落到 AGC 的「开始共创」确认页，见 §3.6.2；§7 第 10 条的其余候选不再需要）；`GET …/fork-source` **M2a 已实现**（受鉴权元数据 + 取件本体，实际字段与状态码见 §3.4「登录用户」表），但本图里的响应字段名是 M2b 的目标形状，定稿一律以 §3.4 表格为准。
+
+**C. 溯源与命名**
+
+- 溯源卡出现在详情页与 AGC 项目内（项目信息区显示「改编自《X》」）。
+- 代际：根作品 = 第 0 代；直接改编根作品 = 第 1 代；`generation = parent.generation + 1`。
+- 「衍生作品数」= lineage 表按 `parent_game_id` 的计数（实时算，与现有评分实时聚合同口径；不新增物化计数）。
+
+---
+
+## 3. 技术方案
+
+### 3.1 分层与边界
+
+```text
+src/（网页）            详情页/我的作品/族谱页  ←→ /api/game-distribution/**
+apps/ai-game-creator-shell（AGC）
+  React 展示层        发布面板、改造入口
+  Rust facade         工程包打包/上传/下载/解压/建项（复用 template_library 基座）
+api-server            鉴权、灰度、OSS 编排、ZIP 校验、payload 组装
+spacetime-client      typed facade / mapper
+spacetime-module      表、procedure、事务
+module-game-distribution  领域规则（授权状态机、代际计算、血缘校验）
+shared-contracts      Rust DTO  ←→  packages/shared   TS DTO
+```
+
+不新增数据库访问通道；不新增第二套作品系统。
+
+### 3.2 数据模型
+
+#### 3.2.1 `game_distribution_game` 追加 1 列（表尾，带默认）
+
+```rust
+/// 共创授权等级：forbidden（默认）/ nonCommercial / full。只允许单向提升；不改变不写库。
+#[default("forbidden".to_string())]
+pub(crate) fork_authorization: String,
+```
+
+旧行反序列化自动补 `"forbidden"`，与「默认禁止共创」语义一致。写入有两个来源：**母版**按创建请求的档位（缺省 `forbidden`）；**衍生作品**在创建时继承父作品当时的档位（创建时快照，见 §2.3）。
+
+#### 3.2.2 新增 `game_distribution_lineage`（父子血缘，1:1）
+
+```rust
+#[spacetimedb::table(
+    accessor = game_distribution_lineage,
+    index(accessor = by_game_distribution_lineage_parent, btree(columns = [parent_game_id])),
+    index(accessor = by_game_distribution_lineage_root, btree(columns = [root_game_id])),
+    index(accessor = by_game_distribution_lineage_owner, btree(columns = [owner_user_id])),
+)]
+pub struct GameDistributionLineage {
+    /// 子作品；主键即 1:1 约束，一个作品只能有一个父。
+    #[primary_key]
+    pub(crate) game_id: String,
+    /// 子作品作者，冗余用于「我改编过的作品」列表，不参与授权判定。
+    pub(crate) owner_user_id: String,
+    pub(crate) parent_game_id: String,
+    /// 建立血缘时父作品的当前公开版本（不可变溯源事实）。
+    pub(crate) parent_version_id: String,
+    /// 0 代母版；根作品自身不写行，读侧以「无行」判定为根。
+    pub(crate) root_game_id: String,
+    /// 代际；直接改编根作品为 1。
+    pub(crate) generation: u32,
+    pub(crate) created_at: Timestamp,
+}
+```
+
+为什么用独立表而不是在 game 上再加 3 列：
+- 血缘查询必须按 `parent` / `root` 建索引，而这两列在 game 上只能是 `Option<String>`；本仓从未验证过对 `Option` 列建 btree 索引的行为，不拿 schema 赌。
+- 血缘是 1:1 关系实体，主键承载「一个作品只有一个父」这条不变量。
+- 不污染 game 主行读路径（详情页绝大多数请求不需要血缘行）。
+- 事务一致性：创建 game 与插入 lineage 必须同事务，插入失败整笔回滚。
+
+#### 3.2.3 `game_distribution_version` 追加 3 列（表尾，带默认）
+
+```rust
+/// 该版本随包上传的工程源包对象键（不含 node_modules/.git/dist 等，规则见模板包组织指南）。
+#[default(None::<String>)]
+pub(crate) project_bundle_object_key: Option<String>,
+#[default(0u64)]
+pub(crate) project_bundle_bytes: u64,
+#[default(None::<String>)]
+pub(crate) project_bundle_sha256: Option<String>,
+```
+
+工程包跟随版本，**只在版本尚未公开时可上传一次**（已实现口径，2026-10-05）：
+
+- **上传时机**：只允许版本处于 `awaiting_upload` / `upload_failed`（与发行包确认同一道阶段门）；`uploaded`、验证中、待审核、已拒绝、已公开、已撤回、已取消一律拒绝。工程包是**可选**资产：不上传不影响发布与审核。
+- **不可变**：同一版本一旦确认过工程包，**换内容按冲突拒绝**（`409 同一版本已存在不同的工程源包`），同内容按幂等重放（`replayed = true`）；要改内容只能新建版本。
+- **不做版本回溯**：作者 v1 传了、v2 没传，那么 v2 只能走「试玩 + 素材参考」的成品包路径，历史版本不给补。
+- **已公开版本的补传（backfill）未实现**：原方案曾设想「作品公开后可给当前公开版本补传一次」。本期**不做**——上传阶段门与发行包一致，公开后不接受任何内容写入；若产品要这条，需要单独设计（它会是「版本不可变」的例外）。
+- **产品口径（已拍板）**：平台**不做**独立的「源码可见性」开关。作品授权非 `forbidden` 时，工程包与成品包走同一道取件鉴权与校验被他人取走；作者不想给源码，就是**不上传**。「上传与否」本身就是作者的开关，不传即退化为产物级改编。三态授权保留不变，但 `nonCommercial` 的约束力是**平台规则层面**（源码一旦被取走，无法从技术上阻止商用），文档与界面必须如实标注这一点。
+
+对象键：`{GAME_DISTRIBUTION_OBJECT_PREFIX}{game_id}/{version_id}.project.zip`（即 `agc/project-snapshots/v1/game-distribution/{game_id}/{version_id}.project.zip`）——与发行包同前缀族便于生命周期统一，靠 `.project.zip` 后缀区分资产，避免同一（作品, 版本）的两份资产互相覆盖或串用读取缓存。对象键只在服务端使用，投影里只回 `projectBundleBytes` / `projectBundleSha256`。
+
+- **知情同意（2026-10-05 复核后新增，必须落到面板文案）**：校验清单是**黑名单**——作者工程里的 `docs/`、`*.pdf`、`notes.txt`、截图、素材源文件等**不在任何拒绝集内，会被原样外发**。因此发布面板必须写明「**整个项目目录（除少数排除项）会原样公开**」，让作者自己决定要不要把某个文件留在工程里。这不是技术漏洞，而是知情同意要求；技术侧能保证的是「凭据类内容尽量被拦」，不能保证「除源码外什么都不外发」。
+
+### 3.3 状态与流转
+
+| 对象 | 字段 | 取值 | 合法迁移 | 触发方 | 并发控制 |
+| --- | --- | --- | --- | --- | --- |
+| game | `fork_authorization` | `forbidden` / `nonCommercial` / `full` | **母版**：只升不降（可跳级）；**衍生作品（有血缘行）**：终态，任何 `PUT` 都拒（409 `FORK_AUTHORIZATION_INHERITED`，含传同值） | owner | `expectedForkAuthorization` 值 CAS（衍生作品的拒绝先于 CAS，因此码不随载荷变化） |
+| lineage | 全字段 | 创建即不可变 | 无 | 创建 game 时 | 主键冲突 → 409 |
+| version | `project_bundle_*` | 有 / 无 | 只在 `awaiting_upload` / `upload_failed` 时可写一次（未公开前）；写入后不可再改，换内容 → 409 | owner | 与 `confirm_package` 同一幂等键族 |
+
+**血缘建立的服务端校验（全部失败关闭）**：
+
+1. `forkedFromGameId` 必须存在 → 否则 `409 FORK_SOURCE_NOT_FOUND`。
+2. 父游戏 `visibility == published`、`deleted_at` 为空，且存在 `status == published` 的当前版本 → 否则 `409 FORK_SOURCE_NOT_AVAILABLE`（下架 / 封禁 / 已软删除作品不可被新 fork，但不影响既有子作品）。
+3. 父游戏 `fork_authorization != forbidden` → 否则 `403 FORK_NOT_AUTHORIZED`。
+4. `forkedFromVersionId` 必须等于父游戏当前公开版本 id → 否则 `409 FORK_SOURCE_VERSION_MISMATCH`（禁止指向历史版本或伪造）。
+5. 同一 `localProjectId` 复用既有 game 的场景**不允许**携带血缘（避免把既有作品改判成衍生作品）→ `409 FORK_DECLARATION_ON_EXISTING_GAME`。
+6. `generation = parent.generation + 1`；`root_game_id = parent 有血缘行 ? parent.root_game_id : parent.game_id`。服务端计算，不接受客户端传入。
+
+### 3.4 接口契约
+
+所有新增路径沿用 `/api/game-distribution` 命名空间与平台 envelope；作者写路由叠加 Bearer + 发布灰度；读路径 `Cache-Control: no-store`。
+
+#### 公开（匿名可读）
+
+| 方法 / 路径 | 说明 |
+| --- | --- |
+| `GET /games?search=&category=&authorId=&limit=&cursor=&forkable=`（**既有，2026-10-07 补真分页与 `forkable` 过滤**） | 公开游戏目录（游戏广场）。匿名可读 + `no-store`；只含公开可玩的作品（`published` + 未软删除 + 有当前公开版本）。**真游标分页**：`limit` 缺省 **48**（保持既有首屏语义，AGC 共创页首屏就是 48 条）、上限 **100**（约束单响应体量），超界**截断**而非报错；`cursor` 形如 `"{createdAtMicros}:{gameId}"`（与 `/my-collections`、主题列表同一套 `"{micros}:{id}"` 惯例，解析只切第一个冒号）；**游标格式非法 → 400 `CATALOG_INVALID_CURSOR`**（模块侧报错透传，不吞成 200 空页）。响应 `{ games: [<公开作品投影>], nextCursor }`；排序 `createdAt` 倒序 + `gameId` 升序兜底（全序，翻页不重不漏），顺序定义为「**先按可见性过滤、再排序切页**」。**`forkable`（2026-10-07 新增，供 AGC「共创」页）**：真值（`1` / `true`，**大小写不敏感、先 trim**）时只保留**可被共创**的作品（`forkAuthorization != forbidden`）；**省略 / 空 / `0` / `false` / 非法取值（如 `abc`）一律按「不过滤」处理**——非法取值**宽容降级**而不是 400，理由：这是公开只读列表，`forkable` 只是可选的展示过滤，客户端（尤其旧版外壳）拼错一个可选参数不该让整个游戏广场 400；而「不过滤」正好等于本参数出现之前的既有行为，降级既不会多列（相对现状只会少列）也不改变任何既有调用方的语义。过滤**在事务内、切页之前**完成（与可见性过滤同一处、同一序，api-server **不**过滤返回结果），因此禁止共创的作品**不占页名额**、翻页不重不漏、末页 `nextCursor` 仍为 `null`，分页 / 游标语义与不带该参数时逐字相同；**未知档位按禁止解释**（与 `/fork-source` 的 403 判据同一口径，避免列出「点进去必然失败」的入口）。响应形状**不变**（`forkAuthorization` 本来就在公开作品投影里）。**修正的问题**：此前 `limit` 写死 48 且 `nextCursor` 恒为 `null`，库里第 49 条起的作品（含最老的母版与主干）在 HTTP 面永久不可见（客户端只能显示「已检查最新 48 个作品」）——数据一直在、详情与 `/lineage` 都读得到，缺的只是翻页通道。**网页侧已接（2026-10-07）**：`listGames()` 返回 `{ games, nextCursor }` 并支持 `limit` / `cursor` 透传（不再丢弃游标、不再假装「一次拿全」）；游戏广场与创作者主页都在 `nextCursor` 非空时渲染「加载更多」，点击用服务端游标取下一页、**按 `gameId` 去重追加**、加载中禁用、**失败保留已加载内容**并给可读提示、**末页（`nextCursor = null`）自动隐藏入口**。真机实测（真实栈 51 条 published）：首屏 48 条 → 加载更多 → 51 条，最老的 `共创演示·A0/A1/A11` 可见 |
+| `GET /games/{gameId}`（**既有，响应增量**） | 追加 `forkAuthorization`、`forkCount`、`lineage`（可选）。**不追加 `forkSourceAvailable`**：网页端「改造这个作品」入口的显隐只依据 `forkAuthorization`（已公开 + 非禁止即可引导去取件），真实可复刻形态由 `/games/{gameId}/fork-source` 的 `source` 字段回答，不需要在公开详情里提前判断；若 M2b 需要在详情页区分「可源码级改造 / 只能参考」，再在 M2b 里加该字段。**另追加 `collected`（仅登录用户，2026-10-06）**：登录已认证时返回 `true` / `false`（真实投影，值来自 `is_game_distribution_collected_and_return`）；**匿名请求不返回该字段**（也不发 `false`——`false` 会把「未登录」说成「没收藏」）。该字段随请求者变化，所以这条路径必须 `no-store`、不得有任何共享缓存。**再追加 `themes: [{ themeId, name, badge }]`（2026-10-06 增量，共创主题）**：该作品所属的**公开**主题（只含 `status == published`）；**匿名与登录都发、无主题时恒发空数组**（与「仅登录才发」的 `collected` 不同——没有主题与没登录因此不会被混成同一种缺键）。口径是「先取该作品的**根**、再按根反查公开主题」，所以**第 N 代作品也能看到并跳到主题页**；单条只够渲染跳转入口（简介与成员数去主题页取）**。**版本摘要 `currentVersion` 再追加 `changeSummary`（2026-10-06，衍生作品发布必填项）**：该版本相对**改编来源**作品的核心改动说明——衍生作品必有（`20–500` 个字符，详见下方作者路由的 `POST /versions` 行），0 代母版为 **`null`**（发键不发值：客户端不必靠缺键猜），因此详情页与族谱溯源能逐代展示「这一版改了什么」。它不含任何私有字段（没有对象键 / 素材 id），匿名可读，也不需要按查看者变化 |
+| `GET /games/{gameId}/lineage`（新） | 以该 game 的根为顶返回树：`{ rootGameId, root: LineageNode \| null, nodes: [LineageNode], truncated }`，`LineageNode = { gameId, title, authorName, generation, parentGameId, playCount, status, coverObjectKey }`（`coverObjectKey` 为该节点作品**当前生效的封面对象键**，与公开目录 / 详情**同源同口径**、都来自游戏行 `cover_object_key`，**无封面时为 `null`**；只发对象键，不带 `coverAssetId` 等私有 id），按代际升序 / 同代创建时间升序稳定排序；节点上限 200，超出返回 `truncated: true`。**锚点必须公开可读**：未公开、已软删除或不存在的作品返回 404（与公开详情同口径），不用空标题占位或空树代替 404。树内只出现未软删除且已公开的作品；父/祖辈被排除时孩子照常出现并保留 `generation` 与 `parentGameId`，由展示层标注「原作品已不可用」，不补 null 占位节点。**「累计世代数」不是服务端字段**：本作品子树的深度 = 子树最大代际 − 本作品代际（根作品若有 3 层后代则为 3），前端从同一次响应的 `generation` 自算，服务端不新增字段也不为此多查一次。**右侧面板的「本次核心改动说明」不贴到节点上**：`LineageNode` 保持现在的字段集（不加 `changeSummary`），面板只对**选中节点**请求一次公开详情取 `currentVersion.changeSummary`（衍生作品为字符串、母版为 `null`，见上方公开详情行）——即**不做 N+1**：不是每渲染一个节点就查一次详情（两条前端口径已落地：`bd73acfcc`） |
+| `GET /games/{gameId}/derived`（新，可选分页） | 直接子代列表：`{ gameId, nodes: [LineageNode], truncated }`，只含未软删除且已公开的直接子代（与公开详情 `forkCount` 同口径，因此条数与「被改编 N」一致）；锚点同样必须公开可读，否则 404 |
+| 公开作品投影（`public_game_payload`，**2026-10-07 增量**） | **已有** `forkCount` = **被改编次数（直接子代数量）**，公开目录与公开详情都发。**新增（2026-10-07 定义定稿 + **已上线**（提交 `ffd751014`））** `coCreationCount` = **「共创次数」= 该作品子树里公开可见的全部后代数（不含自己）**——网页端「共创」页卡片指标位的「被共创 N 次」优先读它、缺省时回退 `forkCount`（见 §3.6.1 的卡片条目）。**两个计数的口径（不可互相推导）**：`forkCount` 只数**直接子代**（「被改编 N」）；`coCreationCount` 数**整棵子树**的可见后代（「共创 N」），同一张卡上后者的数字只会 ≥ 前者。两者共用同一批可见性规则（`module_game_distribution::counts_as_public_derivative`：**未软删除 + 已公开**），只是深度不同；已删 / 未公开的后代**不进任何一层计数**（中间作品不可见也不断链：它可见的后代仍算进祖先的后代数，与族谱「父被排除时孩子照常出现」同一口径）；血缘环 / 自引用按 `visited` 去重，**自己永远不计数**。`scripts/check-game-distribution-dto-parity.mjs` 已把 `forkCount`、`coCreationCount` **都**钉成「公开 payload 必须发」的字段（`mustEmit`），因此**可依赖**；**没有后代时发 `0` 而不是缺键**（缺键会被读成旧响应而触发回退）。**作者侧同形响应不发 `coCreationCount`**（与 `currentVersion` / `ratingSummary` 同类：它只是公开投影的字段），所以读取方仍需按 `coCreationCount ?? forkCount` 取值。**算法与成本（事务侧，2026-10-07 定稿）**：公开目录事务本来就要全表扫 `game_distribution_game` 做过滤 / 排序 / 切页，因此在该**只读事务里先建一次**「父 → 直接子代」血缘索引 + 一次可见性集合（`PublicDerivativeIndex`），再对**本页每一行**做一次 BFS 子树计数（`visited` 去重，边际成本 O(后代数)～O(作品数)）；索引**每个事务只建一次**（公开目录 / 公开详情 / 我的收藏 / 主题成员各自建一条），**不新增表 / 列 / 索引、不落物化计数**（避免与下架 / 封禁 / 删除状态产生第二份真相），**api-server 只发键、不遍历**。证据：`module-game-distribution` 的 `PublicDerivativeIndex` 纯函数单测（根 + 3 直接子代 + 1 孙代 ⇒ `forkCount == 3`、`coCreationCount == 4`；无子代 ⇒ 两键皆 `0` 且恒发；软删 / 未公开后代不计数；自引用与血缘环安全）+ api-server 的 payload 测试 + 本 parity 脚本。**运行栈实测（2026-10-07，`GET /games?limit=100&forkable=1`）**：45 条**全部**带该键，分布 `0×25 / 1×9 / 2×5 / 3×1 / 5×4 / 7×1`；且「富树分支 B1 258237」`forkCount=1` 而 `coCreationCount=2`（1 直接子代 + 1 孙代）⇒ 两键口径确实不同，前端指标位显示的是**后者**。 |
+| `GET /api/game-distribution/themes?limit=&cursor=`（新，2026-10-06） | 公开共创主题列表。**匿名可读 + `no-store`**，只含 `status == published` 的主题。响应 `{ themes: [{ themeId, name, summary, badge, memberCount }], nextCursor }`；`memberCount` = 该主题**真实可见成员数**（不截断、不套响应体积上限，也不是成员行总数）。它与详情 `roots` 的长度在可见成员超过 50 时**故意不相等**——「展示上限」不该污染「这个主题有多少棵树」，判定口径仍是同一份。分页沿用 `/my-collections` 那套游标惯例：`limit` 缺省 **20**、上限 **50**、超界**截断**（客户端拿到一个完整页，而不是需要重试的错误）；`cursor` 形如 `"{createdAtMicros}:{themeId}"`（解析只切第一个冒号）；**非法游标 → 400 `THEME_INVALID_CURSOR`**（模块侧报错透传，不吞成 200 空页）；`nextCursor` 为真实值，**末页为 `null`**。排序 `created_at` 倒序 + `themeId` 升序兜底（全序，翻页不重不漏），顺序定义为「**先按可见性过滤、再排序切页**」 |
+| `GET /api/game-distribution/themes/{themeId}`（新，2026-10-06） | 公开主题详情。**匿名可读 + `no-store`**；顶层**扁平** `{ themeId, name, summary, badge, memberCount, roots, rootsTruncated }`（与 `GET /games/{gameId}` 同形，不引入第二套包装）。`roots` 逐条是公开目录**同一份** `public_game_payload` 投影，按 `sort_order` 升序 + `member_id` 升序稳定排序（不泄露对象键、不泄露未公开作品）。主题**不存在 / `draft` / `archived` 一律 404**（模块侧回同一句「主题不存在」，由既有映射落 404；**不返回空壳**、公开侧不发 `THEME_*` 码）；**已发布但可见成员为空 = 200 + 空 `roots`**（空态而不是错误）。**成员数口径已定（2026-10-06）**：`roots` 受响应体积上限 **50** 约束（排序后取前 50 条），`memberCount` 报**真实可见成员数**（不截断），`rootsTruncated` 仅当 `roots` 少于 `memberCount` 时为 `true`——即「下面这份 `roots` 被上限截断」的显式信号，与族谱响应的 `truncated` 同约定（详见 §3.10.6 与 §3.10.9） |
+
+#### 作者（Bearer + 发布灰度）
+
+| 方法 / 路径 | 说明 |
+| --- | --- |
+| `PUT /games/{gameId}/fork-authorization`（新） | body `{ expectedForkAuthorization, forkAuthorization }` + `Idempotency-Key`；**只有母版可用**——母版只允许提升（降级与未知档位拒绝），返回最新 `forkAuthorization` 与 `replayed`；**衍生作品（存在血缘行）任何请求都 409 `FORK_AUTHORIZATION_INHERITED`**（与降级同为 409、码不同），包括传同值的幂等重试。判定取**血缘行**且**先于 CAS**，所以同一个衍生作品不会因载荷不同（同值 / 新值 / 期望值过期）而回不同的码；失败一律不写库 |
+| `PUT /versions/{versionId}/project-bundle`（**M2b 已实现**） | `application/octet-stream` 整包一次上传（≤ 200 MiB）；另有分片族 `GET …/project-bundle/upload-state`、`PUT …/project-bundle/chunk`（偏移头 `x-genarrative-upload-offset`）、`POST …/project-bundle/complete`（服务端独立跑工程包 zip 门禁 + 算摘要 + 确认）、`POST …/project-bundle/reset`（丢弃未确认的暂存对象）。前置：调用者是该版本作者；版本处于 `awaiting_upload` / `upload_failed`；该版本**尚无**已确认的工程包（换内容 → 409）。对象键由服务端派生（`…/{version_id}.project.zip`），不接受客户端指定。**两个按实现为准的细节（端到端实测，A5/A5b/A6）**：① **非作者上传返回 `404` 而不是 `403`**——api-server 用 `load_owner_version_or_404` 把 owner 不匹配按「版本不存在」处理，与发行包上行族同口径，既不会泄露「这个版本存在但不属于你」，响应里也不含对象键；② **阶段门先判「已存在」再判版本档位**——`ensure_project_bundle_uploadable` 先看 `project_bundle_bytes > 0`（→ 409 `PROJECT_BUNDLE_ALREADY_EXISTS`，因为确认工程包不驱动版本状态机，已确认的版本可能仍停在 `awaiting_upload`），再看 `status`（→ 409 `PROJECT_BUNDLE_UPLOAD_NOT_ALLOWED`）；因此「已公开**且已有**工程包」返回的是 `ALREADY_EXISTS`，只有「已公开**但还没有**工程包」才落到 `UPLOAD_NOT_ALLOWED` |
+| `POST /games`（**既有，请求增量**） | 追加可选 `forkedFromGameId` / `forkedFromVersionId`；再追加可选 `forkAuthorization`（`forbidden` / `nonCommercial` / `full`，**母版缺省禁止共创**，非法取值整请求 400 + 平台信封），使作者**上架时**即可选择授权档位，不必事后提升。**该字段只对母版生效**：带 `fork` 声明的衍生作品在创建时**继承父作品当时的档位**（创建时快照），请求里传的值一律被忽略且不报错（旧客户端惯常带默认值）；「收窄授权」不实现（产品决定 2026-10-06）。继承来的档位是**终态**：该作品之后再调 `PUT …/fork-authorization` 一律 409 `FORK_AUTHORIZATION_INHERITED`（母版才走只升不降）；父作品为 `forbidden` 时建立不了血缘，因此衍生作品**不会继承到 `forbidden`**。 |
+| `POST /games/{gameId}/versions`（**既有，请求增量**，2026-10-06「衍生作品发布必填核心改动说明」） | 追加可选 `changeSummary`：「本次核心改动说明」，发布设置页的「二创信息区」随包提交。**谁必填**：**衍生作品**（该 `gameId` **有血缘行**，即带过 `fork` 声明、代际 ≥ 1）**必须**提供；**0 代母版忽略该字段**——不校验、不落库（写 `NULL`）而不是「可选」，否则一个与血缘无关的字段会在母版上分叉出第二套语义。判定取**血缘行**本身、不接受客户端自称派生（`fork` 声明只在创建作品时生效一次），后续每一版都按血缘行判。**长度口径**：先 `trim` 再按**字符**数计（`chars().count()`，不是字节数——中文一字 3 字节，按字节算会让中文作者只能写 1/3 的内容），区间 **20–500**（常量 `GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS` / `_MAX_CHARS` 单点持有）。下限 20 的理由：这一项要回答「这一版相对来源作品改了什么」，比作品标题（40）短、比主题角标（16）长，是一句话能说清的最小规模；只写「改了」这类敷衍串等于没有说明，而展示层要把它当「这一代的差异」读。上限 500 的理由：它是发布流程里的一个文本框、不是正文（作品详细介绍 2000 才是正文），500 个字符足够写清「加了什么玩法、换了什么美术、修了什么」，同时保证详情页 / 族谱里相邻代际不会被挤出首屏。**失败关闭**且两条失败各有稳定码（都 400，客户端可只补说明或改短重试，不必按 409 去刷新后重放）：缺失 / trim 后为空 → **`FORK_CHANGE_SUMMARY_REQUIRED`**；越界 → **`FORK_CHANGE_SUMMARY_INVALID`**。**存储**：`game_distribution_version` 表尾追加可空列 `change_summary`——存**版本级**（同一作品的不同代各说各的改动），随版本冻结不可改。**投影**：公开版本摘要发 `changeSummary`（衍生必有、母版 `null`），见上方公开详情行。**幂等**：该字段属于请求体，因此参与请求摘要——同 `Idempotency-Key` 换说明会被按「同键不同请求」拒绝（409）；`serde` 上缺省**不序列化 `null`**，省略该键的旧客户端请求与升级前逐字节一致，同键重放不会被误判成新请求 |
+
+#### 登录用户（Bearer，**不叠加**发布灰度）
+
+灰度只针对「发布」，改编不应当被发布开关挡住：任何已登录用户都能改编已授权公开的作品。改编的三个取件接口共用同一条校验（同一个函数，规则不分叉），错误码沿用 `FORK_*`。本章末尾的收藏（收录）三条路由同样只要求 Bearer，但它们是**用户态**接口，与改编取件无关，不走 `FORK_*` 错误码：
+
+| 方法 / 路径 | 说明 |
+| --- | --- |
+| `GET /games/{gameId}/fork-source`（**M2a 已实现**，M2b 增补 `source`） | 受鉴权元数据。404 `FORK_SOURCE_NOT_FOUND`（作品不存在）/ 409 `FORK_SOURCE_NOT_AVAILABLE`（已软删除、未公开、或没有当前公开版本）/ 403 `FORK_NOT_AUTHORIZED`（授权为 `forbidden` 或未知档位，未知按禁止解释）；通过时返回 `{ forkSource: { gameId, versionId, source, sha256, bytes, downloadPath } }`。**`source` 现在可能是 `project`（该版本有工程源包时优先）或 `package`**；`sha256` / `bytes` 取自**所选资产**在版本行上的摘要（不重算），`downloadPath` 是同源相对路径并指向对应资产（`…/fork-source/project` 或 `…/fork-source/package`），**绝不下发 OSS 对象键** |
+| `GET /games/{gameId}/fork-source/project`（**M2b 已实现**） | 取件本体（源码级）：与 `/fork-source/package` 同一套鉴权与校验（同一个函数），仅当该作品当前公开版本**确有工程包**时才服务，否则 `409 FORK_SOURCE_NOT_AVAILABLE`（**失败关闭**，绝不悄悄回落成品包）。响应头与成品包同形，文件名为 `{gameId}-{versionId}-project.zip`；不做引用归一化 / `RELEASE_STORAGE_BOOTSTRAP` 注入（下发原始源码包），读取走同一条 OSS 读路径但**缓存键含资产维度**（对象键不同，两份资产不串味） |
+| `GET /games/{gameId}/fork-source/package`（**M2a 已实现**） | 取件本体：直接回该版本发行包 ZIP 的字节，头为 `Content-Type: application/zip`、`Content-Length`、`Content-Disposition: attachment; filename="{gameId}-{versionId}.zip"`、`Cache-Control: no-store`。数据复用现役发行网关的读包路径（整包进内存 + 进程内缓存，上限 4 条 / 256 MiB），**不做**网关那套引用归一化与 `RELEASE_STORAGE_BOOTSTRAP` 注入——下发的是原始构建产物，客户端要按摘要校验后离线解压，任何改写都会让摘要对不上 |
+
+**收藏（收录）三条路由（2026-10-06 新增，Bearer，`no-store`）**
+
+收藏是被收藏作品的**服务端真实投影**（表 `game_distribution_collection`），不是前端本地状态；`PUT` / `DELETE` 共用同一个响应形状 `{ collected }`，客户端不按动词推断结果。
+
+| 方法 / 路径 | 说明 |
+| --- | --- |
+| `PUT /games/{gameId}/collection` | 收藏。要求 `Idempotency-Key`；请求摘要绑定 `(userId, gameId)`。**幂等**：同键重放返回 `replayed: true`（本次没有新事实）；同键**换作品** → **409**（同一收据键、摘要不同）；同键**换用户** → **200 各自成功**（收据键是 `(userId, action, idempotencyKey)`，本身含 `userId`，两个用户不会命中彼此的收据）。**防重靠结构**：主键是确定性构造的 `{userId}:{gameId}`，同一 (用户, 作品) 不可能出现第二行（重复收藏只留一行、仍算成功），不靠「事务里先查后写」，也不额外建唯一索引。错误码：作品不存在 → **404**；未公开 / 已软删除 / 没有当前公开版本 → **409**（失败关闭，文案 `作品状态不允许收藏（未公开或已软删除）`，不含「不存在」/「已被删除」，不用错误码泄露未公开作品的存在性）。响应 `{ collected: true, replayed: boolean }` |
+| `DELETE /games/{gameId}/collection` | 取消收藏。**不要求 `Idempotency-Key`**：按确定性主键删除，重复调用结果完全相同（不存在也算成功），没有「重放 vs 新意图」需要区分。**也不要求作品仍公开 / 未被删除**：下架后拒绝取消只会给用户留下清理不掉的脏行。响应 `{ collected: false }`（**不带** `replayed`） |
+| `GET /my-collections?limit=&cursor=`（2026-10-06 补真分页） | 「我的收藏（收录）」列表：逐条用公开目录同一份 `public_game_payload` 投影，形状与公开目录一致 `{ games, nextCursor }`。**真游标分页**：`limit` 缺省 **20**（网格一屏）、上限 **50**（约束单响应体积；与后台列表的 200 口径**不必相等**），超界**截断**而非报错；`cursor` 形如 `"{createdAtMicros}:{collectionId}"`（与后台列表同一套 `"{micros}:{id}"` 惯例，`collectionId` = `{userId}:{gameId}` 自带冒号，解析只切第一个冒号）；**格式非法 → 400**；`nextCursor` 为真实值，**最后一页为 `null`**。排序：**收藏时间倒序，同值用 `collectionId` 升序兜底**（`collectionId` 唯一 ⇒ 全序，翻页不重不漏）。分页顺序定义为「**先按可见性过滤、再排序切页**」——游标位置落在已过滤序列上，否则每翻一页都会漏掉自己的若干条收藏。**只含当前公开可读的作品**；未公开 / 已软删除的行在投影时被跳过但**不删除**，作品重新公开后自动回到列表 |
+
+**贡献归集与归因（作者视角只读，2026-10-06 新增，Bearer，`no-store`）**
+
+口径与不变量见 §3.11；这里是路由层的合同摘要。
+
+| 方法 / 路径 | 说明 |
+| --- | --- |
+| `GET /games/{gameId}/contribution` | 作者读取自己作品的贡献归集：`{ gameId, own, inherited, total, byGeneration, directChildren, nodeCount, truncated, truncatedReason }`（指标集合当前只有 `playCount`）。**只要求 Bearer、不叠加发布灰度**；未登录 / 失效 → **401**，作品不存在或已软删除 → **404**，非作者 → **403**（沿用既有 owner-mismatch 惯例，理由与代价见 §3.11.5）。子树遍历只用血缘表既有父索引，**不新增表 / 索引**；受节点上限 **500** / 深度上限 **32** 约束，超限时 `truncated: true` + `truncatedReason` ∈ `node_limit` / `depth_limit`，已计入部分的数字仍自洽。**本期只做计算**：响应里没有资金 / 分成 / 结算字段 |
+
+#### 后台（admin）
+
+| 方法 / 路径 | 说明 |
+| --- | --- |
+| `GET /admin/api/game-distribution/games`（**既有，响应增量**） | 追加 `forkAuthorization` / `generation` / `forkedFromGameId` / `derivedCount`（只读展示） |
+| `POST /admin/api/game-distribution/themes`（新，2026-10-06） | 创建主题。**鉴权复用既有 admin 体系**：`route_layer(require_admin_auth)` + handler 取 `Extension<AuthenticatedAdmin>`——未带 / 失效会话 → **401 `UNAUTHORIZED`**（与同组 games/reviews 路由同码同形），非 admin role → 403；模块侧第二层再要求受信服务身份（只有 api-server 能调 procedure）。`theme_id` 由**服务端**生成 `theme-{uuid}`（请求体里没有该字段，外部无法指定），`created_by_user_id` 取 admin 会话主体。要求 `Idempotency-Key`（缺 / 超 128 字符 → 400 `BAD_REQUEST`，沿用既有写接口口径，不为主题另开一套）；**同键同请求摘要重放 → `replayed: true` 且回库里那一行（不写库）**，同键不同请求 → **409 `THEME_IDEMPOTENCY_CONFLICT`**。响应 `{ theme, replayed }`。空 `name` / 文本超长（名称 40 / 简介 200 / 角标 16）/ 未知 `status` → 400 `THEME_BAD_REQUEST`（不是 axum 默认 422 纯文本） |
+| `PUT /admin/api/game-distribution/themes/{themeId}`（新，2026-10-06） | 整体覆盖 `name` / `summary` / `badge` / `sortOrder` / `status`。鉴权与幂等口径同上（要求 `Idempotency-Key`；生效即刷新 `updated_at`，**重放不写库、不刷新**）。`themeId` 不存在 → **404 `THEME_NOT_FOUND`**；字段非法 → 400 `THEME_BAD_REQUEST`。响应 `{ theme, replayed }` |
+| `GET /admin/api/game-distribution/themes?limit=&status=`（新，2026-10-06） | 后台列表，**含 `draft` / `archived`**。`limit` 缺省与上限同为 **200**（超界截断），**无游标**（主题是运营维护的小集合）。`status` 白名单 `all` / `draft` / `published` / `archived`（缺省 = `all`），非法过滤值 → 400 `THEME_BAD_REQUEST`（失败关闭，不退化成全量）。响应 `{ themes: [{ themeId, name, summary, badge, sortOrder, status, memberCount, createdAt, updatedAt }] }`；此处 `memberCount` 是**成员行总数**（含当前对外不可见的成员），与公开侧同名键的「可见成员数」口径不同 |
+| `PUT /admin/api/game-distribution/themes/{themeId}/members/{rootGameId}`（新，2026-10-06） | 增 / 改成员（幂等 upsert，body 可带 `sortOrder`，缺省 0）。**不要求 `Idempotency-Key`**：成员身份完全由路径给出，确定性主键 `"{themeId}:{rootGameId}"` 天然幂等，重复调用只更新 `sortOrder`（`createdAt` 不变）。只允许**根作品**：非根（有血缘行）→ **409 `THEME_MEMBER_NOT_ROOT`**；作品不存在 → 404 `THEME_MEMBER_GAME_NOT_FOUND`；主题不存在 → 404 `THEME_NOT_FOUND`。**不做「作品必须已公开」的前置校验**（可先挂草稿根，作品公开后自动进入公开投影）。响应 `{ themeId, rootGameId, sortOrder, createdAt }` |
+| `DELETE /admin/api/game-distribution/themes/{themeId}/members/{rootGameId}`（新，2026-10-06） | 移除成员。**不要求 `Idempotency-Key`**：按确定性主键删除，**成员不存在也算成功（200）**；响应刻意不含「之前存不存在」，重复调用逐字节相同。主题不存在仍是 404 `THEME_NOT_FOUND`（那是路径里的主题 ID 错了）。响应 `{ themeId, rootGameId }` |
+| `GET /admin/api/game-distribution/themes/{themeId}/members?limit=&cursor=`（新，2026-10-06） | 后台读取主题成员**名单**（运营核对）。鉴权同上（`require_admin_auth` + `Extension<AuthenticatedAdmin>`；未登录 / 失效会话 → **401 `UNAUTHORIZED`**，非 admin role → **403**）。**返回全部成员行、不套公开可见性过滤**，且 **`draft` / `archived` 主题照常可读**——公开投影只服务已发布主题，后台借道它时草稿 / 归档主题根本列不出成员，运营没法在发布前核对（本接口就是补这个缺口）。响应 `{ themeId, totalMembers, members: [{ rootGameId, title, sortOrder, createdAt, visible, visibility }], nextCursor }`：`totalMembers` 是**成员行总数**（含当前不可见的行、**不受分页影响**）；`title` 取游戏行标题，游戏行不存在时为 `null`（键仍发出）；`visible` = 此刻**公开投影**会不会包含它（未删 + 已公开 + 有当前公开版本，**复用** `game_distribution_theme_member_visible`，不另写一套判定），`visibility` = 更细的状态（软删除 → `deleted`，游戏行不存在 → `missing`，否则原样透传游戏行的 `published` / `unpublished` / `suspended`）——两者**刻意独立**：`visibility == "published"` 且**无**当前公开版本时 `visible == false`，运营据此看出「作品已公开、但没有公开版本」这种异常。分页与其它列表完全一致：`limit` 缺省 **20** / 上限 **50** / `0` 取默认 / 超界**截断**；游标形如 `"{sortOrder}:{memberId}"`（`memberId` 本身是 `"{themeId}:{rootGameId}"`，解析只切第一个冒号，与 `"{i64}:{rest}"` 惯例同构）；**非法游标 → 400 `THEME_INVALID_CURSOR`**（可达的稳定码，不吞成 200 空页）；`nextCursor` 为真实值、**末页为 `null`**。排序 `sortOrder` 升序 + 成员主键升序兜底（**与公开侧同一份比较器** `sort_theme_members`，翻页不重不漏）。主题不存在 → **404 `THEME_NOT_FOUND`**；`draft` / `archived` **不是** 404（后台要看得见） |
+
+#### 契约同步（强制）
+
+- Rust DTO：`server-rs/crates/shared-contracts/src/game_distribution.rs`
+- TS DTO：`packages/shared/src/contracts/gameDistribution.ts`
+- 版本状态枚举如需新增取值，同步 `GameDistributionVersionStatus` 与 `scripts/check-game-distribution-dto-parity.mjs` 的公开构建器约束。
+- 本期不动 `/api/external/v1`，因此不改 External OpenAPI；若后续对外开放 Fork 查询，再按现有门禁同步 OpenAPI。
+
+### 3.5 两条改造路径：成品包（先行）与工程源包（补强）
+
+> **术语更正（2026-10-04，2026-10-07 再更正一次）**：本节原来的标题把成品包路径称为「改造」，正文还写了「项目无需构建步骤即可试玩与发布」。2026-10-04 的只读侦察按**当时的落点假设**（成品铺进项目里、项目没有 `package.json`）把能力判成「本地试玩 + 素材来源，不含重新发布」；2026-10-07 落地的建项形态是「**先建 Phaser 4 + Vite 合规脚手架，再把成品铺进预览根**，并登记可运行原型」，于是**试玩与发布都成立**，只有「在成品上重建核心逻辑」不成立（包里没有源码）。本节下面按实现事实重写。路线取舍见 §3.5.4。
+
+#### 3.5.1 成品包路径（零新增上传资产：可玩参考 + 素材来源）
+
+- **内容来源**：父作品当前公开版本的 `package_object_key`（已存在，无需作者做任何额外动作）。服务端按现有发行网关同一套对象读取与校验复用该 ZIP，不新造存储。包内容是纯运行产物：`collect_project_export_package_files`（`src-tauri/src/project/export.rs:770-804`）只收 `dist` 树（条目统一改名成 `game/...`）+ 根 `assets/` 兜底 + `exports/README.md`，**根 `package.json` 与源码不进 ZIP**。
+- **下载通道（M2a 已实现）**：`GET /games/{gameId}/fork-source`（元数据）+ `GET /games/{gameId}/fork-source/package`（ZIP 字节）两条受鉴权路由，**要求 Bearer、不叠加发布灰度**（灰度只针对发布），校验顺序与错误码见 §3.4「登录用户」小节。服务的是**当前已公开版本**的发行包（与公开发行网关同一份对象），元数据里的 `sha256` / `bytes` 直接取该版本行，`downloadPath` 是同源相对路径、不下发对象键；本体复用发行网关的读包路径（整包进内存 + 进程内缓存，上限 4 条 / 256 MiB，`:926-958`、`:101-104`），但**不做**引用归一化与 bootstrap 注入——取件下发的是原始构建产物，客户端按摘要校验后离线解压，任何改写都会让摘要对不上。客户端侧仍是整包读取（`fetch_limited_bytes`，上限 512 MiB、无 Range 无续传；分片能力只有上传侧），大包的续传/分片下载是后续议题。**未实现**的是按版本直取任意历史版本：取件只服务当前公开版本，与发行网关同口径。
+- **AGC 建项：fork 完即可运行，也能发布（2026-10-07 起）。**
+  - **落点 = 预览根**：先 `init_local_game_project_at` 生成合规脚手架（Phaser 4 + Vite，`project/manifest.rs` 的 `DEFAULT_GAME_PACKAGE_JSON` / `DEFAULT_GAME_VITE_CONFIG`），再把发行包整包解到**预览根**（`game_fork.rs` 的 `fork_playable_root`，即 `preview::project_game_root()` 给出的 `game/dist`）。运行视图只服务预览根，铺在别处的副本用户既看不到也播不了——这正是「fork 之后没法直接运行」的成因。
+  - **平台发行包契约保证入口在包根**：服务端 `validate_release_zip` 要求 ZIP 根有 `index.html`（`module-game-distribution/src/package.rs:98,146`），api-server 强制 `package_entry_path == "index.html"`（`api-server/src/modules/game_distribution.rs:5434`），AGC 侧的归一化同样在新 ZIP 里剥掉 `game/` 前缀并强制根 `index.html`（`project/export.rs:489-590`）。因此解到预览根后就是 `<预览根>/index.html`，`validate_project_game_entry`（`verification.rs:49-52`）与 `start_local_game_preview_for_project`（`preview.rs:403-420`）都能通过。
+  - **建项收口登记「可运行原型」**：`game_fork.rs` 的 `register_forked_project_state_at` 在**同一次收口**里完成「任务状态 → 推进 project revision → 追加 `initial-<revision>` 工程内部版本 → 宣告清单失效」（与 AI 直连回合收口 `agent/direct_runtime/mod.rs:4181-4194` 同一套模式）。成品包形态因为预览根确实有 `index.html`，会把 `code-prototype` 置为已完成——运行页签与发布入口读的就是这一条事实（`view/project-development/index.tsx` 的 `runAvailable`、`project/export.rs` 的 `project_has_runnable_prototype`）。
+  - **发布也成立**：导出/发布入口「已有可玩入口」的分支（`export.rs:262-265`）只要求工程栈合规（phaser 4 + vite），脚手架已满足（`ensure_publish_project_stack`，`:413-470`），于是发包内容就是**当前预览根**——作者没改就是取到的那份成品产物（平台仍要求衍生作品填「本次核心改动说明」）。**没有**「改完再发布断裂」这一步了：源码缺失只影响「能不能在取到的成品上重建核心逻辑」，不影响「能不能运行 / 能不能发布」。
+  - **不再写第二份 `reference/` 副本**：可玩参考就落在预览根这一处。多写一份既让「哪份是事实源」含糊（两份都要同步），又白占一份磁盘；来源与形态事实由 `.agent/fork-source.json`（v2，`source: package`）承担，界面据此如实措辞。
+  - **不会被当成作者源码外发**：`game/dist` 属于工程源包排除清单（`project_bundle.rs:88` 的 `BUNDLE_EXCLUDED_GAME_BUILD_DIRS`），fork 来的成品不会被重新包进该作者的工程源包。
+- **能力边界**：可试玩（fork 完直接运行）、可发布（发布当前预览根）、可提取包内素材（受上面扩展名白名单限制）、可阅读已压缩的运行产物；**不可**在取到的成品上重建核心逻辑（包里没有源码与 `package.json`）。面板必须如实说明最后一点。
+- **价值**：零新增上传资产即可跑通「授权 → 运行/试玩 → 素材复用 → 直接发布（或改后在自建工程里发布）→ 血缘与溯源」；工程源包仍是有源码时的正解路径（§3.5.2）。
+
+#### 3.5.2 工程源包路径（源码级复刻，现为正解路径）
+
+- **打包（AGC，已落地）**：客户端 `project_bundle` 模块做**确定性打包**（条目排序 + 固定时间戳，同内容同摘要），排除 `.agent` / `.git` / `.svn` / `node_modules` 段（任意层级）与根 `dist` / `build` / `library` / `temp` / `local` / `.idea` / `.vscode`；客户端自身另有总量上限（512 MiB）。
+- **服务端复核（已落地、不信任客户端）**：`module-game-distribution/src/project_bundle.rs` 的 `validate_project_bundle_zip` 独立校验上传内容——上限与发行包**逐项相等**（压缩包 200 MiB / 展开 500 MiB / 单文件 64 MiB / 条目 10 000 / 压缩比 100，理由是两者共用同一条上传链路，反代与 Pingora 的放行量就是按 200 MiB 校准的）；额外拦凭据与隐私文件（`.env`、`.env*`、`*.pem`、`*.key`、`*.p12`、`*.pfx`、`.npmrc`、`.netrc`、`.git-credentials`、`id_rsa*`、`id_ed25519*`、`*.map`）、嵌套 `.zip`、符号链接、加密条目与不安全路径；**不要求**根 `index.html`（源码包没有入口约定）。
+- **上传（AGC，已落地）**：发布链路在「授权非 `forbidden`」时随版本上传工程源包（失败**不阻断**发布，按可重试处理）；面板明确提示「未上传工程包，你的作品只能被他人试玩与参考（不能直接重新发布）」。是否有工程包**不改变**授权是否开放（见 §3.2.3 的产品口径）。客户端规则与服务端对齐，并有机器门禁 `npm run check-project-bundle-policy-parity` 钉住两端排除清单/上限一致（含路径形状维度，见下）。
+- **凭据/依赖识别补强（2026-10-05 对抗性复核后）**：除上面那份清单，还拦任意层级的 `.aws` / `.ssh` / `.kube` / `.docker` / `.gnupg` / `.terraform` / `.secrets`，以及文件名前缀 `credentials` / `id_ecdsa` / `id_dsa` / `terraform.tfstate` / `service-account`、后缀 `.jks` / `.keystore` / `.ppk` / `.p8` / `.kdbx` / `.der`、全名 `.htpasswd` / `.pgpass`。另外对**小体积文本条目**做内容特征扫描（PEM 私钥块标记、AWS `AKIA…`、GitHub `ghp_` / `github_pat_`、Slack `xox*`）——这是唯一能兜住「未知凭据文件名」的形状；更宽的前缀启发（例如 `sk-`）**故意不做**，因为误报会直接阻断作者发布，收益与代价不成比例。
+- **嵌套包识别**：扩展名并集 `.zip` / `.tar` / `.gz` / `.tgz` / `.7z` / `.rar` / `.jar` / `.whl` / `.nupkg`，**并对每个条目按 magic bytes 嗅探**（`PK\x03\x04`、`7z`、`Rar!`、gzip、tar 的 `ustar`）——改名成 `.dat` 也拦。客户端打包器同款检查，命中即报错（指明路径与格式），不静默跳过。
+- **规模检查的读取层封顶**：实际读取按**该条目声明大小**封顶（只允许多读 1 字节用于判溢出，短读同样算失败），预分配同样收紧到硬上限。因此「声明说谎的 deflate 炸弹」在**读**这一层就失败关闭，不会先解完再比对；**同一处修法同步到发行包校验器**（那里原有同样的写法）。
+- **压缩比口径更正**：分母是**该条目的压缩字节**（不是整包字节），而且它**不是 zip 炸弹防线**——真正的约束是单文件 64 MiB 与累计展开 500 MiB 两条上限，压缩比只是补充。文档与代码注释都按这个语义写。
+- **路径形状与嗅探维度（一致性门禁新增）**：客户端过去只过 `template_library::safe_archive_relative_path`（不查结尾点/空格与 `<>"|?*`），于是 macOS/Linux 上 `src/a?.ts`、`x.` 这类名字**客户端能打、服务端必 422**（白传一趟）。现在客户端打包器自带一份与服务端逐字符对齐的路径形状检查，且 `check-project-bundle-policy-parity` 覆盖四类：① 目录/前缀/后缀/全名 + 5 项上限；② **路径形状**（哨兵段 / 结尾字符 / 禁止字符 + 两侧必须显式拒 `/` 开头与 `\`）；③ **内容嗅探特征表**（`SECRET_CONTENT_SIGNATURES` / `AWS 前缀` / PEM 标记 / 文本扩展名白名单 / 嗅探窗口，两侧逐字相等）；④ **嵌套包 magic bytes**（服务端 ⊆ 客户端）。抽不到一律报错，不做「抽不到就绿」。
+- **下载与建项（AGC，已落地；2026-10-07 更正落点）**：`fork-source` 返回 `source: 'project'` 时走 `GET /games/{gameId}/fork-source/project`（`package` 时走原路径）→ 校验 `sha256` 与 `bytes`（失败关闭、不落盘）→ 按来源分支建项：**工程源包**解到项目根（包就是工程本身，复用模板归档同一套条目门禁）；**成品包**先 `init_local_game_project_at` 生成合规脚手架、再整包解到**预览根**（`fork_playable_root`，即 `game/dist`；先前文档写的「解压到 `<app_data>/forks/<gameId>/<versionId>/`、成品包形态是可玩参考副本」与实现不符，已按代码更正——那一版落点不在预览根，导致副本播不了）。建项收口统一走 `register_forked_project_state_at`：登记「可运行原型」（仅当预览根确有 `index.html`）与 `initial-<revision>` 工程内部版本，并宣告清单失效。改编来源写在 `.agent/fork-source.json`（**不写 manifest**：manifest 是 `deny_unknown_fields` 的 v1 契约，加拓扑字段等于改契约）。来源记录为 **v2**（记录取件形态与对应摘要），**兼容 v1**（旧记录仍可读）；取件成功提示按两种形态分别如实措辞。
+- **优先级（已落地）**：同一版本同时存在工程源包与成品包时，`fork-source` 优先返回工程源包并标 `source: 'project'`；只有工程包缺失（或行上「字节数 > 0 但摘要为空」这种半写状态）才回落 `package`，客户端据此决定建项形态。
+
+#### 3.5.3 发布时声明（两条路径共用）
+
+AGC 发布链路（`game_distribution_publish.rs`）读取 `manifest.forkedFrom` 并写入创建 game 的请求体。网页端**不提供**手填来源，声明只能来自真实下载过的内容，避免伪造血缘；网页端发布的作品因此只能作为父作品，不能作为子作品。
+
+#### 3.5.4 第二阶段（Fork 落地）的路线选择（决策材料，待用户拍板）
+
+> 本节是**待拍板材料**，不是定稿合同；定稿前不得据此实现。结论来自 2026-10-04 的只读侦察（材料：`local://m2a-design.md`），它否掉了原方案「成品包铺进项目即可试玩与发布」的假设（事实依据见 §2.5 与 §3.5.1）。
+
+**进展（2026-10-05）**：产品已采纳下面的推荐口径（**不做**独立的「源码可见性」开关；作者不传工程包即退化产物级改编；`nonCommercial` 的约束力是平台规则层面）。路线 **B 两端均已落地**：服务端（§3.2.3 三列 + `module-game-distribution` 的工程包校验器 + 上行/下行路由族，见 §3.4）与 AGC 侧（确定性打包器、发布时上传、按 `source` 分支的取件建项、来源记录 v2），两端规则由 `npm run check-project-bundle-policy-parity` 机器门禁钉住一致；A 作为默认路径继续服务未上传工程包的作品；C 不做。
+
+**落地补记（2026-10-07）**：A 路线的**兑现度被提高了**，但**没有**走成 C（不造「dist 实体的伪工程」）：成品包仍只当可玩参考（内容原样解到预览根，不改写任何字节），合规工程骨架由既有 `init_local_game_project_at` 标准脚手架提供（**不是** fork 自己拼 `package.json`），并在建项收口把「可运行原型」登记进 manifest。因此 A 路线现在是「可玩参考 + 素材来源 + 合规骨架 + 开箱可运行/可发布」，唯一没兑现的仍是「在成品上重建核心逻辑」（包里没有源码）。产品口径同步见 §2.5 与 §5.8。
+
+三条候选路线：
+
+| 路线 | 用户拿到什么 | 能不能发布 | 对「一键复刻完整工程」的兑现度 | 工作量 |
+| --- | --- | --- | --- | --- |
+| **A. 参考式改编**：成品包只当「可玩参考 + 素材来源」，AGC 侧另建合规骨架（真 Phaser 4 + Vite） | 原作副本（**预览根可直接试玩**）+ 新工程骨架 + 从成品包提取的素材（受扩展名白名单限制） | 能（骨架是合规工程；2026-10-07 起建项同时登记可运行原型） | 低：脚本与配置要重写，对外不能说「复刻工程」 | AGC 侧中；若要把血缘做到平台可查询则跨端大 |
+| **B. 只做工程源包**（跳过成品包路线） | 作者随版本上传的可编辑工程包，fork 后即完整可开发工程 | 能（源包本身是 Phaser 4 + Vite 时） | 高（前提是作者真的提供工程包） | 大（需新增工程包下载/授权接口，见 M2b） |
+| **C. 成品包 + 自动补工程栈** | 铺产物 + 生成声明 phaser 4/vite 的 `package.json` | 能过客户端校验，但产出的是「dist 实体的伪工程」 | 表面中（能发布）、实质低（不可再构建） | 小–中 |
+
+**推荐（2026-10-05 已拍板；2026-10-07 按落地事实补记）**：第二阶段落 **A**（试玩 + 素材 + 血缘，现为「开箱可运行/可发布」），对外口径从「复刻工程」改为「参考改编 / 素材复用」；**B 作为正解同样已落地**（源码级复刻，`game/dist` 不在包内，所以源码形态 fork 后需要先构建才可运行——按产品口径**不自动构建**，界面如实提示）；**C 不做**，或仅限一次性存量兼容且需产品书面接受「不可再构建」的语义。
+
+A 路线里那个必须提前知道的互斥点已经按既有做法绕开：`create_npm_scaffold` 的触发条件是「没有 manifest **且** 根与 `game/` 都没有 `index.html`、都没有 `package.json`」（`apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs:609-613`），所以 fork 流程**先**走标准初始化生成脚手架、**再**把成品铺进 `game/dist`（预览根，不在判据覆盖的两个根上），既不需要自己拼 `package.json` / `vite.config.*`，也不会让脚手架与产物互相打断。成品铺在预览根而不是 `reference/<gameId>/`，是因为运行视图只服务预览根（`preview::project_game_root`）；`game/dist` 同时被工程源包排除清单覆盖（`project_bundle.rs:88`），不会被当成作者源码外发。
+
+### 3.6 前端链路
+
+| 文件 | 改动 |
+| --- | --- |
+| `src/routing/activeAppPageRoutes.ts` | 新增 `['game-lineage', '/games/lineage']`；同步 `SelectionStage` 类型与 `PlatformEntryActiveFlowShell` 的 stage 分支 |
+| `src/components/game-distribution/GameDetailPage.tsx` | 世代/授权标签、数据概览（累计衍生作品 + 累计创作世代数）、血缘链（纵向滚动单链）、热门衍生栏、族谱入口、主题入口、「开始共创」主行动作 |
+| `src/components/game-distribution/GameLineagePage.tsx`（新） | 族谱页：桌面画布（节点-连线树）、移动端大纲模式、筛选器、主干线、信息面板 / bottom sheet |
+| `src/components/game-distribution/LineageNodeContent.tsx`（新） | 族谱**节点内容**（封面 + 代际角标 + 标题 + 作者）唯一实现，画布卡片与血缘链共用（避免第二套省略规则导致逐字换行） |
+| `src/components/game-distribution/LineageOutlineList.tsx`（新） | 移动端**大纲式缩进树**：全宽行 + 左缩进 + 肘形导线，无横向滚动 |
+| `src/components/game-distribution/LineageInfoPanel.tsx`（新） | 选中节点信息面板：桌面右侧浮层 / 移动端 bottom sheet（同一组件两种形态） |
+| `src/components/game-distribution/MyGamesPage.tsx` | 授权三态设置（只升，**仅母版**；衍生作品显示只读「继承自父作品」）、分类标签、「被改编 N」行内展开 |
+| `src/components/game-distribution/GamePublishPage.tsx` | 发布新版本的**「本次核心改动说明」**（衍生作品必填，20~500 字，前端同等校验） |
+| `src/services/gameDistributionClient.ts` | `setForkAuthorization` / `getGameLineage` / `getDerivedGames` / `setGameCollection` / `listMyCollections` / `listThemes` / `getTheme`；`getGame` 类型增量 |
+| `apps/ai-game-creator-shell` | 「共创」列表页（公开目录过滤 + 卡片入口，无粘贴输入块）、「开始共创」确认页（父作品卡 / 强制阅读 3 秒 / 真实同步阶段 / 吸附底部操作条）、发布面板（授权三态 + 衍生作品只读「继承自父作品」 + 「本次核心改动说明」）、`genarrative://fork` deep link 注册、外壳滚动链（见 §3.6.2） |
+| `apps/admin-web/src/pages/AdminGameManagementPage.tsx` | 列表新增授权 / 代际列 |
+
+#### 3.6.1 交互口径（2026-10-06 补充）
+
+- **世代与授权标签**：世代按文档三档命名 `0 代原创 / 1 代二创 / 2 代三创 / N 代迭代`（`coCreationCopy.ts`）；授权类型沿用平台既有常量（禁止共创 / 允许非商用共创 / 允许全开放共创）。
+- **主操作「开始共创」始终显示**：授权为「禁止共创」时**置灰（`aria-disabled`）并给出原因**（悬停 `title` + 点击可读提示），不再静默隐藏；未登录走既有登录门禁。
+- **衍生作品的授权不可单独提升**：服务端会拒绝对衍生作品的授权 PUT，因此我的作品页对衍生作品**隐藏提升入口**，改为只读展示「共创授权继承自父作品（当前档位）」。
+- **血缘链（详情页共创卡）**：只画**祖先链**（根 → … → 当前），**纵向滚动**（`overflow-y: auto` / `overflow-x: hidden`）、**初次进入与当前作品变化时自动滚到底**；节点卡片为「横版封面缩略 + 标题 + 代际角标」的矮宽行，标题 2 行截断（`min-width: 0` + line-clamp），**不允许逐字换行**。整棵树由「查看创作族谱」入口承担——右栏只有 200 多像素，塞整棵树必然不可读。
+- **「累计创作世代数」在前端计算**：＝本作品子树深度（子树最大代际 − 本作品代际），用详情页**已经请求的同一份 `/lineage` 数据**算，不新增请求、也不加服务端字段。
+- **移动端形态**（跟随仓库既有窄断点，`useIsMobileViewport`）：
+  - **默认大纲式缩进树**（`LineageOutlineList`）：全宽行、层级用左缩进 + 肘形导线表达、主干链导线加粗用主题色；**无横向滚动**、无需缩放平移；行高 ≥44px，点击行 = 选中（无 hover）。
+  - **大纲行版式口径（2026-10-07 追加，来自真机截图复盘）**：
+    - **内容列限宽居中**：`.lineage-outline` 用 `max-width: 54rem` + `margin: 0 auto`，宽屏不再整屏出血（之前 1300px+ 横条、文字与「打开 / Fork」之间约 700px 死空白）。操作按钮是行的**最后一个子元素**，因此固定在**内容列右端**，不会飘到屏幕最右侧。
+    - **角标成组、永不叠印**：代际 / 主干 / 当前作品 / 父代-子代 / ▶游玩数 统一放进 `.game-lineage-node__badges`（flex + gap + 可换行）。此前它们各自 `position: absolute`（代际左上、主干右上、「当前作品」在流内），在窄容器里会**互相叠印成乱码字形**（大纲行的「第 1 代」与「主干」）；现在组内一律静态定位，重叠在结构上不可能发生。**2026-10-07 起两种形态都把该组放在封面下方**（画布卡片的信息区第一行），不再作为封面浮层。
+    - **缩略图统一 16:9**：大纲行的封面与画布同一比例（16:9，4.5rem 宽），不再被角标撑成窄竖条；行用 `min-height: 3.5rem` 做统一基线，标题最多 2 行 clamp → 同层行等宽、跨行等高，连线端点一致。
+    - **信息密度**：代际 + 主干 + 当前作品 + 父代/子代 由「三行」收敛成**一行角标组**，标题 2 行 clamp、作者一行 → 每行比改版前少一行。
+  - **图谱卡 = 广场作品卡的同一个组件（2026-10-07 用户口径：「不是要长得像，而是就应该是广场卡」）**：画布节点卡与图下方「父代 / 子代」清单卡**都直接渲染** `@genarrative/shared/components` 的 `GameCard`（不是仿制样式、也不是 CSS 覆盖）。为此对共享卡做了**纯加法**扩展：`game` 参数放宽为结构化子集（按「字段是否在对象上」决定是否渲染该行，广场用法行为不变）、新增可选 `badges` 角标槽与 `className`。
+  - **卡面不再有动作按钮**：「打开作品 / 开始共创」已从卡面移除（用户口径：看封面决定不了共创，必须点进去看）——**整卡就是入口**（`GameCard` 本身是 `<button>`，点击 → 作品详情；占位节点点击不导航）。
+  - **图谱语义走角标槽**：第 N 代 / 主干 / 当前作品 / 父代-子代 / `▶N`（子树合计）全部通过 `badges` 槽承载；高亮 / 变暗 / 主干线状态仍在外层最薄 wrapper 的 class（wrapper 只负责定位与连线锚点、不改卡内视觉）。选中/高亮改为**悬停或键盘聚焦**驱动（点击已让位给「进详情」）。
+  - **封面**：`.game-card--lineage .game-cover { aspect-ratio: 16/9; min-height: 0 }` + 图片 `100%×100% + object-fit: cover`（统一 16:9 铺满）。
+  - **层高常量按新卡实测重算**：真机实测（212 宽画布卡、标题两行）卡高 **231.5px** → `LINEAGE_CARD_BASE_HEIGHT = 214` / `TITLE_LINE_HEIGHT = 20`（两行估算 234 ≥ 实测）；每行字符数按实测换行取 `10`；紧凑卡 **`182 / +20`**（窄视口 390×844 / 360×800、卡宽 148、两行标题实测 **196px** ⇒ 估算 202 ≥ 实测，留 6px）。层间距 = 上一层最高卡 + `rowGap`，冷启动实测层间空隙 **107 / 107 / 107**（层盒 `0..232 / 318..550 / 656..888 / 994..1226`），层内零重叠。
+  - **连线锚点口径（2026-10-07 真机定标）**：竖版 `from = 父盒下边中点`、`to = 子盒上边中点`；横版 `from = 父盒右边中点`、`to = 子盒左边中点`。**水平方向严格落在卡片中心**：真机 7 条边 × 两端共 14 个端点，用 `path.getPointAtLength(0|len)` + `getScreenCTM()` 变换到视口坐标与 `getBoundingClientRect()` 同坐标系比较，偏差 **全部 0.00px**（节点盒内左右内边距相等 ⇒ 卡片中心 == 盒中心，实测 `cardCenter − nodeCenter = 0`）。**不存在任何横向扇出偏移**：一个父带多个子时，各条边从同一个父中点出发、各自落到不同子的中点（`lineageTreeLayout.test.ts` 已用 `toEqual` 钉住每条边，含扇出边）。纵向锚点取的是**布局盒**（`node.y` / `node.y + 估算层高`）而不是卡片自身的矩形：节点盒实际渲染高度 = 卡片 + 上下内边距（`11.2px×2` + `1px 边框`），比估算层高高，所以父端锚点落在卡片底边**上方约 9.7px**（被卡片盖住，不可见）、子端锚点落在子卡上边**上方约 12.2px**（一段空地）；两端留白**只与这组 CSS 度量有关、逐边恒定**，因此视觉上各条连线一致。
+  - **大纲行（移动端列表形态）继续用 `LineageNodeContent`**：它是**列表行**不是卡片（行内保留「打开作品 / 开始共创」，是移动端的既有设计），因此该组件未被删除；若产品要求连大纲也卡化，再单独处理。
+    - **层高按该层最高卡片**：布局新增输入 `cardHeights`（每个节点的卡片高度，由**纯函数** `estimateLineageCardHeight` 估算：基础高 + (标题行数−1)×行高，标题行数按字符宽度估、上限 2 行）。竖版 `第 N 层的 y = 上一层 y + 上一层最高卡片高度 + rowGap`，层内所有卡片取该层最大高度（同层等高，`min-height` 撑开），因此「同层里有一张 2 行标题的高卡」也不会被下一层压住；横版（窄屏图谱）槽位高取全局最大卡片高。**不测量 DOM**（纯函数可单测、离线复算，不会先渲染再重排抖动）。常量由真机校准（**卡片改为广场卡组件后重测**）：桌面两行标题实测 231.5px → 取 214 / +20；每行字符数取 10；窄屏紧凑卡 **182 / +20**（实测两行 196px ⇒ 估算 202，只多不少）。
+    - **代际轴按层高画**：`LineageGenerationAxisEntry` 增加 `height`（该层层高），轴的每一行高度跟着层高走（不再拿「第一个节点的高度」凑）。
+    - **角标组移到封面下方**（不再用深色药丸压在封面图上），并且**上色**——每类语义一色、**全部取自平台既有 `--platform-*` 变量，不新增色值**：代际 = 中性（neutral）｜**主干 = 暖色（warm，强调）**｜**当前作品 = 主色实心（accent solid）**｜父代 = cool｜子代 = success｜▶游玩数 = 中性。组内仍是 flex + gap + 可换行（**绝不重叠**），并有 1px 边框保证在浅色卡片上有边界。
+    - **卡片底部重做**：作者行独立一行、更小更淡（`--platform-text-muted`）；操作区是**两个等权重按钮**（`flex: 1 1 0`、`min-height: 2rem` = 32px 触控目标、同圆角同内边距），`打开作品` = 次要（描边），`**开始共创**` = 主要（填充/着色）；窄卡允许换行但不裁切。大纲行同口径（`打开作品` 描边 / `开始共创` 填充）。
+    - **动作改名**：树节点（画布 + 大纲）上的 `Fork` 一律改为 **`开始共创`**（`aria-label` 同步为 `开始共创《标题》`）。**2026-10-07 用户拍板对外统一口径后，网页侧全量跟上**：详情页主操作 = 「开始共创」（未登录「登录后开始共创」）、信息面板针对某版本 = 「开始共创此版本」、提示/引导里引用该动作一律写「开始共创」；`Fork` 只作为内部标识（类名 / 字段 / 路由 / 类型名 / 协议）保留。AGC 客户端与主题页的改名不在本轮网页侧范围内。
+    - **详情页主操作行两个按钮定名（2026-10-07 用户口径：「文本改成开始游戏和开始共创」）**：
+      | 位置 | 改前 | 改后 | 说明 |
+      | --- | --- | --- | --- |
+      | 详情页主操作（游玩） | `立即玩` | **`开始游戏`** | 与**游玩页**（`GamePlayPage` 的启动按钮本就是「开始游戏」）统一词表；图标仍 `Gamepad2`、lg / pill / 位置 / 颜色一个不动 |
+      | 详情页主操作（共创者侧） | `一键开始共创` | **`开始共创`** | 与玩家侧同一词表；两侧的差别只在**样式**（共创者侧实心强调 lg，玩家侧次要小按钮 `.game-fork-remix-guest`），不再靠「一键」二字区分 |
+      | 详情页主操作（玩家侧） | `开始共创` / `登录后开始共创` | **不变** | 核对一致性即可（未登录 = 「登录后开始共创」，点击走登录门禁） |
+    两个按钮都**没有单独的 `aria-label`**，无障碍名 = 可见文本，因此随文案自动一致；`title` 只在「禁止共创」时出现（内容与新词一致）。**共创广场 hero 的按钮一并改名（2026-10-07 用户拍板，原「立即试玩」）**：它的动作是**滚动到列表**、不启动任何作品，所以改叫 **「浏览作品」**（描述滚动/查看列表；不叫「开始游戏」以免被读成会启动作品）。同一按钮在「游戏广场」与「共创广场」两种 scope 下共用，两处一起改；`aria-label` 本来就没有、无障碍名 = 可见文本，因此随之自动一致。
+
+  - **图谱视图为可选开关**（形态 B = **横版画布**，`orientation: 'horizontal'`：根在左、代际向右、兄弟分支沿纵向排开，窄屏上比顶→下更省横向空间）：切到画布后支持拖拽平移 / 缩放；横版**不渲染左侧代际轴**，代际信息由节点自带角标承担。**初次进入按宽度适配**（整棵树横向看完；触及最小缩放时给出「可拖拽平移」提示），并把**当前作品**用最小位移拉进视口——贴最近的边，父代 / 兄弟仍留在视口里，不会出现「停在 100% 缩放、一个节点都看不到」的空屏。桌面仍为纵向画布 + 宽高同时适配并居中。
+  - **信息面板用 bottom sheet**：从底部升起（含简介 / 授权 / 核心改动说明 / 前往体验 / 开始共创此版本），遮罩点击或关闭按钮收起；桌面保持画布右上浮层。
+  - **父代 / 子代区分与「只看父代与子代」开关**（2026-10-06 追加）：
+    - 每个节点相对**当前作品**有四种角色（纯函数 `collectLineageRelationRoles`）：`self` / `ancestor`（**父代** = 祖先链）/ `descendant`（**子代** = 整棵后代子树）/ `side`（旁支）。渲染层打 `data-relation`，并在节点上给**可读角标**「父代」「子代」（自己不标——已有「当前作品」角标；旁支不标）。**不靠颜色深浅表达**，因此可断言、读屏可读。
+    - **「只看父代与子代」开关**在筛选行，默认**关**（= 以根为作用域的整棵树）。打开后只留 **祖先链（父代）+ 自己 + 直接子代**（`collectLineageImmediateScope`，**不含孙代**），语义是「看这个作品的上一步与下一步」；**再点一次取消**回到整棵树。作用域里找不到锚点时不筛选（避免空图）；切换后仍重新定位到当前作品。反馈有三重：`aria-pressed`、按钮文案变「（已开启）」、旁边一行说明。
+    - 侧栏共创卡文案按同一口径：`{N 代…} · 改编自父代《…》` + `父代作者 …`；子代侧沿用「累计衍生作品 N」（全部世代）与「累计创作世代数」。
+  - 面包屑横向可滚动且**当前项常驻可见**；尊重 `prefers-reduced-motion`；底部留 `env(safe-area-inset-bottom)`。
+  - **筛选行口径**（2026-10-06 追加）：`高亮整棵子树`复选框**已删除**——它恒为真、没有用户可见意义，子树高亮改为**恒定开启**（`collectLineageHighlight` 默认即含子树；页面不再持有该开关状态，也不再有恒为 `true` 的布尔往下传）。`改动类型`下拉**保留但禁用**并在旁边写明原因（`changeSummary` 是自由文本、服务端没有可枚举分类），不编造值域。
+  - **移动端门限豁免（2026-10-06）**：平台原有的「移动端仅支持作品展示」欢迎弹窗只看 `!isDesktopLayout`、忽略路由，会把公开只读的族谱树 / 共创主题页首屏盖住。现在按**显式白名单**豁免这几个只读浏览 stage：`game-lineage` / `game-themes` / `game-theme` / `game-co-creation`（清单在 `PlatformActiveMobileWelcomeDialog.tsx` 的 `MOBILE_WELCOME_EXEMPT_STAGES`，键名即 stage 名，不做前缀/范围匹配）。**创作 / 项目 / 发布 / 我的 / 平台首页仍保持门限**——那些才是「移动端不支持体验创作工具」的部分；弹窗文案未改（与豁免后的事实不矛盾：族谱与主题页本身就是作品展示）。
+- **画布交互硬化（2026-10-07，用户口径）**：① **滚轮只缩放画布**——React 的 `onWheel` 挂在根容器上且是 **passive** 的（`preventDefault` 无效 ⇒ 页面跟着滚），因此改为在**画布元素本身**挂原生 `wheel` 监听并显式 `{ passive: false }`（不绑 `window`）；② **拖动不选中/不拖走文本**——画布容器 `user-select: none` + `touch-action: none` + `overscroll-behavior: contain`，拖动期间把 `user-select: none` 压到 `document.body`（跨出画布也有效，松手恢复），并对 `selectstart` / `dragstart` 挂原生阻止、画布内图片 `-webkit-user-drag: none; pointer-events: none`；指针捕获（`setPointerCapture`）保证移出容器仍跟手；③ **平移边界**：`clampLineagePan`（纯函数）保证任何时刻至少 `LINEAGE_PAN_KEEP_PX = 96` 像素内容可见，拖到底/拖到顶不会把内容拖飞。真机实测（Chromium，1440×900）：滚轮后缩放 60%→65%、`window.scrollY` 与平台滚动容器 `scrollTop` **都不变**；两次连续拖动各位移 +120px 且 `window.getSelection()` 始终为空字符串。
+- **「开始共创」位置与未安装检测（2026-10-07，用户口径）**：按钮从共创信息卡**搬到主操作行**（与「开始游戏 / 收藏」并列，保持主操作视觉权重；卡内不再重复出现）。未安装检测：纯 web **拿不到系统级安装信息**，只能靠「唤起后浏览器是否被接管」间接判断（`blur` / `visibilitychange`，超时 `FORK_LAUNCH_FALLBACK_DELAY_MS = 1200ms`）；**未接管 / 移动端视为「没有客户端」→ 打开与顶栏「下载客户端」同一个下载入口**（`requestClientDownload()` 事件 → `ClientDownloadEntry` 弹窗），并保留手动复制作品 ID 的降级路径与一句人话提示。**局限**：慢启动的客户端/被用户取消的系统确认框/某些不派发 blur 的环境都会误判成「未安装」，代价只是多打开一个下载入口（用户可关掉重试），不会阻断正常路径；老客户端（不响应深链）走同一条兜底。
+- **共创信息卡只留「标签 + 数据 + 入口」（2026-10-07，用户口径）**：卡里保留世代/授权标签、父代文案、数据概览（游玩合计与分解、累计衍生物、累计创作世代数）、「查看创作族谱」与所属主题 tag；**派生作品卡列表（含原「热门衍生栏」）整块移除**（`CoCreationHotDerived` 组件与其 `.co-creation-hot*` 样式已删除，零引用），改由族谱页**图下方**的「父代 / 子代」两块清单承担（父代 = 祖先链根→直接父；子代 = **直接子代**、按**热度（自身 `playCount`）降序**、同热度保持服务端创建序）。选「直接子代」的理由：与 `forkCount`/「被改编 N」同口径（数字与卡片数一致）、与画布「只看父代与子代」开关同义、更深的层级已由上面的树表达。
+- **交互口径（2026-10-07 二次修正，来自真机反馈）**：
+  - **滚轮 = 画布竖向平移**（不再是缩放）：原生非 passive 监听仍绑在**画布元素**上并 `preventDefault`，所以外部页面与平台滚动容器都**不滚**；平移到边界过 `clampLineagePan`。**`Ctrl`/`⌘` + 滚轮 = 缩放**（保留通用手势与触控板缩放能力），**`Shift` + 滚轮 = 横向平移**（内容超宽时用）。两个按钮（现在是 `Minus` / `Plus`，见下条）与「总览」（原「适应窗口」，2026-10-07 改名）负责缩放与全览。
+  - **画布控件栏图标语义逐个定标（2026-10-07 用户口径：「改成向中间的箭头，因为现在这个就是起到这个作用的」）**：整条控件栏 = 缩小 / 读数 / 放大 / 总览 / 刷新，逐个核对「图标造型 ↔ 真实行为」：
+
+    | 控件 | 图标（lucide） | 语义 | 与行为是否一致 |
+    | --- | --- | --- | --- |
+    | 缩小 | `Minus`（−） | 减号 = 缩小 | ✅ 一致（`zoomBy(1/1.2)`） |
+    | 读数 | 文本 `NNN%`（`role="status"`） | 当前缩放值 | ✅ 一致（不随字号缩放，始终可读） |
+    | 放大 | `Plus`（+） | 加号 = 放大 | ✅ 一致（`zoomBy(1.2)`） |
+    | **总览** | **`Minimize`（箭头指向中间）** | 收拢/适配到一屏 | **本轮修正**：原先用 `Expand`（四角向外）——造型表达「放大/展开」，而动作是 `fitToView(true)`（**缩小到装得下整棵树**），方向相反。`Minimize` 与 `Expand` 是 lucide 里同一对反向图标，换成它才对得上行为 |
+    | 刷新 | `RefreshCcw` | 重新拉取 | ✅ 一致（`loadLineage()`） |
+    | （无搜索） | — | — | ✅ 这条栏里**没有**放大镜，也没有搜索动作（曾有截图误读成搜索，已用测试钉住 `ZoomIn` / `ZoomOut` 不得回归） |
+
+    「总览」的**文案与 `aria-label` / `title` 保持「总览」不变**（它描述的是结果：整棵树都在视野里），只改图标造型；提示文案里的「点「总览」看全树」同步成立。
+
+  - **拖动阈值**：按下时**不捕获指针、不拦默认**；移动超过 `DRAG_START_THRESHOLD_PX = 4` 才算拖动，此时才 `setPointerCapture` + 禁选 + `preventDefault`。原因：在**容器**上按下即捕获会把 `pointerup`/`click` 重定向到容器，**卡片按钮点不动**（真机复现：鼠标点「打开作品」8s 超时、键盘 Enter 正常 ⇒ 纯指针路径被吃掉）。纯点击完全走浏览器原生 `click`。
+  - **「全屏查看族谱」= 真·全屏 overlay**：`createPortal` 到 `document.body` + `position: fixed; inset: 0`（实测 overlay 矩形 1440×900 == `innerWidth/innerHeight`），`role="dialog"` + `aria-modal="true"`，`Esc` 与「关闭」都可关，打开时焦点进 overlay、关闭后回触发按钮，`body` 滚动锁定并在关闭时恢复；移动端同样整屏并留 `env(safe-area-inset-*)`；里面就是 `GameLineagePage embedded`（**同一套画布**，点选/拖动/滚轮/封面全部同一份实现），打开时卸载内嵌那棵树避免双画布。独立 `/games/lineage` 页面与共创卡的「查看创作族谱」仍是页面级入口。
+  - **被搬出信息卡的按钮必须脱离卡内作用域**：`.game-fork-remix-*` / `.co-creation-fork-primary*` / `.game-fork-lineage-link` 原先都写成 `.game-detail-info-card .xxx`，搬到主操作行/正文区块后**选择器不再命中**，按钮退回浏览器默认样式（细边框、无内边距）。现已把这些选择器**去作用域化**，并按平台度量对齐主操作行：主操作「开始共创」= 实心强调、高 48 / 圆角 16 / 内边距 0 16（与「开始游戏」逐项一致，实测数值相同）；次级「全屏查看族谱」= 描边 pill。
+  - **封面固定 16:9 且铺满**：`.game-lineage-node__cover` 强制 `aspect-ratio: 16 / 9` + `flex: 0 0 auto`（不再被纵向 flex 拉伸），内层 `.game-cover` / `img` `100%×100%` + `object-fit: cover; object-position: center`。三处（画布卡片 / 大纲行 / 图谱下方父代子代清单）共用同一套；无封面时仍由 `GameCover` 给渐变占位（兜底未丢）。真机实测封面比例 **1.778 = 16:9**。
+  - **图谱交互**：节点卡片与图下方父代/子代清单**每项都可点开详情**（真机鼠标点击与键盘 `Enter` 都验证过），焦点样式保持。
+  - **封面盒几何口径（2026-10-07 收口）**：共享样式 `.game-cover` 自带 `min-height: 12rem`（紧凑态 `7rem`），会把族谱封面里的内层盒子撑到 192px，使 `height: 100%` 永远不生效（图片盒虚高、只靠 `overflow: hidden` 裁）。族谱封面里已显式 `.game-lineage-node__cover .game-cover { min-height: 0 }` —— **内层盒与 img 盒真正等于封面盒**（真机：画布卡片 127.4×71.7、清单行 72×40.5，比例都是 1.778 = 16:9，`object-fit: cover`）。
+  - **全屏 overlay 的画布高度口径**：全屏模式画布高度 = **视口高度 − 头部栏 − 筛选/控件两行**（`--lineage-overlay-chrome: 6.5rem`，真机 900−54−50 = **796px**），即「吃满一屏、底部没有空白带」，图下方的父代/子代清单接在画布下面随 overlay 滚动；**内嵌在详情页时仍用可读高度上限** `clamp(22rem, 62vh, 46rem)` —— 两种模式分开取值。
+- **截断 / 空树 / 不可用父节点**在两种形态下都有降级：截断提示、空态、以及「原作品已不可用」的占位节点（可聚焦、不可点进详情、不展示被删作品标题与作者名）。
+- **「共创」= 侧边栏顶层入口（2026-10-07 用户口径修正，取代同日早前的「游戏页子页签」）**：用户明确「共创页不应该是游戏页里的子标签，而应该是**侧边栏里的大标签**」。因此：
+  - **入口**：桌面侧边栏一级入口为 `创作 / 项目 / 游戏 / 共创 / 创作者主页 / 我的`（「共创」紧挨「游戏」，与它平级、**同一套** `ActiveRailButton` 样式），窄屏底部 dock 同步为 `游戏 / 共创 / 创作者主页 / 我的`（4 列）。两侧都指向**同一个** `GameGalleryPage`（`scope="forkable"`）：数据来自公开目录并带 `forkable=1`（分页/游标/去重/末页/失败态全部沿用已实现的「加载更多」）；**服务端尚未生效期间客户端再兜一层同义过滤**（`forkAuthorization !== 'forbidden'`，未知按禁止关闭），两条口径一致、服务端上线后等价幂等。页面标题 `game-co-creation` → 「共创 - 陶泥儿」，路由 `/games/co-creation`，移动端门限同样按「只读浏览 = 作品展示」豁免。空态为「暂时没有开放共创的作品」。
+  - **高亮互斥**：进共创时高亮「共创」而**不再**高亮「游戏」——`isGamesStage`（游戏区，含共创，决定搜索口语/面板滚动）与导航高亮拆开：新增 `isCoCreationStage`，导航用 `isGamesNavActive = isGamesStage && !isCoCreationStage`。
+  - **子页签删除**：游戏页与共创主题列表页里的「游戏 / 共创」子页签**全部删除**（它只为这个切换而存在）——`GameGalleryPage` 的 `onOpenGallery` / `onOpenThemes` 两个 prop 与那段 `role="tablist" aria-label="游戏区"` 一并移除，`GameThemesPage` 的同一行也删除（它保留「返回」，入口来自作品详情的「所属主题」或直接 URL）。
+  - **老链接 / 深链**：子页签从来没有自己的路径（点击即 `setSelectionStage('game-co-creation', { path: '/games/co-creation' })`），因此 **`/games/co-creation` 这个深链语义完全不变**、收藏与分享继续可用，无需重定向；路由表（`activeAppPageRoutes`）、stage 枚举、标题表本来就有这一项，未改。
+  - **卡片指标位 = 「被共创 N 次」（2026-10-07 用户口径：「并非游玩次数，而是共创次数」）**：共创页卡片的**标题行右侧指标位**从默认的「N 次游玩」换成 **「被共创 N 次」**，**封面角标「共创 N」已删除**——同一张卡上只留这一处计数。
+    - **为什么选 meta 而不是封面角标**：用户截图圈的就是 meta 这处；且角标与 meta 并存是两处重复计数，而 meta 位有固定的 0.66rem 次要信息字号可被提升成强调样式，改动面最小。
+    - **为什么文案是「被共创 N 次」而不是「共创 N 次」**：「共创 N 次」有主动语态歧义（读成「这个作品共创了 N 次」），而数字表达的是「**别人**接着做了 N 次」；平台已有词汇「累计被共创次数」（我的作品页）因此沿用被动式。与卡片上其它文案一致：`aria-label` 同为「被共创 N 次」。
+    - **突出方式**（真机实测值）：平台既有强调色 `--platform-accent-strong`（`rgb(199,101,61)`，与详情页世代标签同色）+ `font-weight: 700` + 字号 `0.72rem`（默认游玩数是 `0.66rem` / `--platform-text-soft`）+ 前置 `Sparkles` 小图标 `12.8px`（与共创 hero、侧边栏同一套语汇）+ `tabular-nums` 让同列数字竖直对齐。
+    - **只在共创页出现**：`metric` 是共享卡 `GameCard` 的**可选槽**（不传 = 原来那行「N 次游玩」，一个字不改），只有 `scope="forkable"` 传它 ⇒ 广场 / 游戏页 / 我的游戏不受影响。
+    - **0 要显示**：「被共创 0 次」= 还没人接着做，是信息不是噪声；只有**两个字段都缺省**（作者侧同形响应 / 旧响应）才不传 `metric`、退回默认游玩数——**不伪造 0**。
+    - **取值**：`resolveCoCreationCount(game) = game.coCreationCount ?? game.forkCount`（`>= 0` 才取，否则 `null`），口径同 §3.4 公开作品投影行。
+- **图下方「父代 / 子代」清单 = 响应式多列网格（2026-10-07 用户口径：「一行一个太奢侈了，你整小一点，响应式布局」）**：
+  - **问题**：两段清单曾经用**两套**容器——父代是 `grid`，子代是 `flex column + max-width: 54rem`，后者一张卡占满一行，16:9 封面被拉到 ~850×480，一屏只看得到一张半。
+  - **现在**：两段共用同一个 `.lineage-relation__grid` = `repeat(auto-fill, minmax(10rem, 1fr))` + `gap: 0.75rem`，外层 `.lineage-relations` 限宽 **54rem**（与大纲列 / 族谱内容列同一档，**不再 full-bleed**）。卡宽由列数决定 ⇒ 有上限，封面不可能再被拉成整页宽。
+  - **卡宽与画布卡的关系**：清单卡 160–200px（实测 1440 视口 **5 列**、1024 视口 **5 列**、390 窄屏 **2 列**），比画布卡（桌面 212 / 窄屏 148）**窄一档**；仍然复用**同一个** `GameCard`（`className="game-card--lineage"`），尺寸差异**只由 wrapper 表达**（`.lineage-relation__item` 作用域内）。
+  - **小卡内文字**：标题**单行省略**（`white-space: nowrap` + `text-overflow: ellipsis`，覆盖族谱卡默认的 2 行 clamp）、信息区与角标行的留白按卡宽收紧（`0.7rem` 侧内边距、游玩数/作者 `0.64rem`）。**封面仍是 16:9 + `object-fit: cover`**（实测比例 1.778），卡面无动作按钮、整卡可点。
+  - **保留**：父代为 0 时仍是「这部作品是母版，没有父代（它的后代都在上面的树里）。」空态。
+
+- **主干线唯一性复核（2026-10-07，真实数据）**：演示树 `共创演示·A0｜星海工坊`（8 节点、`playCount` 全 0，仅 A111 = 1）实测 **每代恰好一个主干**：A0（0 代）/ A1（1 代）/ A11（2 代）/ A111（3 代）；A2、A3、A12、A21 **都不是**主干。同代并列 0 热度时取「同代中**创建时间最早**」的那个（`/lineage` 契约即「代际升序、同代按创建时间升序」，布局只按输入顺序稳定取第一个），因此结果确定、不随渲染变化。**结论：主干逻辑未改**；新增「每代 isTrunk 数量恰好 1」的断言把它钉住（`lineageTreeLayout.test.ts`）。
+
+#### 3.6.2 AGC 客户端：「共创」列表页与「开始共创」确认页（2026-10-07 补充）
+
+对外口径只有一句，两处文案一字不差：**把平台上的作品整个工程复制到你的项目里继续改造。**（内部说明：设计意图与 git fork 同源——整份工程搬到你的项目里、副本独立；这层类比只写在这里与代码注释里，**不出现在任何用户可见文案中**。）
+
+**客户端动作名统一为「开始共创」**（与网页侧同一套词）：卡片按钮、确认页标题与正文、进度/错误文案（含原生 Rust 侧合成的取件错误与深链解析提示）、`aria-label`（形如「开始共创《标题》」）全部改；**内部标识保持不变**——Tauri 命令名（`create_local_project_from_platform_game`）、`.agent/fork-source.json`、协议 scheme `genarrative://fork`、组件/模块名（`ForkConfirmView`、`platform-fork/*`）、Rust 类型与埋点枚举都不改。文档里描述机制的「Fork」保留原义（它本来就是 fork）。
+
+**入口只有两条**
+
+- **卡片**：`src/view/co-creation/index.tsx` 顺序扫公开目录（最多 3 页 × 50，够 12 个即停）过滤 `forkAuthorization !== 'forbidden'`，卡片点「开始共创」→ 确认页。
+- **深链**：`genarrative://fork?gameId=<id>` 由原生解析后 `WorkspaceLauncher` 直接 `open({origin:'deep-link'})` + 切到确认页；**不带 `gameId`** 的链接回到「共创」页并把链接原因原样显示成一条提示。
+- **已移除**：手动粘贴「作品 ID 或链接」的输入块（连同 `parsePlatformGameId` / `PLATFORM_FORK_INPUT_ERROR` 死代码）。理由：深链已覆盖「从平台过来」的场景，手动粘贴属于重复入口；删掉后**深链仍直达确认页**（回归用例：`tests/appSurface/home.suite.ts` 的「深链带 gameId 时直接落到确认页」）。
+
+**「开始共创」确认页**（`src/view/fork-confirm/index.tsx`）
+
+- 结构：父作品信息卡（标题 / 作者 / 授权类型 / 作品 ID，缺项逐项降级）→ 授权须知与风险说明（**五条全文**：可修改范围 / 商用权限说明 / 署名要求 / 溯源规则 / 违规后果说明）→ 工程同步（四个**原生真实**阶段：取回作品内容 / 校验摘要与字节 / 解压到项目 / 生成工程与来源记录，不造百分比）→ 底部操作条。
+- **强制阅读 = 3 秒计时门禁**（`MANDATORY_READING_SECONDS`）：徽章显示 `Ns 后可确认`，按钮文案带倒计时且 `disabled`；**不要求「把须知滚到底」**——须知块**没有内层滚动容器**，全文随页面自然流动（页面滚动由外壳统一承担，见下）。
+- **底部操作条吸附**：`position: sticky; bottom: 0`（`FORK_STICKY_FOOTER`）挂在页面根下，滚动容器是 `.launcher-main`，因此长页面下「取消 / 确认并进入编辑」始终可见可点。
+- **卡片时间字段如实**：公开目录 payload 只有 `createdAt`（无 `updatedAt`），卡片就写「创建时间」并按本地时区格式化为 `YYYY-MM-DD`；字段缺失或不可解析时**整行不渲染**，不留恒为「—」的死行。
+
+**外壳滚动链（全应用一次修好，不再每页打补丁）**
+
+- 唯一页面滚动容器 = **`.launcher-main`**（`src/styles.css`）：`display:flex; flex-direction:column; min-height:0; overflow-y:auto; overflow-x:hidden`，视图统一 `flex: 0 0 auto` 保持自然高度；链路上 `#root`（`100dvh`）、`.window-chrome__content`（`height:100%` + `min-height:0` + `overflow:hidden`）、`.launcher-shell`（`height:100%` + `min-height:0`）逐层都给足高度并允许收缩。
+- **改动前的断点就在这一层**：`.launcher-main` 原是 `display:grid` + `grid-template-rows: auto auto auto` + `overflow:hidden`——行高被内容撑到 1494px、容器只有 570px，`overflow:hidden` 又让用户滚不动（实测：`overflow-y: hidden`、`userScrollable=false`、最后一行 `bottom=1512 > viewport 620`）。因此「共创」列表最后一行与确认页底部按钮都被裁掉、够不到。
+- **版式令牌**：两页共用 `src/features/platform-fork/forkPageStyles.ts`（内容列 `min(860px, 100vw - 124px)`、正文 `72ch` 上限、4/8 步进间距、状态用**徽章**而非灰字、只用 `packages/shared/src/theme.css` 既有 `--platform-*` 变量、`:focus-visible` 统一 `3px solid var(--platform-warm-text)`）。
+
+#### 3.6.3 游玩次数的三种口径（2026-10-07 追加，纯前端显示层）
+
+需求方口径：「游玩次数的**显示**必须是**子代叠加到父代**」——父代展示的是**自己 + 全部后代的合计**。
+于是同一份 `playCount` 有三种口径，**必须分清、不要合并**：
+
+| 口径 | 值 | 落点 |
+| --- | --- | --- |
+| 公开接口字段 `playCount` | **自身值**（服务端**不做**子树遍历） | `/lineage` 节点、`/derived` 节点、公开详情 DTO、我的作品列表 |
+| **显示** | **子树合计** = 自身 + 全部后代，并给出分解（自身 M + 衍生 K） | 详情页 hero 与「共创」卡、主题页母版行、**族谱/血缘图节点（紧凑角标 `▶ N`，`title`/`aria-label` 注明含衍生）**、热门衍生栏 |
+| **主干线判据 / 热度排序** | **自身值** | 族谱「每代热度最高」的主干线判据（裁定：主干线表达「**这一版自己**有多热」，用合计会让深层子树压制真正热的叶子）、热门衍生栏排序 |
+
+- **族谱 / 血缘图节点也显示游玩次数（2026-10-07 用户口径追加）**：显示值 = 该节点的**子树合计**
+  （同一个 `collectLineagePlayCountTotals().total`，不另算一套），画布卡片与移动端大纲行都有；
+  呈现为与其它角标**同一行的紧凑 pill**（`▶ N`，全 0 也显示以保证列稳定），`title` / `aria-label`
+  写明「游玩次数（含衍生作品）」，因此**不撑高卡片、也不额外占一行**。
+  **主干线与「按热度排序」的判据仍用自身 `playCount`**——显示=合计、判据=自身，两处代码注释互相指认。
+- **不在服务端加字段、也不让公开接口做子树遍历**（列表页会因此 N 次遍历，正是要省掉的算力成本）：
+  客户端用**已经拿到的那棵树**一次自底向上遍历即可，纯函数 `collectLineagePlayCountTotals`
+  满足与 §3.11 贡献归集**同一条不变量** `total(W) = own(W) + Σ 直接子代 total(C)`，**零额外请求**。
+- 主题页母版行复用内嵌族谱页**同一次** `/lineage`（`GameLineagePage.onPlayCountTotals` 回传），不额外请求。
+- **拿不到树的界面继续显示自身值**（我的作品列表、广场卡片等），并且**不暗示含衍生**；详情页在树回来前
+  也是自身值，「合计 + 分解」只在拿到树后出现（截断/失败时同样回退）。
+
+### 3.7 灰度与可观测
+
+- **M1 实现口径**：共创写入复用现役 `game-distribution:publish` 开关（`ensure_publish_enabled`），不新增独立灰度键——本功能与发布能力同批上线，先少一个开关减少漂移面。独立键 `game-distribution:fork`（含 `/api/runtime/frontend-config` 的 `gameDistributionForkEnabled` 与前端入口门禁）作为后续增强保留，接入前需要同时改 `module-runtime`、`api-server` 与前端配置读取。
+- 事件：`game_fork_source_downloaded`、`game_fork_declared`、`game_fork_authorization_updated`，含成功/失败分类；不发对象键与用户隐私字段。
+- **M1 未接埋点**：上述事件在 M1 未实现（当前只有既有 `tracing` 日志），随 M2 的内容下发一起补，避免在无下载能力时先埋无意义事件。
+- **M2b 口径（2026-10-05）**：共创写入仍复用 `game-distribution:publish`，未新增独立灰度键；**内容下发与工程包上传目前只有 `tracing` 日志**（带 `operation` 与 `request_id` 标签，便于按请求串联），上面三个结构化埋点事件**仍未接**——待产品确认事件口径与埋点表后再补，避免先埋一套随后要改的字段。
+
+### 3.8 兼容与迁移
+
+1. `game_distribution_game` / `game_distribution_version` 均为**表尾追加 + 明确默认值**，符合 SpacetimeDB 兼容追加规则；旧行语义 = 禁止共创 / 无工程包。
+2. `game_distribution_lineage` 为新表，初始为空；根作品的「0 代」由「无血缘行」表达，不需要回填。
+3. `migration.rs` 的 `migration_tables!` 白名单登记新表，并在注释中说明「血缘是业务事实，随迁移导出/导入；工程包正文在对象存储，不进入表」。
+4. 必须运行 `npm run spacetime:generate`、`npm run check:spacetime-schema`、`npm run check:game-distribution-dto-parity`、`npm run check:generated-bindings`。
+5. 不改删除 / 改名 / 重排 / 类型；若实施中发现必须如此，先停下来确认迁移计划。
+
+### 3.9 与「作品管理」改动的关系（PR #565）
+
+`feat/game-works-management`（PR #565，作品管理与 Phaser4 客户端发布）与本功能改同一批文件，且引入了三处**语义**影响，落地时必须按其口径收敛：
+
+| PR #565 带来的变化 | 对本功能的影响 |
+| --- | --- |
+| `game_distribution_game` 追加 `deleted_at`，软删除后对该作品一律按「不存在」处理（作者视图、公开目录/详情、发行网关、后台默认列表全部下线，版本行与冻结资料保留） | ① 血缘来源校验增加「父作品未软删除」；②「衍生作品数」只统计**未删除**的子作品；③ 已被软删除的父作品是既有子作品的可见来源，但溯源只展示「原作品已不可用」，**不展示被删作品标题**，避免软删除语义被血缘绕过 |
+| 游戏行同时被两条分支在表尾追加列（`deleted_at` 与 `fork_authorization`） | 合并后两列并存即可；SpacetimeDB 自动迁移按列补齐，旧行各自取默认值 |
+| `play_count` 由新增的游玩计数上报变成**活字段** | 本功能不依赖它；主规范 §1.3 里「死字段」的结论在 #565 合并后失效，以合并结果为准 |
+
+补充（2026-10-05）：作者**上架时即可指定档位**——创建作品的请求增量里新增可选 `forkAuthorization`（缺省 `forbidden`，非法取值 400 + 平台信封，见 §3.4），不再是「先落 `forbidden`、再靠 PUT 提升」；事后提升（`PUT …/fork-authorization`）仍然保留，用于把已上架作品单向提升。该增量对 #565 侧无影响：创建请求与游戏行默认值都保持向后兼容。
+
+补充（2026-10-06，授权继承口径，产品决定）：**衍生作品创建时直接继承父作品当时的档位**，不再落 `forbidden`、也不接受客户端另选档位——带 `fork` 声明的创建请求里 `forkAuthorization` **一律被忽略且不报错**（旧客户端会惯常带自己的默认档位），新行的 `fork_authorization` 取父行的档位；母版维持原样（按请求值，缺省 `forbidden`）。继承是**创建时快照**：父作品之后提升档位不会回溯改写既有子作品的行（子作品行的档位此后不再变化，见下一条补充）。父作品为 `forbidden` 时本来就不能建立血缘（`403 FORK_NOT_AUTHORIZED`），所以继承到的档位必然是 `nonCommercial` 或 `full`。**收窄入口不做**（需求里「可选择收窄授权，不可放宽」已划掉）。落点：`spacetime-module/src/game_distribution.rs` 的血缘解析返回父行档位、创建事务经 `resolve_game_distribution_creation_fork_authorization` 裁决（衍生忽略请求值 / 母版按请求值）。`PUT …/fork-authorization` 的**母版**合同未改（仍只升不降、仍服务提升）；但衍生作品的提升随后被关掉，见下一条补充。
+
+补充（2026-10-06，授权**终态**口径，产品决定）：**衍生作品的档位是终态**，不再允许沿 `PUT …/fork-authorization` 提升。原口径「继承只影响创建、提升照旧」留下一个真漏洞：继承是「创建时快照等值」，而 `PUT` 只限方向不限对象——作者可把继承来的 `nonCommercial` 再提成 `full`，得到一个**比祖先更宽**的子作品，把父作品在非商用授权下公开的工程内容变成可用商用。现在的判定：该作品**存在血缘行（即衍生作品）→ 直接拒绝**，稳定错误码 **`FORK_AUTHORIZATION_INHERITED`（409）**，文案「衍生作品的共创授权由父作品继承，不能自行修改」。口径是**任何** `PUT` 都拒（含传同值这种幂等重试），因为档位是终态、只由继承决定，这样客户端不会遇到「有时成功有时失败」的随机性；母版（无血缘行）保持可提升（只升不降 + CAS 语义一律不变）。判定落点：`spacetime-module/src/game_distribution.rs` 的 `set_game_distribution_fork_authorization_tx`——**幂等重放分支之后、CAS 之前**查血缘行（`game_distribution_lineage().game_id().find(...)`），把 `has_lineage_row` 连同 `current` / `expectedForkAuthorization` / `target` 交给纯函数 `module_game_distribution::resolve_fork_authorization_promotion` 一次裁决（衍生终态 → CAS → 只升不降；判据只有这一份实现）。api-server 的 `FORK_` 映射表登记同一码（409），并纳入「模块真实文案可达」枚举测试（未登记的码会退化成 `FORK_ERROR`/409，该反证保持）。
+
+同一批重叠文件（24 个）里多数是**机械冲突**（同一函数/同一 `json!` 块/同一枚举块各加一段），唯一需要重新生成的是 `spacetime-client/src/module_bindings/**`：合并后必须重跑 `npm run spacetime:generate`，不得手工合并生成物。
+
+合并顺序：**先合 #565 到 master，再把本分支 rebase 到新 master**，然后重跑 §5.1 的全部门禁与本地发布 smoke。
+
+#### 3.9.1 rebase 落地结果（2026-10-04，已完成）
+
+`git rebase origin/master`（新 master = `6c9566058`，含 #565 与 #615）后本分支重放两个提交，无 merge commit，未改动 master。
+
+**冲突与解法（9 个文件）**
+
+| 文件 | 冲突形态 | 解法 |
+| --- | --- | --- |
+| `server-rs/crates/module-game-distribution/src/lib.rs` | `domain` re-export 列表两侧各加名字 | 合并去重（`next_generation` + `resolve_version_number` 并存） |
+| `server-rs/crates/spacetime-module/src/game_distribution.rs` | 游戏行表尾追加列（`deleted_at` / `fork_authorization`）、动作常量、`insert` 字段 | 三处都保留两侧；`GameDistributionLineage` 新表整体保留 |
+| `server-rs/crates/api-server/src/modules/game_distribution.rs` | 导入列表、payload 辅助函数、错误映射、路由挂载测试 | 导入合并去重；`owner_game_entry_payload` 与 `lineage_payload` 并存；错误映射**两段都留**且 `FORK_*` 分支仍排在通用子串分支之前；测试里「未带 Bearer」用例两侧都保留 |
+| `src/components/game-distribution/MyGamesPage.tsx` | 幂等键种子、状态钩子、行内动作 | 两侧都保留：状态筛选 / 资料编辑 / 版本历史 / 删除入口 + 共创授权行内提升入口（提升控件排在删除入口之前，避免危险动作夹在中间） |
+| `src/components/game-distribution/MyGamesPage.test.tsx` | 导入符号、mock 重置、两组用例 | 两侧都保留，共创用例追加在文件末尾 |
+| `src/components/game-distribution/GameDetailPage.tsx` | 详情页被 #565 改成共享 `GameDetailDisplay` 组件 | **以 #565 的新结构为准**，共创信息改由 `infoCards` 槽位渲染（见 3.9.2） |
+| `src/components/game-distribution/gameDistribution.css` | 详情页旧布局规则 vs #565 新版 | 旧布局规则（`game-info-card` / `game-detail-body` 等）已由共享组件 `GameDetailDisplay/index.css` 接管，不再保留；只保留 `game-fork-*` 卡内样式并改挂 `.game-detail-info-card` 前缀 |
+| `src/services/gameDistributionClient.ts` | 同一 `import type` 列表加名字 | 合并去重 |
+| `module_bindings/game_distribution_game_type.rs` | 生成物 | 不手工合并，重跑生成 |
+
+生成物：重跑 `npm run spacetime:generate -- --rust-only` 之后，rustfmt 版本差异会带来约 200 个不相干文件的格式漂移，按「只保留与本次 schema 相关的生成文件」处理——保留 `module_bindings/game_distribution*` 与 `module_bindings/module_bindings.rs`，其余 `git checkout --` 还原。
+
+#### 3.9.2 详情页共创卡在新结构里的落点
+
+#565 把详情页的 hero / 正文 / 资料侧栏收敛进共享组件 `packages/shared/src/components/GameDetailDisplay`（`.game-detail-info-card` 等类名，样式随组件自带）。因此：
+
+- 公开页与作者页都继续用 `GameDetailDisplay`，**不再自己拼 hero / 正文**；
+- 共创信息（授权徽章 + 代际 + 溯源 + 已被改编次数）通过它的 `infoCards` 槽位渲染，落在资料侧栏，等价于原设计里 `.game-info-card.game-fork-card` 的位置；
+- 共享组件会把 `value` 再包一层内联 flex 的 `span`，卡内样式统一用 `.game-detail-info-card .game-fork-*` 前缀保证优先级；
+- 父作品被软删除时后端 `parentTitle` 为 `null`，卡片降级为「第 N 代作品 · 原作品已不可用」，不猜测、不回显已删内容。
+- **`lineage.parentAuthorName` 是读时联账号表的结果（2026-10-06 修）**：账号显示名优先，账号不可得或昵称为空白时退回发布时冻结的作者名，两者都为空则 `null`（不占位、不伪造）。**不得**只读游戏行的冻结列 `author_name`——老数据与程序化创建的作品上它常为 `None`，真实库里就出现过「`parentTitle` 有值而 `parentAuthorName` 为 `null`」，导致溯源条「父作品 · 作者名」开天窗；口径与公开投影 / 族谱节点共用 `resolve_lineage_author_name`。
+- **不提供 `rootAuthorName`**：前端溯源条只展示父作者（`GameDetailPage` 只消费 `parentAuthorName`），根侧只发 `rootTitle`；除非将来确实要展示根作者，否则不加字段以免契约膨胀。
+
+---
+
+### 3.10 共创主题（平台命名的作品树归组实体）
+
+> **形态**：网页端「游戏 / 共创」**不再是页内子页签**——2026-10-07 用户口径修正后，「共创」是**侧边栏顶层入口**（与「游戏」平级、桌面与移动端都有），指向的仍是 `scope="forkable"` 的 `GameGalleryPage`（**只列支持共创的作品**，请求带 `forkable=1`，见 §3.4 目录接口与 §3.6.1 的入口条目）。早前两次口径变更记录在案：先「共创页签进共创主题列表」→ 用户「先别整主题了」改成直出作品卡片 → 再「不该是子标签、应该是侧边栏大标签」升为顶层入口；**共创主题的实现与路由全部保留**（`/games/themes` 主题列表、`/games/theme?id=` 主题详情、作品详情里的主题链接），只是没有任何页签入口，主题相关页面由「作品详情 → 所属主题」或直接 URL 进入。
+>
+> 本节把 §7 第 3 条（「是否引入共创主题实体」）从**待拍板**收敛为**已拍板**：采纳「平台命名主题 → 作品树」。归属关系的**曝光口径不变**——作品之间不互相挂靠，主题是运营侧的**额外归组维度**，不是作品的可读锚点。**设计定稿于 2026-10-06（commit `063c04a1b`）；服务端三块随后落地**：数据模型与领域纯函数 `2fa201e0d`、公开读路径 `742723a58`、后台写路径 `033e3aa79`。**前台（共创 Tab / 主题页 / 详情页入口）与后台管理 UI 仍未做**。
+>
+> 每小节末尾显式标注 **已实现**（服务端已落地，附提交号）或 **留白**（明确不做，需另立需求）；**已实现**只表示服务端接口 / 事务 / 纯函数已落地，不代表前台 UI 或 dev 栈端到端已验收。
+
+#### 3.10.1 实体：`game_distribution_theme` + `game_distribution_theme_member`
+
+```rust
+#[spacetimedb::table(
+    accessor = game_distribution_theme,
+    index(
+        accessor = by_game_distribution_theme_created_at,
+        btree(columns = [created_at])
+    ),
+)]
+#[derive(Clone)]
+pub struct GameDistributionTheme {
+    /// 平台签发的主题 ID，形如 `theme-*`；由服务端生成，不接受客户端指定。
+    #[primary_key]
+    pub(crate) theme_id: String,
+    /// 主题名（运营命名，不是根作品标题的派生）。
+    pub(crate) name: String,
+    pub(crate) summary: String,
+    /// 角标短文本（本轮用它 + 名称承担「封面」的呈现职责，见 §3.10.9）。
+    pub(crate) badge: String,
+    /// 运营排序权重（成员排序使用；主题侧的用途见 §3.10.6 的说明）。
+    pub(crate) sort_order: i64,
+    /// `draft` / `published` / `archived`。
+    pub(crate) status: String,
+    /// 创建该主题的运营账号（= 后台会话主体），用于审计，不参与鉴权判定。
+    pub(crate) created_by_user_id: String,
+    pub(crate) created_at: Timestamp,
+    pub(crate) updated_at: Timestamp,
+}
+
+#[spacetimedb::table(
+    accessor = game_distribution_theme_member,
+    index(
+        accessor = by_game_distribution_theme_member_theme_id,
+        btree(columns = [theme_id])
+    ),
+    index(
+        accessor = by_game_distribution_theme_member_root_game_id,
+        btree(columns = [root_game_id])
+    ),
+)]
+#[derive(Clone)]
+pub struct GameDistributionThemeMember {
+    /// 确定性主键 `"{theme_id}:{root_game_id}"`（同 `game_distribution_collection` 的写法）。
+    #[primary_key]
+    pub(crate) member_id: String,
+    pub(crate) theme_id: String,
+    /// 只允许**根作品**（见 §3.10.2）。
+    pub(crate) root_game_id: String,
+    pub(crate) sort_order: i64,
+    pub(crate) created_at: Timestamp,
+}
+```
+
+| 设计点 | 取值 | 理由 | 代价 |
+| --- | --- | --- | --- |
+| 独立表而不是在 `game` 上挂「主题」列 | 两张新表 | 归属是**多对多**关系（见 §3.10.3），`game` 上加单值列直接表达不了；且 `game` 主行是详情页热路径，不该再塞运营归组字段 | 多两张表与两条索引，迁移白名单与生成绑定都要跟着走 |
+| `theme_id` 由服务端生成、形如 `theme-*` | 与 `game-*` 同族命名 | 主题是平台实体，ID 不应由调用方决定（避免运营侧的碰撞与「抢 ID」）；命名同族便于日志与排障一眼区分实体 | 运营无法用自选 ID 做外部引用；本轮不做 slug（§3.10.9） |
+| `member_id` 用**确定性**主键 `"{theme_id}:{root_game_id}"` | 与 `collection_id` 同款 | 去重由**主键结构**保证，而不是靠「事务里先查后写」：同一主题内同一根不可能出现第二行，因此**不需要**再建唯一索引 | 跨主题的同一根会有**多行**（每主题一行）——这是预期的，不是重复数据（§3.10.3） |
+| `theme_id` / `root_game_id` 各建**具名** btree 索引 | 两条具名索引 | 两条真实查询路径都需要它：① 主题页按主题取成员；② 作品详情按根反查所属主题（§3.10.7）。具名（`by_game_distribution_*`）与仓库既有命名一致，生成绑定与 schema 门禁都按具名索引核对 | 写入多两条索引维护成本；主题量级小，可忽略 |
+| `status` 三态：`draft` / `published` / `archived` | 三态白名单 | 运营需要「未发布」「已发布」「已归档下架」三种处置；归档不是删除（成员行保留，见 §3.10.5），语义比 `deleted_at` 更弱也更可逆 | 每次新增一态都要在三处（可见性纯函数、后台列表过滤白名单、DTO）同步，靠测试与 DTO parity 钉住 |
+| `created_by_user_id` = 运营账号 | 审计字段 | 后台写接口是运营动作，出问题时必须能答「谁建的 / 谁改的」；与仓库现有 admin 操作留痕同口径 | 仅记录创建者，不记录后续每次改动者（本轮不建单独的主题修改日志） |
+
+**已实现（`2fa201e0d`）**：两表、两条具名索引、`migration.rs` 的 `migration_tables!` 白名单登记、生成绑定与 schema 门禁。
+
+#### 3.10.2 成员只允许「根作品」
+
+| 判断 | 结论 | 理由 | 代价 |
+| --- | --- | --- | --- |
+| 成员可以是任意代作品吗 | **不可以，只允许根**（根 = 该作品没有血缘行，即第 0 代） | 主题页要呈现的是**作品树**，而我们的树查询 `/games/{id}/lineage` 是**按根聚合**的（`by_game_distribution_lineage_root_game_id` 取整棵子树）。若允许任意代作品入主题，同一棵树会在主题页里出现**多次**（子作品自己一条成员、它的根又一条成员），去重与「高亮当前节点」都会打架 | 运营不能把某一代子作品单独挂进主题——**要挂就挂它所属的根**。这是产品口径上的约束，不是技术限制 |
+
+实现口径：成员写入时按「该 `game_id` 是否存在血缘行」判定——`game_distribution_lineage().game_id().find(&game_id)` 命中（有行 ⇒ 非根）一律拒绝（`409 THEME_MEMBER_NOT_ROOT`）；未命中即视为根。
+
+**族谱页已有 `from` 高亮参数**，因此「从主题页直接跳到某一代节点」将来属于 **UI 层**能力，**不需要**模型支持「成员是第几代」这类字段。**留白**：主题内的「跳到某一代节点」高亮本轮不做（§3.10.9）。
+
+#### 3.10.3 一个作品可以属于多个主题（跨主题多归属）
+
+| 判断 | 结论 | 理由 | 代价 |
+| --- | --- | --- | --- |
+| 同一根能否同时属于多个主题 | **可以**，这是预期行为 | 主题是**运营叙事**而不是分类学唯一归属：「平台精选」「双人合作」完全可能同时收录同一个根。`member_id` 的确定性主键只保证「**同一主题内**同一根不重复」，跨主题重复是设计的一部分 | ① 运营改作品时要意识到它可能出现在多个主题里（本轮不做「该作品属于 N 个主题」的运营侧提示）；② 作品详情必须返回**多值** `themes`（§3.10.7），不是一个可选单值 |
+
+**已实现（`2fa201e0d`）**：多归属由 `(theme_id, root_game_id)` 的复合语义自然承载，不需要额外结构。
+
+#### 3.10.4 与血缘树的关系：直接复用 `/games/{id}/lineage`
+
+| 判断 | 结论 | 理由 | 代价 |
+| --- | --- | --- | --- |
+| 主题页怎么拿树 | 主题页呈现**多棵树**（一个主题可含多个根），树数据**直接复用既有 `/games/{id}/lineage`** | 该端点已落地且已收敛全部口径（锚点 404、只出现公开未删节点、稳定排序、上限截断，见 §3.4 与 `lineage.rs`）。**不在主题侧重建任何树查询或树整形**，就没有第二套可见性/排序规则可漂移 | 前端要按成员根清单**逐个**请求树（N 次），存在 N+1 |
+| 主题详情返回什么 | **只返回成员根清单**（按 `sort_order` 稳定排序 + 每个根的既有公开摘要） | 服务端职责边界清晰：主题管「有哪些根、什么顺序」，树是 lineage 的职责。两个端点各自可独立演进（例如将来 lineage 加上限/分页，不需要动主题） | 响应里没有整棵树，客户端组装；**留白**：将来如确有必要，再提供一个**批量树端点**（§3.10.9） |
+
+**已实现（`742723a58`）**：主题详情返回 `roots`（逐条为既有 `public_game_payload` 投影）。**留白**：批量树端点。
+
+#### 3.10.5 可见性口径（与现有一致）
+
+判定写成**纯函数**（`module-game-distribution`，不碰 `ReducerContext`），与 `game_distribution_collection_visible` / `lineage_anchor_readable` 同一层，理由：可见性是最容易漂移的规则，必须能脱离真库单测。
+
+| 对象 | 可见条件 | 理由 |
+| --- | --- | --- |
+| 主题 | `status == published` | 公开侧不出现草稿与归档；运营在后台仍可见全量 |
+| 成员（根） | 作品**公开未删**且**有当前公开版本** | 与公开目录 / 收藏同一份口径：未公开、已软删除、没有当前公开版本的作品不得出现在任何公开投影里 |
+
+| 情形 | 响应 | 理由 | 代价 |
+| --- | --- | --- | --- |
+| 主题不存在 | **404** | 与「锚点必须公开可读」同一条纪律：不用空壳回应，避免对外确认「这个 `theme_id` 存在」 | 客户端无法区分「主题不存在」与「主题存在但未发布」——这正是目的 |
+| 主题未发布（`draft` / `archived`） | **404**（同上） | 同上；不区分「存在但未发布」 | 运营预览需要后台接口（本轮后台 UI 不做） |
+| 主题已发布、但可见成员为空 | **200 + 空成员列表** | 主题是**运营实体**，不是「不可读锚点」：它的存在本身由运营发布行为对外确认，且不指向任何具体作品，空树不构成泄露。用 404 反而会让「刚建好还没挂作品」的正常运营状态被误判为故障 | 前端要显式写空态（不能把「空」当「错」） |
+| 成员作品下架 / 软删除 | 该成员在**投影里跳过**，**行不删除** | 与收藏同口径：重新公开后**自动回来**，不需要运营重新挂 | 主题页的成员数会随作品状态变化（这是真实投影，不是计数漂移）；行与投影的差异必须靠测试钉住 |
+
+**已实现（`2fa201e0d` 纯函数 + `742723a58` 事务投影）**：`theme` 可见性纯函数、`member` 可见性纯函数、以及「投影跳过但不删行」的事务级断言。**留白**：主题级联下架 / 归档时的成员清理（不做——归档本身就是「不再公开」，成员行按同一口径保留）。
+
+#### 3.10.6 公开接口（匿名可读、`Cache-Control: no-store`）
+
+| 方法 / 路径 | 响应 | 说明 |
+| --- | --- | --- |
+| `GET /api/game-distribution/themes?limit=&cursor=` | `{ themes: [{ themeId, name, summary, badge, memberCount }], nextCursor }` | 公开主题列表（只含 `published`）。**分页沿用刚落地的那套游标惯例**：默认 20、上限 50、超界截断；游标 `"{createdAtMicros}:{themeId}"`（`"{micros}:{id}"` 同一套惯例，解析只切第一个冒号）；非法游标 **400**；`nextCursor` 为真实值，**末页为 `null`** |
+| `GET /api/game-distribution/themes/{theme_id}` | `{ themeId, name, summary, badge, memberCount, roots: [<既有公开作品投影>...], rootsTruncated }` | 主题详情 + 成员根清单。`roots` 逐条用公开目录同一份 `public_game_payload` 投影；排序 `sort_order` 升序 + `member_id` 升序兜底（`sort_order` 允许重复，兜底键保证全序、翻页/渲染不重不漏），并按响应体积上限取前 50 条。`memberCount` 是**真实可见成员数**，`rootsTruncated` 说明这份 `roots` 有没有被上限截断。顶层扁平形状与 `GET /games/{gameId}` 同形，不引入第二套包装。不存在 / 未发布 → 404（§3.10.5） |
+
+补充口径：
+
+- **`memberCount` = 真实可见成员数**（不截断），回答「这个主题有多少棵作品树」；理由：若回报「全部成员行数」，运营就能通过计数变化探测「存在草稿或被下架成员」。代价：计数是逐主题现算的（不新增物化计数字段，与仓库「实时算、不加物化计数」的既有取舍一致）。
+- **`rootsTruncated` = 「下面这份 `roots` 被响应体积上限截断」的显式信号**（仅当 `roots` 少于同响应的 `memberCount` 时为 `true`）。它与 §3.4 族谱响应的 `truncated` 是**同一个约定**（「这份列表被上限截断」，客户端按同一种方式分支），不发明第二套「还有更多」的表示。为什么不让 `memberCount` 继续等于 `roots.len()`：那个等式把「展示上限」（响应体积）和「事实」（主题有多少棵树）绑成一个数，可见成员 > 50 时客户端拿到一个**偏低**的成员数却毫无察觉；拆成两个字段后，客户端既能显示真实规模，也知道自己看到的是不是全集。
+- 切页与计数的顺序：`roots` 走「先按可见性过滤 → 再按 `sort_order` 排序 → 取前 50 条」，`memberCount` 数的是**过滤后、切页前**的整份可见成员（同一份可见性判定，只有一处实现），因此两个数只可能因「上限」而不同，不会因口径不同而漂移。
+- 排序与切页顺序定义为「**先按可见性过滤、再排序切页**」，游标位置落在已过滤序列上——否则每翻一页都会漏掉自己的若干条（与 `/my-collections` 同一条纪律）。
+- 全路径 `no-store`，挂在既有 `add_no_store_response_headers` 上；不新增第二套响应头中间件。
+- **口径已定（2026-10-06，原「三个备选待拍板」的选项 ③）**：详情 `roots` **保留** 50 上限（一次全发的响应体积风险与超长主题的首屏成本都不划算，`roots` 分页则要把「一次拿全」的契约改成翻页，得配成员游标），同时 `memberCount` 报**真实可见成员数**、并新增 `rootsTruncated` 给客户端一个能分支的信号。落地位置：纯函数 `module_game_distribution::game_distribution_theme_roots_truncated`、事务 `get_game_distribution_theme_detail_tx`（`member_count` 不再取 `roots.len()`）、响应键 `rootsTruncated`（已在 `check:game-distribution-dto-parity` 的 `mustEmit` 里钉住）。
+
+**已实现（`742723a58`）**：上述两条公开路由 + 可见性过滤 + 游标分页；DTO parity 登记 `public_themes_payload` / `public_theme_detail_payload` / `public_theme_summary_payload` 三个构建器。
+
+#### 3.10.7 作品详情增量：`themes: [{ themeId, name, badge }]`
+
+`GET /games/{game_id}`（公开详情）在既有字段之上追加 `themes`：该作品所属的**公开**主题列表。
+
+**实现口径（必须先取根，再按根反查）**：
+
+1. 先取该作品的**根**——`game_distribution_lineage().game_id().find(&game_id).map(|l| l.root_game_id)`，**无血缘行则为自身**（与 `game_distribution_lineage_entries` 的根解析同一写法，复用既有函数而不是重写一遍）；
+2. 再用 `by_game_distribution_theme_member_root_game_id` 按根取出成员行，联主题行，只保留 `status == published` 的主题。
+
+| 决策 | 理由 | 代价 |
+| --- | --- | --- |
+| 按**根**反查而不是按作品自身 | 成员只允许根（§3.10.2）。若按 `game_id` 自身查成员，**第 N 代作品永远查不到任何主题**，而产品要求「作品详情能看到并跳到对应主题页」——第 N 代作品恰恰是最需要跳转的那一批 | 详情页多一次血缘点查 + 一次成员索引查（都在本进程的 SpacetimeDB 上，不走网络） |
+| 多值数组，不是可选单值 | 跨主题多归属（§3.10.3） | DTO 是数组，前端要按数组渲染 |
+| 排序用与公开列表**同一份**排序纯函数（创建时间倒序 + `theme_id` 升序兜底） | 同一份比较器复用，避免「列表一种顺序、详情另一种顺序」的第二套语义 | 数组顺序不承载运营意图（运营侧顺序是成员的 `sort_order`，不是主题之间的顺序） |
+
+**已实现（`742723a58`）**：详情 payload 追加 `themes`；DTO parity 登记该构建器（证明这条路径确实会发出该键）。**留白**：主题入口在详情页的 UI 呈现（属前端里程碑）。
+
+#### 3.10.8 后台接口与鉴权（后台 UI 不在本轮）
+
+鉴权**照仓库既有 admin 体系**，不自造：路由挂进 `game_distribution::router` 的 `admin` 子路由族，统一 `route_layer(middleware::from_fn_with_state(state, require_admin_auth))`，handler 取 `Extension<AuthenticatedAdmin>`（`server-rs/crates/api-server/src/admin.rs:130`、`:2042`），路径前缀 `/admin/api/game-distribution/*`。写接口要求 `Idempotency-Key`（上限 128 字符，与既有常量同口径）。
+
+| 方法 / 路径 | 语义 | 幂等 / 并发 | 错误 |
+| --- | --- | --- | --- |
+| `POST /admin/api/game-distribution/themes` | 创建主题（`name` 必填、非空；`summary` / `badge` / `sortOrder` / `status` 可选，缺省 `draft`） | 要求 `Idempotency-Key`；同键重放返回 `replayed: true`，同键不同请求 → 409 | 非法 `status` / 空 `name` → 400；未带 admin 会话 → 401 |
+| `PUT /admin/api/game-distribution/themes/{theme_id}` | 改名 / 简介 / 角标 / 排序 / 状态（整体覆盖这几个字段） | 要求 `Idempotency-Key`；`updated_at` 每次生效即刷新 | `theme_id` 不存在 → 404 `THEME_NOT_FOUND`；非法 `status` → 400 |
+| `GET /admin/api/game-distribution/themes?limit=&status=` | 后台列表，**含 `draft` / `archived`**；`status` 缺省 = 全量 | 只读 | 非法 `status` 过滤值 → 400（白名单 `all` / `draft` / `published` / `archived`，与后台作品列表同一处理方式） |
+| `PUT /admin/api/game-distribution/themes/{theme_id}/members/{root_game_id}` | 增 / 改成员（幂等 upsert，body 可带 `sortOrder`） | 幂等由**确定性主键**保证（同主题同根只有一行），重复调用不产生第二行、结果相同 | 主题不存在 → 404 `THEME_NOT_FOUND`；作品不存在 → 404 `THEME_MEMBER_GAME_NOT_FOUND`；作品**非根**（有血缘行）→ 409 `THEME_MEMBER_NOT_ROOT` |
+| `DELETE /admin/api/game-distribution/themes/{theme_id}/members/{root_game_id}` | 移除成员 | **不要求** `Idempotency-Key`：按确定性主键删除，重复调用结果相同（不存在也算成功），没有「重放 vs 新意图」需要区分（与 `DELETE …/collection` 同一取舍） | 主题不存在 → 404；成员不存在 → 200（幂等成功） |
+| `GET /admin/api/game-distribution/themes/{theme_id}/members?limit=&cursor=` | 读取主题成员**名单**：**全部成员行**（含当前不可见的）+ 每行 `visible` / `visibility`；**`draft` / `archived` 主题照常可读** | 只读；分页 `limit` 缺省 20 / 上限 50 / `0` 取默认 / 超界截断，游标 `"{sortOrder}:{memberId}"`，末页 `nextCursor: null` | 非法游标 → 400 `THEME_INVALID_CURSOR`；主题不存在 → 404 `THEME_NOT_FOUND`；`draft` / `archived` **不是** 404 |
+
+说明与理由：
+
+- **成员增删「都幂等」**：`PUT` 靠确定性主键、`DELETE` 靠「不存在也算成功」，两条都不需要「先查后写」的事务假设。
+- **不做「成员必须是公开作品」的前置校验**：运营完全可以先把主题和成员备好（作品还是草稿），等作品公开后成员**自动**出现在公开投影里；这与 §3.10.5「投影跳过但不删行」是同一条规则的正面用法。代价：运营不能靠 `PUT` 的返回判断成员当前是否对外可见——后台列表需要按可见性口径显示「当前不可见」标记（**本轮后台 UI 不做**）。
+- **`sort_order` 的定位**：本轮的**公开主题列表排序由游标惯例决定（`created_at` 倒序 + `theme_id` 升序兜底）**，`sort_order` 用于**主题内成员排序**与后台列表展示顺序。理由：游标格式的主键是 micros，若公开列表改按 `sort_order` 排，就需要 `(sort_order, theme_id)` 双键游标，与「沿用刚落地的那套游标惯例」冲突。若产品要求共创 Tab 按运营序展示，需要显式改游标格式（见 §7 与本轮里程碑的待确认项）。**留白**：主题级排序的运营拖拽 UI。
+- **成员名单**读**接口（2026-10-06 补）**：后台要成员名单，原先只能借道**公开投影** `GET /api/game-distribution/themes/{theme_id}`，而公开投影只服务 `status == published` 的主题——**草稿 / 归档主题的成员在后台根本列不出来**，运营没法在发布前核对名单。因此补 `GET …/themes/{theme_id}/members?limit=&cursor=`：**不套公开可见性过滤**（草稿主题也读得到）、返回**全部成员行**，每行带两个**刻意独立**的字段——`visible` = 此刻公开投影会不会包含它（未删 + 已公开 + 有当前公开版本，**复用** `game_distribution_theme_member_visible`，不另写一套判定），`visibility` = 更细的状态（软删除 → `deleted`，游戏行不存在 → `missing`，否则原样透传游戏行的 `published` / `unpublished` / `suspended`）。两者不可互相推导：`visibility == "published"` 而**没有**当前公开版本时 `visible == false`，这个组合是刻意的——运营要能一眼看出「作品已公开、但没有公开版本」。排序复用公开侧**同一份**比较器（`sort_theme_members`：`sort_order` 升序 + 成员主键升序兜底），只是多套一层游标与 `limit`；游标 `"{sortOrder}:{memberId}"` 沿用 `"{i64}:{rest}"` 惯例、解析**只委托**主题列表那套解析（因此非法游标仍是**可达的** 400 `THEME_INVALID_CURSOR`）。`title` 只为后台渲染而发（后台本就允许看草稿作品），游戏行不存在时为 `null` 但**键仍发出**。`draft` / `archived` **不是** 404（主题不存在才是）。
+- **错误码命名**：沿用 `FORK_*` 那套「`模块前缀_原因` 字符串 → 状态码」的映射写法（`theme_*` 纯函数产出，api-server 集中映射），不落到 axum 默认的 422 纯文本。
+
+**已实现（`033e3aa79`）**：五条后台路由 + 权限校验 + 幂等 + 错误码映射 + 后台列表（含 `draft` / `archived`）。**已实现（本条）**：成员名单读接口（第 6 条后台路由，含 `visible` / `visibility` 两个口径与游标分页），把「后台要成员名单只能借公开投影、草稿 / 归档主题看不到成员」这个缺口补掉。**留白**：后台管理页面（UI 不在本轮，本条只落接口与事务）。
+
+#### 3.10.9 留白与已知限制（显式列出，不静默省略）
+
+| 留白项 | 为什么不做 | 将来怎么接 |
+| --- | --- | --- |
+| 主题**封面图** | 要接平台素材链路（上传 / 存储 / 生命周期）与公开授权口径，是一份**独立小需求**，塞进本轮会把「主题模型」和「素材链路」两件事绑在一起 | 本轮用 `badge` + `name` 呈现；封面落地时在 `game_distribution_theme` 表尾追加对象键列（兼容追加），复用既有素材上传链路 |
+| **slug / URL 别名** | 公开 URL 直接用 `theme_id` 就够（`theme-*` 已经是稳定、可读的标识）；引入 slug 就要处理唯一性约束、改名后的重定向与「谁是第二套身份」的问题 | 本轮不做 slug 与唯一性约束；如将来要做，slug 只是 `theme_id` 的**别名**，不得成为第二个主键 |
+| **埋点 / 统计** | 主题曝光、点击、成员转化的口径必须等 UI 上线后按真实数据决定，先埋一套随后要改的字段是负收益（与 §3.7 的取舍一致） | 等共创 Tab 上线，按数据决定事件字段；本轮只有 `tracing` 日志 |
+| 主题内「**跳到某一代节点**」高亮 | 属 UI 层能力，族谱页已有 `from` 参数（§3.10.2），后端不需要新字段；在没有主题页 UI 之前做它没有消费方 | 主题页 UI 落地时直接复用 `from` 参数 |
+| **批量树端点** | 本轮接受前端 N 次 `/games/{id}/lineage`（N = 成员数）；主题成员量级小，且「不在主题侧重建树查询」的价值高于省这几次请求 | 若主题成员规模上升或出现首屏超时，再提供一个批量端点（服务端内部仍是同一份 `build_lineage_tree`，不新造规则） |
+
+**已知限制（已落地行为；原「待拍板」项已于 2026-10-06 定口径，见下）**：
+
+| 限制 | 现状 | 处置 |
+| --- | --- | --- |
+| 主题详情 `roots` 的 **50 上限** | `get_game_distribution_theme_detail_tx` 用 `GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX`（= 50）截断 `roots`。**已定口径**：`memberCount` 改为报**真实可见成员数**（不再取 `roots.len()`），并新增 `rootsTruncated` 仅当 `roots` 少于 `memberCount` 时为 `true`——客户端据此知道「我看到的不是全集」，与族谱响应的 `truncated` 同约定（详见 §3.10.6）。 | ✅ 已定：保留 50 上限（选项 ③：不加成员游标、不一次全发）。落地点见 §3.10.6；`rootsTruncated` 已进 DTO parity 的 `mustEmit` |
+
+#### 3.10.10 迁移、契约与门禁
+
+| 项 | 口径 |
+| --- | --- |
+| 迁移 | 两张**新表**，初始为空，无回填；`migration.rs` 的 `migration_tables!` 白名单登记新表，并在注释中写明「主题与成员是运营业务事实，随迁移导出/导入」 |
+| 生成绑定 | 必须重跑 `npm run spacetime:generate`，并跑 `npm run check:generated-bindings`、`npm run check:spacetime-schema` |
+| DTO | Rust 侧 `server-rs/crates/shared-contracts/src/game_distribution.rs`、TS 侧 `packages/shared/src/contracts/gameDistribution.ts`；新响应构建器登记进 `check:game-distribution-dto-parity` |
+| 数据契约表 | `docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md` **已随表落地补齐**（`2fa201e0d`，两张表小节；`check:spacetime-schema` 现为 **96** tables） |
+| 不改的东西 | 不动 `/api/external/v1`（不新增 External OpenAPI 条目）；不新增数据库访问通道；不新增第二套作品系统；游戏 Tab / 广场的公开目录**不变**（主题是额外维度，不改变作品的独立展示） |
+
+### 3.11 贡献归集与权益归因（2026-10-06）
+
+> **口径原话**：「子代所有的都算父代的」，并且要能回答「能溯源多少是子代给的、多少是自己的」。
+> **本期只做计算**：只做贡献归集（rollup）与归因（attribution）**计算**——没有账本、没有结算周期、
+> 没有金额字段，**不含资金 / 分成 / 结算**，资金与分成口径留待产品决定（见 §2.2 与 §7）。
+> 唯一实现在 `server-rs/crates/module-game-distribution/src/contribution.rs`（纯函数，无
+> `ReducerContext`）。
+
+#### 3.11.1 递归定义
+
+> **前端显示也复用这一条**（2026-10-07，§3.6.3）：公开接口的 `playCount` 仍是**自身值**，
+> 但界面上显示的「游玩次数」按**同样的不变量**在客户端用已有的那棵树算（`collectLineagePlayCountTotals`），
+> 所以展示口径与本节的服务端归集**永远一致**，且不为显示新增任何服务端字段或子树遍历。
+> 唯一例外：**主干线与热度排序的判据**用自身值（裁定见 §3.6.3）。
+
+```text
+inherited(W) = Σ_{c ∈ 直接子代(W)} total(c)
+total(W)     = own(W) + inherited(W)
+```
+
+- `own(W)`：作品 W 自己的指标（本期只有 `playCount`）。
+- `inherited(W)`：W 的**全部**直接子代按 `total` 汇总；子代的子代已经含在子代的 `total` 里，
+  因此「子代所有的都算父代的」，而**每个后代在它的每个祖先里只计一次**（不重复、不漏）。
+- 等价恒等式（三条不变量里最有用的一条）：`inherited(W) == Σ_{d ∈ 后代(W)} own(d)`。
+- 指标集合做成结构体 `ContributionTotals { play_count }`（`Default` + `AddAssign` 风格的**单一
+  合并点**）：**将来加点赞 / 收藏 / 收入只需加字段**并改那一处合并，递归定义、归因分解与上限 /
+  截断语义都不需要动。
+
+#### 3.11.2 归因分解（根节点的明细）
+
+| 字段 | 语义 |
+| --- | --- |
+| `own` / `inherited` / `total` | 根自身的三个数，`total == own + inherited` |
+| `byGeneration[]` | **每一代贡献多少**：只含**后代**（不含根自身），`generation` 用**绝对代际**（与族谱一致），按代际**升序** |
+| `directChildren[]` | **每个直接子代带来多少**：每项是该直接子代的 `total`（含它自己的整棵子树），按 `gameId` 升序 |
+
+`byGeneration` 每条的 `total` 是「这一代对祖先 `inherited` 的贡献」，也就是**该代节点自身的量**；
+`inherited` 恒为 `0`——该代从更深代际继承到的量已计入更深代际那一条。若把后代也滚进本代，
+同一个后代会在多层分解里被重复计入，各代之和就会**大于**祖先的 `inherited`（这正是本功能要避免的事）。
+
+不变量（**在截断后的子树上依然成立**，纯函数单测逐条钉住）：
+
+- `inherited == Σ byGeneration.total == Σ directChildren.total`；
+- `total == own + inherited`；
+- `nodeCount == Σ byGeneration.gameCount`（`nodeCount` = 参与计算的**后代**节点数，**不含根**）。
+
+#### 3.11.3 接口：作者视角只读
+
+`GET /api/game-distribution/games/{gameId}/contribution`
+
+```json
+{
+  "gameId": "game_x",
+  "own":       { "playCount": 120 },
+  "inherited": { "playCount": 340 },
+  "total":     { "playCount": 460 },
+  "byGeneration": [ { "generation": 1, "gameCount": 2, "own": {"playCount":90}, "inherited": {"playCount":0}, "total": {"playCount":90} } ],
+  "directChildren": [ { "gameId": "game_b", "generation": 1, "own": {"playCount":70}, "inherited": {"playCount":40}, "total": {"playCount":110} } ],
+  "nodeCount": 5,
+  "truncated": false,
+  "truncatedReason": null
+}
+```
+
+口径：
+
+- **遍历只用血缘表既有索引**（`by_game_distribution_lineage_parent_game_id`）逐层下钻；
+  **不新增表或索引**，也不新建第二套血缘查询。
+- **不做公开可见性过滤**：这是作者自己血缘子树的账目，口径就是「血缘上属于我的后代」，
+  因此**已下架 / 已软删除的后代照常计入**（血缘事实仍在）。入参与纯函数里都没有可见性维度——
+  要改口径必须显式加字段，不会悄悄漂移。
+- 子孙的游戏行缺失（脏数据 / 历史遗留）按不存在处理：跳过该节点，也不拿它当父继续下钻
+  （与族谱装配同一口径）。
+- 缺失 / 悬空行（父不在集合里、自环、重复行）由纯函数安全跳过，不 panic、不发半残节点。
+- 除「作品不存在」外，本接口**不把任何异常抛成 404 / 409**：截断与数据问题都走
+  `truncated` / `truncatedReason` 或 5xx 映射，不用状态码掩盖。
+
+#### 3.11.4 规模上限与截断语义
+
+| 常量 | 值 | 语义 |
+| --- | --- | --- |
+| `GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT` | **500** | 单次最多计入多少个**后代**（根不计入） |
+| `GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT` | **32** | 相对深度上限（根 = 0），更深的节点不再计入 |
+
+- 超限时**如实标注**：`truncated: true` + `truncatedReason` ∈ `node_limit` / `depth_limit`
+  （未截断为 `null`）——与族谱接口 `truncated` 的既有约定一致，**不静默给半个数**。
+- 两种上限同时拦住同一批节点时按 **`node_limit`** 报：调用方该去收敛范围，
+  而不是去怀疑血缘真有 32 层。
+- **已计入部分仍自洽**：三条不变量在截断后的子树上依旧成立（数字只覆盖被计入的那部分子树）。
+- 事务侧多收**一条**后代、多收**一层**深度：只收满上限时「刚好满」与「还有更多」不可分辨，
+  截断会被静默吞掉。同层按 `gameId` 升序下钻，截断点因此确定，两次读不会换一批节点。
+
+#### 3.11.5 鉴权口径与理由
+
+| 情形 | 状态码 | 落点 |
+| --- | --- | --- |
+| 未登录 / 令牌失效 | **401** | 路由层 `require_bearer_auth`（不进入业务；**不叠加**发布灰度——它不是发布动作） |
+| 作品不存在或**根自身**已软删除 | **404** | 事务 `Ok(None)` → 客户端折成 `None` → handler 404 |
+| 作品存在但不属于当前主体 | **403** | 事务报 `游戏 owner 不匹配`，命中 `map_spacetime_error` 既有的 owner-mismatch → FORBIDDEN 分支 |
+
+**为什么非作者是 403 而不是「也折 404」**（代价一并写明）：
+
+1. 沿用仓库既有 owner-mismatch 惯例——`map_spacetime_error` 早已把这类文案映射成 FORBIDDEN，
+   作者侧写路由同源；在这里另立一套 404 会多出第二种「不属于你」的语义。
+2. 这是作者账目页：客户端必须能分辨「我没有权限看」（停手 / 换账号 / 回我的作品）与
+   「作品没了」（回列表刷新），两者折成同一个 404 只能靠再猜一次。
+3. 代价明确且被接受：登录用户可用 403 / 404 之分辨别某个 `gameId` 是否存在。已公开作品本就能从
+   公开目录枚举；未公开作品会因此多出一个存在性预言机，但本接口只服务作者本人，故接受并显式记录。
+
+响应整组 `Cache-Control: no-store`（per-author 的商业敏感数据，不给任何共享缓存留缝）；
+procedure 另要求**受信服务身份**（归属判定靠 `owner_user_id`，而 SpacetimeDB 客户端身份本身不携带
+作品归属），与其它作者侧 procedure 同口径。
+
+---
+
+## 4. 为什么是 `game` 而不是 `version`
+
+| 判断 | 结论 | 理由 |
+| --- | --- | --- |
+| 血缘（forkedFrom / root / generation） | **game** | 血缘是作品间关系；父作品后续发 v4 不应改写子作品的父指针。放 version 会导致同一作品的每个版本都要重复声明来源，且任一新版本可能丢掉来源 |
+| 授权（能否被 fork） | **game** | 是作者对「这部作品」的策略，不是对某个构建产物；且授权可后续提升，必须有稳定载体 |
+| 衍生计数 | **game**（由 lineage 表按 parent 计） | 与 game 维度一致 |
+| 被复刻的内容（工程源包） | **version** | 内容随版本演进；复刻必须取到确定的内容快照，才能让溯源精确到「改编自 v3」 |
+| 复刻时锁定的父版本 | **game 侧血缘行里的 `parent_version_id`** | 是建立血缘那一刻的不可变事实，之后父作品发新版不影响它 |
+
+一句话：**关系与策略在 game，内容在 version，血缘行把两者钉在一起。**
+
+---
+
+## 5. 验收标准与证据
+
+| 条款 | 验收方式 | 证据 |
+| --- | --- | --- |
+| 授权默认 `forbidden`，旧作品迁移后一律禁止共创 | 迁移后读旧 game 的公开详情 | 待补 |
+| 授权只能提升：`forbidden→nonCommercial→full` 合法，任何降级 `409` | 定向 API/领域测试 + 真实栈 smoke | 待补 |
+| 非 owner 改授权 `403`；CAS 不匹配 `409`；同 key 重放 `replayed=true` | 定向测试 + 真实栈 | 待补 |
+| 未授权 / 已下架 / 已软删除 / 非当前公开版本的 fork 声明被拒（`403` / `409`） | 定向测试 | 待补 |
+| 血缘不可变：同一作品第二次声明血缘 `409`；`local_project_id` 复用场景拒绝携带血缘 | 定向测试 | 待补 |
+| 代际与根计算正确：A→B→C 得到 generation 1/2、root 均为 A | 领域单测 + 真实栈三层链路 smoke | 待补 |
+| 父作品下架或软删除后：既有子作品保持公开，新 fork 被拒；子作品被软删除后不计入父作品衍生数 | 真实栈 smoke | 待补 |
+| 溯源摘要不泄露被软删除作品的标题与作者名（降级为「原作品已不可用」） | 定向测试 + DTO parity | 待补 |
+| 工程包门禁：含 `node_modules` / 符号链接 / 绝对路径 / 超限的包被拒且不产生任何对象 | 客户端 Rust 定向测试 + 服务端校验测试 | 待补 |
+| 补齐：提升授权后可对当前公开版本补传工程包一次，补齐后改造升级为源码级；二次补传或换内容重传被拒；历史版本不被补齐 | 定向测试 + 真实栈 | 待补 |
+| 源码路径闭环（工程源包）：详情页 → AGC → 下载 → 解压 → 建项 → 改源码 → 重跑构建 → 发布 → 详情页出现溯源 | 真实 AGC + 真实 api-server smoke（含截图/录屏） | 待补 |
+| 参考路径（成品包）：详情页 → AGC → **fork 完即可运行**（预览根 `game/dist/index.html` 播的就是取到的那份成品）、素材可提取；且不伪造血缘、不出现空白或死链 | 客户端 Rust 定向测试（落点与收口断言）+ 真实栈浏览器验证 | 建项断言 ✅（§5.8）；真机画面 ⏳ 待补 |
+| 交付口径一致：对外文案不出现「成品包可直接**发布**但不可运行」这类与 §3.5.1 新事实冲突的表述（现行口径：成品包 fork 可运行、可发布，**只有**「在成品上重建核心逻辑」不可行） | 文案评审 + 浏览器验证 | 待补 |
+| Fork 建项收口：成品包 fork 后 `manifest.tasks[code-prototype] == completed`、`versions == [initial-1]`；工程源包 fork 后只写 `versions == [initial-1]`（**不**标完成，界面如实提示需先构建）；运行页签不可用时的提示文案按清单事实分叉 | 客户端 Rust 定向测试 + 前端投影用例（§5.8） | ✅ 已验证 |
+| 公开 DTO 不泄露对象键、不泄露未公开作品信息 | DTO parity + 逐键核对 | 待补 |
+| 署名：公开详情/广场展示真实作者名与陶泥号，不再落到「创作者」兜底 | 真实栈 + 浏览器验证 | 待补 |
+| 移动端与桌面端布局可用；移动端改造入口给出桌面端提示 | 320px / 1280px 浏览器验证 | 待补 |
+
+### 5.1 M1（授权与血缘）实施证据 — 2026-10-04
+
+分支 `/` 工作树：`feat/game-fork` / `.worktrees/feat/game-fork`。
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| schema 迁移（持久表加列 + 新表 + 新索引） | 本地 SpacetimeDB 2.8.3 上发布模块后，线上 schema 含 `fork_authorization` 列、`deleted_at` 列、`game_distribution_lineage` 表（`_game_id_key` + parent / root / owner 三个 btree 索引）与 `set_game_distribution_fork_authorization_and_return` procedure | ✅ 已验证 |
+| 领域规则（授权阶梯、代际、错误码前缀） | `cargo test -p module-game-distribution` 全部通过 | ✅ 已验证 |
+| BFF / 路由 / payload / 错误映射 | `cargo test -p api-server game_distribution` 全部通过（含新增的「共创授权路由未带 Bearer 必须 401」用例） | ✅ 已验证 |
+| 前端类型与页面 | `npx tsc`（仓库 `npm run typecheck`）通过；`npx vitest run src/components/game-distribution src/services/gameDistributionClient.test.ts` 全部通过 | ✅ 已验证 |
+| 契约一致性 | `npm run check:game-distribution-dto-parity`、`npm run check:spacetime-schema`、`npm run check:encoding`、`git diff --check` 通过 | ✅ 已验证 |
+| 生成绑定 | `npm run spacetime:generate` 后 `check:generated-bindings` 的 shared-contracts 段通过；AGC 段因工作树缺少随包 Codex CLI 资源（`resources/codex/win-x64/manifest.json`，非本次改动）无法运行 | ⚠️ 环境限制 |
+| HTTP 端到端（BFF 路由与真实数据库连接） | `npm run dev` 整套拉起后：`/healthz` 200；`GET /api/game-distribution/games` 200（空列表，走通真实数据库查询与 envelope）；`PUT …/fork-authorization` 未带 Bearer 返回 401 `UNAUTHORIZED` | ✅ 已验证 |
+| HTTP 端到端（真实登录态下的提升 / 声明血缘 / 详情页字段） | 未跑：需要真实登录态与一个已发布作品；本地开发库当前为空 | ⏳ 待补 |
+| 浏览器视觉与交互验证（详情页共创卡、我的作品授权入口、移动端布局） | 未跑：本地库无作品数据，登录态不可用，页面无法进入有效状态 | ⏳ 待补 |
+| 权限与边界（非作者 403、降级 409、父作品下架后新声明被拒、软删除边界） | 领域层与 procedure 校验已实现；**软删除×Fork 三条规则已提取为纯函数并补单测**——`can_serve_as_fork_source`（未删+已公开，四组合，含「已删但 visibility 仍 published」必须 false）、`counts_as_public_derivative`（同四组合）、`fork_lineage_visible_identity`（父可用透传；父不可用即使传入非空标题/作者名也必须返回 `(None, None)`；作者名三态）由 `cargo test -p module-game-distribution`（36 passed）覆盖。真实栈边界用例仍待补 | ⏳ 部分（单测已补，真实栈待补） |
+| **rebase 到含 #565 的新 master** | `git rebase origin/master`（新 master `6c9566058`）重放两个提交，9 个冲突文件按 §3.9.1 全部解决（两侧业务逻辑都保留），无 merge commit，未改动 master；提交信息沿用原中文提交 | ✅ 已验证 |
+| **生成物重生成** | `npm run spacetime:generate -- --rust-only` 后保留 `module_bindings/game_distribution*` 与 `module_bindings/module_bindings.rs`，rustfmt 版本差异带来的其它文件格式漂移已 `git checkout --` 还原 | ✅ 已验证 |
+| **软删除语义收敛 ①来源校验** | `resolve_game_distribution_fork_declaration_tx` 增加「来源 `deleted_at` 非空 → `FORK_SOURCE_NOT_AVAILABLE`（409）」，显式判定而不是只靠 `visibility` 复位 | ✅ 已验证（`cargo test -p api-server game_distribution`；领域错误码沿用 `FORK_*` 前缀） |
+| **软删除语义收敛 ②衍生作品数** | `game_distribution_public_fork_count` 只统计 `deleted_at.is_none() && visibility == published` 的子作品；作者删除子作品后父作品计数随之下降 | ✅ 已验证（同上） |
+| **软删除语义收敛 ③溯源摘要** | `game_distribution_lineage_snapshot` 在父（或根）作品被软删除时把 `parent_title` / `root_title` 置空、父作者名置空，api-server 原样发 `null`，TS 契约改为 `string \| null`，详情页降级为「原作品已不可用」 | ✅ 已验证（DTO parity + 前端用例 + `fork_lineage_visible_identity` 单测，「父不可用即使传入标题也必须 `(None, None)`」已由 `cargo test -p module-game-distribution` 断言） |
+| **未知共创档位（HTTP 面合同）** | `PUT /api/game-distribution/games/{gameId}/fork-authorization` 载荷里目标或期望档位为未知值（如 `"allowed"`）时返回 **400 + 平台信封**（不再落到 axum 默认的 422 纯文本）；新用例 `set_fork_authorization_maps_unknown_authorization_to_envelope_bad_request` 断言 `ok=false`、`data=null`、`error.code=BAD_REQUEST`、message 含「共创授权档位不合法」、带 `meta.apiVersion`，且不带框架的 `Failed to deserialize` 文案。领域层 `FORK_AUTHORIZATION_UNKNOWN` 分支保留（procedure 读到库里未知档位时仍可达） | ✅ 已验证（`cargo test -p api-server game_distribution`，45 passed） |
+| **详情页结构对齐 #565** | 详情页改用共享 `GameDetailDisplay`，共创卡通过 `infoCards` 渲染；vitest 用例「展示共创授权、代际与溯源信息，且不提供改造入口」与「旧数据缺少授权与血缘字段时只按禁止共创渲染」通过 | ✅ 已验证 |
+
+### 5.2 M2b（工程源包）实施证据 — 2026-10-05
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| 数据模型与契约 | 版本行三列（`project_bundle_object_key` / `_bytes` / `_sha256`）落地；`GameDistributionPrivateVersion` 两侧同步（对象键不下发）；生成绑定只保留 `module_bindings/game_distribution*` 与 `module_bindings.rs`，其余漂移还原 | ✅ 已验证（DTO parity 42 组、`check:spacetime-schema` 92 tables、`cargo check --all-targets` 0） |
+| 工程包校验器 | `module-game-distribution` 的 `validate_project_bundle_zip`：拒绝清单见 §3.5.2，上限与发行包**逐项相等**（测试用 `assert_eq!` 钉住）；`package.rs` 已同批补强（读取层按声明大小封顶 + 压缩比分母改为条目压缩字节，+70/−4） | ✅ 已验证（**19 条校验器单测**；`cargo test -p module-game-distribution` **73 passed**） |
+| 上行路由族 | 5 条路由（整包 / upload-state / chunk / complete / reset）；对象键服务端派生且与发行包不同；唯一共享阶段门；`complete` 独立复核 zip + 422 映射 | ✅ 已验证（`cargo test -p api-server game_distribution` **60 passed**，含 6 条路由与阶段门/资产选择用例） |
+| 下行优先与缓存 | `source` 取 `Project`（优先）/`Package`；半写行回落 `package`；`/fork-source/project` 无工程包时 409 而非静默回落；缓存键 = 对象键（资产维度） | ✅ 已验证（同一批 api-server 用例：对象键互不相等 + `ReleasePackageCache` 双资产不串味） |
+| 端到端（真实本地栈 + 真实客户端链路） | `npm run （本地夹具脚本，无 npm 条目）` → **51 个 `check(` 调用点**（复核另按 72 条断言计，差值来自同一 `check` 内的多条子断言；含 A4 / A5 / A5b / A6 与对抗用例：路径形状、凭据目录、嵌套包改名、符号链接、声明说谎） | ✅ 已验证 |
+| 两端规则一致（机器门禁） | `npm run check-project-bundle-policy-parity` → OK（客户端打包器与服务端校验器的排除清单/上限逐项对齐，防止两端口径漂移） | ✅ 已验证 |
+| 客户端 | AGC 打包器（确定性打包，**24 条单测**，含路径形状检查）、发布时上传（失败不阻断，且**上传前按 `max_archive_bytes` 预检**）、按 `source` 分支的取件建项、来源记录 v2（兼容 v1）；`npx vitest run apps/ai-game-creator-shell/tests` 1961 passed（补强前一次的运行；本次未改前端 TS）；AGC 定向 `cargo test -- project_bundle` **24 passed** | ✅ 已验证 |
+| 校验器对抗性补强（P0-a/b/c） | 凭据识别补强（目录 `.aws` / `.ssh` / `.kube` / `.docker` / `.gnupg` / `.terraform` / `.secrets`；前缀 `credentials` / `id_ecdsa` / `id_dsa` / `terraform.tfstate` / `service-account`；后缀 `.jks` / `.keystore` / `.ppk` / `.p8` / `.kdbx` / `.der`；全名 `.htpasswd` / `.pgpass`，外加小文本内容嗅探 PEM / `AKIA…` / `ghp_` / `xox*`）；嵌套包扩展名并集 + magic bytes 嗅探（改名也拦）；读取层按声明大小封顶 + 压缩比分母改为条目压缩字节；新增错误变体 `CredentialDirectoryNotAllowed` / `SecretContentDetected` | ✅ 已验证（19 条校验器单测；**发行包回归** `cargo test -p api-server game_distribution` 60 passed，含新增「声明说谎 → `ReadFailed`」） |
+| 执行级交叉证据（P1-b） | 客户端 crate 用 dev-dependency 依赖 `module-game-distribution`：新测试用**真实打包器**产出字节喂服务端 `validate_project_bundle_zip` 断言接受（并逐项比对摘要 / 字节数 / 条目顺序），再手造含 `.env` / `node_modules` 的包断言服务端独立拒绝 | ✅ 已验证（AGC `cargo test -- project_bundle` 24 passed） |
+| 一致性门禁（P1-a + 嗅探维度） | `check-project-bundle-policy-parity` 现已覆盖四类：目录/前缀/后缀/全名 + 5 项规模上限；**路径形状**（哨兵段 / 结尾字符 / 禁止字符，并单独钉两侧都必须显式拒 `/` 开头与 `\`）；**内容嗅探特征表**（`SECRET_CONTENT_SIGNATURES` / `SECRET_AWS_ACCESS_KEY_PREFIX` / PEM 标记 / 文本扩展名白名单 / 嗅探窗口，逐字相等）；**嵌套包 magic bytes**（服务端 ⊆ 客户端）。空集合一律报错 | ✅ 已验证（服务端 51 条规则全被客户端覆盖；「故意改一侧会红」两次实测：路径禁止字符、内容特征表） |
+| 已知留白 | 未纳入的归档格式（`.bz2` / `.xz` / `.zst`）与数据库转储（`*.db` / `*.sql`）、未纳入的凭据目录（`.gcloud` / `.azure` / `.password-store`）、CP437 条目名与 `external_attributes == 0` 的条目、以及「爆炸包峰值内存」未做真实量测 | ⏳ 已知限制（详见 §3.5.2 与里程碑「已知留白」） |
+| 已公开版本的补传（backfill） | **未做**（按产品口径不做：阶段门与发行包确认一致，公开后不接受内容写入），文档三处已如实写明 | ⏭ 明确不做 |
+| 真实边界（>200 MiB / 10 001 条目 / 半包续传的极端组合）与结构化埋点事件 | 未跑/未接：边界靠常量与单测钉住，结构化埋点（`game_fork_source_downloaded` 等）待产品定口径 | ⏳ 待补 |
+
+---
+
+### 5.3 授权继承口径（2026-10-06）实施证据
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| 落点（事务内取父档位的那一步） | `server-rs/crates/spacetime-module/src/game_distribution.rs`：血缘解析 `resolve_game_distribution_fork_declaration_tx` 在既有校验（父存在 / 未软删 / 已公开 / 允许共创 / 来源版本等于父当前公开版本）之后把父行档位一并返回（`(root_game_id, generation, parent_authorization)`）；`create_game_distribution_game_tx` 把血缘解析**排在授权裁决之前**，再调纯函数 `resolve_game_distribution_creation_fork_authorization(parent, input.fork_authorization)`，写行仍用裁决结果 | ✅ 已验证 |
+| 衍生作品继承父档位（`full` / `nonCommercial` / `forbidden` 三条） | 行为矩阵 `creation_authorization_inherits_the_parent_tier_and_ignores_the_request`（父 `full` / `nonCommercial` 各请求组合都落父档位；父 `forbidden` 由结构性用例 `create_game_tx_takes_fork_authorization_from_the_parent_row` 钉住「在血缘解析里就以 `FORK_NOT_AUTHORIZED` 拒绝，继承函数拿不到它」） | ✅ 已验证（`cargo test -p spacetime-module` → 301 passed / 1 ignored） |
+| 衍生作品传了别的档位也被忽略 | 同一矩阵覆盖：父 `full` 传 `forbidden` / `nonCommercial` / `full` / `allowed`（未知）、父 `nonCommercial` 传 `forbidden` / `full` / 空串，结果都等于父档位（不报错） | ✅ 已验证（同上） |
+| 母版仍按请求值 / 缺省 `forbidden` | `creation_authorization_uses_the_request_for_masters_and_fails_closed_on_unknown`：`forbidden` / `nonCommercial` / `full` 原样落库；空串与未知取值失败关闭且文案带 `FORK_AUTHORIZATION_UNKNOWN:`。DTO 侧的缺省值（省略 = `forbidden` 且幂等摘要不变）由既有用例 `create_game_request_defaults_fork_authorization_without_changing_digest` 继续覆盖 | ✅ 已验证（`cargo test -p spacetime-module`、`cargo test -p api-server game_distribution` → 104 passed） |
+| 契约不变 | `GameDistributionCreateGameRequest.forkAuthorization` 保留且 serde 形状未动（改形状会动幂等摘要）；无列/表/索引变更，schema 基线比对通过 | ✅ 已验证（`check:spacetime-schema`：98 表对 `9f4c7d76` 通过） |
+| 门禁 | wasm build 0；`cargo check --all-targets` 0（仅既有 `TEST_AGC_MODEL_DEFAULT_ID` dead_code 警告）；`cargo test -p module-game-distribution` 0（119 passed）；`cargo test -p api-server game_distribution` 0（104 passed）；`cargo test -p spacetime-module` 0（301 passed / 1 ignored）；`cargo test -p spacetime-client` 0（43 passed）；`check-game-distribution-dto-parity` 0；`check-project-bundle-policy-parity` 0；`SPACETIME_SCHEMA_BASE_REF=9f4c7d76 check:spacetime-schema` 0；`check:encoding` 0；`cargo fmt --all --manifest-path server-rs/Cargo.toml -- --check` 0；`git diff --check` 0；另跑 `check:doc-index` 0 | ✅ 已验证 |
+| 遗留：两个 e2e 脚本仍按旧语义 | 本地夹具脚本（族谱/血缘） 富树段（`createPublishedNode` 的 `promoteTo` 自带 `from = 'forbidden'`，且 `richF1` 刻意留给 `forbidden`）与 `scripts/capture-game-lineage-visual.mjs`（同款 `promoteForkAuthorization`）：改口径后衍生节点的创建档位已等于父档位，这些「再从 `from` 提升」的 PUT 现在**一律**回 409 `FORK_AUTHORIZATION_INHERITED`（不再只是 CAS 不符），需改成「按新继承档位断言 / 不再提升」。**2026-10-07 已由 `scripts/**` owner 改写**：衍生节点改为「探针 PUT 被拒（409 `FORK_AUTHORIZATION_INHERITED`）+ 档位不变」，母版仍断言可提升；同轮补上「核心改动说明落在版本摘要（`currentVersion.changeSummary`）」与贡献归集断言（`fa9ef9037`；lineage 188 项、capture 工具 67 项全绿）。 | ✅ 已改（2026-10-07） |
+| 客户端 UI 的衍生场景 | 已落地（后续提交）：`src/components/game-distribution/MyGamesPage.tsx` 对衍生作品隐藏提升入口、改为只读展示「继承自父作品」（`4f888d8c9`，含用例「衍生作品的授权入口改为只读展示（授权继承父作品，不可单独提升）」）；AGC 发布面板 `GameDistributionPublishPanel.tsx` 同轮改为只读展示「授权继承自父作品」 | ✅ 已接（由 `src/**`、`apps/**` owner 落地） |
+
+---
+
+### 5.4 贡献归集与权益归因（2026-10-06）实施证据
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| 纯函数（递归 + 归因分解 + 上限 / 截断） | 新增 `server-rs/crates/module-game-distribution/src/contribution.rs`：`build_contribution_breakdown`（无 `ReducerContext`）+ `ContributionTotals { play_count }`（`Default` + `AddAssign` 的**单一合并点**，将来加指标只动它）；常量 `GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT = 500` / `_DEPTH_LIMIT = 32` 在单测里按**合同值**钉住 | ✅ 已验证（**12 条纯函数单测**：A→B→C 三层链路 `A.inherited = B.own + C.own` / `B.inherited = C.own` / `C.inherited = 0`、根带 3 子 + 1 孙的多分支、无子代、悬空 / 缺失 / 自环 / 重复行安全跳过、绝对代际、两条分解之和 == `inherited`、`inherited == Σ 后代 own`、`node_limit` / `depth_limit` 截断且数字自洽；`cargo test -p module-game-distribution` → **131 passed**） |
+| 事务与 procedure | `game_distribution_contribution_tx`（行不存在 / 已软删除 → `Ok(None)`；owner 不匹配 → `Err("游戏 owner 不匹配")`；正常 → 快照）+ `collect_game_distribution_contribution_nodes`（只用 `by_game_distribution_lineage_parent_game_id` 逐层下钻，同层按 `gameId` 排序，**多收一条 / 多收一层**作为截断判据）+ `get_game_distribution_contribution_and_return`（受信服务身份 + 单一 `try_with_tx`，失败路径显式给空） | ✅ 已验证（3 条结构性单测；`cargo test -p spacetime-module` → **304 passed / 1 ignored**） |
+| 接口（作者视角只读） | `GET /api/game-distribution/games/{gameId}/contribution` 挂独立 Bearer + `no-store` 路由组（**不叠加发布灰度**）；未登录 / 失效 → 401，不存在 / 已软删除 → 404，非作者 → 403（owner-mismatch → FORBIDDEN）；响应经 DTO 逐字段搬运，不在 api-server 重算任何数字 | ✅ 已验证（3 条新用例：① 401 + `no-store`；② 403 / 404 映射可分辨；③ 用纯函数构造的节点喂进 `contribution_payload`，逐字段断言 `own` / `inherited` / `total` / `nodeCount` / `byGeneration` / `directChildren` 与纯函数一致，且 `truncated` + `truncatedReason = node_limit` 透传、截断后两条分解之和仍等于 `inherited`；`cargo test -p api-server game_distribution` → **107 passed**） |
+| 契约与 parity | Rust DTO `GameDistributionContributionTotals` / `...Generation` / `...Child` / `...Response`（`server-rs/crates/shared-contracts/src/game_distribution.rs`）+ TS 镜像（`packages/shared/src/contracts/gameDistribution.ts`）+ `check-game-distribution-dto-parity` 登记 4 组（`truncatedReason` 的可空性双向比对） | ✅ 已验证（`check-game-distribution-dto-parity` → **66 组** Rust/TS 类型一致） |
+| 生成绑定 | `npm run spacetime:generate -- --rust-only`：新增 6 个类型文件 + 1 个 procedure 文件；`module_bindings.rs` 只多出这 7 条登记，**无其它漂移** | ✅ 已验证（`git status` 核对：`module_bindings/` 只新增上述 7 个文件） |
+| 迁移与 schema | **不新增表 / 索引 / 列**（只加 procedure 入参 / 结果类型），因此无迁移、schema 基线比对通过 | ✅ 已验证（`SPACETIME_SCHEMA_BASE_REF=9f4c7d76 check:spacetime-schema` → 98 tables 通过） |
+| 口径取舍：`byGeneration[i].total` | 取「**这一代对祖先 `inherited` 的贡献**」（= 该代节点自身量），`inherited` 恒为 `0`；把后代也滚进本代会让同一个后代在多层分解里被重复计入，各代之和就会**大于**祖先的 `inherited`，与 §3.11.2 的不变量冲突。`directChildren[i].total` 仍是「含整棵子树」的子代总量 | ✅ 已定（单测与接口用例都断言 `Σ byGeneration.total == inherited`；§3.11.2 已写明语义） |
+| 门禁 | wasm build 0；`cargo check --all-targets` 0（仅既有 `TEST_AGC_MODEL_DEFAULT_ID` dead_code 警告）；`cargo test -p module-game-distribution` 0（131 passed）；`cargo test -p api-server game_distribution` 0（107 passed）；`cargo test -p spacetime-module` 0（304 passed / 1 ignored）；`cargo test -p spacetime-client` 0（43 passed）；`check-game-distribution-dto-parity` 0；`check-project-bundle-policy-parity` 0；`SPACETIME_SCHEMA_BASE_REF=9f4c7d76 check:spacetime-schema` 0；`check:encoding` 0；`cargo fmt --all --manifest-path server-rs/Cargo.toml -- --check` 0；`git diff --check` 0 | ✅ 已验证 |
+| 尚未覆盖 | 真实 dev 栈 / 浏览器端到端未跑（需本地库数据与登录态）；前台作者账目页 UI 不在本次工作树权限内 | ⏳ 待补 |
+
+---
+
+### 5.5 衍生作品授权终态（2026-10-06）实施证据
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| 错误码与状态码 | `FORK_AUTHORIZATION_INHERITED` → **409 CONFLICT**（与 `FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED` 同状态码、不同码）。模块常量 `module_game_distribution::GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE`，`Display` 插值它产出 `"{CODE}: 衍生作品的共创授权由父作品继承，不能自行修改"`；api-server 的 `FORK_` 映射表逐条登记该码 | ✅ 已验证（module 的 `inherited_authorization_message_starts_with_its_code` + api-server 的 `fork_error_codes_are_reachable_from_module_messages`） |
+| 判定落点（哪个事务的哪一步） | `set_game_distribution_fork_authorization_tx`：**幂等重放分支之后、CAS 之前**查 `game_distribution_lineage().game_id().find(&game_id)` 得 `has_lineage_row`，再交给纯函数 `resolve_fork_authorization_promotion(has_lineage_row, current, expected, target)` 裁决（顺序：衍生终态 → CAS → 只升不降）；失败不写库，事务里不再出现 `can_promote_to`、也不自己比 CAS 期望值 | ✅ 已验证（结构性用例 `set_fork_authorization_tx_rejects_derivatives_before_cas`：血缘行先于裁决、裁决先于 `.update`） |
+| 衍生作品任何 PUT 都被拒（含传同值） | 单测矩阵：同值 / 想再提一级 / 终态再传同值 / 期望值已过期 / 期望值与当前值都不符 —— 五种都回同一码（判定先于 CAS，码不随载荷变化） | ✅ 已验证（`derivative_put_is_rejected_even_with_the_same_or_stale_value`） |
+| 母版语义未变 | `forbidden → nonCommercial` / `forbidden → full` / `nonCommercial → full` 照常放行；同级与降级仍回 `FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED:`；CAS 不符仍是纯文案（含「不匹配」，不带 `FORK_` 前缀） | ✅ 已验证（`master_put_still_promotes_with_unchanged_cas_semantics`） |
+| 契约与形状 | **无列 / 表 / 索引 / DTO 形状变更**（只加一个错误码常量与错误变体）；`GameDistributionSetForkAuthorizationRequest` serde 形状未动，幂等摘要不变 | ✅ 已验证（`SPACETIME_SCHEMA_BASE_REF=9f4c7d76`：98 表通过；`check-game-distribution-dto-parity`：66 组类型一致） |
+| 文档 | 技术方案 §2.3（授权模式 + 状态机）、§2.4（`/games/mine`、`/games/publish`、`/games/lineage`）、§2.6 时序图、§3.3 状态表、§3.4（`PUT` 行、`POST /games` 行、`/lineage` 行）、§3.9 第二条补充、§7 第 2 条；数据契约文档 `fork_authorization` 条目；里程碑实施记录；`decision-log.md` 同日条目 | ✅ 已改 |
+| 门禁（本工作树自跑，逐条 exit） | wasm build 0；`cargo check --all-targets` 0（仅既有 `TEST_AGC_MODEL_DEFAULT_ID` dead_code 警告）；`cargo test -p module-game-distribution` 0（**134 passed**，+3）；`cargo test -p api-server game_distribution` 0（107 passed）；`cargo test -p spacetime-module` 0（**305 passed / 1 ignored**，+1）；`cargo test -p spacetime-client` 0（43 passed）；`check-game-distribution-dto-parity` 0；`check-project-bundle-policy-parity` 0；`SPACETIME_SCHEMA_BASE_REF=9f4c7d76 npm run check:spacetime-schema` 0（98 表）；`npm run check:encoding` 0（5544 文件）；`cargo fmt --all --manifest-path server-rs/Cargo.toml -- --check` 0；`git diff --check` 0 | ✅ 已验证 |
+| 改动清单（测试） | **新增**：`module-game-distribution` 的 2 条行为用例 + `errors.rs` 1 条前缀用例、`spacetime-module` 1 条结构用例；**扩展**：api-server 的 `fork_error_codes_are_reachable_from_module_messages`（加一条码 + 常量字面量断言）、`module-game-distribution` 的 `fork_errors_are_prefixed_with_their_machine_code`（加一条码）。**没有既有 Rust 用例断言过「衍生作品 PUT 提升成功」**——旧语义的断言在两个 e2e 脚本里（见 §5.3 遗留） | ✅ 已改 |
+| 遗留：两个 e2e 脚本 | 本地夹具脚本（族谱/血缘）、`scripts/capture-game-lineage-visual.mjs` 里对**衍生作品**的 PUT 现在一律 409 `FORK_AUTHORIZATION_INHERITED`，需按新语义改写（按新继承档位断言 / 只对母版提升）。**2026-10-07 已改**：见 §5.3 同一行（`fa9ef9037`）——衍生作品 PUT 一律 409 `FORK_AUTHORIZATION_INHERITED` 已成断言口径，母版提升语义未变。前端入口与只读展示已落地（见 §5.3 对应的两行） | ✅ 已改（2026-10-07） |
+
+---
+
+### 5.6 端到端实测覆盖与工具（2026-10-07，`scripts/**` owner）
+
+> **脚本入库口径（2026-10-07 供需方要求）**：本表提到的夹具类/演示数据类 e2e 脚本（族谱、主题、收藏、工程源包、共创授权、演示数据灌装）是**本地验收脚本，未入库**——只存在于本地工作树，团队其他人拉分支拿不到；它们的路径写在本地 `info/exclude` 里，不在仓库。表中所有「已覆盖 / 实测结论」都是这些脚本**真实跑出来**的结果，结论有效。隔离与截图类工具（目标解析+护栏、隔离栈启动器、族谱截图、客户端 CDP 验收）仍在仓库里。
+
+在**本地真实栈**上跑通的实测（地址从 `.app/dev-stack.json` 读：api-server `8082` / web `3000` / SpacetimeDB `3101` / admin-web `3102`，库 `genarrative-game-creator-dev`），按「平台 web → 客户端取件建项 → 回平台看血缘」这条链路分段列。**「覆盖到哪一段」以本表为准**（其余段落要么只能 API 等价复现，要么尚未自动化）。
+
+| 链路分段 | 覆盖方式 | 脚本 / 证据 | 状态 |
+| --- | --- | --- | --- |
+| 平台 web：共创列表 / 作品详情 / 族谱页 / 主题页 | 真实浏览器（Playwright 驱动 Chromium，落 DOM 断言 + 截图） | 本地夹具脚本（族谱/血缘）（F 段）、`scripts/capture-game-lineage-visual.mjs`、本地夹具脚本（共创主题） | ✅ 已覆盖 |
+| Fork 授权三态（禁止 / 非商用 / 全开放）+ 衍生继承与「不可再提升」 | HTTP 契约（+ 浏览器入口） | 本地夹具脚本（共创授权）；`…lineage-e2e.mjs` H 段（探针 PUT → 409 `FORK_AUTHORIZATION_INHERITED` 且档位不变；母版仍可提升） | ✅ 已覆盖 |
+| 族谱与衍生：`/games/{id}/lineage`（按根聚合、200 上限、父作品下架降级）、`/derived` | HTTP 契约 + 浏览器 | 本地夹具脚本（族谱/血缘）（A–E、G 段） | ✅ 已覆盖 |
+| Fork 取件：成品包通道 + **工程源包下行优先** `/fork-source`；工程包上行校验（禁项 / 分片 / 幂等 / 阶段门） | HTTP 契约（无浏览器） | 本地夹具脚本（工程源包）、`…lineage-e2e.mjs` G 段 | ✅ 已覆盖 |
+| 收藏（收录）与「我的收藏」 | HTTP 契约 | 本地夹具脚本（收藏） | ✅ 已覆盖 |
+| 共创主题（公开读 + 后台写 + 作品详情 `themes` 增量 + 只允许根） | HTTP 契约 | 本地夹具脚本（共创主题） | ✅ 已覆盖 |
+| 贡献归集（作者视角 `GET /games/{id}/contribution`） | HTTP 契约（作者 Bearer） | 本地夹具脚本（族谱/血缘） I 段 | ✅ 已覆盖 |
+| **真实 AGC 客户端里点一遍**：共创列表 → 开始共创确认 → 取件校验 → 生成工程（写 `.agent/fork-source.json`）→ **运行可用** | **已自动化（2026-10-07）**：Tauri + WebView2 通过 CDP 附着真实客户端（客户端启动时带 `--remote-debugging-port=9222`，见 `~/.config/genarrative/.env` 的 `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS`；探活 `curl --noproxy '*' http://127.0.0.1:9222/json/version` 应回 `Edg/…`） | `scripts/check-agc-co-creation-fork-e2e.mjs`（19 项，npm script `check:agc-co-creation-fork-e2e`）：共创列表滚到底且无「直接 Fork 指定作品」输入块；确认页 3 秒门禁 + 须知无内层滚动 + 底部吸附条；Fork 后本机 `projects/gameagent-*` 的 `.agent/fork-source.json`（v2、`source: package`）、`game/dist/index.html`、无 `reference/`、`code-prototype=completed`、`versions=[initial-1]`；**运行视图可用**（无「首个可运行原型尚未完成」空态、运行表现层 + 预览 iframe） | ✅ 已覆盖 |
+| 客户端里**发布**新作品（上传发行包 → 送审 → 管理员审核 → 平台看到新节点/血缘） | 未自动化：客户端发布面板需要人工填「本次核心改动说明」等 | 平台侧同一段由 本地夹具脚本（族谱/血缘） 的发布链路 + 血缘断言覆盖 | ⏳ 待补 |
+| 窄屏三档（360 / 390 / 414）移动端形态 | 真实浏览器 | `scripts/capture-game-lineage-visual.mjs` 的 `E2E_CAPTURE_NARROW_WIDTHS=360,390,414`：深链进 `/games/lineage` **不再被「移动端仅支持作品展示」弹窗盖住**、默认大纲式缩进树（行高 ≥44、有导线与层级缩进）、长标题不横向溢出、点节点弹底部 sheet 且可关闭、选中后当前面包屑已被滚进视口 | ✅ 已覆盖（另见下方两条未修问题） |
+| 演示数据与视觉基线（供需求方验收） | 幂等灌数据 + 截图工具 | 本地演示数据灌装脚本（标题前缀 `共创演示·`，**判重不绑账号**：先查公开目录同标题再查本人 `my-games`；13 节点 / 3 棵树 / 4 作者 / 最大 3 代 / 13 张不同封面）、`scripts/capture-game-lineage-visual.mjs`（`E2E_CAPTURE_LINEAGE_URL` 开启「只截现有作品」模式） | ✅ 已覆盖 |
+
+实测固定口径（可直接复用）：pinned 端口 `--api-port 8188 --bgfilter-worker-port 8189 --spacetime-port 3110 --admin-web-port 3111 --web-port 3112`；管理员 `admin / 123456`；Playwright 走临时目录（`E2E_PLAYWRIGHT_DIR`）+ 本机 Chromium（`E2E_CHROMIUM_EXECUTABLE`）；断言口径一律按**符号**引用实现（不写行号），详见各脚本头部注释。
+
+> ⚠️ **复验前必读（2026-10-07 实测踩到）**：在 `W:` 盘上跑着的 Vite **不会感知源码变更**（文件监视事件没生效，`touch` 也不触发失效），因此**长时间运行的 dev 栈会把改动前的模块一直发出去**：直接 `curl 'http://127.0.0.1:3000/src/components/game-distribution/LineageNodeContent.tsx'` 拿到的是旧代码（不带新加的 `compact`），刷新浏览器也没用；带查询串（`?t=<ts>`）才会拿到新代码。复验 UI 修复时要么**重启 dev 栈的 web**，要么起一个**新的 Vite 实例**（例如 `node scripts/vite-cli.mjs --port=3300 --host=127.0.0.1 --strictPort`，再用 `E2E_WEB_BASE=http://127.0.0.1:3300` 跑 e2e/截图）——本次两个回归的复验就是这么做的（API 仍打在 8082 那把栈上，没有动它）。
+
+**2026-10-07 实测发现 → 当日已修（`src/**` owner 修复，`scripts/**` owner 复验）**：
+
+| 问题 | 证据 | 状态 |
+| --- | --- | --- |
+| 族谱画布（`layout="stacked"`）节点**不再显示作者名** | 原因：`LineageNodeContent` 只在 `layout === 'inline'` 渲染作者行，画布传 `stacked` → 作者整列消失（`aria-label` 里仍有，故只有视觉缺失）。修复 `9cf30517d`：仅**窄屏紧凑卡片**省作者，其余两种形态都渲染。复验：本地夹具脚本（族谱/血缘） → **188/188 PASS**（原唯一 FAIL「浏览器视觉：母版节点显示作者名」转绿）；1440 桌面截图可见卡片上有「演示作者甲/乙/丙/丁」 | ✅ 已修并复验 |
+| 移动端切「图谱视图」（横向画布）**不会初始定位到当前作品** | 修复前 390 宽实测：`zoom=100%`、`transform: matrix(1,0,0,1,0,0)`，画布可视区 `x 37–353`，当前作品节点头部 `x 457–633` → 0/8 节点可见。修复 `ec8f27cb2`（横版画布 + 进入时按宽度适配并定位当前作品）。复验（360/390/414 三档）：`zoom=35%`、当前作品在画布内、可见节点 **7/8（360、390）/ 8/8（414）** | ✅ 已修并复验 |
+| （遗留备注）窄屏图谱视图里点卡片会跳详情 | 窄屏紧凑卡片整块是「打开详情」按钮，没有可锁定区域 → 信息面板/面包屑的窄屏验证改由**大纲形态**做（点行弹底部 sheet、面包屑出现并被滚进视口，三档均 PASS）。不是缺陷，但窄屏画布下确实没有「锁定」入口 | 📝 记录 |
+| **连线锚点是否落在卡片水平中心**（2026-10-07 定标，用户点名要逐条数值） | 方法：`path.getPointAtLength(0)` / `(len)` 取端点 + `path.getScreenCTM()` 变换到视口坐标，与 `card.getBoundingClientRect()` **同一坐标系**比较（不手算 `scale(0.6)`）。演示树 7 条边 × 两端 = 14 个端点，`Δx` **全部 0.00px**（父/子卡中心与端点 x 完全相等）；同一批还量到 `cardCenter − nodeCenter = 0.00`（节点盒左右内边距相等 ⇒ 卡片在盒内精确居中），故早期一次「13.8px」是**配对错误**（按最近卡中心匹配）不是错位。纵向：父端锚点在卡底边上方 9.7px（被卡片盖住）、子端在子卡顶边上方 12.2px，逐边恒定（来源 = 节点盒 `11.2px` 上下内边距 + `1px` 边框，见 §3.6.1）。原始数据 `%TEMP%\lineage-cardunify-verify\anchor-table.json`、截图 `05-anchor-table.png` | ✅ 已验证 |
+| **「expected 304 to be 344」（差 40px）定性** | **结论：我的断言写错，不是布局错位**。elbow 路径末点是写成 `… V 344`（无逗号）的，我用 `/(\d+),(\d+)/g` 抓「最后一个坐标对」时抓到的是圆角 `Q 348,292 348,304` 的**曲线控制点**（`348,304`），它当然不等于端点。证据三重：① 纯函数打印（`lineageTreeLayout.test.ts` 临时 `console.log`）显示 4 条边的 `from/to` 与父底中点 / 子顶中点**逐字段相等**；② 已把断言补成「对**每一条边**（含一父多子扇出）`toEqual` 父底中点 / 子顶中点 + 路径首点 = from + 路径末段以 `to.y` 结尾」并常驻测试（本轮提交）；③ 真机 14 端点 Δx 全 0.00。**因此「横向扇出偏移」这条假设被否掉**，连线不存在横向扇出 | ✅ 已定性并落地断言 |
+
+### 5.7 AGC 客户端共创页 / 「开始共创」确认页与外壳滚动链（2026-10-07）实施证据
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| 滚动链断点（改动前的实测） | 真实 Chromium（1440×900 / 1000×620 / 800×600）逐层量计算值：`#root` 620(h)/`min-height:0`、`.window-chrome__content` 620/`hidden`、`.launcher-shell` 570/`min-height:0`、**`.launcher-main` `display:grid` + `grid-template-rows: 1494px 0 0` + `overflow-y:hidden`**、`.fork-page` 1494。用户滚不动（`overflow-y: hidden`）、最后一行 `bottom=1512 > viewport 620` | ✅ 已验证（A/B：注入旧规则复现，见下） |
+| 修后行为 | `.launcher-main` `display:flex` / `overflow-y:auto`、`clientHeight 570` / `scrollHeight 1494`；列表页滚到底 `scrollTop=924`「最后一张卡可见」、确认页 `scrollTop=579`「吸附页脚仍在视口内且两个按钮可见」；三档窗口 `horizontalOverflow=false` | ✅ 已验证 |
+| 冲突容器收敛 | 确认页须知块计算值 `overflow-y: visible` / `max-height: none` / `noticesClipped=false`（无内层滚动）；页脚 `position: sticky` + `bottom: 0`（滚动前后 `footerVisible=true`） | ✅ 已验证 |
+| jsdom 用例 | 新增 `tests/launcherScrollContract.test.ts`（CSS 契约：根/外壳/`.launcher-main` 逐层高度与 `overflow`、视图 `flex: 0 0 auto`、旧 grid 覆盖已删、内容列 720–880px 与 `72ch`）；`tests/coCreation.test.tsx`（删除「直接 Fork 指定作品」标题/输入框/按钮/占位的四条断言、`创建时间` 真实值与缺失整行不渲染、`.fork-page` 内无 `overflow-y-auto`）；`tests/forkConfirm.test.tsx`（须知块无内层滚动且五条全文、页脚 `sticky bottom-0` 且是页面根最后一个子元素、徽章倒计时 3s→0 与按钮 enable） | ✅ 已验证 |
+| 死代码删除 | `parsePlatformGameId` / `PLATFORM_FORK_INPUT_ERROR` / `GAME_ID_PATTERN` / `GAME_ID_QUERY_KEYS` 与对应解析用例全部移除（`platformGameForkModel.ts` 只剩失败分类）；`formatCatalogTime` 更名 `formatCatalogCreatedAt` 并返回 `null` 表示「无值」 | ✅ 已验证 |
+| 门禁（AGC 本工作树自跑，逐条 exit） | `tsc -p tsconfig.json` 0；`tsc -p tsconfig.tests.json` 0；`npm run ai-game-creator-shell:typecheck` 0（含 `check-config.mjs`：`read_public_game_detail` 已登记 native-only 白名单）；`npx vitest run apps/ai-game-creator-shell/tests` 0（**211 文件通过 / 1 跳过，2095 用例通过 / 17 跳过**）；`npx eslint . --ext .ts,.tsx,.js,.mjs,.cjs --max-warnings 0` 0；`npm run check:encoding` 0（5550 文件）；`git diff --check` 0 | ✅ 已验证 |
+| 改动清单（提交） | 外壳滚动链 `501fd0925`（`styles.css` + `tests/launcherScrollContract.test.ts`）；共创列表页与版式令牌 `2010c1382`（`view/co-creation`、`platformForkCatalog`、`platformGameForkModel`、`forkPageStyles` + 用例）；确认页与发布面板 `caf7db4ba`（`view/fork-confirm`、`GameDistributionPublishPanel` + 用例） | ✅ 已提交 |
+| 真实浏览器（本次核验方式） | 一次性夹具把两页挂进与 `WindowChrome` 同构的外壳（`#root` → `.window-chrome__content` → `main.launcher-shell > aside + section.launcher-main`），真实 `styles.css` + Vite；在 1440×900 / 1000×620 / 800×600 三档量逐层计算值、滚到底后末项与页脚可见性、横向溢出；夹具用完即删（`git status` 干净） | ✅ 已验证 |
+
+### 5.8 Fork 建项收口（对外动作名「开始共创」）：可运行原型与初始工程版本（2026-10-07）实施证据
+
+**背景（实物证据）**：一次真实 Fork（`%APPDATA%/world.genarrative.ai-game-creator/projects/gameagent-a74aa1d9`，2026-10-06 15:27:58，`.agent/fork-source.json` = `source: package`）建出来的项目，manifest 里 **16 个 seed 任务全 `pending`（含 `code-prototype`）、没有 `versions[]`、没有 `preview`**，父作品那套可玩产物被解到 `reference/<gameId>/`（**不在预览根**）。于是运行页签命中 `run-unavailable-hint`「首个可运行原型尚未完成，运行视图暂不可用」且点击无反应；发布也被同一判据拦下。根因是 Fork 建项**没有**像 AI 直连回合收口那样登记「可运行原型」与工程内部版本，且可玩内容放错了位置。
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| 落点改为预览根 | `game_fork.rs` 新增 `fork_playable_root`（= `preview::project_game_root`，本形态即 `game/dist`），`ProjectForkSourceKind::Package` 分支把发行包整包解到这里；不再写 `reference/<gameId>/`（原 `fork_reference_relative_path` 与其用例随之删除，改为「可玩参考永远落在预览根」用例） | ✅ 已验证（`cargo test -- game_fork`） |
+| 建项收口登记原型与初始版本 | `game_fork.rs` 新增 `register_forked_project_state_at`：预览根确有 `index.html` 时 `update_manifest_task_status_at("code-prototype", Completed)` → `advance_agent_runtime_project_revision_locked` → `append_agent_game_iteration_version_at`（得到 `initial-1`）→ `emit_game_creator_manifest_invalidated`；返回收口**之后**重读的清单，避免把过期快照交给进项目通道 | ✅ 已验证 |
+| 成品包形态断言 | 建项后：`game/dist/index.html` == 包内 `index.html`、`game/dist/game/main.js` == 包内脚本、`!reference` 存在；`code-prototype == Completed`；`versions == [initial-1]`（`projectRevision 1`、`createdReason initial`、无父版本）；`project_has_runnable_prototype(&manifest) == true` | ✅ 已验证 |
+| 工程源包形态断言（如实不标完成） | 建项后：源码逐字节落地（`game/package.json` / `game/src/game.js` / `game/index.html`）、`!game/dist` 与 `!reference` 存在；`code-prototype == Pending`；`versions == [initial-1]`；`project_has_runnable_prototype == false` | ✅ 已验证 |
+| 门禁判据可见性 | `project/export.rs` 的 `project_has_runnable_prototype` 提升为 `pub(crate)`，供建项用例直接断言「运行/发布读的就是这一条事实」 | ✅ 已验证 |
+| 提示文案诚实化 | 新增 `src/view/project-development/runUnavailableHint.ts`：清单里已有工程内部版本（`versions` 非空）时说「已有工程内容但还没有可运行的构建产物：让智能体完成可运行原型后即可运行」，否则保留原句；`index.tsx` 的 `run-unavailable-hint` 改为调用它 | ✅ 已验证（`tests/runUnavailableHint.test.ts`） |
+| 前端投影（fork 后直接可跑） | appSurface 新用例：`code-prototype` 完成 + `versions = [initial-1]` 渲染后提示消失、`#run-unavailable-hint` 不存在、`data-unavailable` 不置位，点运行页签 → `aria-selected=true` 且 `onPlay` 调用 1 次；另一用例钉「只有 `versions` 无完成原型」时显示新提示且点击不发播放请求 | ✅ 已验证 |
+| 既有 Fork 项目 | **不迁移**（不写一次性补丁）：修复只对**新 Fork** 生效，既有 fork 项目请**重新 Fork 一次** | ⏭ 明确不做 |
+| 真机端到端（截图 / 录屏） | 待重建客户端后按「Fork（无工程源包的作品）→ 运行看到父作品画面 → 改源码 → build → 发布 → 详情页出现溯源」跑一遍并留证据 | ⏳ 待补 |
+
+---
+
+### 5.9 AGC 客户端动作名统一为「开始共创」（2026-10-07）实施证据
+
+| 项 | 证据 | 状态 |
+| --- | --- | --- |
+| 改动清单（提交） | `78b6ac5a8`（15 文件：AGC 用户可见文案 + 用例） | ✅ 已提交 |
+| 渲染层文案（TS） | 卡片按钮（+ `aria-label`「开始共创《标题》」）、确认页标题 / 副标题 / 空态 / 页脚 `aria-label` / 进行中按钮、须知正文、成功通知、发布面板授权告知（`view/co-creation`、`view/fork-confirm`、`forkNotice.ts`、`usePlatformFork.ts`、`GameDistributionPublishFormView.tsx`） | ✅ 已改 |
+| 原生文案（Rust） | 取件错误（读取 / 下载 / 校验 / 解压 / 大小 / 来源 ID / 响应形状）、深链解析提示、「请先选择要开始共创的平台作品」、默认项目名「共创项目」（`game_distribution_publish.rs` / `game_fork.rs` / `game_fork/desktop.rs`） | ✅ 已改 |
+| 内部标识未动 | Tauri 命令 `create_local_project_from_platform_game`、`.agent/fork-source.json`、scheme `genarrative://fork`、`ForkConfirmView` 等组件 / 模块名、Rust 类型与字段、埋点枚举、测试名里的内部术语 | ✅ 刻意不改 |
+| 用例 | `coCreation.test.tsx`（卡片按钮可见文案与无障碍名同一套词、页面根文本不含 `Fork`）、`forkConfirm.test.tsx`（新增「用户可见文案统一叫「开始共创」，不出现 Fork 动作名」——只检查声明出来的可见节点，不做全页 `not.toContain('Fork')`）、`platformGameForkModel.test.ts`、`gameDistributionPublishForm.test.tsx`、appSurface 两个 suite | ✅ 已验证 |
+| 门禁（AGC 本工作树自跑） | `tsc` 两套 0；AGC vitest 目标文件全绿（含 appSurface 217 passed / 9 skipped）；全量套件另有 11 条**与本改动无关的既有失败**（已用 stash 复验归属）；`npx eslint . --ext .ts,.tsx,.js,.mjs,.cjs --max-warnings 0` 0；`npm run check:encoding` 0；`git diff --check` 0；`cargo check --tests` 0；`cargo fmt -- --check` 0；隔离 `CARGO_TARGET_DIR` 跑 `cargo test -- fork deep_link` **17 passed** | ✅ 已验证 |
+
+## 6. 里程碑拆分（评审后逐个开实施计划）
+
+| 里程碑 | 范围 | 交付判据 |
+| --- | --- | --- |
+| [M1 授权与血缘骨架](./project-memory/plans/【里程碑】游戏共创授权与血缘-2026-10-03.md) | game 追加授权列、新血缘表、创建 game 携带血缘的校验与写入、授权提升接口、公开 DTO 增量、详情页徽章+溯源卡、`/games/mine` 授权设置、后台展示、署名修复 | 可在平台内看到并管理「能否被改编 / 改编自谁 / 第几代」；改造动作本身在 M2a 接线 |
+| [M2a 参考式改编（可玩参考 + 素材 + 血缘）](./project-memory/plans/【里程碑】成品包改造闭环-2026-10-03.md) | 复用已存在的成品包做受鉴权内容下发、AGC 下载/建项（成品解到**预览根**）、素材提取、血缘写入与溯源展示、发布面板授权选择 | 真实 AGC 上完成「看别人的作品 → fork 后**直接运行** → 参考改编 → 改后在自建合规工程里重做 → 发布 → 溯源正确」。**2026-10-07 更正**：M2b 建项形态落地后，成品包 fork **也能直接发布**（发布当前预览根），原「不承诺可直接重新发布」的口径作废（§3.5.1 / §5.8） |
+| [M2b 工程源包与源码级复刻](./project-memory/plans/【里程碑】作品工程源包与一键改造-2026-10-03.md) | version 追加工程包字段、AGC 打包/上传、`fork-source` 优先返回工程包、源码形态建项、**新增工程包下载/授权接口**（当前不存在，§3.5.1） | 真实 AGC 上完成「拿到源码 → 改核心逻辑 → 发布 → 溯源正确」；这是「一键复刻完整工程」的**唯一正解路径**（§3.5.4 路线 B） |
+| [M3 族谱与衍生列表](./project-memory/plans/【里程碑】创作族谱与衍生列表-2026-10-03.md) | `/games/lineage` 树页、`/games/{id}/lineage` 与 `/derived` 接口、`/games/mine` 被改编列表 | 族谱树可浏览、可跳转、父作品下架有降级展示 |
+| [M4 共创主题与作品树](./project-memory/plans/【里程碑】共创主题与作品树-2026-10-06.md) | 两张主题表（主题 + 成员，成员只允许根）、公开主题列表 / 详情接口、作品详情 `themes` 增量、后台主题写接口（后台 UI 不在本轮） | 共创 Tab 能按运营命名列出主题并进入多棵作品树；作品详情能看到并跳到所属主题；方案见 §3.10。**已拍板采纳「平台命名主题」方案**（§7 第 3 条），设计已定、实现排在下一轮 |
+
+依赖：M2 依赖 M1 的数据模型；M3 依赖 M1；M4 依赖 M1（按根归组）与 M3（树查询复用），且设计上依赖 M2 的实际使用数据来验证共创意愿。
+
+---
+
+## 7. 未决问题（需要拍板）
+
+> 第 1、7–11 条来自 2026-10-04 的只读侦察（`local://m2a-design.md`），其中 7–11 条是**第二阶段（M2a/M2b）落地前必须拍板**的五项；未拍板前不得据 §3.5.4 的推荐实现。
+>
+> **已移出待拍板并定稿（2026-10-06）**：
+> ① **相似度反洗稿校验**——**产品已决定搁置**。这不是「没想到」，而是**明确不做**：无判定标准，且判定只能基于工程源包做结构化比对，属独立议题；本方案只保证来源声明真实、不可伪造。口径落在 §2.2。
+> ② **结算**——统一为「**本期只做贡献归集与归因计算**（§3.11），**资金 / 分成不在范围内**（口径留待产品决定）」。原先「做不做分成」的问法作废：本期连账本与金额口径都没有，不预留半成品字段。
+
+1. **成品包路径的事实边界已改写**（原条目「成品包路径默认要做……建议：做」的前提已被否证）：成品包路径能试玩、能提供素材，但**不能发布**（§3.5.1）。因此要拍板的不再是「要不要顺带做工程源包」，而是「是否接受对外口径从『一键复刻完整工程』改成『参考改编 / 素材复用』，并把工程源包作为唯一源码级路径」。建议：接受并改口径（§3.5.4 路线 A 先行、B 排后续）。
+2. **授权默认值与终态已定口径（2026-10-06，原为待拍板）**：**母版**默认仍取「禁止共创」（`forbidden`，飞书评论里「默认允许 + 发布前合同勾选」的建议未采纳）；**衍生作品**改为**创建时继承父作品当时的档位**（不再落 `forbidden`、也不接受客户端另选或收窄），并且继承来的档位是**终态**——衍生作品任何 `PUT …/fork-authorization` 都回 409 `FORK_AUTHORIZATION_INHERITED`（含传同值的幂等重试），只有母版能单向提升。见 §2.3 / §3.4 / §3.9 两条补充。存量作品不受影响：既有子作品的档位保持原值（继承只在创建时发生，不回填；本改动只堵住「再提升」，不回溯改写任何行）。**仍待接的是前端**：AGC 发布面板 / `/games/mine` 在衍生作品上不该再给出可点的档位控件（服务端已一律拒绝），见 §5.3 遗留。
+3. **「共创主题」已拍板采纳且服务端已实现（2026-10-06，原为待拍板）**：采纳包仲航提出的「平台命名主题 → 作品树」，且明确作品之间不存在曝光挂靠。设计见 §3.10，实施清单见 `docs/project-memory/plans/【里程碑】共创主题与作品树-2026-10-06.md`（M4）。**已落地**：设计定稿 `063c04a1b`、数据模型与领域纯函数 `2fa201e0d`、公开读路径 `742723a58`、后台写路径 `033e3aa79`（前台共创 Tab / 主题页与后台管理 UI **仍未做**）。**仍待产品拍板的是两点**：① **主题级排序口径**——公开列表当前按「沿用既有 micros 游标」排在 `created_at` 倒序 + `themeId` 升序兜底上，`sort_order` 只用于主题内成员排序；若要求共创 Tab 按运营序展示，需要把游标改成 `(sort_order, theme_id)` 双键并同步前端；② **主题详情 `roots` 的 50 上限**——可见成员 > 50 时静默截断且无「还有更多」标志（`memberCount == roots.len()`），三个备选（去上限 / 给成员加独立游标 / `memberCount` 报真实可见数）见 §3.10.6 与 §3.10.9，**本轮不改契约**。
+4. **结算口径（2026-10-06 统一）**：需求文档要求「每一代均享有权益（署名 / 流量回馈 / 版权分成）」。署名本期已做；**本期只做贡献归集与归因计算**（§3.11），**资金 / 分成 / 版税结算与流量回馈不在范围内**，口径留待产品决定（无账本、无算力成本口径，`docs/【技术方案】外部产品支付服务接入-2026-10-03.md:200` 明确人工结算）。贡献数是**计算事实**，不是可结算金额，也没有预留任何金额字段。
+5. **「永久链上溯源」表述**：实现为平台持久化的不可变父子链，不上链。需确认该措辞是否可以调整。
+6. **`play_count` 死字段**：它被前端展示为「N 次游玩」但永不自增。本方案不依赖它；是否顺带修复（新增游玩上报）需单独立项。
+7. **对外表述**：第二阶段是否接受「只能试玩 + 素材复用，不能一键复刻工程」？建议接受并同步改文案（AGC 侧注释 `export.rs:407-408` 已把无 `package.json` 的静态项目排除在发布合同外）。
+8. **血缘承载位**：血缘只作为客户端本地注释（项目内独立文件，如 `.agent/fork.json`），还是要平台可查询（服务端新增字段）或随工程包传输（manifest 升 v2，旧客户端读到即失败）？建议先本地，等工程源包（M2b）落地再上平台字段。
+9. **是否立刻做工程源包（M2b）**：它需要**新增工程包下载/授权接口**（当前不存在）并定义包内禁项（服务端已拒绝 `node_modules`/`.git`/`.env*`/`*.map`/`*.pem`/`*.key` 与嵌套 zip，`module-game-distribution/src/package.rs:135-142`、`:170-176`），成本最大。建议先做 A 验证需求。
+10. **从平台唤起 AGC 的方式（2026-10-07 部分落地）**：已实现并落地 **deep link** —— `tauri.conf.json` 注册 `genarrative://` scheme、`tauri-plugin-deep-link` + 单实例插件、原生解析 `genarrative://fork?gameId=<id>` 并聚焦主窗口，带 `gameId` 时直接落到 AGC 的 Fork 工程确认页（§3.6.2）；**手工输入作品 ID/链接**这一候选已按产品要求移除（重复入口）。因此本条只剩「平台网页端何时把「改造这个作品」按钮改成直接发 deep link」这个前端接线问题，不再涉及唤起机制选型。
+11. **是否允许「伪工程」（C 路线，补声明 phaser 4/vite 的 `package.json` 让成品包过检）用于存量作品兼容**：产出不可再构建，建议不允许；若确要做，需产品书面接受「不可再构建」的语义并限定为一次性兼容。
+12. **收藏（收录）已纳入并落地**（2026-10-06）：原先它在 §2.2「非目标」里，现已实现为真实用户态投影（表 `game_distribution_collection` + `PUT`/`DELETE /games/{gameId}/collection` + `GET /my-collections` + 公开详情 `collected`），见 §2.4 / §3.4 与 `docs/【后端架构】server-rs与SpacetimeDB数据契约-2026-05-15.md` 的 `game_distribution_collection` 小节。仍**不在**范围内的是「收藏数公开计数」「收藏动态流」「关注 / 粉丝」——它们各自需要独立的口径与表。
diff --git a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
index 91a714821..3aface131 100644
--- a/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
+++ b/docs/【玩法创作】平台入口与玩法链路-2026-05-15.md
@@ -109,7 +109,7 @@
 - 提议网页根路径 `/` 进入 `/games`；桌面一级导航为“游戏 / 创作 / 项目 / 我的”，移动端为“游戏 / 我的”。图片创作及项目编辑仍遵守原有桌面端边界，移动端不再以仅支持作品展示的欢迎遮罩阻断游戏浏览和游玩。该变更仅在本节通过评审并完成验收后生效。
 - 游戏目录 `/games`、详情 `/games/detail?id=<gameId>`、游玩 `/games/play?id=<gameId>`；作者管理 `/games/mine` 只列当前账号的游戏和发行状态。平台壳及既有账号页提供入口，不建立第二套账号或作品系统。
 - 目录使用重点推荐位和紧凑卡片网格，首版推荐位只消费后台明确设置且已公开的游戏；其余列表按发布时间排列。支持关键词、分类与设备筛选，筛选写入 URL，返回列表恢复筛选和滚动位置；没有内容时展示真实空态。
-- 详情的主动作是“立即玩”，展示封面、标题、作者、短简介、设备标识、截图和简短操作方式；不虚构评分、玩家数、排名和收藏状态。游客浏览详情及启动游戏均无需登录；上传、更新、撤回和作者管理需要当前平台登录态。
+- 详情的主动作是“开始游戏”，展示封面、标题、作者、短简介、设备标识、截图和简短操作方式；不虚构评分、玩家数、排名和收藏状态。游客浏览详情及启动游戏均无需登录；上传、更新、撤回和作者管理需要当前平台登录态。
 - 游玩页先展示封面与开始按钮，用户点击后加载游戏，避免列表自动加载多个 iframe 或自动播音；提供加载、超时、重试、返回和全屏。iframe 的 `load` 事件只表示文档已加载，不宣称已经通过运行验证；首版不把 iframe 消息当平台业务状态。
 - 移动端优先采用全宽内容、底部主要动作、至少 44px 点击区域，覆盖安全区、横竖屏和键盘焦点。游戏声明仅支持桌面时，手机详情保留可浏览内容并禁用开始，明确显示“请在电脑上游玩”；横屏游戏提供旋转提示，但不能把系统方向锁定成功作为启动前提。
 - 视觉延续当前暖色主题 token、米白/浅暖背景、橙色主动作与现有字体；通过封面占比、留白、圆角和清晰状态层级现代化呈现，不另建配色系统。通用卡片动作、弹窗、上传、状态反馈、空态与媒体预览优先复用共享组件。发布打开独立弹窗/抽屉，不在当前页面末尾追加表单；技术信息仅在失败诊断或确需用户决策时展示。
@@ -159,7 +159,7 @@
 
 | 方法与路径 | 身份 | 行为 |
 | --- | --- | --- |
-| `GET /games` | 游客 | **已实现**：关键词与分类筛选，最多 48 项；仅公开可玩版本 |
+| `GET /games?search=&category=&authorId=&limit=&cursor=` | 游客 | **已实现**：关键词、分类与作者筛选，仅公开可玩版本（`published`、未软删除、有当前公开版本）。**真游标分页**：`limit` 缺省 **48**（保持既有首屏语义）、上限 **100**，超界**截断**而非报错；`cursor` 形如 `"{createdAtMicros}:{gameId}"`（与 `/my-collections`、主题列表同一套 `"{micros}:{id}"` 惯例，解析只切第一个冒号）；**游标格式非法 → 400 `CATALOG_INVALID_CURSOR`**（不是 200 的空页）。排序 `createdAt` 倒序 + `gameId` 升序兜底（全序，翻页不重不漏），顺序定义为「先按可见性过滤、再排序切页」；响应 `{ games, nextCursor }`，`nextCursor` 是真实游标、**末页为 `null`** |
 | `GET /games/{gameId}` | 游客/登录 | **已实现**：当前公开资料、`priceMudPoints` 与查看者 `purchased`（匿名、坏令牌与读取失败按未购买，内容访问失败关闭）；付费作品对未购买且非作者/管理员的查看者把 `currentVersion.entryUrl` 置为 `null`，资料与价格仍可见；不可见时 404 |
 | `POST /games/{gameId}/plays` | 游客/登录 | **已实现**：上报一次「开始游戏」；可选 Bearer，非公开 404、超限 429，成功返回 `{recorded}`；只进 api-server 内存缓冲，失败不影响游玩 |
 | `POST /games/{gameId}/purchase` | 登录用户 | **已实现**：买断制购买，必填 `Idempotency-Key`，体 `{ expectedPriceMudPoints }`；扣费与购买记录同事务，重复购买幂等返回既有记录不再扣费；余额不足 400 `INSUFFICIENT_MUD_POINTS`、作者自购 400 `GAME_PURCHASE_OWNER_EXEMPT`、后台管理员令牌 403 `GAME_PURCHASE_ADMIN_NOT_ALLOWED`、价格已被新版本改变 409；免费游戏按 400 拒绝 |
@@ -270,7 +270,7 @@
 
 ### 页面布局与交互
 
-游戏详情保留“立即玩”和现有资料，在游戏介绍后增加“我的评价”“全部评价”两个区块；平均分与人数显示在详情资料区，并在评价区域共用同一份后端摘要。
+游戏详情保留“开始游戏”和现有资料，在游戏介绍后增加“我的评价”“全部评价”两个区块；平均分与人数显示在详情资料区，并在评价区域共用同一份后端摘要。
 
 | 状态 | 我的评价区域 | 操作结果 |
 | --- | --- | --- |
@@ -715,14 +715,14 @@
 
 让用户从游戏详情进入任意作者主页、查看作者公开游戏、关注或取消关注，并在自己的列表管理关注和粉丝。验收以真实账号关系、计数、公开游戏过滤及跨页回读一致为准。
 
-2026-10-05 实现状态：桌面导航为“创作 / 项目 / 游戏 / 创作者主页 / 我的”，移动端为“游戏 / 创作者主页 / 我的”；`activeAppPageRoutes` 已接入创作者主页和关系列表。`GameDetailPage` 通过共享 `GameDetailDisplay` 的作者插槽提供主页链接和独立关注按钮。私有关注关系表、查询/写入 API 以及页面交互已实现；后端已由用户验收，前端工程验证通过，用户已要求提交并推送。本文前部旧入口说明不作为本专题的导航基线。
+2026-10-05 实现状态：桌面导航为“创作 / 项目 / 游戏 / 创作者主页 / 我的”，移动端为“游戏 / 创作者主页 / 我的”；`activeAppPageRoutes` 已接入创作者主页和关系列表。**2026-10-07 变更**：新增**顶层「共创」入口**（桌面导航扩为“创作 / 项目 / 游戏 / **共创** / 创作者主页 / 我的”，移动端底部 dock 扩为“游戏 / **共创** / 创作者主页 / 我的”），指向 `scope="forkable"` 的作品列表 `/games/co-creation`；原先“游戏”页与主题列表页里的“游戏 / 共创”子页签已删除（共创不再挂在游戏页下）。`GameDetailPage` 通过共享 `GameDetailDisplay` 的作者插槽提供主页链接和独立关注按钮。私有关注关系表、查询/写入 API 以及页面交互均已实现；后端已由用户验收，前端工程验证通过，用户已要求提交并推送。本文前部旧入口说明不作为本专题的导航基线。
 
 必须项为入口、主页、双向列表查看、关注/取消关注/重新关注、本人移除粉丝、公开游戏列表及详情跳转。风险项为关系方向、越权、公开/私有游戏隔离、并发请求与关系列表分页回读。私信、关注动态、通知、拉黑、推荐榜单、主页装修、关系隐私设置和既有游戏目录分页改造不纳入首版。
 
 ### 页面与导航
 
-- 桌面导航保留前三项顺序，新增第四项“创作者主页”，“我的”变为第五项。第四项默认进入当前登录账号自己的主页（用户已确认）。
-- 移动端为“游戏 / 创作者主页 / 我的”，保留创作、项目的现有桌面限制，不把五项桌面入口强行塞入底部导航。
+- 桌面导航保留前三项顺序，新增第四项“创作者主页”，“我的”变为第五项。第四项默认进入当前登录账号自己的主页（用户已确认）。**2026-10-07 变更**：在“游戏”与“创作者主页”之间插入顶层“共创”（顺序为 `创作 / 项目 / 游戏 / 共创 / 创作者主页 / 我的`），指向 `/games/co-creation`。
+- 移动端为“游戏 / **共创** / 创作者主页 / 我的”（2026-10-07 起为四项），保留创作、项目的现有桌面限制，不把六项桌面入口全塞入底部导航；共创是公开只读的作品列表，窄屏同样可达。
 - 主页路由 `/creators?id=<userId>`；裸 `/creators` 表示自己的主页，登录后解析当前账号。显式 ID 深链可刷新、分享及直接访问，自己的主页与他人的主页共用页面。
 - 列表路由 `/creators/connections?id=<userId>&tab=following|followers`，关注数和粉丝数分别进入对应列表；返回恢复来源页及分页/滚动位置，直接访问的返回兜底为所属主页。
 - 主页和关系列表的返回优先使用应用内浏览器历史；没有可回退的应用内历史时，列表替换当前条目到所属主页，主页替换当前条目到游戏广场 `/games`。兜底返回不得新增历史条目，避免连续返回在主页地址之间循环。
@@ -731,7 +731,7 @@
 - 他人主页按钮为“关注”或“已关注”，点击“已关注”执行取消关注；自己的主页隐藏该按钮，不允许关注自己。按钮的可访问名称明确表达“取消关注”。
 - 游戏详情的作者头像/名称可点击进入主页，包括本人；作者旁增加同一套关注按钮。作者链接和关注按钮是独立点击目标，不因关注同时触发跳转；自己的游戏隐藏关注按钮。
 - 主页游戏卡复用现有公开卡片和详情路由，只列该用户仍然公开、未删除且有有效公开版本的游戏。自己的主页也遵循公开口径；未公开、审核中、下架游戏继续在 `/games/mine` 管理。
-- 游戏列表沿用现有读取限制：服务端先按作者和公开可见性筛选，再按创建时间倒序、游戏 ID 升序排序，最多返回 48 项；`nextCursor` 仍为空，不增加游戏分页或加载更多。不能下载广场前 48 项后在前端过滤作者。游戏广场和“我的游戏”保持原状；用户已明确本次不做额外改造。
+- 游戏列表沿用现有读取口径：服务端先按作者和公开可见性筛选，再按创建时间倒序、游戏 ID 升序排序（**先过滤、再排序切页**）。`GET /api/game-distribution/games` **已补真游标分页**（`limit` 缺省 48 / 上限 100 / 超界截断；`cursor` = `"{createdAtMicros}:{gameId}"`；末页 `nextCursor` 为 `null`），因此按作者过滤后不再受 48 项限制，客户端可继续翻页。不能下载广场前 48 项后在前端过滤作者——作者过滤必须在服务端、与切页同一次事务里完成。“我的游戏”保持原状。
 
 ### 关系方向与列表操作
 
@@ -780,7 +780,7 @@
 | `DELETE /api/creators/me/followers/{followerId}` | 当前登录用户移除自己的粉丝，幂等 |
 | 扩展 `GET /api/game-distribution/games?authorId=<userId>` | 服务端精确作者过滤，复用公开游戏可见性与卡片契约 |
 
-以上接口已在本地隔离环境实现并验证，未部署。关注/粉丝列表默认 20、上限 50，按关系建立时间与稳定身份倒序，返回 `items/nextCursor/total`；游标绑定主人和列表类型，非法/错域游标返回 400。增删期间重新加载可能改变页内成员，前端按用户 ID 去重，重新关注产生新的建立时间。此分页规则仅用于新关系列表；游戏列表继续最多读取 48 项，不实现分页。
+以上接口已在本地隔离环境实现并验证，未部署。关注/粉丝列表默认 20、上限 50，按关系建立时间与稳定身份倒序，返回 `items/nextCursor/total`；游标绑定主人和列表类型，非法/错域游标返回 400。增删期间重新加载可能改变页内成员，前端按用户 ID 去重，重新关注产生新的建立时间。此分页规则用于关系列表；游戏列表原为「最多读取 48 项、不实现分页」，现已由公开目录自身的真游标分页替换（缺省 48 / 上限 100 / 超界截断 / 末页 `nextCursor` 为 `null`，见上文 HTTP 边界表的 `GET /games` 行），因此作者过滤后不再受 48 项限制。`/my-games`（作者自己的作品管理列表）单次仍最多 48 项、不分页。
 
 关系写入成功返回 200 与当前访问者关系；重复删除不存在的关系仍成功。不合法输入或关注自己返回 400，未认证 401，越权 403，目标不存在或不可公开 404。本人读取自己的关系列表时以有效认证批量附带各行关系；游客和他人的关注、粉丝列表该字段为 null，后者即使已登录也不计算逐行关系。带关系的响应禁用共享缓存，认证失效时清除访问者关系并按游客重新读取。
 
diff --git a/package.json b/package.json
index 201fd65ae..2a9cfba81 100644
--- a/package.json
+++ b/package.json
@@ -74,6 +74,7 @@
     "check:spacetime-schema": "node scripts/check-spacetime-schema-guard.mjs",
     "check:generated-bindings": "node scripts/check-generated-bindings.mjs",
     "check:game-distribution-dto-parity": "node scripts/check-game-distribution-dto-parity.mjs",
+    "check:project-bundle-policy-parity": "node scripts/check-project-bundle-policy-parity.mjs",
     "check:game-distribution-price-limit-parity": "node scripts/check-game-distribution-price-limit-parity.mjs",
     "check:game-distribution-media-e2e": "node scripts/check-game-distribution-media-e2e.mjs",
     "check:game-distribution-owner-isolation": "node scripts/check-game-distribution-owner-isolation.mjs",
@@ -81,6 +82,7 @@
     "check:game-distribution-upload-resume": "node scripts/check-game-distribution-upload-resume.mjs",
     "check:agc-project-snapshot-admin-http": "node scripts/check-agc-project-snapshot-admin-http.mjs",
     "check:agc-update-channel-manifests": "node scripts/check-agc-update-channel-manifests.mjs",
+    "check:agc-co-creation-fork-e2e": "node scripts/check-agc-co-creation-fork-e2e.mjs",
     "check:game-distribution-sandbox-e2e": "node scripts/check-game-distribution-sandbox-e2e.mjs",
     "check:external-v1-scene-generation-smoke": "node scripts/check-external-v1-scene-generation-smoke.mjs",
     "check:game-distribution-web-e2e": "node scripts/check-game-distribution-web-e2e.mjs",
@@ -138,7 +140,7 @@
     "check:server-rs-ddd": "npm run check:spacetime-schema && npm run check:spacetime-runtime-access && npm run check:module-runtime-artifact && node scripts/check-server-rs-ddd-boundaries.mjs",
     "lint:eslint": "eslint . --ext .ts,.tsx,.js,.mjs,.cjs --max-warnings 0",
     "typecheck": "tsc -p tsconfig.typecheck-guardrails.json --noEmit",
-    "lint": "npm run check:encoding && npm run check:doc-index && npm run check:npm-workspaces && npm run check:git-hooks && npm run check:rustfmt && npm run check:spacetime-schema && npm run check:generated-bindings && npm run check:game-distribution-dto-parity && npm run check:game-distribution-price-limit-parity && npm run check:production-ops && npm run check:preview-deployer && npm run check:maintenance-page && npm run check:nginx-spa-routes && npm run check:pingora-route-parity && npm run lint:eslint && npm run typecheck",
+    "lint": "npm run check:encoding && npm run check:doc-index && npm run check:npm-workspaces && npm run check:git-hooks && npm run check:rustfmt && npm run check:spacetime-schema && npm run check:generated-bindings && npm run check:game-distribution-dto-parity && npm run check:project-bundle-policy-parity && npm run check:game-distribution-price-limit-parity && npm run check:production-ops && npm run check:preview-deployer && npm run check:maintenance-page && npm run check:nginx-spa-routes && npm run check:pingora-route-parity && npm run lint:eslint && npm run typecheck",
     "lint:fix": "eslint . --ext .ts,.tsx,.js,.mjs,.cjs --fix && prettier --write .",
     "format:rust": "cargo fmt --all --manifest-path server-rs/Cargo.toml && cargo fmt --all --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml && cargo fmt --all --manifest-path plugins/agc-unity-editor/native/unity-editor-bridge/Cargo.toml && cargo fmt --all --manifest-path plugins/agc-godot-editor/native/godot-editor-bridge/Cargo.toml",
     "format": "prettier --write . && npm run format:rust",
diff --git a/packages/shared/src/components/GameCard/index.tsx b/packages/shared/src/components/GameCard/index.tsx
index 683e20c1b..ede5bcbda 100644
--- a/packages/shared/src/components/GameCard/index.tsx
+++ b/packages/shared/src/components/GameCard/index.tsx
@@ -4,34 +4,99 @@ import type { ReactNode } from 'react';
 
 import type { GameDistributionGame } from '../../contracts/gameDistribution';
 import { GameRatingSummaryText } from '../GameRatingSummaryText';
+
+/**
+ * 卡面真正用到的字段（结构化子集）。
+ *
+ * 为什么收窄成子集：族谱/血缘图里的节点只有公开投影（标题、作者名、游玩数、封面、代际…），
+ * 拿不到 `summary` / `category` / `ratingSummary`。把它写成子集后，**图谱卡与广场卡用的是
+ * 同一个组件**（不是复制一份看起来一样的样式），缺失的字段行**不渲染**而不是渲染空行。
+ * 完整的 `GameDistributionGame` 仍然可以直接传进来（向后兼容）。
+ */
+export type GameCardModel = {
+  title: string;
+  playCount: number;
+  summary?: string | null;
+  category?: string | null;
+  ratingSummary?: GameDistributionGame['ratingSummary'] | null;
+  author?: { name?: string | null } | null;
+};
+
 export function GameCard({
   game,
   cover,
+  badges,
+  metric,
   onOpen,
+  className,
 }: {
-  game: GameDistributionGame;
+  game: GameCardModel;
   cover: ReactNode;
+  /**
+   * 卡面角标槽（可选）：图谱用「第 N 代 / 主卡 / ▶N 游玩合计」这类**标记**，
+   * 不承载动作按钮 —— 卡本身就是一个整体入口。
+   */
+  badges?: ReactNode;
+  /**
+   * 标题行右侧指标（可选）：不传时是默认的「N 次游玩」；传了就用它**替换**整块。
+   *
+   * 为什么做成槽而不是加字段：同一个指标位在不同列表里要表达的东西不同——「共创广场」上
+   * 用户要看的是「这个作品被多少人接着做了」（共创次数），不是游玩数（2026-10-07 用户口径：
+   * 「并非游玩次数，而是共创次数」）。槽让调用方给任意节点，默认行为一字不改。
+   */
+  metric?: ReactNode;
   onOpen: () => void;
+  className?: string;
 }) {
+  const summary = (game.summary ?? '').trim();
+  const category = (game.category ?? '').trim();
+  const authorName = (game.author?.name ?? '').trim();
+  /**
+   * 行存在性按「**字段是否在对象上**」判断，而不是按值是否为空：
+   * 广场/共创页签传的是完整作品对象（字段都在，哪怕是空串/未评分）→ 渲染行为与改动前**完全一致**；
+   * 族谱节点只有一个公开投影（字段真的不在）→ 不渲染空行。这样扩展是**纯加法**。
+   */
+  const hasField = (key: PropertyKey) =>
+    Object.prototype.hasOwnProperty.call(game, key);
   return (
-    <button type="button" className="game-card" onClick={onOpen}>
+    <button
+      type="button"
+      className={className ? `game-card ${className}` : 'game-card'}
+      onClick={onOpen}
+    >
       {cover}
+      {badges ? <span className="game-card__badges">{badges}</span> : null}
       <span className="game-card__body">
         <span className="game-card__title-row">
           <strong>{game.title}</strong>
-          <span className="game-card__play-count">
-            {game.playCount.toLocaleString()} 次游玩
+          {metric ?? (
+            <span className="game-card__play-count">
+              {game.playCount.toLocaleString()} 次游玩
+            </span>
+          )}
+        </span>
+        {hasField('summary') || summary ? (
+          <span className="game-card__summary">{game.summary}</span>
+        ) : null}
+        {hasField('ratingSummary') || game.ratingSummary ? (
+          <span className="game-card__rating">
+            <GameRatingSummaryText summary={game.ratingSummary ?? undefined} />
           </span>
-        </span>
-        <span className="game-card__summary">{game.summary}</span>
-        <span className="game-card__rating">
-          <GameRatingSummaryText summary={game.ratingSummary} />
-        </span>
-        <span className="game-card__meta">
-          <span>{game.category}</span>
-          <span>·</span>
-          <span>{game.author.name}</span>
-        </span>
+        ) : null}
+        {hasField('category') ||
+        hasField('author') ||
+        category ||
+        authorName ? (
+          <span className="game-card__meta">
+            {hasField('category') || category ? (
+              <span>{game.category}</span>
+            ) : null}
+            {hasField('category') || category ? <span>·</span> : null}
+            {hasField('author') || authorName ? (
+              <span>{game.author?.name}</span>
+            ) : null}
+          </span>
+        ) : null}
       </span>
     </button>
   );
diff --git a/packages/shared/src/components/GameCard/style.css b/packages/shared/src/components/GameCard/style.css
index 59225d1f9..e5dcac3ab 100644
--- a/packages/shared/src/components/GameCard/style.css
+++ b/packages/shared/src/components/GameCard/style.css
@@ -63,3 +63,24 @@
   color: var(--platform-text-soft);
   font-size: 0.7rem;
 }
+/* 卡面角标槽（可选）：图谱用「第 N 代 / 主卡 / ▶N」这类标记；仍然整卡可点，不承载动作按钮。 */
+.game-card {
+  position: relative;
+}
+.game-card__badges {
+  position: absolute;
+  top: 0.55rem;
+  left: 0.55rem;
+  right: 0.55rem;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.25rem;
+  pointer-events: none;
+}
+/* 图谱卡是高而窄的卡：标题允许两行（广场卡仍是单行省略）。 */
+.game-card--lineage .game-card__title-row strong {
+  white-space: normal;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+}
diff --git a/packages/shared/src/components/GameDetailDisplay/index.tsx b/packages/shared/src/components/GameDetailDisplay/index.tsx
index fe0f5104f..12ba8f6aa 100644
--- a/packages/shared/src/components/GameDetailDisplay/index.tsx
+++ b/packages/shared/src/components/GameDetailDisplay/index.tsx
@@ -66,7 +66,7 @@ export interface GameDetailDisplayProps extends GameDetailShowcaseProps {
   infoCards?: GameDetailDisplayInfoCard[];
   /** hero 里的评分摘要（公开详情传评分，后台可省略）。 */
   rating?: ReactNode;
-  /** hero 里的主行动作区（公开详情是「立即玩」，后台是「试玩待审版本」）。 */
+  /** hero 里的主行动作区（公开详情是「开始游戏」，后台是「试玩待审版本」）。 */
   actions?: ReactNode;
   /** hero 与正文之间的内容（作者作品状态、后台版本与审核信息等）。 */
   children?: ReactNode;
diff --git a/packages/shared/src/contracts/gameDistribution.ts b/packages/shared/src/contracts/gameDistribution.ts
index 165ed4b72..ca445f645 100644
--- a/packages/shared/src/contracts/gameDistribution.ts
+++ b/packages/shared/src/contracts/gameDistribution.ts
@@ -103,6 +103,220 @@ export type GameDistributionVersionSummary = {
   sha256: string;
   publishedAt: string;
   controls: string[];
+  /**
+   * 本版相对改编来源作品的核心改动说明（衍生作品必有；母版为 `null`）。
+   *
+   * 版本级字段：详情页与族谱溯源逐版渲染「每一代的差异」。公开投影里它不含任何私有字段
+   * （没有对象键 / 素材 id），因此匿名可读；母版发 `null` 而不是省略该键。
+   */
+  changeSummary?: string | null;
+};
+
+/**
+ * 共创授权三态：只允许单向提升（forbidden → nonCommercial → full），不可降级。
+ */
+export type GameDistributionForkAuthorization =
+  | 'forbidden'
+  | 'nonCommercial'
+  | 'full';
+
+/** 授权阶梯顺序；`canUpgradeGameForkAuthorization` 按这个顺序判定可提升档位。 */
+export const GAME_DISTRIBUTION_FORK_AUTHORIZATIONS: readonly GameDistributionForkAuthorization[] =
+  ['forbidden', 'nonCommercial', 'full'];
+
+/** 旧数据、字段缺省或未知取值时的兜底档位：保守拒绝共创。 */
+export const GAME_DISTRIBUTION_DEFAULT_FORK_AUTHORIZATION: GameDistributionForkAuthorization =
+  'forbidden';
+
+export const GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS: Record<
+  GameDistributionForkAuthorization,
+  string
+> = {
+  forbidden: '禁止共创',
+  nonCommercial: '允许非商用共创',
+  full: '允许全开放共创',
+};
+
+/** 空间受限场景（卡片行内选择等）用的短标签。 */
+export const GAME_DISTRIBUTION_FORK_AUTHORIZATION_SHORT_LABELS: Record<
+  GameDistributionForkAuthorization,
+  string
+> = {
+  forbidden: '禁止',
+  nonCommercial: '非商用',
+  full: '全开放',
+};
+
+/** 把任意原始值收敛到合法档位；缺省与未知一律按 `forbidden` 兜底。 */
+export function resolveGameForkAuthorization(
+  value: string | null | undefined,
+): GameDistributionForkAuthorization {
+  return GAME_DISTRIBUTION_FORK_AUTHORIZATIONS.includes(
+    value as GameDistributionForkAuthorization,
+  )
+    ? (value as GameDistributionForkAuthorization)
+    : GAME_DISTRIBUTION_DEFAULT_FORK_AUTHORIZATION;
+}
+
+/** 授权阶梯比较：只有严格高于当前档位的目标才允许提交。 */
+export function canUpgradeGameForkAuthorization(
+  current: GameDistributionForkAuthorization,
+  target: GameDistributionForkAuthorization,
+) {
+  return (
+    GAME_DISTRIBUTION_FORK_AUTHORIZATIONS.indexOf(target) >
+    GAME_DISTRIBUTION_FORK_AUTHORIZATIONS.indexOf(current)
+  );
+}
+
+/**
+ * 作品血缘摘要：代际、父作品与根作品。
+ * 根作品或旧数据为 null/缺省；父作品下架后仍按快照回传标题与作者名，用于溯源署名。
+ * 父/根作品被**软删除**（`game_distribution_game.deleted_at` 非空）时不再对外输出标题，
+ * `rootTitle` / `parentTitle` 为 null，`parentAuthorName` 一并缺省，展示层降级为
+ * 「原作品已不可用」；ID 与代际照常返回。
+ * `parentAuthorName` 在账号信息不可得时可能缺省或为 null，展示层按「无署名」处理。
+ */
+export type GameDistributionLineage = {
+  generation: number;
+  rootGameId: string;
+  rootTitle: string | null;
+  parentGameId: string;
+  parentTitle: string | null;
+  parentAuthorName?: string | null;
+};
+
+/**
+ * 族谱树上的单个作品节点。
+ *
+ * 只有公开且未软删除的作品会成为节点（锚点不可读时接口直接 404），因此 `title` 必然存在；
+ * `authorName` 为 null 表示作者信息不可得。`parentGameId` 指向的作品可能不在树里
+ * （父作品已删/未公开），展示层据此把该节点标注为「原作品不可用」，不猜测父作品内容。
+ * 节点只带作品级公开信息，不含**素材键 / 内部 id**（例如 `coverAssetId`）；`coverObjectKey`
+ * 是公开投影的一部分，与公开目录 / 详情同源同口径，无封面时为 null。
+ */
+export type GameDistributionLineageNode = {
+  gameId: string;
+  title: string;
+  authorName?: string | null;
+  /** 代际；母版为 0。 */
+  generation: number;
+  /** 父作品 ID；母版为 null。 */
+  parentGameId?: string | null;
+  playCount: number;
+  status: GameDistributionGameVisibility;
+  /**
+   * 该节点作品当前生效的封面对象键（与公开目录 / 详情同源，都来自游戏行
+   * `cover_object_key`）；无封面时为 null。只发对象键，不带 `coverAssetId` 等私有 id。
+   */
+  coverObjectKey?: string | null;
+};
+
+/**
+ * 族谱读接口响应：`nodes` 按代际升序、同代按创建时间升序稳定排序，含根（若根可见）；
+ * 超过节点上限时截断尾部并置 `truncated`，不静默丢弃。
+ */
+export type GameDistributionLineageResponse = {
+  /** 请求作品所属的根作品 ID；根不可用时仍返回，展示层据此标注树顶不可用。 */
+  rootGameId: string;
+  /** 根节点在可见集合中的投影；根已删或未公开时为 null。 */
+  root?: GameDistributionLineageNode | null;
+  nodes: GameDistributionLineageNode[];
+  truncated: boolean;
+};
+
+/** 直接衍生作品（「被改编」）列表响应；只含对外可见的直接子代。 */
+export type GameDistributionDerivedResponse = {
+  gameId: string;
+  nodes: GameDistributionLineageNode[];
+  truncated: boolean;
+};
+
+/**
+ * 归集的指标集合（当前只有游玩数）。
+ *
+ * 单独成结构体而不是把字段摊进响应里：将来加点赞 / 收藏 / 收入只需加字段，
+ * 递归定义（`inherited(W) = Σ 直接子代 total`、`total = own + inherited`）与投影形状都不动。
+ */
+export type GameDistributionContributionTotals = {
+  playCount: number;
+};
+
+/**
+ * 按代际分解的一条：**只含后代**（不含根自身），`generation` 为绝对代际（与族谱一致）。
+ *
+ * 语义：这一条是祖先 `inherited` 里**由这一代自己产生**的那一份，`total` 即该代贡献；
+ * `inherited` 恒为 `0`——该代从更深代际继承到的量已计入更深代际那一条，重复计入会让
+ * 「各代之和」大于祖先的 `inherited`（同一个后代会在多层分解里被重复计数）。
+ */
+export type GameDistributionContributionGeneration = {
+  generation: number;
+  /** 这一代计入分解的后代节点数。 */
+  gameCount: number;
+  own: GameDistributionContributionTotals;
+  inherited: GameDistributionContributionTotals;
+  total: GameDistributionContributionTotals;
+};
+
+/** 直接子代明细的一条：`total` 是该直接子代**含自己整棵子树**的值。 */
+export type GameDistributionContributionChild = {
+  gameId: string;
+  generation: number;
+  own: GameDistributionContributionTotals;
+  inherited: GameDistributionContributionTotals;
+  total: GameDistributionContributionTotals;
+};
+
+/**
+ * 作者视角的贡献归集与归因响应（`GET /api/game-distribution/games/{gameId}/contribution`）。
+ *
+ * 不变量（在**截断后的子树**上依然成立）：
+ * - `inherited == Σ byGeneration.total == Σ directChildren.total`；
+ * - `total == own + inherited`；
+ * - `nodeCount == Σ byGeneration.gameCount`（= 参与计算的**后代**节点数，不含根）。
+ *
+ * `truncated` 为真时 `truncatedReason` 取 `node_limit` / `depth_limit`，未截断为 `null`
+ * （与族谱接口 `truncated` 同约定：超限如实标注，不静默给半个数）。
+ * **本期只做计算**：响应里没有资金 / 分成 / 结算字段。
+ */
+export type GameDistributionContributionResponse = {
+  gameId: string;
+  own: GameDistributionContributionTotals;
+  inherited: GameDistributionContributionTotals;
+  total: GameDistributionContributionTotals;
+  byGeneration: GameDistributionContributionGeneration[];
+  directChildren: GameDistributionContributionChild[];
+  /** 参与计算的后代节点数（不含根）。 */
+  nodeCount: number;
+  truncated: boolean;
+  truncatedReason: string | null;
+};
+
+/**
+ * Fork 取件内容的形态。M2a 只有已构建的发行成品包；M2b 引入工程源包后，同一版本同时存在
+ * 两者时优先 `project`。
+ */
+export type GameDistributionForkSourceKind = 'package' | 'project';
+
+/**
+ * Fork 取件元数据：客户端据此校验取到的内容并决定建项形态。
+ *
+ * 只含版本身份与摘要，**不含 OSS 对象键**——下载走同源受鉴权路径 `downloadPath`，
+ * 对象键只留在服务端。`sha256` / `bytes` 取自版本行已存的发行包摘要，不重新计算。
+ */
+export type GameDistributionForkSource = {
+  gameId: string;
+  versionId: string;
+  source: GameDistributionForkSourceKind;
+  sha256: string;
+  bytes: number;
+  /** 同源相对路径；客户端按当前 origin 解析后带 Bearer 请求，不接受绝对 URL。 */
+  downloadPath: string;
+};
+
+/** Fork 取件元数据接口（`GET …/fork-source`）的响应体。 */
+export type GameDistributionForkSourceResponse = {
+  forkSource: GameDistributionForkSource;
 };
 
 export type GameDistributionGame = {
@@ -135,6 +349,52 @@ export type GameDistributionGame = {
   currentVersion?: GameDistributionVersionSummary | null;
   /** 公开列表和详情返回有效评价摘要；作者侧或旧响应可省略。 */
   ratingSummary?: GameDistributionRatingSummary;
+  /**
+   * 共创授权三态；旧数据或字段缺省时读作 `forbidden`。
+   *
+   * 衍生作品（有血缘行）的档位由创建时继承父作品决定、是**终态**（不能靠 `PUT` 提升）；
+   * 只有母版能单向提升，因此 `forbidden` 只可能出现在母版上。
+   */
+  forkAuthorization?: GameDistributionForkAuthorization;
+  /**
+   * 被**直接**改编的次数（直接子代数量）；旧数据或字段缺省时读作 0。
+   *
+   * 与 `coCreationCount` 的区别：这里只数**直接**子代（「被改编 N」），`coCreationCount`
+   * 数**整棵子树**的可见后代（「共创 N」）。两者共用同一批可见性规则，只是深度不同。
+   */
+  forkCount?: number;
+  /**
+   * **共创次数** = 该作品子树里**公开可见的全部后代**数（**不含自己**）。
+   *
+   * - 口径（服务端 2026-10-07 定稿）：沿血缘边 BFS 整棵子树，只数「未软删除 + 已公开」的后代
+   *   （与 `forkCount` 同一批规则 `counts_as_public_derivative`，只是深度不同）；已删 / 未公开的
+   *   后代不进任何一层计数。血缘环 / 自引用按已访问集合去重，自己永远不计数。
+   * - **公开投影恒发该键**：公开目录、公开详情，以及共用同一份公开投影的「我的收藏」与
+   *   「主题成员」都会发出；没有后代时发 `0`（不是缺键——缺键会被读成旧响应）。
+   * - 作者侧同形响应（我的作品 / 创建 / 提交 / 审核 / 撤回）**不发**这个键，因此读取方仍需
+   *   回退：`coCreationCount ?? forkCount`，两者都缺省或 `<= 0` 时不渲染角标。
+   * - 计数在服务端**只读事务里现算**（一次建「父 → 直接子代」索引 + 一次子树计数），不落表、
+   *   不新增索引，api-server 只发键不遍历。
+   */
+  coCreationCount?: number;
+  /** 血缘摘要；根作品或旧数据为 null/缺省。 */
+  lineage?: GameDistributionLineage | null;
+  /**
+   * 当前登录用户是否已收藏（收录）该作品。
+   *
+   * **只有公开详情在登录时返回**：匿名请求（含携带无效 token 按匿名处理）不带这个键，
+   * 也不发 `false`——`false` 会把「未登录」说成「没收藏」，客户端没法区分，会渲染出错误的
+   * 收藏按钮态。公开目录不返回。值来自服务端真实投影，不是前端本地状态。
+   */
+  collected?: boolean;
+  /**
+   * 该作品所属的**公开**共创主题（先取作品的根、再按根反查，跨主题多归属因此是数组）。
+   *
+   * **只有公开详情返回**（匿名与登录都返回；没有所属主题时是空数组，展示层据此不渲染空容器），
+   * 公开目录与作者侧不带这个键。第 N 代作品同样能看到主题——反查用的是根，不是作品自身。
+   * 排序与公开主题列表共用同一份比较器（创建时间倒序 + themeId 升序兜底）。
+   */
+  themes?: GameDistributionThemeReference[];
   /**
    * 买断价（整数泥点，`0` 表示免费）。后端公开投影始终下发；作者侧与旧响应可省略
    * （Rust 侧 `#[serde(default)]` 同样允许缺字段），读取方必须按 `0`（免费）兜底。
@@ -148,11 +408,323 @@ export type GameDistributionGame = {
   createdAt: string;
 };
 
+/**
+ * 公开游戏目录（`GET /api/game-distribution/games`）的响应体。
+ *
+ * 只含公开可玩的作品（`published` + 未软删除 + 有当前公开版本）。**真游标分页**：`limit` 缺省
+ * **48**（保持既有首屏语义）、上限 **100**，超界截断而非报错；`cursor` 形如
+ * `"{createdAtMicros}:{gameId}"`（解析只切第一个冒号）；游标格式非法时服务端返回 400
+ * `CATALOG_INVALID_CURSOR`（不是 200 的空页）。排序为创建时间倒序 + `gameId` 升序兜底
+ * （全序，翻页不重不漏）；`nextCursor` 是真实游标，**最后一页为 `null`**。
+ */
 export type GameDistributionListResponse = {
   games: GameDistributionGame[];
   nextCursor?: string | null;
 };
 
+/**
+ * 「我的收藏（收录）」列表接口（`GET /api/game-distribution/my-collections`）的响应体。
+ *
+ * 形状与公开目录 `GameDistributionListResponse` 一致（同一份公开投影），但分页语义不同：
+ * 默认一页 20 条、上限 50 条，排序按「收藏时间倒序 + collectionId 升序兜底」。
+ * `nextCursor` 是真实游标（`"{createdAtMicros}:{collectionId}"`），最后一页为 `null`；
+ * 游标格式非法时服务端返回 400（不是 200 的空页）。
+ */
+export type GameDistributionMyCollectionsResponse = {
+  games: GameDistributionGame[];
+  nextCursor?: string | null;
+};
+
+/**
+ * 共创主题的三态处置：`draft`（未发布）/ `published`（公开可见）/ `archived`（归档下架）。
+ *
+ * 公开侧只出现 `published`；`archived` 不是删除（主题行与成员行都保留，只是不再公开）。
+ * 后台写接口的 `status` 用这个联合类型，非法取值由服务端拒绝（400）。
+ */
+export type GameDistributionThemeStatus = 'draft' | 'published' | 'archived';
+
+/**
+ * 作品详情「所属主题」增量的单个条目：只够渲染一个跳转入口（主题页里才有完整信息）。
+ */
+export type GameDistributionThemeReference = {
+  themeId: string;
+  name: string;
+  badge: string;
+};
+
+/**
+ * 公开主题列表的单条：主题名、简介、角标与**当前公开可见成员数**。
+ *
+ * `memberCount` 是**真实可见成员数**（不含草稿 / 已下架成员），服务端不回报「全部成员行数」。
+ * 它是真实数：可见成员超过响应体积上限（50）时，它与主题详情 `roots` 的长度**故意不相等**——
+ * 「这份 `roots` 被截断」由详情响应上的 `rootsTruncated` 单独表达，客户端不要用这个字段反推。
+ */
+export type GameDistributionThemeSummary = {
+  themeId: string;
+  name: string;
+  summary: string;
+  badge: string;
+  memberCount: number;
+};
+
+/**
+ * 公开主题列表接口（`GET /api/game-distribution/themes`）的响应体。
+ *
+ * 只含 `published` 主题。分页沿用既有游标惯例：默认 20 条、上限 50 条、超界截断；
+ * `nextCursor` 是真实游标（`"{createdAtMicros}:{themeId}"`），最后一页为 `null`；游标格式非法时
+ * 服务端返回 400（不是 200 的空页）。排序为创建时间倒序 + `themeId` 升序兜底（全序，不重不漏）。
+ */
+export type GameDistributionThemeListResponse = {
+  themes: GameDistributionThemeSummary[];
+  nextCursor?: string | null;
+};
+
+/**
+ * 公开主题详情接口（`GET /api/game-distribution/themes/{themeId}`）的响应体。
+ *
+ * 顶层扁平形状与 `GET /games/{gameId}` 同形，不引入第二套包装。`roots` 逐条是公开目录同一份
+ * 作品投影，排序为 `sortOrder` 升序 + `memberId` 升序兜底。主题不存在或未发布时接口返回 404
+ * （不返回空壳）；已发布但可见成员为空时返回 200 + 空 `roots`（展示层按空态而不是错误渲染）。
+ *
+ * 两个成员数相关的字段口径**独立，不要互相推导**：
+ * - `memberCount` 是**真实可见成员数**（不截断），回答「这个主题有多少棵作品树」；
+ * - `rootsTruncated` 才是「**下面这份 `roots` 被响应体积上限（50）截断**」的信号，与族谱响应的
+ *   `truncated` 同一个约定（列表被上限截断时置 `true`）。`roots.length !== memberCount` 时就得看它。
+ */
+export type GameDistributionThemeDetail = {
+  themeId: string;
+  name: string;
+  summary: string;
+  badge: string;
+  memberCount: number;
+  roots: GameDistributionGame[];
+  rootsTruncated: boolean;
+};
+
+/**
+ * 后台创建主题（`POST /admin/api/game-distribution/themes`）的请求体。
+ *
+ * `name` 必填且非空；其余字段省略时按「空文本 / 排序 0 / `draft`」落库（与表列默认一致）。
+ */
+export type GameDistributionCreateThemeRequest = {
+  name: string;
+  summary?: string;
+  badge?: string;
+  sortOrder?: number;
+  status?: GameDistributionThemeStatus;
+};
+
+/**
+ * 后台更新主题（`PUT /admin/api/game-distribution/themes/{themeId}`）的请求体。
+ *
+ * **整体覆盖**这几个字段（不是部分更新）：字段都必填，避免「省略 = 保留旧值」与「省略 = 清空」
+ * 两种解释在客户端之间漂移。
+ */
+export type GameDistributionUpdateThemeRequest = {
+  name: string;
+  summary: string;
+  badge: string;
+  sortOrder: number;
+  status: GameDistributionThemeStatus;
+};
+
+/**
+ * 后台增 / 改成员（`PUT …/themes/{themeId}/members/{rootGameId}`）的请求体。
+ *
+ * 成员身份完全由路径给出，body 只承载运营权重；重复调用由确定性主键保证幂等。
+ */
+export type GameDistributionUpsertThemeMemberRequest = {
+  sortOrder?: number;
+};
+
+/**
+ * 后台主题条目：`{ themeId, name, summary, badge, sortOrder, status, memberCount, createdAt, updatedAt }`。
+ *
+ * 与公开的 `GameDistributionThemeSummary` **刻意不同形**：后台多出 `sortOrder` / `status` / 时间戳，
+ * 且 `memberCount` 的口径是**成员行总数**（含当前对外不可见的成员）——后台没有「不该被探测」的顾虑，
+ * 运营需要知道这个主题挂了几个根；公开投影里的同名键是**当前可见**成员数。
+ *
+ * 没有 Rust 结构体可对（服务端由 `admin_theme_payload` 逐字段手拼 JSON），因此在 DTO parity 里
+ * 走 `TS_ONLY_TYPES` + `RESPONSE_BUILDERS` 登记：形状由机器门禁钉住，后台 UI 与实现不能各自漂移。
+ */
+export type GameDistributionAdminTheme = {
+  themeId: string;
+  name: string;
+  summary: string;
+  badge: string;
+  sortOrder: number;
+  status: GameDistributionThemeStatus;
+  memberCount: number;
+  createdAt: string;
+  updatedAt: string;
+};
+
+/**
+ * 后台主题列表响应：`{ themes: [...] }`。
+ *
+ * **没有 `nextCursor`**：这条路径不分页（`limit` 缺省与上限都是 200），因此这里也不能声明可选游标，
+ * 否则前端会以为存在第二页。
+ */
+export type GameDistributionAdminThemeListResponse = {
+  themes: GameDistributionAdminTheme[];
+};
+
+/**
+ * 后台创建 / 更新主题的响应：`{ theme, replayed }`。
+ *
+ * `replayed` 必须原样发出：客户端据此区分「这次真的写了」与「同键重放，库里没动」。
+ */
+export type GameDistributionAdminThemeMutationResponse = {
+  theme: GameDistributionAdminTheme;
+  replayed: boolean;
+};
+
+/**
+ * 后台成员写入的响应：`{ themeId, rootGameId, sortOrder, createdAt }`。
+ *
+ * `createdAt` 是**首次挂载**的时间：重复 `PUT` 只改 `sortOrder`，不会刷新它。
+ */
+export type GameDistributionAdminThemeMemberResponse = {
+  themeId: string;
+  rootGameId: string;
+  sortOrder: number;
+  createdAt: string;
+};
+
+/**
+ * 后台移除成员的响应：`{ themeId, rootGameId }`。
+ *
+ * 刻意不含「之前存不存在」：删掉的与本来就没有的回同一个形状，重复调用逐字节相同。
+ */
+export type GameDistributionAdminThemeMemberRemovalResponse = {
+  themeId: string;
+  rootGameId: string;
+};
+
+/**
+ * 后台成员行的细粒度状态（**只给后台**，公开投影不发这个键）。
+ *
+ * - `published` / `unpublished` / `suspended`：成员行还在、游戏行也在，原样透传游戏行的可见性；
+ * - `deleted`：游戏行被软删除；
+ * - `missing`：游戏行**根本不存在**（历史脏行）。
+ *
+ * 与同一行的 `visible` **是两个独立字段、不许互相推导**：`visible` 回答「此刻公开投影会不会
+ * 出现它」，`visibility` 回答「为什么」。因此 `visibility === 'published'` 但没有当前公开版本时
+ * `visible === false`——这是刻意的，运营据此看出「作品已公开、但没有公开版本」这种异常。
+ */
+export type GameDistributionAdminThemeMemberVisibility =
+  | 'published'
+  | 'unpublished'
+  | 'suspended'
+  | 'deleted'
+  | 'missing';
+
+/**
+ * 后台主题成员行：`GET /admin/api/game-distribution/themes/{themeId}/members` 的 `members[]`。
+ *
+ * **后台看得到全部成员行**（含当前对外不可见的），这是本接口存在的理由：草稿 / 归档主题在公开
+ * 投影里根本不存在，运营没法在发布前核对名单。
+ *
+ * `title` 取游戏行标题，游戏行不存在时为 `null`（该行仍要出现在名单里，否则与 `totalMembers` 对不上）。
+ * 只为后台渲染而发，后台本就允许看草稿作品。
+ */
+export type GameDistributionAdminThemeMemberRow = {
+  rootGameId: string;
+  title: string | null;
+  sortOrder: number;
+  /** 首次挂载时间（重复 PUT 只改 `sortOrder`，不刷新它）。 */
+  createdAt: string;
+  /** 此刻**公开投影**是否包含它（未删除 + 已公开 + 有当前公开版本）。 */
+  visible: boolean;
+  visibility: GameDistributionAdminThemeMemberVisibility;
+};
+
+/**
+ * 后台主题成员列表响应。
+ *
+ * `totalMembers` 是该主题的**成员行总数**（含当前不可见的成员），**不受分页影响**；它与
+ * `members.length` 不是一回事（后者只是这一页）。
+ *
+ * 分页与其它列表同一口径：`limit` 缺省 **20** / 上限 **50** / `0` 取默认 / 超界截断；游标形如
+ * `"{sortOrder}:{memberId}"`（`memberId` 本身是 `"{themeId}:{rootGameId}"`，解析只切第一个冒号），
+ * 排序为 `sortOrder` 升序 + 成员主键升序兜底（全序，翻页不重不漏）；**非法游标 → 400
+ * `THEME_INVALID_CURSOR`**；末页 `nextCursor` 为 `null`。
+ *
+ * 主题不存在 → 404 `THEME_NOT_FOUND`；`draft` / `archived` **不是** 404（后台要看得见）。
+ */
+export type GameDistributionAdminThemeMemberListResponse = {
+  themeId: string;
+  totalMembers: number;
+  members: GameDistributionAdminThemeMemberRow[];
+  nextCursor: string | null;
+};
+
+export type GameDistributionCreateGameRequest = {
+  /** 发布方本地项目标识；同一作者重复发布会复用既有 gameId。 */
+  localProjectId?: string | null;
+  title: string;
+  summary: string;
+  description?: string;
+  category: GameDistributionCategory;
+  tags?: string[];
+  /** 沿用线上封面时给出既有对象键；同时携带 `cover` 二进制 part 时以 part 为准。 */
+  coverObjectKey?: string | null;
+  /** 与最终截图顺序一一对应：`string` 沿用线上 objectKey，`null` 取按序的 `screenshot` 二进制 part。 */
+  screenshots?: (string | null)[];
+  deviceSupport: GameDistributionDeviceSupport;
+  inputModes: GameDistributionInputMode[];
+  orientation: GameDistributionOrientation;
+  /**
+   * 上架时选择的共创授权档位：`forbidden` / `nonCommercial` / `full`。
+   *
+   * 缺省按「禁止共创」解释（与库表默认、与旧客户端行为一致）；非法取值整请求 400，不会静默
+   * 落成 `forbidden`。上架之后**母版**只能通过 `PUT …/fork-authorization` 单向提升。
+   *
+   * **只对母版（0 代作品）生效**：带 `fork` 声明时，服务端在新作品创建时**继承父作品当时的
+   * 档位**，这里传的值被忽略且不报错（旧客户端惯常带默认值）；服务端不接受「收窄」。继承来的
+   * 档位是**终态**——衍生作品再调 `PUT …/fork-authorization` 一律被拒（409
+   * `FORK_AUTHORIZATION_INHERITED`）；父作品为 `forbidden` 时建立不了血缘，因此衍生作品
+   * 不会继承到 `forbidden`。
+   * 字段形状刻意保持不变——改成 `Option` 之类的形状会让创建请求的幂等摘要漂移。
+   */
+  forkAuthorization?: GameDistributionForkAuthorization;
+  /** 改编来源声明；只在全新作品上生效，复用既有身份时会被拒绝。 */
+  fork?: GameDistributionForkDeclaration | null;
+};
+
+export type GameDistributionCreateVersionRequest = {
+  localProjectId?: string | null;
+  /**
+   * 用户可见的正整数版本标签（AGC 发布面板由工程内部版本序数派生后原样提交）。
+   *
+   * 传入时只要求 `>= 1`：同一 `gameId` 的同一个版本号可以反复提交，每次提交生成新的
+   * `versionId`，允许重复标签与回退到更小的版本号，不与已有最大值比较。
+   * 缺省时保留旧客户端兼容行为：服务端按该游戏已有最大版本号 +1。
+   */
+  versionNumber?: number | null;
+  /**
+   * 作者提交的买断价（整数泥点，`0` 表示免费）。
+   *
+   * 价格随版本冻结，审核通过时与资料一起生效到游戏行；缺省按 `0`（免费）处理。
+   * 取值范围由服务端约束：`0..=1_000_000`，付费必须是正整数。
+   */
+  priceMudPoints?: number;
+  packageSha256: string;
+  packageBytes: number;
+  packageFileCount: number;
+  packageEntryPath: 'index.html';
+  gameMetadata: GameDistributionCreateGameRequest;
+  /**
+   * 「本次核心改动说明」：**衍生作品**（该作品有改编来源）发布新版本时必填，
+   * trim 后按**字符**计 20–500 个字符；0 代母版忽略该字段（不校验、不落库）。
+   *
+   * 缺失 → 400 `FORK_CHANGE_SUMMARY_REQUIRED`；长度越界 → 400 `FORK_CHANGE_SUMMARY_INVALID`。
+   * 它参与请求摘要：同一个 `Idempotency-Key` 换了说明会被按「同键不同请求」拒绝（409），
+   * 省略该键的旧客户端请求与升级前逐字节一致（缺省不序列化 `null`）。
+   */
+  changeSummary?: string | null;
+};
+
 /**
  * 作者编辑游戏级展示资料。
  *
@@ -190,6 +762,10 @@ export type GameDistributionPrivateVersion = {
   reviewReason?: string | null;
   /** 审核通过后由服务端派生的公开入口，未公开版本为 null。 */
   entryUrl: string | null;
+  /** 工程源包字节数；0 表示该版本未上传工程源包（作者上架时选择不给源码）。 */
+  projectBundleBytes: number;
+  /** 工程源包整包 SHA-256；未上传缺省。对象键不下发，只在服务端使用。 */
+  projectBundleSha256?: string | null;
   createdAt: string;
   updatedAt: string;
 };
@@ -242,6 +818,36 @@ export type GameDistributionCancelVersionResponse = {
   replayed: boolean;
 };
 
+/**
+ * 修改共创授权；`expectedForkAuthorization` 是 CAS 期望值。
+ *
+ * **只有母版**能提升（只升不降）。衍生作品（存在血缘行）的档位由创建时继承父作品决定、是终态，
+ * 任何请求都返回 409 `FORK_AUTHORIZATION_INHERITED`——包括传同值的幂等重试。
+ */
+export type GameDistributionSetForkAuthorizationRequest = {
+  expectedForkAuthorization: GameDistributionForkAuthorization;
+  forkAuthorization: GameDistributionForkAuthorization;
+};
+
+/** 创建游戏时的改编来源声明：父作品 + 建立血缘时锁定的父版本。 */
+export type GameDistributionForkDeclaration = {
+  parentGameId: string;
+  parentVersionId: string;
+};
+
+/**
+ * 收藏（收录）写入 / 取消后的权威投影值。
+ *
+ * `collected` 是**调用后**的收藏事实（服务端真实投影，不是前端本地状态）；PUT 与 DELETE
+ * 共用一个形状，客户端不按「动词」推断结果。`replayed` 只在带幂等键的 PUT 上有意义：
+ * 命中同键收据时为 `true`（本次没产生新事实）；DELETE 按确定性主键删除、天然幂等，
+ * 因此不返回该键。
+ */
+export type GameDistributionCollectionState = {
+  collected: boolean;
+  replayed?: boolean;
+};
+
 /**
  * 买断制购买请求体。
  *
diff --git a/packages/shared/src/contracts/gameDistributionPublish.ts b/packages/shared/src/contracts/gameDistributionPublish.ts
index d31e4f656..925c8e744 100644
--- a/packages/shared/src/contracts/gameDistributionPublish.ts
+++ b/packages/shared/src/contracts/gameDistributionPublish.ts
@@ -32,6 +32,13 @@ export type NewGameVersionRequest = {
   packageEntryPath: string;
   /** 作品展示资料：首次发布用于 bootstrap 游戏行，同时冻结进版本资料快照。 */
   gameMetadata: GameMetadata;
+  /**
+   * 「本次核心改动说明」：衍生作品发布新版本时由服务端事务校验；母版忽略。
+   *
+   * 与旧两步请求同口径：api-server 原样透传、事务统一判定；未携带该字段的旧客户端请求
+   * 序列化结果保持逐字节不变（缺省不序列化 `null`）。
+   */
+  changeSummary?: string | null;
 };
 
 /** 统一发布响应：作者侧游戏投影 + 私有版本投影 + 是否幂等重放。 */
diff --git a/packages/shared/src/contracts/generated/GameMetadata.ts b/packages/shared/src/contracts/generated/GameMetadata.ts
index 2106f2c24..c22da06ba 100644
--- a/packages/shared/src/contracts/generated/GameMetadata.ts
+++ b/packages/shared/src/contracts/generated/GameMetadata.ts
@@ -16,4 +16,27 @@ coverObjectKey: string | null,
 /**
  * 与最终截图顺序一一对应：`Some(objectKey)` 沿用线上，`None` 取按顺序出现的 `screenshot` 二进制 part。
  */
-screenshots: Array<string | null>, deviceSupport: { desktop: boolean, mobile: boolean, touch: boolean }, inputModes: Array<'keyboard' | 'mouse' | 'touch'>, orientation: 'landscape' | 'portrait' | 'responsive', };
+screenshots: Array<string | null>, deviceSupport: { desktop: boolean, mobile: boolean, touch: boolean }, inputModes: Array<'keyboard' | 'mouse' | 'touch'>, orientation: 'landscape' | 'portrait' | 'responsive', 
+/**
+ * 上架时选择的共创授权档位；缺省按「禁止共创」解释（与表列默认一致，旧客户端不受影响）。
+ *
+ * **只对母版（0 代作品）生效**：带 `fork` 声明时，新作品的档位在创建时**继承父作品当时的
+ * 档位**，本字段一律被忽略且不报错（旧客户端会惯常带默认值），服务端也不接受「收窄」。
+ * 继承来的档位是**终态**：衍生作品之后再调 `PUT …/fork-authorization` 一律被拒（409
+ * `FORK_AUTHORIZATION_INHERITED`），母版才走「只升不降」。父作品为 `forbidden` 时根本建立
+ * 不了血缘，所以衍生作品不会继承到 `forbidden`。
+ * 字段形状刻意保持不变（非 `Option` + `#[serde(default)]`）：改了会让幂等摘要漂移。
+ *
+ * 写成非 `Option` + `#[serde(default)]` 而不是 `Option<..>`：省略与显式传 `forbidden`
+ * 得到同一个值，因此 `create_game` 的幂等摘要（对整个请求体取摘要）也相同——省略与显式
+ * 传默认不会变成两个不同的请求；未知取值由反序列化直接拒绝（api-server 映射 400），
+ * 不会静默落成 `forbidden`。
+ */
+forkAuthorization: 'forbidden' | 'nonCommercial' | 'full', 
+/**
+ * 改编来源声明；只在全新作品上生效，复用既有身份时会被拒绝。
+ *
+ * TS 侧标成可选：渲染层**不**提交该键，改编声明由原生发布链路从项目内
+ * `.agent/fork-source.json` 读取后并入；显式 `null` 与省略在服务端等价。
+ */
+fork?: { parentGameId: string, parentVersionId: string }, };
diff --git a/scripts/capture-game-lineage-visual.mjs b/scripts/capture-game-lineage-visual.mjs
new file mode 100644
index 000000000..734ed7690
--- /dev/null
+++ b/scripts/capture-game-lineage-visual.mjs
@@ -0,0 +1,1745 @@
+// 族谱可视化（节点-连线树）的截图与 DOM 断言工具。
+//
+// 这不是 CI 门禁脚本，是给人看的验收工具：它先造一棵真实的多代多分支树（+一个降级态 fixture），
+// 再用 Playwright 打开 /games/lineage?id=<根> 出 5 张截图并顺手做 DOM 断言。
+//
+// 用法（需要本地 dev 栈 + admin 凭据；playwright 走临时目录，见仓库既有 e2e 的用法）：
+//   E2E_ADMIN_USER=admin E2E_ADMIN_PASSWORD=123456 \
+//   E2E_PLAYWRIGHT_DIR=%TEMP%/genarrative-pw E2E_CHROMIUM_EXECUTABLE='C:/Program Files/Google/Chrome/Application/chrome.exe' \
+//   node scripts/capture-game-lineage-visual.mjs
+//
+// 契约来源（读实现确认；符号检索定位，不写行号）：src/components/game-distribution/GameLineagePage.tsx
+//   - 节点：`.game-lineage-node`（`role="button"` + `tabIndex=0` + `aria-label`）、锚点额外 `--anchor` + `aria-current="true"`、
+//     占位节点 `--stub` + `aria-disabled="true"`（标题就是「原作品已不可用」）、非高亮节点 `--dimmed`
+//   - 画布：`.game-lineage-canvas`（滚轮缩放、指针拖拽平移）→ `.game-lineage-canvas__content` 带 transform
+//   - 缩放控件：`button[aria-label="放大"]` / `button[aria-label="缩小"]`、百分比 `role="status"` 的 `.game-lineage-zoom`
+//   - hover：节点 onMouseEnter → 祖先路径高亮、其余 `--dimmed`
+//   - 降级文案：占位节点标题「原作品已不可用」、页内 notice「母版已不可用…」
+//   - 首次进入自动 fitToView（不抢用户后续缩放）
+//   - 布局纯函数：src/components/game-distribution/lineageTreeLayout.ts（缺失父作品会生成 stub 节点）
+
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { deflateSync } from 'node:zlib';
+
+import JSZip from 'jszip';
+
+const ENVELOPE = { 'x-genarrative-response-envelope': 'v1' };
+const ADMIN_USER = (process.env.E2E_ADMIN_USER ?? '').trim();
+const ADMIN_PASSWORD = process.env.E2E_ADMIN_PASSWORD ?? '';
+const DEV_PASSWORD = 'GenE2e123!';
+const GATE_KEY = 'game-distribution:publish';
+/** 隔离实例的缺省地址（专用端口；库名/data-dir 由隔离实例启动器负责，见《开发运维》「本地 e2e 必须用隔离实例」）。 */
+const ISOLATED_API_BASE = 'http://127.0.0.1:8188';
+const ISOLATED_WEB_BASE = 'http://127.0.0.1:3112';
+
+if (!ADMIN_USER || !ADMIN_PASSWORD) {
+  console.error('缺少 E2E_ADMIN_USER / E2E_ADMIN_PASSWORD');
+  process.exit(2);
+}
+
+/**
+ * 解析目标地址（本工具**自带**这份逻辑，不依赖未入库的本地模块）：
+ * - 「只截现有作品」模式是只读，按 `.app/dev-stack.json` 解析（要的就是用户开发栈里的演示数据）；
+ * - 造树模式会写夹具 → 缺省打隔离实例，并拒绝误打用户开发栈。
+ */
+function readDevStackMarker() {
+  try {
+    return JSON.parse(
+      readFileSync(path.resolve(process.cwd(), '.app/dev-stack.json'), 'utf8'),
+    );
+  } catch {
+    return null;
+  }
+}
+function normalizeBase(value) {
+  return String(value ?? '')
+    .trim()
+    .replace(/\/+$/u, '');
+}
+function resolveCaptureTarget() {
+  const marker = readDevStackMarker();
+  const devApi = normalizeBase(marker?.services?.['api-server']?.url);
+  const devWeb = normalizeBase(marker?.services?.web?.url);
+  const captureOnly = (process.env.E2E_CAPTURE_LINEAGE_URL ?? '').trim() !== '';
+  const explicitApi = normalizeBase(process.env.E2E_API_BASE);
+  const explicitWeb = normalizeBase(process.env.E2E_WEB_BASE);
+  const apiBase =
+    explicitApi ||
+    (captureOnly ? devApi || ISOLATED_API_BASE : ISOLATED_API_BASE);
+  const webBase =
+    explicitWeb ||
+    (captureOnly ? devWeb || ISOLATED_WEB_BASE : ISOLATED_WEB_BASE);
+  if (!captureOnly && (process.env.E2E_ALLOW_DEV_STACK ?? '').trim() !== '1') {
+    const samePort =
+      devApi &&
+      new URL(apiBase).port &&
+      new URL(apiBase).port === new URL(devApi).port;
+    if (devApi && (apiBase === devApi || samePort)) {
+      console.error(
+        [
+          `capture-game-lineage-visual.mjs: 目标 ${apiBase} 就是用户正在用的开发栈（.app/dev-stack.json → ${devApi}）。`,
+          '造树模式会写夹具，缺省必须打隔离实例：二选一——',
+          `  1) 用隔离实例：专用端口（api ${ISOLATED_API_BASE} / web ${ISOLATED_WEB_BASE}）+ 专用库名 + 临时 data-dir（见《开发运维》「本地 e2e / 夹具必须用隔离实例」）`,
+          '  2) 明确越权：E2E_API_BASE=<dev 栈地址> E2E_ALLOW_DEV_STACK=1（这会真的写进用户的库）',
+        ].join('\n'),
+      );
+      process.exit(2);
+    }
+  }
+  return { apiBase, webBase };
+}
+const { apiBase: API, webBase: WEB } = resolveCaptureTarget();
+
+let checks = 0;
+let failures = 0;
+function check(name, ok, detail = '') {
+  checks += 1;
+  if (!ok) failures += 1;
+  console.log(
+    `${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` :: ${detail}` : ''}`,
+  );
+}
+// ---------- 真实封面图（脚本内生成，不依赖网络/外部资源） ----------
+//
+// 需求方要凭截图判断「够不够帅」，1×1 透明 PNG 会在卡片上显示成灰块，看不出视觉上限；
+// 这里用纯 Node（zlib + 手写 PNG chunk）生成 512×288 的**有内容**封面：每个节点一张、
+// 色相不同、并叠加斜条纹与底部条带，便于在截图里一眼分辨不同节点的封面。
+
+const PNG_SIGNATURE = Buffer.from([
+  0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);
+
+const PNG_CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < 256; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+
+function pngCrc32(buffer) {
+  let crc = 0xffffffff;
+  for (const byte of buffer) {
+    crc = PNG_CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function pngChunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const typeAndData = Buffer.concat([Buffer.from(type, 'ascii'), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(pngCrc32(typeAndData), 0);
+  return Buffer.concat([length, typeAndData, crc]);
+}
+
+function hslToRgb(hue, saturation, lightness) {
+  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  const hueSection = (((hue % 360) + 360) % 360) / 60;
+  const second = chroma * (1 - Math.abs((hueSection % 2) - 1));
+  const base = lightness - chroma / 2;
+  const table = [
+    [chroma, second, 0],
+    [second, chroma, 0],
+    [0, chroma, second],
+    [0, second, chroma],
+    [second, 0, chroma],
+    [chroma, 0, second],
+  ];
+  const [red, green, blue] = table[Math.floor(hueSection) % 6];
+  return [
+    Math.round((red + base) * 255),
+    Math.round((green + base) * 255),
+    Math.round((blue + base) * 255),
+  ];
+}
+
+/// 每个 index 一张不同的封面：色相轮转 + 斜条纹 + 底部条带，便于在截图里区分节点。
+function makeCoverPng(index, total = 6) {
+  const width = 512;
+  const height = 288;
+  const hue = Math.round((360 / total) * index + 18);
+  const stripeCount = 3 + index;
+  const raw = Buffer.alloc((width * 3 + 1) * height);
+  let offset = 0;
+  for (let y = 0; y < height; y += 1) {
+    raw[offset] = 0; // filter: none
+    offset += 1;
+    for (let x = 0; x < width; x += 1) {
+      // 垂直渐变：顶部亮、底部暗
+      const gradient = 0.72 - (y / height) * 0.42;
+      // 斜条纹：每张图的条数不同，条纹上提亮
+      const stripe = (x + y * 0.75) % 96 < 96 / stripeCount ? 0.16 : 0;
+      // 底部条带：模拟卡片下缘的一条深色 caption
+      const bottomBand = y > height - 46 ? -0.24 : 0;
+      const lightness = Math.min(
+        0.9,
+        Math.max(0.08, gradient + stripe + bottomBand),
+      );
+      const [red, green, blue] = hslToRgb(hue, 0.55, lightness);
+      raw[offset] = red;
+      raw[offset + 1] = green;
+      raw[offset + 2] = blue;
+      offset += 3;
+    }
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8; // bit depth
+  ihdr[9] = 2; // color type: truecolor
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  return Buffer.concat([
+    PNG_SIGNATURE,
+    pngChunk('IHDR', ihdr),
+    pngChunk('IDAT', deflateSync(raw, { level: 9 })),
+    pngChunk('IEND', Buffer.alloc(0)),
+  ]);
+}
+
+const COVER_PNG = makeCoverPng(0);
+
+async function api(pathname, options = {}) {
+  const { method = 'GET', token, body, headers = {}, binary } = options;
+  const finalHeaders = { ...ENVELOPE, ...headers };
+  if (token) finalHeaders.Authorization = `Bearer ${token}`;
+  let finalBody;
+  if (binary) {
+    finalBody = binary;
+  } else if (body !== undefined) {
+    finalHeaders['Content-Type'] = 'application/json';
+    finalBody = JSON.stringify(body);
+  }
+  const response = await fetch(`${API}${pathname}`, {
+    method,
+    headers: finalHeaders,
+    body: finalBody,
+    signal: AbortSignal.timeout(120_000),
+  });
+  const text = await response.text();
+  let json = null;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = null;
+  }
+  return {
+    status: response.status,
+    text,
+    json,
+    data: json?.data,
+    error: json?.error,
+  };
+}
+
+function brief(body) {
+  const code = body?.error?.code ?? body?.json?.error?.code ?? '';
+  return `status=${body?.status} code=${code} text=${String(body?.text ?? '').slice(0, 160)}`;
+}
+
+async function register(prefix) {
+  const phone = `${prefix}${String(Date.now()).slice(-8)}`;
+  const response = await api('/api/auth/entry', {
+    method: 'POST',
+    body: { purePhoneNumber: phone, password: DEV_PASSWORD },
+  });
+  return { phone, token: response.data?.token };
+}
+
+async function setDisplayName(token, displayName) {
+  return api('/api/profile/me', {
+    method: 'PATCH',
+    token,
+    body: { displayName },
+  });
+}
+
+function gameMetadata({ title, coverAssetId }) {
+  return {
+    title,
+    summary: '族谱可视化截图 fixture',
+    description: '',
+    category: '休闲',
+    tags: ['e2e'],
+    coverAssetId,
+    deviceSupport: { desktop: true, mobile: false, touch: false },
+    inputModes: ['keyboard', 'mouse'],
+    orientation: 'landscape',
+  };
+}
+
+async function uploadCover(token, id, png = COVER_PNG) {
+  const fileName = `visual-${id}.png`;
+  const ticket = await api('/api/assets/direct-upload-tickets', {
+    method: 'POST',
+    token,
+    body: {
+      legacyPrefix: 'generated-character-drafts',
+      pathSegments: ['game-distribution', 'lineage-visual', String(id)],
+      fileName,
+      contentType: 'image/png',
+      access: 'private',
+      maxSizeBytes: png.length,
+      metadata: { asset_kind: 'game_distribution_cover' },
+    },
+  });
+  if (ticket.status !== 200) throw new Error(`直传凭证失败 ${brief(ticket)}`);
+  const upload = ticket.data.upload;
+  const form = new FormData();
+  for (const [key, value] of Object.entries(upload.formFields ?? {})) {
+    if (value !== null && value !== undefined) form.append(key, String(value));
+  }
+  form.append('file', new Blob([png], { type: 'image/png' }), fileName);
+  const put = await fetch(upload.host, { method: 'POST', body: form });
+  if (!put.ok) throw new Error(`直传失败 ${put.status}`);
+  const confirm = await api('/api/assets/objects/confirm', {
+    method: 'POST',
+    token,
+    body: {
+      bucket: upload.bucket,
+      objectKey: upload.objectKey,
+      contentType: 'image/png',
+      contentLength: png.length,
+      assetKind: 'game_distribution_cover',
+      accessPolicy: 'private',
+      entityId: 'game-distribution-lineage-visual',
+    },
+  });
+  if (confirm.status !== 200) throw new Error(`确认素材失败 ${brief(confirm)}`);
+  return confirm.data.assetObject.assetObjectId;
+}
+
+async function createGame({ token, metadata, idemKey, fork }) {
+  return api('/api/game-distribution/games', {
+    method: 'POST',
+    token,
+    headers: { 'Idempotency-Key': idemKey },
+    body: fork ? { ...metadata, fork } : metadata,
+  });
+}
+
+async function ownerGame(token, gameId) {
+  const response = await api(`/api/game-distribution/my-games/${gameId}`, {
+    token,
+  });
+  return response.data?.game ?? null;
+}
+
+async function publicVersionIdOf(token, gameId) {
+  const versions = (await ownerGame(token, gameId))?.versions ?? [];
+  return (
+    versions.find((version) => version.status === 'published')?.versionId ?? ''
+  );
+}
+
+function publicDetail(gameId) {
+  return api(`/api/game-distribution/games/${gameId}`);
+}
+
+async function buildZip(marker) {
+  const zip = new JSZip();
+  zip.file(
+    'index.html',
+    `<!doctype html><html><head><meta charset="utf-8"><title>${marker}</title></head><body><h1>${marker}</h1></body></html>`,
+  );
+  const bytes = Buffer.from(await zip.generateAsync({ type: 'uint8array' }));
+  return {
+    bytes,
+    fileCount: 1,
+    sha256: createHash('sha256').update(bytes).digest('hex'),
+  };
+}
+
+async function publishToPublic({
+  token,
+  admin,
+  gameId,
+  gameRevision,
+  metadata,
+  stamp,
+  tag,
+  label,
+  changeSummary,
+}) {
+  const zip = await buildZip(`visual-${tag}-${stamp}`);
+  const created = await api(`/api/game-distribution/games/${gameId}/versions`, {
+    method: 'POST',
+    token,
+    headers: { 'Idempotency-Key': `visual-version-${tag}-${stamp}` },
+    body: {
+      packageSha256: zip.sha256,
+      packageBytes: zip.bytes.length,
+      packageFileCount: zip.fileCount,
+      packageEntryPath: 'index.html',
+      gameMetadata: metadata,
+      // 衍生作品必填「本次核心改动说明」；根节点不传（传了也会被忽略）。
+      ...(changeSummary ? { changeSummary } : {}),
+    },
+  });
+  const versionId = created.data?.versionId;
+  if (!versionId) {
+    check(`${label} 建版本`, false, brief(created));
+    return { versionId: null };
+  }
+  const upload = await api(
+    `/api/game-distribution/versions/${versionId}/package`,
+    {
+      method: 'PUT',
+      token,
+      headers: {
+        'Idempotency-Key': `visual-upload-${tag}-${stamp}`,
+        'Content-Type': 'application/zip',
+      },
+      binary: zip.bytes,
+    },
+  );
+  if (upload.status !== 200) {
+    check(`${label} 传发行包`, false, brief(upload));
+    return { versionId: null };
+  }
+  const submitted = await api(
+    `/api/game-distribution/versions/${versionId}/submit`,
+    {
+      method: 'POST',
+      token,
+      headers: { 'Idempotency-Key': `visual-submit-${tag}-${stamp}` },
+      body: { expectedPublicationRevision: gameRevision },
+    },
+  );
+  const readback = await api(`/api/game-distribution/versions/${versionId}`, {
+    token,
+  });
+  const approved = await api(
+    `/admin/api/game-distribution/versions/${versionId}/review`,
+    {
+      method: 'POST',
+      token: admin,
+      headers: { 'Idempotency-Key': `visual-approve-${tag}-${stamp}` },
+      body: {
+        decision: 'approve',
+        expectedPublicationRevision:
+          readback.data?.version?.publicationRevision ?? gameRevision,
+      },
+    },
+  );
+  check(
+    `${label} 发布链路完成（送审 ${submitted.status} / 通过 ${approved.status}）`,
+    submitted.status === 202 && approved.status === 200,
+    `submitted=${submitted.status} approved=${approved.status}`,
+  );
+  return { versionId };
+}
+
+async function promoteForkAuthorization({ token, gameId, to, key }) {
+  return api(`/api/game-distribution/games/${gameId}/fork-authorization`, {
+    method: 'PUT',
+    token,
+    headers: { 'Idempotency-Key': key },
+    body: { expectedForkAuthorization: 'forbidden', forkAuthorization: to },
+  });
+}
+
+// ---------- 造树 ----------
+
+async function createPublishedNode({
+  label,
+  title,
+  owner,
+  admin,
+  parent,
+  promoteTo,
+  stamp,
+  coverPng,
+}) {
+  const coverAssetId = await uploadCover(
+    owner.token,
+    `${stamp}-${label}`,
+    coverPng,
+  );
+  const parentVersionId = parent
+    ? await publicVersionIdOf(parent.token, parent.gameId)
+    : '';
+  const metadata = gameMetadata({ title, coverAssetId });
+  const created = await createGame({
+    token: owner.token,
+    metadata,
+    idemKey: `visual-${label}-${stamp}`,
+    ...(parent
+      ? { fork: { parentGameId: parent.gameId, parentVersionId } }
+      : {}),
+  });
+  const gameId = created.data?.id;
+  check(
+    `造树：节点 ${label} 创建（${parent ? `父=${parent.label}` : '根'}）`,
+    created.status === 200 && Boolean(gameId),
+    brief(created),
+  );
+  if (!gameId) return { label, gameId: null, token: owner.token, title };
+  await publishToPublic({
+    token: owner.token,
+    admin,
+    gameId,
+    gameRevision: created.data?.publicationRevision ?? 0,
+    metadata,
+    stamp,
+    tag: `visual-${label}`,
+    label,
+    // 衍生节点（有父）必填核心改动说明：截图里的「每一代差异」用它渲染。
+    ...(parent
+      ? {
+          changeSummary: `视觉夹具：节点 ${label} 相对 ${parent.label} 的核心改动说明`,
+        }
+      : {}),
+  });
+  const detail = await publicDetail(gameId);
+  check(
+    `造树：节点 ${label} 已公开`,
+    detail.data?.status === 'published',
+    `status=${detail.data?.status ?? '∅'}`,
+  );
+  // 新语义：衍生作品在创建时**继承**父作品档位（创建后忽略请求里的档位、母版才允许 PUT 提升）。
+  if (parent) {
+    const childView = await ownerGame(owner.token, gameId);
+    const parentView = await ownerGame(parent.token, parent.gameId);
+    const childTier = childView?.forkAuthorization ?? null;
+    const parentTier = parentView?.forkAuthorization ?? null;
+    check(
+      `造树：衍生节点 ${label} 继承父档位（${childTier} === ${parentTier}）`,
+      childTier !== null && childTier === parentTier,
+      `child=${childTier} parent=${parentTier}`,
+    );
+  } else if (promoteTo) {
+    const promoted = await promoteForkAuthorization({
+      token: owner.token,
+      gameId,
+      to: promoteTo,
+      key: `visual-promote-${label}-${stamp}`,
+    });
+    check(
+      `造树：母版节点 ${label} 授权提升=${promoteTo}`,
+      promoted.status === 200,
+      brief(promoted),
+    );
+  }
+  return { label, gameId, token: owner.token, title };
+}
+
+// ---------- Playwright ----------
+
+async function loadPlaywright() {
+  const dir = (process.env.E2E_PLAYWRIGHT_DIR ?? '').trim();
+  if (!dir) return import('playwright');
+  const requireFromDir = createRequire(path.join(dir, 'noop.js'));
+  return requireFromDir('playwright');
+}
+
+/// 窄屏三档核验（360 / 390 / 414）：移动端形态（大纲缩进树 / 图谱画布 / bottom sheet / 面包屑）、
+/// 触控尺寸与横向溢出，以及**本轮新豁免**：深链进 `/games/lineage?id=…` 首屏不再被
+/// 「移动端仅支持作品展示」欢迎弹窗盖住。
+///
+/// 契约来源（读实现确认，按符号引用）：
+///   - 移动端形态与默认值：`src/components/game-distribution/GameLineagePage.tsx` 的 `viewMode` /
+///     `effectiveViewMode`（`isMobileViewport ? 'outline' : 'canvas'`）
+///   - 大纲树：`src/components/game-distribution/LineageOutlineList.tsx` 的 `lineage-outline` /
+///     `lineage-outline__row` / `lineage-outline__main` / `lineage-outline__guide`
+///   - 底部 sheet：`game-lineage-panel--sheet` + `game-lineage-sheet-backdrop`（点遮罩关闭）
+///   - 图谱视图切换：`button[aria-pressed]` 文案「图谱视图」
+///   - 面包屑：`game-lineage-breadcrumb__crumb`（`scrollIntoView` 由实现保证）
+async function captureNarrowBreakpoints({ browser, lineageUrl, shotDir }) {
+  const widths = (process.env.E2E_CAPTURE_NARROW_WIDTHS ?? '')
+    .split(',')
+    .map((entry) => Number.parseInt(entry.trim(), 10))
+    .filter((value) => Number.isInteger(value) && value >= 320);
+  if (widths.length === 0) return;
+  for (const width of widths) {
+    const context = await browser.newContext({
+      viewport: { width, height: 844 },
+      hasTouch: true,
+      permissions: ['clipboard-read', 'clipboard-write'],
+    });
+    const page = await context.newPage();
+    const take = async (name) => {
+      const file = path.join(shotDir, `narrow-${width}-${name}.png`);
+      await page.screenshot({ path: file, fullPage: false });
+      console.log(`[lineage-visual] 截图 ${file}`);
+      return file;
+    };
+    try {
+      await page.goto(lineageUrl, { waitUntil: 'commit', timeout: 120_000 });
+      await page.waitForFunction(
+        () =>
+          document.querySelector('.lineage-outline') !== null ||
+          document.querySelector('.game-lineage-canvas') !== null,
+        undefined,
+        { timeout: 120_000 },
+      );
+      await page.waitForTimeout(1500);
+
+      const welcome = await page.evaluate(() => ({
+        text: document.body.innerText.includes('移动端仅支持作品展示'),
+        node: document.querySelectorAll(
+          '[class*="platform-mobile-home-welcome"]',
+        ).length,
+      }));
+      check(
+        `${width}px：深链进族谱页不再被「移动端仅支持作品展示」弹窗盖住`,
+        !welcome.text && welcome.node === 0,
+        `text=${welcome.text} nodes=${welcome.node}`,
+      );
+
+      const layout = await page.evaluate(() => {
+        const rows = [...document.querySelectorAll('.lineage-outline__row')];
+        const mains = rows
+          .map((row) => row.querySelector('.lineage-outline__main'))
+          .filter(Boolean);
+        const rects = mains.map((el) => el.getBoundingClientRect());
+        const outer = document.querySelector('.lineage-outline');
+        const outerRight = outer
+          ? outer.getBoundingClientRect().right
+          : window.innerWidth;
+        return {
+          outline: document.querySelectorAll('.lineage-outline').length,
+          rows: rows.length,
+          guides: document.querySelectorAll('.lineage-outline__guide').length,
+          minRowHeight: rows.length
+            ? Math.min(
+                ...rows.map((el) =>
+                  Math.round(el.getBoundingClientRect().height),
+                ),
+              )
+            : 0,
+          firstIndent: mains.length
+            ? getComputedStyle(mains[0]).paddingLeft
+            : '',
+          lastIndent: mains.length
+            ? getComputedStyle(mains[mains.length - 1]).paddingLeft
+            : '',
+          // 缩进的真实载体是「每一代多一列导线」：比较各行内容的左边界更有意义（padding 不变）。
+          firstLeft: rects.length ? Math.round(rects[0].left) : 0,
+          lastLeft: rects.length ? Math.round(rects[rects.length - 1].left) : 0,
+          distinctLefts: new Set(rects.map((box) => Math.round(box.left))).size,
+          overflowingRows: rects.filter((box) => box.right > outerRight + 1)
+            .length,
+          docOverflow: document.documentElement.scrollWidth - window.innerWidth,
+        };
+      });
+      check(
+        `${width}px：默认是大纲式缩进树（有行、有导线、有缩进层级）`,
+        layout.outline === 1 &&
+          layout.rows >= 2 &&
+          layout.guides >= 1 &&
+          layout.distinctLefts >= 2 &&
+          layout.lastLeft - layout.firstLeft >= 8,
+        `rows=${layout.rows} guides=${layout.guides} leftOrders=${layout.firstLeft}→${layout.lastLeft} levels=${layout.distinctLefts}`,
+      );
+      check(
+        `${width}px：大纲行高 ≥44（触控友好）且长标题不横向溢出`,
+        layout.minRowHeight >= 44 &&
+          layout.overflowingRows === 0 &&
+          layout.docOverflow <= 1,
+        `minRowHeight=${layout.minRowHeight} overflowingRows=${layout.overflowingRows} docOverflow=${layout.docOverflow}`,
+      );
+      await take('outline');
+
+      // 点第一行 → bottom sheet
+      await page
+        .locator('.lineage-outline__row .lineage-outline__main')
+        .first()
+        .click();
+      await page.waitForTimeout(1200);
+      const sheet = await page.evaluate(() => {
+        const panel = document.querySelector('.game-lineage-panel--sheet');
+        const backdrop = document.querySelector('.game-lineage-sheet-backdrop');
+        if (!panel) return null;
+        const box = panel.getBoundingClientRect();
+        return {
+          bottomGap: Math.round(window.innerHeight - box.bottom),
+          height: Math.round(box.height),
+          hasBackdrop: Boolean(backdrop),
+        };
+      });
+      check(
+        `${width}px：点节点弹出底部 sheet（贴底、有遮罩）`,
+        Boolean(sheet) && sheet.bottomGap <= 6 && sheet.hasBackdrop,
+        JSON.stringify(sheet),
+      );
+      await take('sheet');
+      // 关闭 sheet：先试显式的「关闭信息面板」按钮（遮罩就是它），再试 Esc。
+      const closeButton = page
+        .getByRole('button', { name: '关闭信息面板' })
+        .first();
+      let sheetClosed = false;
+      if ((await closeButton.count()) > 0) {
+        await closeButton.click({ force: true }).catch(() => {});
+        await page.waitForTimeout(600);
+        sheetClosed =
+          (await page.locator('.game-lineage-panel--sheet').count()) === 0;
+      }
+      if (!sheetClosed) {
+        await page.keyboard.press('Escape').catch(() => {});
+        await page.waitForTimeout(400);
+        sheetClosed =
+          (await page.locator('.game-lineage-panel--sheet').count()) === 0;
+      }
+      check(`${width}px：底部 sheet 可关闭（遮罩按钮或 Esc）`, sheetClosed);
+
+      // 面包屑（锁定路径）：窄屏上「锁定」由大纲行触发（画布卡片在窄屏是紧凑卡片，
+      // 整个卡片体都是「打开详情」按钮，点它只会跳详情——见下方图谱视图段的备注），
+      // 所以这里在大纲形态下再点一行，断言面包屑出现且当前项已被滚进视口。
+      await page
+        .locator('.lineage-outline__row .lineage-outline__main')
+        .first()
+        .click();
+      await page.waitForTimeout(1200);
+      const outlineCrumb = await page.evaluate(() => {
+        const items = [
+          ...document.querySelectorAll('.game-lineage-breadcrumb__crumb'),
+        ];
+        if (items.length === 0) return null;
+        const box = items[items.length - 1].getBoundingClientRect();
+        return {
+          count: items.length,
+          insideViewport: box.left >= -1 && box.right <= window.innerWidth + 1,
+          left: Math.round(box.left),
+          right: Math.round(box.right),
+          innerWidth: window.innerWidth,
+        };
+      });
+      check(
+        `${width}px：大纲行锁定后面包屑出现且当前项被滚进视口`,
+        Boolean(outlineCrumb) &&
+          outlineCrumb.count >= 1 &&
+          outlineCrumb.insideViewport,
+        JSON.stringify(outlineCrumb),
+      );
+      await take('breadcrumb');
+
+      // 画布检查前重载一次：保证不残留 sheet 与滚动位置，切形态的判断才干净。
+      await page.reload({ waitUntil: 'commit', timeout: 120_000 });
+      await page.waitForFunction(
+        () =>
+          document.querySelector('.lineage-outline') !== null ||
+          document.querySelector('.game-lineage-canvas') !== null,
+        undefined,
+        { timeout: 120_000 },
+      );
+      await page.waitForTimeout(1500);
+      await page.evaluate(() => window.scrollTo(0, 0));
+
+      // 切图谱视图：画布初始定位应把「当前作品」放进画布
+      const toggle = page.getByText('图谱视图', { exact: true }).first();
+      if ((await toggle.count()) > 0) {
+        await toggle.scrollIntoViewIfNeeded().catch(() => {});
+        await toggle.click({ timeout: 20000 }).catch(async () => {
+          await toggle.click({ force: true, timeout: 20000 }).catch(() => {});
+        });
+        await page.waitForTimeout(2500);
+        const canvas = await page.evaluate(() => {
+          const canvasEl = document.querySelector('.game-lineage-canvas');
+          const anchor = document.querySelector('.game-lineage-node--anchor');
+          if (!canvasEl) return null;
+          const canvasBox = canvasEl.getBoundingClientRect();
+          const anchorBox = anchor?.getBoundingClientRect();
+          const visibleNodes = [
+            ...document.querySelectorAll('.game-lineage-node'),
+          ].filter((node) => {
+            const box = node.getBoundingClientRect();
+            return (
+              box.left >= canvasBox.left - 2 &&
+              box.right <= canvasBox.right + 2 &&
+              box.top >= canvasBox.top - 2 &&
+              box.bottom <= canvasBox.bottom + 2
+            );
+          }).length;
+          const totalNodes =
+            document.querySelectorAll('.game-lineage-node').length;
+          return {
+            anchorFound: Boolean(anchor),
+            anchorInside:
+              Boolean(anchorBox) &&
+              anchorBox.left >= canvasBox.left - 2 &&
+              anchorBox.right <= canvasBox.right + 2 &&
+              anchorBox.top >= canvasBox.top - 2 &&
+              anchorBox.bottom <= canvasBox.bottom + 2,
+            visibleNodes,
+            totalNodes,
+            zoom: document
+              .querySelector('.game-lineage-zoom')
+              ?.textContent?.trim(),
+            hint: document.body.innerText.includes('已按可读缩放显示'),
+          };
+        });
+        check(
+          `${width}px：图谱视图（横向画布）首屏把当前作品放进画布`,
+          Boolean(canvas) && canvas.anchorFound && canvas.anchorInside,
+          JSON.stringify(canvas),
+        );
+        await take('canvas');
+        console.log(
+          `[narrow ${width}] 备注：图谱视图里点卡片会跳详情（窄屏紧凑卡片整块是「打开详情」按钮，没有可锁定区域）——信息面板/面包屑改由大纲形态验证。`,
+        );
+      }
+    } finally {
+      await context.close();
+    }
+  }
+}
+
+/// 「只截图、不造树」模式：给已有作品（例如本地演示数据灌装脚本放进开发栈的共创网络）
+/// 出验收截图。设 `E2E_CAPTURE_LINEAGE_URL` 即进入该模式——不注册账号、不建作品、不下架，纯 GET + 截图。
+async function captureExistingUrls() {
+  const lineageUrl = (process.env.E2E_CAPTURE_LINEAGE_URL ?? '').trim();
+  const themeUrl = (process.env.E2E_CAPTURE_THEME_URL ?? '').trim();
+  const selectTitle = (process.env.E2E_CAPTURE_SELECT_TITLE ?? '').trim();
+  // 最小节点数：两节点的子树（例如「母版 → 一个衍生」）也要能截，默认 3。
+  const minNodes =
+    Number.parseInt((process.env.E2E_CAPTURE_MIN_NODES ?? '').trim(), 10) || 3;
+  // 视口可配：全树总览常常比 960 高，给个高的窗口才能真的「一眼看全」。
+  const sizeMatch = /^(\d{3,4})x(\d{3,4})$/u.exec(
+    (process.env.E2E_CAPTURE_WINDOW ?? '').trim(),
+  );
+  const desktopViewport = sizeMatch
+    ? { width: Number(sizeMatch[1]), height: Number(sizeMatch[2]) }
+    : { width: 1440, height: 960 };
+  const { chromium } = await loadPlaywright();
+  const executablePath = (process.env.E2E_CHROMIUM_EXECUTABLE ?? '').trim();
+  const browser = await chromium.launch({
+    headless: true,
+    ...(executablePath ? { executablePath } : {}),
+  });
+  const shotDir = await mkdtemp(
+    path.join(tmpdir(), 'genarrative-co-creation-visual-'),
+  );
+  const shots = [];
+  const take = async (target, name) => {
+    const file = path.join(shotDir, name);
+    await target.screenshot({ path: file, fullPage: false });
+    shots.push(file);
+    console.log(`[lineage-visual] 截图 ${file}`);
+    return file;
+  };
+  try {
+    // 封面是远端资源：等所有 <img> 落地再截，否则会出现灰块假象。
+    const waitImages = async (target) => {
+      await target
+        .waitForFunction(
+          () =>
+            [...document.images].every(
+              (img) => img.complete && img.naturalWidth > 0,
+            ),
+          undefined,
+          { timeout: 60_000 },
+        )
+        .catch(() => {});
+      await target.waitForTimeout(600);
+    };
+    // ---------- 桌面：全树总览 ----------
+    const desktop = await browser.newContext({
+      viewport: desktopViewport,
+    });
+    const page = await desktop.newPage();
+    await page.goto(lineageUrl, { waitUntil: 'commit', timeout: 120_000 });
+    await page.waitForFunction(
+      (min) => document.querySelectorAll('.game-lineage-node').length >= min,
+      minNodes,
+      { timeout: 120_000 },
+    );
+    await page.waitForTimeout(1400);
+    await waitImages(page);
+    const nodeCount = await page.locator('.game-lineage-node').count();
+    check(
+      '截图模式：/games/lineage 已渲染多代节点',
+      nodeCount >= minNodes,
+      `nodes=${nodeCount} url=${lineageUrl}`,
+    );
+    // 首屏视野契约（与 lineage 工具同口径）：要么真的全览，要么按可读缩放下限 + 提示。
+    const fit = await page.evaluate(() => {
+      const canvas = document
+        .querySelector('.game-lineage-canvas')
+        ?.getBoundingClientRect();
+      if (!canvas) return { allInside: false, hint: false };
+      const allInside = [
+        ...document.querySelectorAll('.game-lineage-node'),
+      ].every((node) => {
+        const box = node.getBoundingClientRect();
+        return (
+          box.left >= canvas.left - 2 &&
+          box.top >= canvas.top - 2 &&
+          box.right <= canvas.right + 2 &&
+          box.bottom <= canvas.bottom + 2
+        );
+      });
+      return {
+        allInside,
+        hint: [...document.querySelectorAll('*')].some((element) =>
+          (element.textContent ?? '').includes('已按可读缩放显示'),
+        ),
+      };
+    });
+    check(
+      '截图模式：首屏要么全树在画布内，要么给出「已按可读缩放显示」提示',
+      fit.allInside || fit.hint,
+      `allInside=${fit.allInside} hint=${fit.hint} 视口=${desktopViewport.width}x${desktopViewport.height}`,
+    );
+    await take(page, '01-lineage-overview.png');
+
+    // ---------- 桌面：选中态（信息面板 + 面包屑） ----------
+    // 注意：卡片主体是「打开详情」按钮（stopPropagation），点它会跳走；要「选中/锁定」得点卡片**内边距**（6,6）。
+    const card = selectTitle
+      ? page
+          .locator('.game-lineage-node')
+          .filter({ hasText: selectTitle })
+          .first()
+      : page.locator('.game-lineage-node').nth(1);
+    let selected = false;
+    if ((await card.count()) > 0) {
+      await card.click({ position: { x: 6, y: 6 } });
+      selected = true;
+    } else {
+      await page
+        .locator('.game-lineage-node')
+        .nth(1)
+        .click({ position: { x: 6, y: 6 } });
+      selected = true;
+    }
+    if (selected) {
+      await page
+        .locator('.game-lineage-panel')
+        .first()
+        .waitFor({ state: 'visible', timeout: 30_000 });
+      await page.waitForTimeout(700);
+      const crumbs = await page
+        .locator('.game-lineage-breadcrumb__crumb')
+        .count();
+      check(
+        '截图模式：选中节点后出现信息面板与面包屑',
+        crumbs >= 1,
+        `面包屑=${crumbs}`,
+      );
+      await waitImages(page);
+      await take(page, '02-lineage-selected.png');
+    }
+
+    // ---------- 窄屏 ----------
+    // 移动端自 2026-10-07 起默认是**大纲式缩进树**（`lineage-outline`），不再默认渲染画布节点；
+    // 这里两种形态都接受，只断言「有可交互节点 + 页面不横向溢出」。
+    const mobile = await browser.newContext({
+      viewport: { width: 390, height: 844 },
+    });
+    const mobilePage = await mobile.newPage();
+    await mobilePage.goto(lineageUrl, {
+      waitUntil: 'commit',
+      timeout: 120_000,
+    });
+    await mobilePage.waitForFunction(
+      (min) =>
+        document.querySelectorAll('.game-lineage-node').length >= min ||
+        document.querySelectorAll('.lineage-outline__row').length >= min,
+      minNodes,
+      { timeout: 120_000 },
+    );
+    await mobilePage.waitForTimeout(1400);
+    // 窄屏首次进入可能弹「移动端仅支持作品展示」的欢迎弹窗（族谱深链已豁免，这里兜底）：
+    // 先点掉再截图，否则截出来只剩一个遮罩弹窗。
+    const welcomeOk = mobilePage.getByRole('button', {
+      name: '好',
+      exact: true,
+    });
+    if ((await welcomeOk.count()) > 0) {
+      await welcomeOk.first().click();
+      await mobilePage.waitForTimeout(800);
+    }
+    await waitImages(mobilePage);
+    const narrow = await mobilePage.evaluate(() => ({
+      canvas: Boolean(document.querySelector('.game-lineage-canvas')),
+      outline: document.querySelectorAll('.lineage-outline__row').length,
+      nodes: document.querySelectorAll('.game-lineage-node').length,
+      overflow: document.documentElement.scrollWidth - window.innerWidth > 1,
+    }));
+    check(
+      '截图模式：窄屏下族谱有可交互节点（大纲或画布）且页面不横向溢出',
+      (narrow.outline >= minNodes || narrow.nodes >= minNodes) &&
+        !narrow.overflow,
+      `outline=${narrow.outline} nodes=${narrow.nodes} canvas=${narrow.canvas} overflow=${narrow.overflow}`,
+    );
+    await take(mobilePage, '03-lineage-narrow.png');
+    await mobile.close();
+
+    // ---------- 主题页 ----------
+    if (themeUrl) {
+      const themePage = await desktop.newPage();
+      await themePage.goto(themeUrl, { waitUntil: 'commit', timeout: 120_000 });
+      await themePage
+        .locator('.game-theme-root')
+        .first()
+        .waitFor({ state: 'visible', timeout: 60_000 });
+      await themePage.waitForTimeout(1000);
+      await waitImages(themePage);
+      const roots = await themePage.locator('.game-theme-root').count();
+      check('截图模式：主题页已渲染作品树', roots >= 1, `roots=${roots}`);
+      await take(themePage, '04-theme-page.png');
+      void themePage;
+    }
+    await desktop.close();
+    await captureNarrowBreakpoints({ browser, lineageUrl, shotDir });
+    console.log(`[lineage-visual] 截图目录=${shotDir}`);
+    console.log(`[lineage-visual] 结果：check=${checks} fail=${failures}`);
+  } finally {
+    await browser.close();
+  }
+  return shots;
+}
+
+async function main() {
+  if ((process.env.E2E_CAPTURE_LINEAGE_URL ?? '').trim()) {
+    await captureExistingUrls();
+    const failed = failures > 0;
+    console.log(
+      `[lineage-visual] 只用现有作品截图：check=${checks} fail=${failures}`,
+    );
+    process.exit(failed ? 1 : 0);
+  }
+  console.log(`[lineage-visual] api-server=${API} web=${WEB}`);
+  const stamp = Date.now();
+  const suffix = String(stamp).slice(-6);
+
+  const adminLogin = await api('/admin/api/login', {
+    method: 'POST',
+    body: { username: ADMIN_USER, password: ADMIN_PASSWORD },
+  });
+  const admin = adminLogin.data?.token ?? adminLogin.data?.accessToken;
+  check('管理员登录', Boolean(admin), `status=${adminLogin.status}`);
+  if (!admin) process.exit(1);
+  await api('/admin/api/feature-gates', {
+    method: 'PUT',
+    token: admin,
+    body: {
+      gateKey: GATE_KEY,
+      enabled: true,
+      rolloutPercent: 100,
+      allowUserIds: [],
+      allowUserTags: [],
+      denyUserIds: [],
+      description: '族谱可视化截图',
+    },
+  });
+
+  const authorA = await register('132');
+  const authorB = await register('133');
+  const nameA = `可视化作者甲${suffix}`;
+  const nameB = `可视化作者乙${suffix}`;
+  await setDisplayName(authorA.token, nameA);
+  await setDisplayName(authorB.token, nameB);
+  check(
+    '两个作者账号就绪（用于分支上的作者多样性）',
+    Boolean(authorA.token && authorB.token),
+    `phones=${authorA.phone}/${authorB.phone}`,
+  );
+
+  // 每个节点一张不同的真实封面（脚本内生成，512×288 渐变+斜条纹），便于在截图里区分节点。
+  const coverFor = (index) => makeCoverPng(index, 8);
+
+  // 富树：1 根 + 3 直接子 + 1 孙 + 1 曾孙
+  const root = await createPublishedNode({
+    label: 'R',
+    title: `可视化母版 ${suffix}`,
+    owner: authorA,
+    admin,
+    promoteTo: 'nonCommercial',
+    stamp,
+    coverPng: coverFor(0),
+  });
+  const b1 = await createPublishedNode({
+    label: 'B1',
+    title: `分支 B1 ${suffix}`,
+    owner: authorA,
+    admin,
+    parent: root,
+    promoteTo: 'nonCommercial',
+    stamp,
+    coverPng: coverFor(1),
+  });
+  const c1 = await createPublishedNode({
+    label: 'C1',
+    title: `分支 C1 ${suffix}`,
+    owner: authorB,
+    admin,
+    parent: root,
+    promoteTo: 'full',
+    stamp,
+    coverPng: coverFor(2),
+  });
+  const f1 = await createPublishedNode({
+    label: 'F1',
+    title: `分支 F1 ${suffix}`,
+    owner: authorB,
+    admin,
+    parent: root,
+    stamp,
+    coverPng: coverFor(3),
+  });
+  const d = await createPublishedNode({
+    label: 'D',
+    title: `二代 D ${suffix}`,
+    owner: authorA,
+    admin,
+    parent: b1,
+    promoteTo: 'nonCommercial',
+    stamp,
+    coverPng: coverFor(4),
+  });
+  const e = await createPublishedNode({
+    label: 'E',
+    title: `三代 E ${suffix}`,
+    owner: authorB,
+    admin,
+    parent: d,
+    stamp,
+    coverPng: coverFor(5),
+  });
+  const nodeIds = {
+    R: root.gameId,
+    B1: b1.gameId,
+    C1: c1.gameId,
+    F1: f1.gameId,
+    D: d.gameId,
+    E: e.gameId,
+  };
+  const allBuilt = Object.values(nodeIds).every(Boolean);
+  check('富树 6 节点全部建成', allBuilt, JSON.stringify(nodeIds));
+  if (!allBuilt) process.exit(1);
+
+  // 降级态 fixture：父作品下架后仍保留子作品（子作品的树里父节点应显示「原作品已不可用」）
+  const degradedParent = await createPublishedNode({
+    label: 'P',
+    title: `降级母版 ${suffix}`,
+    owner: authorA,
+    admin,
+    promoteTo: 'nonCommercial',
+    stamp,
+    coverPng: coverFor(6),
+  });
+  const degradedChild = await createPublishedNode({
+    label: 'P-C',
+    title: `降级子作品 ${suffix}`,
+    owner: authorB,
+    admin,
+    parent: degradedParent,
+    stamp,
+    coverPng: coverFor(7),
+  });
+  const parentNow = await ownerGame(authorA.token, degradedParent.gameId);
+  const unpublish = await api(
+    `/api/game-distribution/games/${degradedParent.gameId}/unpublish`,
+    {
+      method: 'POST',
+      token: authorA.token,
+      headers: { 'Idempotency-Key': `visual-unpublish-${stamp}` },
+      body: {
+        expectedPublicationRevision: parentNow?.publicationRevision ?? 0,
+      },
+    },
+  );
+  check(
+    '降级 fixture：父作品已下架（子作品仍公开）',
+    unpublish.status === 200,
+    brief(unpublish),
+  );
+
+  const richUrl = `${WEB}/games/lineage?id=${nodeIds.R}`;
+  const degradedUrl = `${WEB}/games/lineage?id=${degradedChild.gameId}`;
+  console.log(`[lineage-visual] 富树 URL=${richUrl}`);
+  console.log(`[lineage-visual] 降级态 URL=${degradedUrl}`);
+
+  const { chromium } = await loadPlaywright();
+  const executablePath = (process.env.E2E_CHROMIUM_EXECUTABLE ?? '').trim();
+  const browser = await chromium.launch({
+    headless: true,
+    ...(executablePath ? { executablePath } : {}),
+  });
+  const shotDir = await mkdtemp(
+    path.join(tmpdir(), 'genarrative-lineage-visual-'),
+  );
+  const shots = [];
+  const takeShot = async (page, name) => {
+    const file = path.join(shotDir, name);
+    await page.screenshot({ path: file, fullPage: false });
+    shots.push(file);
+    console.log(`[lineage-visual] 截图 ${file}`);
+    return file;
+  };
+  // 初次进入的视野契约：要么真的全览（所有节点在画布内），要么按可读缩放下限显示并给出提示。
+  const fitContract = async (target) => {
+    const zoom = Number.parseInt(
+      await target.locator('.game-lineage-zoom').first().innerText(),
+      10,
+    );
+    const hint = await target
+      .getByText('已按可读缩放显示', { exact: false })
+      .count();
+    const allInside = await target.evaluate(() => {
+      const canvas = document
+        .querySelector('.game-lineage-canvas')
+        ?.getBoundingClientRect();
+      if (!canvas) return false;
+      return [...document.querySelectorAll('.game-lineage-node')].every(
+        (node) => {
+          const box = node.getBoundingClientRect();
+          return (
+            box.left >= canvas.left - 2 &&
+            box.top >= canvas.top - 2 &&
+            box.right <= canvas.right + 2 &&
+            box.bottom <= canvas.bottom + 2
+          );
+        },
+      );
+    });
+    return { zoom, hint, allInside };
+  };
+
+  try {
+    // ---------- 桌面：总览 / 缩放 / hover ----------
+    const desktop = await browser.newContext({
+      viewport: { width: 1440, height: 960 },
+    });
+    const page = await desktop.newPage();
+    await page.goto(richUrl, { waitUntil: 'commit', timeout: 120_000 });
+    const nodeCards = page.locator('.game-lineage-node');
+    await page.waitForFunction(
+      () => document.querySelectorAll('.game-lineage-node').length >= 6,
+      undefined,
+      { timeout: 120_000 },
+    );
+    await page.waitForTimeout(900);
+
+    const apiTree = await api(
+      `/api/game-distribution/games/${nodeIds.R}/lineage`,
+    );
+    const apiNodeCount = (apiTree.data?.nodes ?? []).length;
+    const domNodeCount = await nodeCards.count();
+    check(
+      'DOM 断言：画布节点数 = 接口返回的可见节点数',
+      domNodeCount === apiNodeCount,
+      `dom=${domNodeCount} api=${apiNodeCount}`,
+    );
+    const generations = await nodeCards.evaluateAll((nodes) =>
+      nodes.map((node) => Number(node.getAttribute('data-generation'))),
+    );
+    check(
+      'DOM 断言：节点代际分布覆盖 0/1/2/3（多代可见）',
+      [0, 1, 2, 3].every((generation) => generations.includes(generation)),
+      `generations=${generations.sort().join(',')}`,
+    );
+
+    const anchor = page.locator('.game-lineage-node--anchor');
+    check(
+      'DOM 断言：当前作品节点有可识别标记（--anchor + aria-current）',
+      (await anchor.count()) === 1 &&
+        (await anchor.first().getAttribute('aria-current')) === 'true' &&
+        (await anchor
+          .first()
+          .innerText()
+          .then((text) => text.includes('当前作品'))),
+      `anchorCount=${await anchor.count()}`,
+    );
+    const accessibleNames = await nodeCards.evaluateAll((nodes) =>
+      nodes.every((node) => (node.getAttribute('aria-label') ?? '').length > 0),
+    );
+    check(
+      'DOM 断言：每个节点卡片都有可访问名称（aria-label）',
+      accessibleNames,
+    );
+    const openButtons = await page.locator('.game-lineage-node__open').count();
+    check(
+      'DOM 断言：每个可交互节点都有可聚焦的「打开《…》详情」主行动作（占位节点除外）',
+      openButtons >= 6,
+      `openButtons=${openButtons}`,
+    );
+
+    const b1Node = nodeCards.filter({ hasText: b1.title }).first();
+    const c1Node = nodeCards.filter({ hasText: c1.title }).first();
+    const rootNode = nodeCards.filter({ hasText: root.title }).first();
+    check(
+      'DOM 断言：三个直接子分支与根都在画布上',
+      (await rootNode.count()) === 1 &&
+        (await b1Node.count()) === 1 &&
+        (await c1Node.count()) === 1 &&
+        (await nodeCards.filter({ hasText: e.title }).count()) === 1,
+    );
+
+    // 本轮返工点：节点卡片减负（只留 封面/代际/标题/作者/Fork）+ 真实封面缩略图
+    const cardText = await nodeCards.first().innerText();
+    check(
+      'DOM 断言：节点卡片已减负（无「次游玩」、无「与原版对比」）',
+      !cardText.includes('次游玩') &&
+        (await page.locator('.game-lineage-node__compare').count()) === 0 &&
+        (await page.getByText('与原版对比').count()) === 0 &&
+        (await page.locator('.game-lineage-node__fork').count()) >= 6,
+      `cardText=${cardText.replace(/\n/gu, ' / ').slice(0, 70)}`,
+    );
+    const coverImages = await page
+      .locator('.game-lineage-node__cover img')
+      .count();
+    check(
+      'DOM 断言：节点卡片渲染真实封面缩略图（coverObjectKey 有值才渲染）',
+      coverImages >= 6,
+      `nodeCoverImages=${coverImages}`,
+    );
+    const axisVisible = await page.locator('.game-lineage-axis').count();
+    check(
+      'DOM 断言：代际轴是独立固定层且标签未被画布裁掉',
+      axisVisible >= 1 &&
+        (await page
+          .locator('.game-lineage-axis')
+          .first()
+          .boundingBox()
+          .then((box) => Boolean(box) && box.x >= 0)),
+      `axisLayers=${axisVisible}`,
+    );
+
+    const initialFit = await fitContract(page);
+    check(
+      'DOM 断言（桌面初访）：要么真全览，要么按可读缩放下限（≥60%）显示并给出提示',
+      initialFit.allInside || (initialFit.zoom >= 60 && initialFit.hint >= 1),
+      `zoom=${initialFit.zoom}% hint=${initialFit.hint} allInside=${initialFit.allInside}`,
+    );
+
+    await takeShot(page, 'lineage-01-overview.png');
+
+    // ② zoom 到分支
+    for (let index = 0; index < 4; index += 1) {
+      await page.locator('button[aria-label="放大"]').first().click();
+      await page.waitForTimeout(150);
+    }
+    const zoomLabel = await page
+      .locator('.game-lineage-zoom')
+      .first()
+      .innerText();
+    await takeShot(page, 'lineage-02-zoom-branch.png');
+    check(
+      'DOM 断言：放大后缩放百分比上升',
+      Number.parseInt(zoomLabel, 10) > 100,
+      `zoom=${zoomLabel}`,
+    );
+
+    // ⑦ 放大状态下 hover：连线级路径强化特写（本轮返工的核心诉求）
+    await page
+      .locator('.game-lineage-node')
+      .filter({ hasText: b1.title })
+      .first()
+      .hover();
+    await page.waitForTimeout(500);
+    const activeEdges = await page
+      .locator('.game-lineage-edge--active')
+      .count();
+    const dimmedEdges = await page
+      .locator('.game-lineage-edge--dimmed')
+      .count();
+    await takeShot(page, 'lineage-07-hover-edge-path.png');
+    check(
+      'DOM 断言：hover 时「祖先路径的连线」被强化（--active 边 ≥1 且其余边 --dimmed）',
+      activeEdges >= 1 && dimmedEdges >= 1,
+      `activeEdges=${activeEdges} dimmedEdges=${dimmedEdges}`,
+    );
+    const strokeWidth = await page
+      .locator('.game-lineage-edge')
+      .first()
+      .evaluate((node) => getComputedStyle(node).strokeWidth);
+    const vectorEffect = await page
+      .locator('.game-lineage-edge')
+      .first()
+      .evaluate((node) => getComputedStyle(node).vectorEffect);
+    check(
+      'DOM 断言：连线用 non-scaling-stroke（缩放后线宽仍可辨）',
+      vectorEffect === 'non-scaling-stroke',
+      `strokeWidth=${strokeWidth} vectorEffect=${vectorEffect}`,
+    );
+
+    // ⑥ 点「适应窗口」→ 全览（所有节点都落在画布内）
+    const zoomBeforeFit = Number.parseInt(
+      await page.locator('.game-lineage-zoom').first().innerText(),
+      10,
+    );
+    await page.locator('button[aria-label="适应窗口"]').first().click();
+    await page.waitForTimeout(600);
+    const zoomAfterFit = Number.parseInt(
+      await page.locator('.game-lineage-zoom').first().innerText(),
+      10,
+    );
+    const allInsideCanvas = await page.evaluate(() => {
+      const canvas = document
+        .querySelector('.game-lineage-canvas')
+        ?.getBoundingClientRect();
+      if (!canvas) return false;
+      return [...document.querySelectorAll('.game-lineage-node')].every(
+        (node) => {
+          const box = node.getBoundingClientRect();
+          return (
+            box.left >= canvas.left - 2 &&
+            box.top >= canvas.top - 2 &&
+            box.right <= canvas.right + 2 &&
+            box.bottom <= canvas.bottom + 2
+          );
+        },
+      );
+    });
+    await takeShot(page, 'lineage-06-fit-window.png');
+    check(
+      'DOM 断言：点「适应窗口」后 6 个节点全部落在画布内（真正的全览）',
+      allInsideCanvas && zoomAfterFit <= zoomBeforeFit,
+      `zoom ${zoomBeforeFit}% → ${zoomAfterFit}% allInside=${allInsideCanvas}`,
+    );
+
+    // 复位视野
+    await page.reload({ waitUntil: 'commit', timeout: 120_000 });
+    await page.waitForFunction(
+      () => document.querySelectorAll('.game-lineage-node').length >= 6,
+      undefined,
+      { timeout: 120_000 },
+    );
+    await page.waitForTimeout(900);
+
+    // ③ hover 中间节点 → 祖先路径高亮、其余降透明度
+    await nodeCards.filter({ hasText: b1.title }).first().hover();
+    await page.waitForTimeout(500);
+    const dimmedTitles = await page
+      .locator('.game-lineage-node--dimmed')
+      .evaluateAll((nodes) => nodes.map((node) => node.textContent ?? ''));
+    const b1Dimmed = await nodeCards
+      .filter({ hasText: b1.title })
+      .first()
+      .getAttribute('class');
+    const rootDimmed = await nodeCards
+      .filter({ hasText: root.title })
+      .first()
+      .getAttribute('class');
+    await takeShot(page, 'lineage-03-hover-ancestor.png');
+    check(
+      'DOM 断言：hover 中间节点 → 自身与祖先不高亮（不降透明度）',
+      !(b1Dimmed ?? '').includes('--dimmed') &&
+        !(rootDimmed ?? '').includes('--dimmed'),
+      `b1=${b1Dimmed} root=${rootDimmed}`,
+    );
+    check(
+      'DOM 断言：hover 时同代兄弟分支降透明度',
+      dimmedTitles.some((text) => text.includes(c1.title)) &&
+        dimmedTitles.some((text) => text.includes(f1.title)),
+      `dimmed=${dimmedTitles.length} 条`,
+    );
+
+    // 点击子节点 → 跳详情页
+    await page.reload({ waitUntil: 'commit', timeout: 120_000 });
+    await page.waitForFunction(
+      () => document.querySelectorAll('.game-lineage-node').length >= 6,
+      undefined,
+      { timeout: 120_000 },
+    );
+    await page.waitForTimeout(800);
+    await nodeCards.filter({ hasText: d.title }).first().click();
+    await page.waitForTimeout(800);
+    check(
+      'DOM 断言：点击节点跳到该作品详情页（URL 含其 id）',
+      page.url().includes(`/games/detail`) && page.url().includes(nodeIds.D),
+      `url=${page.url()}`,
+    );
+    await page.goto(richUrl, { waitUntil: 'commit', timeout: 120_000 });
+    await page.waitForFunction(
+      () => document.querySelectorAll('.game-lineage-node').length >= 6,
+      undefined,
+      { timeout: 120_000 },
+    );
+    await page.waitForTimeout(800);
+    // 关键字可达：主行动作（打开《…》详情）聚焦后按 Enter 应跳转（卡片主体现在=选中，不再跳详情）。
+    const openE = page.locator(
+      `.game-lineage-node__open[aria-label="打开《${e.title}》详情"]`,
+    );
+    await openE.first().focus();
+    await page.keyboard.press('Enter');
+    await page.waitForTimeout(800);
+    check(
+      'DOM 断言：键盘 Enter（在「打开详情」主行动作上）能跳转',
+      page.url().includes(nodeIds.E),
+      `url=${page.url()}`,
+    );
+
+    // 本轮终稿的核心：卡片主体点击 = 选中并保持路径高亮 + 面包屑（不跳详情）
+    await page.goto(richUrl, { waitUntil: 'commit', timeout: 120_000 });
+    await page.waitForFunction(
+      () => document.querySelectorAll('.game-lineage-node').length >= 6,
+      undefined,
+      { timeout: 120_000 },
+    );
+    await page.waitForTimeout(900);
+    const b1CardForSelect = page
+      .locator('.game-lineage-node')
+      .filter({ hasText: b1.title })
+      .first();
+    await b1CardForSelect.click({ position: { x: 6, y: 6 } });
+    await page.waitForTimeout(700);
+    const breadcrumb = page.locator('.game-lineage-breadcrumb');
+    const crumbText = await breadcrumb
+      .first()
+      .innerText()
+      .catch(() => '');
+    const selectedDimmed = await page
+      .locator('.game-lineage-node--dimmed')
+      .count();
+    const selectedActiveEdges = await page
+      .locator('.game-lineage-edge--active')
+      .count();
+    check(
+      'DOM 断言（新）：点击卡片主体 → 出现面包屑「已选中的路径」且包含根与当前节点',
+      (await breadcrumb.count()) >= 1 &&
+        crumbText.includes(root.title) &&
+        crumbText.includes(b1.title),
+      `crumb=${crumbText.replace(/\n+/gu, ' › ').slice(0, 70)}`,
+    );
+    check(
+      'DOM 断言（新）：点击后路径持续高亮（--active 边 ≥1 且其余节点降透明度）',
+      selectedActiveEdges >= 1 && selectedDimmed >= 1,
+      `activeEdges=${selectedActiveEdges} dimmed=${selectedDimmed}`,
+    );
+    await page.mouse.move(5, 5);
+    await page.waitForTimeout(500);
+    const dimmedAfterHoverOut = await page
+      .locator('.game-lineage-node--dimmed')
+      .count();
+    check(
+      'DOM 断言（新）：鼠标移开后选中路径仍保持（不是 hover 一次性效果）',
+      dimmedAfterHoverOut >= 1,
+      `dimmed=${dimmedAfterHoverOut}`,
+    );
+    check(
+      'DOM 断言（新）：卡片主体点击不会跳走详情页',
+      page.url().includes('/games/lineage'),
+      `url=${page.url()}`,
+    );
+    await takeShot(page, 'lineage-08-selected-path.png');
+
+    // ---------- 移动端窄屏 ----------
+    // 只给窄视口宽度（不模拟触摸设备）：验证窄屏布局不溢出 + 画布内部可横向平移。
+    const mobile = await browser.newContext({
+      viewport: { width: 390, height: 844 },
+    });
+    const mobilePage = await mobile.newPage();
+    await mobilePage.goto(richUrl, { waitUntil: 'commit', timeout: 120_000 });
+    await mobilePage.waitForFunction(
+      () => document.querySelectorAll('.game-lineage-node').length >= 6,
+      undefined,
+      { timeout: 120_000 },
+    );
+    await mobilePage.waitForTimeout(1200);
+    // 窄屏首访会弹「欢迎／移动端仅支持作品展示」弹层（platform-mobile-home-welcome-overlay，z-90 覆盖全屏），
+    // 它会拦住画布的指针事件 —— 按真实用户路径先关掉它（按钮文案「好」）。
+    const welcomeOverlay = mobilePage.locator(
+      '.platform-mobile-home-welcome-overlay',
+    );
+    const welcomeVisible = await welcomeOverlay
+      .first()
+      .waitFor({ state: 'visible', timeout: 5_000 })
+      .then(() => true)
+      .catch(() => false);
+    if (welcomeVisible) {
+      const dismiss = mobilePage.getByRole('button', {
+        name: '好',
+        exact: true,
+      });
+      if ((await dismiss.count()) > 0) {
+        await dismiss.first().click();
+        await mobilePage.waitForTimeout(600);
+      }
+    }
+    console.log(
+      `[lineage-visual] 窄屏欢迎弹层：${welcomeVisible ? '出现过并已关闭（按钮「好」）' : '未出现'}`,
+    );
+    const overflow = await mobilePage.evaluate(() => ({
+      scrollWidth: document.documentElement.scrollWidth,
+      innerWidth: window.innerWidth,
+      bodyScrollWidth: document.body.scrollWidth,
+    }));
+    check(
+      'DOM 断言（窄屏）：页面本身不横向溢出（画布内部才平移）',
+      overflow.scrollWidth <= overflow.innerWidth + 1 &&
+        overflow.bodyScrollWidth <= overflow.innerWidth + 1,
+      JSON.stringify(overflow),
+    );
+    const narrowFit = await fitContract(mobilePage);
+    check(
+      'DOM 断言（窄屏初访）：不再一进来 35% —— 要么真全览，要么 ≥可读下限并给提示',
+      narrowFit.allInside || (narrowFit.zoom >= 60 && narrowFit.hint >= 1),
+      `zoom=${narrowFit.zoom}% hint=${narrowFit.hint} allInside=${narrowFit.allInside}`,
+    );
+    const canvasBox = await mobilePage
+      .locator('.game-lineage-canvas')
+      .first()
+      .boundingBox();
+    const contentTransform = async () => {
+      for (let attempt = 0; attempt < 3; attempt += 1) {
+        const value = await mobilePage
+          .locator('.game-lineage-canvas__content')
+          .first()
+          .evaluate((node) => getComputedStyle(node).transform, undefined, {
+            timeout: 8_000,
+          })
+          .catch(() => null);
+        if (value) return value;
+        await mobilePage.waitForTimeout(700);
+      }
+      return 'unavailable';
+    };
+    const transformBefore = await contentTransform();
+    // 起拖点必须在**视口内**且落在画布上：窄屏下画布底部会伸出视口（画布高 56vh+，底部在折叠线外），
+    // 之前的实现从画布底部起拖，落点在视口外，指针事件根本没送到画布上。这里取可见区域内的点，
+    // 并用 elementFromPoint 现场确认命中画布（代际轴是 pointer-events:none，事件会穿透到画布）。
+    if (canvasBox) {
+      // 在画布可见区域里找一个「命中的元素就是画布本身」的空白点：落在节点/标题上会触发节点点击
+      // （拖动后可能直接跳转到详情页），落在底部 tab 栏会被挡住。找不到空白区本身就是一条 UX 发现。
+      const dragPoint = await mobilePage.evaluate(() => {
+        const canvas = document.querySelector('.game-lineage-canvas');
+        if (!canvas) return null;
+        const box = canvas.getBoundingClientRect();
+        // 起点要求：在视口内、在画布内、不在节点卡上（避免拖动被当成节点点击而跳详情页）、
+        // 且左侧至少还有 110px 画布空间（拖 90px 不越出画布）。
+        for (const dy of [0.2, 0.35, 0.5, 0.65, 0.8]) {
+          for (const dx of [0.85, 0.7, 0.55, 0.4, 0.25]) {
+            const x = box.x + box.width * dx;
+            const y = box.y + box.height * dy;
+            if (y > window.innerHeight - 130 || y < box.y + 8) continue;
+            if (x - box.x < 110 || x > box.x + box.width - 8) continue;
+            const element = document.elementFromPoint(x, y);
+            if (!element || !canvas.contains(element)) continue;
+            if (element.closest('.game-lineage-node')) continue;
+            return {
+              x,
+              y,
+              hit: `${element.tagName}.${String(element.className).slice(0, 24)}`,
+            };
+          }
+        }
+        return {
+          x: Math.min(box.x + box.width - 12, box.x + 120),
+          y: Math.min(box.y + box.height - 24, window.innerHeight - 160),
+          hit: 'fallback',
+        };
+      });
+      const hitLabel = dragPoint ? dragPoint.hit : 'null';
+      console.log(
+        `[lineage-visual] 窄屏拖动起点=(${Math.round(dragPoint?.x ?? 0)},${Math.round(dragPoint?.y ?? 0)}) 命中=${hitLabel}`,
+      );
+      check(
+        'DOM 断言（窄屏）：存在可拖动的起点（画布内、未落在节点卡上、左侧留有拖动空间）',
+        hitLabel !== 'fallback' && hitLabel !== 'null',
+        `hit=${hitLabel} at=(${Math.round(dragPoint?.x ?? 0)},${Math.round(dragPoint?.y ?? 0)})`,
+      );
+      if (dragPoint) {
+        await mobilePage.mouse.move(dragPoint.x, dragPoint.y);
+        await mobilePage.mouse.down();
+        await mobilePage.mouse.move(dragPoint.x - 45, dragPoint.y, {
+          steps: 20,
+        });
+        await mobilePage.mouse.move(dragPoint.x - 90, dragPoint.y, {
+          steps: 20,
+        });
+        await mobilePage.mouse.up();
+        await mobilePage.waitForTimeout(500);
+      }
+    }
+    let transformAfter = await contentTransform();
+    if (transformAfter === transformBefore && canvasBox) {
+      // 兜底：换画布右上区域的可见点再试一次
+      const retryX = canvasBox.x + canvasBox.width - 30;
+      const retryY = canvasBox.y + 40;
+      await mobilePage.mouse.move(retryX, retryY);
+      await mobilePage.mouse.down();
+      await mobilePage.mouse.move(retryX - 150, retryY, { steps: 25 });
+      await mobilePage.mouse.up();
+      await mobilePage.waitForTimeout(500);
+      transformAfter = await contentTransform();
+    }
+    check(
+      'DOM 断言（窄屏）：拖拽可横向平移画布（起点命中画布 + transform 改变）',
+      transformAfter !== 'unavailable' &&
+        transformBefore !== 'unavailable' &&
+        transformAfter !== transformBefore,
+      `before=${transformBefore} after=${transformAfter}`,
+    );
+    check(
+      'DOM 断言（窄屏）：拖拽没有误跳转到详情页（拖动 ≠ 点击节点）',
+      mobilePage.url().includes('/games/lineage?id='),
+      `url=${mobilePage.url()}`,
+    );
+    await takeShot(mobilePage, 'lineage-04-mobile-narrow.png');
+
+    // ---------- 降级态 ----------
+    const degradedPage = await desktop.newPage();
+    await degradedPage.goto(degradedUrl, {
+      waitUntil: 'commit',
+      timeout: 120_000,
+    });
+    await degradedPage.waitForTimeout(2500);
+    const stubNodes = degradedPage.locator('.game-lineage-node--stub');
+    const stubCount = await stubNodes.count();
+    const degradedText = await degradedPage.locator('#root').innerText();
+    await takeShot(degradedPage, 'lineage-05-parent-unavailable.png');
+    check(
+      'DOM 断言（降级）：缺失父作品渲染为占位节点（--stub + aria-disabled）',
+      stubCount >= 1 &&
+        (await stubNodes.first().getAttribute('aria-disabled')) === 'true',
+      `stub=${stubCount}`,
+    );
+    check(
+      'DOM 断言（降级）：占位节点标题为「原作品已不可用」',
+      (await stubNodes.first().innerText()).includes('原作品已不可用'),
+      `stubText=${(await stubNodes.first().innerText()).slice(0, 60)}`,
+    );
+    check(
+      'DOM 断言（降级）：页面不出现被下架父作品的标题与作者名',
+      !degradedText.includes(degradedParent.title) &&
+        !degradedText.includes(nameA),
+      `parentTitle=${degradedParent.title}`,
+    );
+    check(
+      'DOM 断言（降级）：给出母版不可用的说明文案',
+      degradedText.includes('不可用'),
+    );
+  } finally {
+    await browser.close().catch(() => {});
+  }
+
+  console.log('');
+  console.log('截图清单（绝对路径 + 应看到什么）：');
+  const expectations = [
+    '① lineage-01-overview.png：初访视野 —— 6 个节点（1 根 + 3 个 1 代 + 1 个 2 代 + 1 个 3 代）与连线、左侧**固定代际轴**（母版/第1代/第2代/第3代）；节点卡只有「封面缩略图 + 代际角标 + 标题 + 作者名 + Fork」，根卡带「当前作品」；若一次装不下，则按可读缩放下限显示并出现「已按可读缩放显示…点「适应窗口」看全树」提示。',
+    '② lineage-02-zoom-branch.png：点 4 次「放大」后（141%）—— 卡片与连线都放大，连线在缩放下仍保持可辨线宽（non-scaling-stroke），**左侧代际轴标签仍完整可见**（不再被画布裁掉）。',
+    '⑦ lineage-07-hover-edge-path.png（新增，核心）—— 在放大状态下 hover 1 代 B1：B1→根的**祖先路径连线被强化**（--active），其余连线变淡（--dimmed），同时节点侧兄弟卡降透明度。这是「可视化路径」需求的直接证据。',
+    '⑥ lineage-06-fit-window.png（新增）—— 点「适应窗口」后：全树真正完整落在画布框内（6 个节点都在框内）、右侧大片空白消失（内容水平居中）、第 3 代不再贴底被裁。',
+    '③ lineage-03-hover-ancestor.png：默认视野 hover B1 —— 自身与祖先不降透明度，同代兄弟 C1/F1（及 D/E）降透明度。',
+    '⑧ lineage-08-selected-path.png（新增）—— 点击 1 代卡片主体（非标题/按钮）后：路径被「选中」并**保持**高亮（祖先连线加粗、其余节点降透明度），鼠标移开也不消失，顶部出现面包屑「已选中的路径」（含根 → 当前节点）；页面不跳转。',
+    '④ lineage-04-mobile-narrow.png：390×844 窄屏 —— 控件折行、**页面本身不横向溢出**、底部 tab 正常；初访不再是 35%（按可读下限 + 提示），画布内可拖拽横向平移（这张是平移后的画面）。',
+    '⑤ lineage-05-parent-unavailable.png：父作品下架后 —— 缺失父作品处是占位卡「原作品已不可用／标题与作者名不对外展示」，顶部有「母版已不可用…」notice，标题回退为「创作族谱」，全文不出现被下架父作品的标题与作者名。',
+  ];
+  console.log(`截图目录=${shotDir}`);
+  for (const line of expectations) console.log(`  ${line}`);
+
+  console.log(
+    `[lineage-visual] 共 ${checks} 项：PASS ${checks - failures}，FAIL ${failures}`,
+  );
+  if (failures > 0) process.exitCode = 1;
+}
+
+main().catch((error) => {
+  console.error(`[lineage-visual] 未捕获异常：${error?.stack ?? error}`);
+  process.exitCode = 1;
+});
diff --git a/scripts/check-agc-co-creation-fork-e2e.mjs b/scripts/check-agc-co-creation-fork-e2e.mjs
new file mode 100644
index 000000000..21bd56656
--- /dev/null
+++ b/scripts/check-agc-co-creation-fork-e2e.mjs
@@ -0,0 +1,425 @@
+// 游戏共创「客户端 AGC 真机」链路验收：连 WebView2 的 CDP，把「共创列表 → Fork 确认 → 生成工程 → 运行可用」
+// 在**真实 AGC 客户端**里点一遍，并对本地项目做文件层断言。
+//
+// 为什么走 CDP：客户端是 Tauri + WebView2，渲染层跑在 WebView2 里；`~/.config/genarrative/.env` 里的
+// `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=9222` 会让**新启动**的客户端打开 CDP 端口，
+// 于是可以用 Playwright `chromium.connectOverCDP()` 接上去点真实界面（渲染层仍然是主世界，
+// `window.__TAURI__` 可直接读——这点与某些「隔离世界」驱动不同）。
+//
+// 用法：
+//   E2E_PLAYWRIGHT_DIR=<临时装了 playwright 的目录> \
+//   AGC_CDP_URL=http://127.0.0.1:9222 AGC_PHONE=13290000001 AGC_PASSWORD=GenE2e123! \
+//   AGC_FORK_TITLE='共创演示·C1｜南岭茶馆·雨前茶会' \
+//   node scripts/check-agc-co-creation-fork-e2e.mjs
+//
+// 契约来源（读实现确认；按**符号**引用，不写行号）：
+//   - 客户端导航：`apps/ai-game-creator-shell/src/view/layout.tsx` 的 `button[aria-label="共创"]`
+//   - 共创页：`src/view/co-creation/index.tsx` —— `section[aria-label="支持共创的作品"]` + 卡片里的 `Fork` 按钮；
+//     该页**没有**「直接 Fork 指定作品」输入块（深链由 launcher 直接落确认页）
+//   - 确认页：`src/view/fork-confirm/index.tsx` —— `footer[aria-label="Fork 操作"]`、
+//     `[aria-label="授权须知全文"]`（不折叠、**不自建内层滚动**）、`[aria-label="强制阅读进度"]`（3s 门禁）、
+//     按钮文案 `确认并进入编辑（Ns）` → `确认并进入编辑`
+//   - 阶段：`src/features/platform-fork/forkProgress.ts` 的 4 段（download/verify/extract/project）
+//   - 建项落盘：`src-tauri/src/game_fork.rs` 的 `create_project_from_platform_fork_at()` → `<app_data_dir>/projects/gameagent-*`；
+//     `.agent/fork-source.json`（`agc-fork-source.v2`，`source: package|project`）、`.agent/manifest.json`
+//   - 运行可用：`src/view/project-development/index.tsx` 的 `runAvailable` / `#run-unavailable-hint` /
+//     `section[aria-label="运行表现层"]`；`src/views/runUnavailableHint.ts` 的两档文案
+
+import {
+  existsSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+const CDP_URL = (process.env.AGC_CDP_URL ?? 'http://127.0.0.1:9222').trim();
+const PHONE = (process.env.AGC_PHONE ?? '13290000001').trim();
+const PASSWORD = process.env.AGC_PASSWORD ?? 'GenE2e123!';
+const FORK_TITLE = (
+  process.env.AGC_FORK_TITLE ?? '共创演示·C1｜南岭茶馆·雨前茶会'
+).trim();
+const PROJECTS_ROOT = (
+  process.env.AGC_PROJECTS_ROOT ??
+  path.join(
+    process.env.APPDATA ??
+      path.join(process.env.USERPROFILE ?? '.', 'AppData/Roaming'),
+    'world.genarrative.ai-game-creator',
+    'projects',
+  )
+).trim();
+const FORK_WAIT_TIMEOUT_MS = Number(
+  process.env.AGC_FORK_TIMEOUT_MS ?? '600000',
+);
+
+let checks = 0;
+let failures = 0;
+const notes = [];
+function check(name, ok, detail = '') {
+  checks += 1;
+  if (!ok) failures += 1;
+  console.log(
+    `${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ` :: ${detail}` : ''}`,
+  );
+}
+function note(text) {
+  notes.push(text);
+  console.log(`NOTE  ${text}`);
+}
+
+function listProjectDirs() {
+  if (!existsSync(PROJECTS_ROOT)) return [];
+  return readdirSync(PROJECTS_ROOT, { withFileTypes: true })
+    .filter(
+      (entry) => entry.isDirectory() && entry.name.startsWith('gameagent-'),
+    )
+    .map((entry) => entry.name);
+}
+
+async function loadPlaywright() {
+  const dir = (process.env.E2E_PLAYWRIGHT_DIR ?? '').trim();
+  if (!dir) return import('playwright');
+  const requireFromDir = createRequire(path.join(dir, 'noop.js'));
+  return requireFromDir('playwright');
+}
+
+/** 客户端可能停在登录页（新实例或登录态过期）：用演示账号登录，返回是否发生过登录。 */
+async function ensureLoggedIn(page) {
+  const loginButton = page.getByRole('button', { name: /^登录$/ }).first();
+  const navCoCreation = page.locator('[aria-label="共创"]').first();
+  if ((await navCoCreation.count()) > 0) return false;
+  await page.getByText('密码登录', { exact: true }).first().click();
+  await page.waitForTimeout(400);
+  await page.locator('input').nth(1).fill(PHONE);
+  await page.locator('input[type="password"]').first().fill(PASSWORD);
+  await loginButton.click();
+  await page.waitForTimeout(5000);
+  return true;
+}
+
+async function main() {
+  console.log(`[agc-fork-e2e] cdp=${CDP_URL} projectsRoot=${PROJECTS_ROOT}`);
+  const { chromium } = await loadPlaywright();
+  const browser = await chromium.connectOverCDP(CDP_URL);
+  const context = browser.contexts()[0];
+  const page =
+    context.pages().find((entry) => entry.url().includes('3080')) ??
+    context.pages()[0];
+  check(
+    '已连上 AGC 客户端（CDP + WebView2 页面）',
+    Boolean(page),
+    page?.url() ?? '',
+  );
+  const shotDir = mkdtempSync(path.join(tmpdir(), 'genarrative-agc-fork-'));
+  const shots = [];
+  const take = async (name) => {
+    const file = path.join(shotDir, name);
+    await page.screenshot({ path: file, fullPage: false });
+    shots.push(file);
+    console.log(`[agc-fork-e2e] 截图 ${file}`);
+    return file;
+  };
+
+  const before = new Set(listProjectDirs());
+  const loggedIn = await ensureLoggedIn(page);
+  if (loggedIn)
+    note(
+      '客户端原本停在登录页：已用演示账号登录（登录态与后续点击均已在本客户端内完成）',
+    );
+  await page
+    .locator('[aria-label="共创"]')
+    .first()
+    .waitFor({ state: 'visible', timeout: 120000 });
+
+  // ---------- 1) 共创列表 ----------
+  await page.locator('[aria-label="共创"]').first().click();
+  const listSection = page.locator('section[aria-label="支持共创的作品"]');
+  await listSection.waitFor({ state: 'visible', timeout: 120000 });
+  await page.waitForFunction(
+    () => document.querySelectorAll('article').length > 0,
+    undefined,
+    { timeout: 120000 },
+  );
+  const listInfo = await page.evaluate(() => ({
+    inputs: document.querySelectorAll('input').length,
+    directForkText: document.body.innerText.includes('直接 Fork 指定作品'),
+    cards: document.querySelectorAll('article').length,
+  }));
+  check('共创页已渲染作品卡片', listInfo.cards > 0, `cards=${listInfo.cards}`);
+  check(
+    '「直接 Fork 指定作品」输入块已消失（页面无输入控件、无该文案）',
+    listInfo.inputs === 0 && !listInfo.directForkText,
+    `inputs=${listInfo.inputs} text=${listInfo.directForkText}`,
+  );
+
+  // 共创页的滚动容器不是 document：客户端把列表套在自己的滚动壳里，这里按「可滚动高度最大」的元素去找。
+  const scrollState = await page.evaluate(() => {
+    const scroller = [...document.querySelectorAll('*')]
+      .filter((el) => el.scrollHeight > el.clientHeight + 20)
+      .sort(
+        (a, b) =>
+          b.scrollHeight - b.clientHeight - (a.scrollHeight - a.clientHeight),
+      )[0];
+    const target = scroller ?? document.scrollingElement;
+    target.scrollTop = target.scrollHeight;
+    return {
+      tag: target.tagName,
+      cls: String(target.className ?? '').slice(0, 60),
+      scrollTop: target.scrollTop,
+      scrollHeight: target.scrollHeight,
+      clientHeight: target.clientHeight,
+      innerHeight: window.innerHeight,
+      docHeight: document.documentElement.scrollHeight,
+    };
+  });
+  const reachedBottom =
+    scrollState.scrollTop + scrollState.clientHeight >=
+    scrollState.scrollHeight - 4;
+  const lastCardVisible = await page.evaluate(() => {
+    const cards = [...document.querySelectorAll('article')];
+    const last = cards[cards.length - 1];
+    if (!last) return false;
+    const box = last.getBoundingClientRect();
+    return box.bottom <= window.innerHeight + 2 && box.top >= -2;
+  });
+  check(
+    '共创列表能滚到底（滚到底后最后一张卡片完整可见）',
+    reachedBottom && lastCardVisible,
+    `scroller=${scrollState.tag}.${scrollState.cls} scrollTop=${scrollState.scrollTop} client=${scrollState.clientHeight} height=${scrollState.scrollHeight} lastVisible=${lastCardVisible}`,
+  );
+  await take('01-co-creation-list-bottom.png');
+
+  // ---------- 2) 打开 Fork 确认页 ----------
+  const card = page.locator('article').filter({ hasText: FORK_TITLE }).first();
+  check(`共创列表里能找到目标作品「${FORK_TITLE}」`, (await card.count()) > 0);
+  await card
+    .getByRole('button', { name: /^Fork$/ })
+    .first()
+    .click();
+  const footer = page.locator('footer[aria-label="Fork 操作"]');
+  await footer.waitFor({ state: 'visible', timeout: 60000 });
+  const countdownBadge = page.locator('[aria-label="强制阅读进度"]').first();
+  const confirmButton = footer
+    .getByRole('button', { name: /确认并进入编辑/ })
+    .first();
+  check('Fork 确认页已打开（底部吸附操作条出现）', await footer.isVisible());
+  const initialDisabled = await confirmButton.isDisabled();
+  check(
+    '强制阅读门禁生效：确认按钮初始禁用且有倒计时徽章',
+    initialDisabled && (await countdownBadge.count()) > 0,
+    `disabled=${initialDisabled}`,
+  );
+  const noticeHasInnerScroll = await page.evaluate(() => {
+    const container = document.querySelector('[aria-label="授权须知全文"]');
+    if (!container) return null;
+    return container.scrollHeight > container.clientHeight + 1;
+  });
+  check(
+    '授权须知全文无内层滚动（随页面自然流动）',
+    noticeHasInnerScroll === false,
+    `innerScroll=${noticeHasInnerScroll}`,
+  );
+  await take('02-fork-confirm-default.png');
+
+  await page.evaluate(() => {
+    const scroller = document.scrollingElement;
+    scroller.scrollTo(0, scroller.scrollHeight);
+  });
+  await page.waitForTimeout(600);
+  const footerStillVisible = await footer.isVisible();
+  check(
+    '滚到页面底部时底部吸附操作条仍然可见',
+    footerStillVisible,
+    `visible=${footerStillVisible}`,
+  );
+  await take('03-fork-confirm-scrolled-bottom.png');
+
+  await confirmButton.waitFor({ state: 'visible', timeout: 15000 });
+  await page.waitForFunction(
+    () => {
+      const button = [...document.querySelectorAll('footer button')].find(
+        (entry) => (entry.textContent ?? '').includes('确认并进入编辑'),
+      );
+      return Boolean(button) && !button.disabled;
+    },
+    undefined,
+    { timeout: 20000 },
+  );
+  check(
+    '3 秒后可确认（按钮由禁用变为可用）',
+    !(await confirmButton.isDisabled()),
+  );
+
+  // ---------- 3) 确认并等待生成工程 ----------
+  await confirmButton.click();
+  const busySeen = await page
+    .getByText('正在同步工程', { exact: false })
+    .first()
+    .waitFor({ state: 'visible', timeout: 20000 })
+    .then(() => true)
+    .catch(() => false);
+  note(
+    busySeen
+      ? '已观察到「正在同步工程…」进行中提示'
+      : '未捕捉到进行中提示（同步可能很快完成）',
+  );
+  const stageText = await page
+    .locator('[aria-label="工程同步"]')
+    .first()
+    .innerText()
+    .catch(() => '');
+
+  const deadline = Date.now() + FORK_WAIT_TIMEOUT_MS;
+  let newProject = null;
+  while (Date.now() < deadline) {
+    const now = listProjectDirs().filter((name) => !before.has(name));
+    if (now.length > 0) {
+      const candidate = path.join(PROJECTS_ROOT, now[0]);
+      const forkRecord = path.join(candidate, '.agent', 'fork-source.json');
+      const distEntry = path.join(candidate, 'game', 'dist', 'index.html');
+      if (existsSync(forkRecord) && existsSync(distEntry)) {
+        newProject = candidate;
+        break;
+      }
+    }
+    await page.waitForTimeout(2000);
+  }
+  check(
+    'Fork 在本机生成了新项目（projects/gameagent-*，含 .agent/fork-source.json 与预览根）',
+    Boolean(newProject),
+    newProject ?? `projects=${JSON.stringify(listProjectDirs().slice(-3))}`,
+  );
+  if (!newProject) {
+    console.log(`[agc-fork-e2e] 同步状态条文本=${JSON.stringify(stageText)}`);
+    await take('04-fork-failed.png');
+    browser.close().catch(() => {});
+    report(shotDir, shots);
+    process.exit(1);
+  }
+  console.log(`[agc-fork-e2e] 新项目=${newProject}`);
+
+  // ---------- 4) 文件层断言 ----------
+  const forkRecordPath = path.join(newProject, '.agent', 'fork-source.json');
+  let forkRecord = null;
+  try {
+    forkRecord = JSON.parse(readFileSync(forkRecordPath, 'utf8'));
+  } catch (error) {
+    forkRecord = null;
+    console.log(`[agc-fork-e2e] fork-source.json 解析失败：${error.message}`);
+  }
+  check(
+    '.agent/fork-source.json 是 v2 且记录了来源作品',
+    forkRecord?.schemaVersion === 'agc-fork-source.v2' &&
+      typeof forkRecord?.gameId === 'string' &&
+      forkRecord.gameId.length > 0,
+    JSON.stringify(forkRecord),
+  );
+  note(
+    `取件形态 source=${forkRecord?.source ?? '?'}（package=成品包，project=工程源包）`,
+  );
+  const distFile = path.join(newProject, 'game', 'dist', 'index.html');
+  check(
+    '成品包已铺进预览根（game/dist/index.html 存在，不再依赖 reference 子目录）',
+    existsSync(distFile) && statSync(distFile).size > 0,
+    distFile,
+  );
+  check(
+    '没有遗留 reference/ 参考子目录',
+    !existsSync(path.join(newProject, 'reference')),
+  );
+  const manifestPath = path.join(newProject, '.agent', 'manifest.json');
+  let manifest = null;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+  } catch (error) {
+    manifest = null;
+    console.log(`[agc-fork-e2e] manifest.json 解析失败：${error.message}`);
+  }
+  const tasks = Array.isArray(manifest?.tasks) ? manifest.tasks : [];
+  const prototypeTask = tasks.find((task) => task.id === 'code-prototype');
+  const versions = Array.isArray(manifest?.versions)
+    ? manifest.versions.map((entry) => entry?.versionId ?? entry?.id ?? entry)
+    : [];
+  check(
+    '清单登记了可运行原型（code-prototype=completed）',
+    prototypeTask?.status === 'completed',
+    JSON.stringify(prototypeTask ?? null),
+  );
+  check(
+    '清单里是初始版本（versions 含 initial-1）',
+    versions.includes('initial-1'),
+    JSON.stringify(versions),
+  );
+
+  // ---------- 5) 运行视图可用（用户 bug 的验收点） ----------
+  const hint = page.locator('#run-unavailable-hint');
+  const runSurface = page.locator('section[aria-label="运行表现层"]');
+  await page.waitForTimeout(2500);
+  const runTab = page.getByRole('tab', { name: /运行/ }).first();
+  if ((await runTab.count()) > 0 && !(await runSurface.isVisible())) {
+    await runTab.click().catch(() => {});
+    await page.waitForTimeout(4000);
+  }
+  const hintText = (await hint.count()) > 0 ? await hint.innerText() : '';
+  const prototypeHint = page.getByText('首个可运行原型尚未完成', {
+    exact: false,
+  });
+  check(
+    '运行视图不再显示「首个可运行原型尚未完成」空态',
+    (await prototypeHint.count()) === 0,
+    `hint=${JSON.stringify(hintText)}`,
+  );
+  const surfaceVisible = await runSurface.isVisible().catch(() => false);
+  const frameCount = await page
+    .locator('iframe[title*="游戏运行画面"]')
+    .count();
+  check(
+    '运行视图出现运行表现层与预览画面（可运行）',
+    surfaceVisible && frameCount > 0,
+    `surface=${surfaceVisible} frames=${frameCount} hint=${JSON.stringify(hintText)}`,
+  );
+  await page.waitForTimeout(3000);
+  await take('04-run-view.png');
+
+  // ---------- 6) 平台侧血缘（可选只读核对）----------
+  const platformBase = (
+    process.env.E2E_API_BASE ?? 'http://127.0.0.1:8082'
+  ).replace(/\/+$/u, '');
+  if (forkRecord?.gameId) {
+    const response = await fetch(
+      `${platformBase}/api/game-distribution/games/${forkRecord.gameId}`,
+      { headers: { 'x-genarrative-response-envelope': 'v1' } },
+    ).catch(() => null);
+    const payload = response ? await response.json().catch(() => null) : null;
+    check(
+      '来源作品在平台上仍可读（Fork 前提到的是真实公开作品）',
+      response?.status === 200 && payload?.data?.id === forkRecord.gameId,
+      `status=${response?.status} title=${payload?.data?.title ?? '?'}`,
+    );
+  }
+
+  browser.close().catch(() => {});
+  report(shotDir, shots);
+  process.exit(failures > 0 ? 1 : 0);
+}
+
+function report(shotDir, shots) {
+  console.log('');
+  for (const shot of shots) console.log(`[agc-fork-e2e] 截图文件 ${shot}`);
+  console.log(`[agc-fork-e2e] 截图目录 ${shotDir}`);
+  if (notes.length > 0) {
+    console.log('[agc-fork-e2e] 备注：');
+    for (const text of notes) console.log(`  - ${text}`);
+  }
+  console.log(
+    `[agc-fork-e2e] 共 ${checks} 项：PASS ${checks - failures}，FAIL ${failures}`,
+  );
+}
+
+main().catch((error) => {
+  console.error(`[agc-fork-e2e] 未捕获异常：${error?.stack ?? error}`);
+  process.exit(1);
+});
diff --git a/scripts/check-game-distribution-dto-parity.mjs b/scripts/check-game-distribution-dto-parity.mjs
index 00b54abcf..6d9449f00 100644
--- a/scripts/check-game-distribution-dto-parity.mjs
+++ b/scripts/check-game-distribution-dto-parity.mjs
@@ -59,7 +59,63 @@ const PAIRS = [
     'GameDistributionUpdateGameMetadataRequest',
   ],
   ['GameDistributionPrivateVersion', 'GameDistributionPrivateVersion'],
+  // 共创（Fork）授权与血缘：档位枚举与公开血缘摘要必须与 TS 逐字对齐。
+  ['GameDistributionForkAuthorization', 'GameDistributionForkAuthorization'],
+  ['GameDistributionLineage', 'GameDistributionLineage'],
+  ['GameDistributionLineageNode', 'GameDistributionLineageNode'],
+  ['GameDistributionLineageResponse', 'GameDistributionLineageResponse'],
+  ['GameDistributionDerivedResponse', 'GameDistributionDerivedResponse'],
+  // 贡献归集与归因（作者视角只读，2026-10-06）：指标集合、按代际分解、直接子代明细与响应体
+  // 逐字段对齐。`truncatedReason` 在 Rust 是 `Option<String>`（未截断为 `null`），TS 侧必须可空。
+  ['GameDistributionContributionTotals', 'GameDistributionContributionTotals'],
+  [
+    'GameDistributionContributionGeneration',
+    'GameDistributionContributionGeneration',
+  ],
+  ['GameDistributionContributionChild', 'GameDistributionContributionChild'],
+  [
+    'GameDistributionContributionResponse',
+    'GameDistributionContributionResponse',
+  ],
+  // M2a 取件通道：元数据响应与内容形态同样逐字段对齐（不含对象键是契约的一部分）。
+  ['GameDistributionForkSourceKind', 'GameDistributionForkSourceKind'],
+  ['GameDistributionForkSource', 'GameDistributionForkSource'],
+  ['GameDistributionForkSourceResponse', 'GameDistributionForkSourceResponse'],
+  ['GameDistributionForkDeclaration', 'GameDistributionForkDeclaration'],
+  [
+    'GameDistributionSetForkAuthorizationRequest',
+    'GameDistributionSetForkAuthorizationRequest',
+  ],
+  // 收藏（收录）：PUT / DELETE 共用同一个权威投影值形状（`replayed` 只有 PUT 会发）；
+  // 列表响应用独立类型登记，避免与公开目录的分页口径混成一个契约。
+  ['GameDistributionCollectionState', 'GameDistributionCollectionState'],
+  [
+    'GameDistributionMyCollectionsResponse',
+    'GameDistributionMyCollectionsResponse',
+  ],
+  // 共创主题：三态枚举、详情增量条目、公开列表 / 详情与后台写请求逐字段对齐。
+  // 公开列表 / 详情的手拼响应构建器（`public_themes_payload` / `public_theme_detail_payload`、
+  // 以及作品详情的 `themes` 增量）要等 api-server 路由落地后才登记进 `RESPONSE_BUILDERS`——
+  // 那里要求函数真实存在，登记不存在的构建器会让本检查直接失败。
+  ['GameDistributionThemeStatus', 'GameDistributionThemeStatus'],
+  ['GameDistributionThemeReference', 'GameDistributionThemeReference'],
+  ['GameDistributionThemeSummary', 'GameDistributionThemeSummary'],
+  ['GameDistributionThemeListResponse', 'GameDistributionThemeListResponse'],
+  ['GameDistributionThemeDetail', 'GameDistributionThemeDetail'],
+  ['GameDistributionCreateThemeRequest', 'GameDistributionCreateThemeRequest'],
+  ['GameDistributionUpdateThemeRequest', 'GameDistributionUpdateThemeRequest'],
+  [
+    'GameDistributionUpsertThemeMemberRequest',
+    'GameDistributionUpsertThemeMemberRequest',
+  ],
   ['GameDistributionPurchaseRequest', 'GameDistributionPurchaseRequest'],
+  // 旧两步发布路径的请求 DTO：两条发布路径并存期间仍是公开契约的一部分，
+  // 因此与统一路径的 `NewGameVersionRequest` 一样登记、逐字段对齐。
+  ['GameDistributionCreateGameRequest', 'GameDistributionCreateGameRequest'],
+  [
+    'GameDistributionCreateVersionRequest',
+    'GameDistributionCreateVersionRequest',
+  ],
   ['GameDistributionPurchase', 'GameDistributionPurchase'],
   ['GameDistributionPurchaseResponse', 'GameDistributionPurchaseResponse'],
   [
@@ -94,6 +150,18 @@ const TS_ONLY_TYPES = [
   'GameDistributionVersionDetail',
   'GameDistributionCancelVersionRequest',
   'GameDistributionCancelVersionResponse',
+  // 后台主题的四个响应形状：服务端也是逐字段手拼 JSON（`admin_theme_payload` 一族），
+  // 因此同样只能走本清单 + `RESPONSE_BUILDERS` 登记，而不是 Rust↔TS 映射表。
+  'GameDistributionAdminTheme',
+  'GameDistributionAdminThemeListResponse',
+  'GameDistributionAdminThemeMutationResponse',
+  'GameDistributionAdminThemeMemberResponse',
+  'GameDistributionAdminThemeMemberRemovalResponse',
+  // 后台主题成员**读**接口：列表响应与单条行也都是手拼 JSON（服务端没有对应的 Rust 结构体），
+  // 与上面四个同类登记；`visibility` 联合类型是服务端按游戏行现算的字符串，同样只有 TS 侧定义。
+  'GameDistributionAdminThemeMemberRow',
+  'GameDistributionAdminThemeMemberListResponse',
+  'GameDistributionAdminThemeMemberVisibility',
 ];
 
 // 服务端逐字段手拼 JSON 的响应构建器：把「这个函数真的会发出的顶层键」与 TS 类型逐键比对。
@@ -104,6 +172,11 @@ const RESPONSE_BUILDERS = [
   {
     fn: 'game_payload',
     ts: 'GameDistributionGame',
+    // `forkAuthorization` 在 TS 里是可选的（旧响应可省略），但**公开与作者响应都必须发出**它：
+    // 详情页的授权徽章与「改造这个作品」入口都读它，缺了会静默退化成「禁止共创」。
+    // mustEmit 是唯一能表达「可选字段在这条路径上必出」的机制，所以钉在这里；
+    // public_game_payload / owner_game_entry_payload 都以它为 base，因此一并受保护。
+    mustEmit: ['forkAuthorization'],
     nested: [
       { key: 'author', ts: 'GameDistributionAuthor' },
       { key: 'deviceSupport', ts: 'GameDistributionDeviceSupport' },
@@ -113,10 +186,164 @@ const RESPONSE_BUILDERS = [
     fn: 'public_game_payload',
     ts: 'GameDistributionGame',
     base: 'game_payload',
-    mustEmit: ['currentVersion', 'ratingSummary'],
+    // `coCreationCount`（公开可见的**全部**后代数）与 `forkCount`（**直接**子代）一样只属于公开投影：
+    // TS 为了同时描述作者侧形状把它标成可选，但公开目录 / 公开详情必须真的发出，故显式钉住。
+    mustEmit: [
+      'currentVersion',
+      'ratingSummary',
+      'forkCount',
+      'lineage',
+      'coCreationCount',
+    ],
+  },
+  {
+    // 公开详情在 `public_game_payload` 之上按**可选登录态**追加 `collected`；匿名请求不加键，
+    // 因此它不能进 `mustEmit`（那条路径本来就不发），但必须是一个真实构建器：
+    // 这层证据说明「登录时确实会发出 `collected`」，而不是只写在 DTO 注释里。
+    fn: 'public_game_detail_payload',
+    ts: 'GameDistributionGame',
+    base: 'public_game_payload',
+    // `themes` 与 `collected` 相反：**匿名与登录都发**（主题入口是公开页的一部分，不是 per-user
+    // 数据），没有所属主题时发空数组而不是缺键，因此它必须进 mustEmit。
+    mustEmit: ['themes'],
   },
   { fn: 'private_version_payload', ts: 'GameDistributionPrivateVersion' },
-  { fn: 'version_summary_payload', ts: 'GameDistributionVersionSummary' },
+  {
+    // 公开版本摘要：`changeSummary` 在 TS 里可省略（旧响应没有这个键），但这条路径**必须发出**
+    // ——衍生作品上它是详情页 / 族谱溯源展示「每一代差异」的唯一来源，缺了会静默退化成「无差异」；
+    // 母版发 `null`（不是省略），「没有来源作品」与「服务端忘了发」必须可分辨。
+    fn: 'version_summary_payload',
+    ts: 'GameDistributionVersionSummary',
+    mustEmit: ['changeSummary'],
+  },
+  {
+    // 「我的收藏」复用公开目录的条目形状，但有自己的分页契约（默认 20 / 上限 50 / 真实游标）：
+    // `nextCursor` 是这条路径**必须**发出的键（最后一页发 `null`，不是省略）。
+    fn: 'my_collections_payload',
+    ts: 'GameDistributionMyCollectionsResponse',
+    mustEmit: ['games', 'nextCursor'],
+  },
+  {
+    // 公开游戏目录（游戏广场）：`games` / `nextCursor` 两个键都必须发出（末页 `nextCursor: null`）。
+    // 修正前这条路径是内联 `json!` 且把 `nextCursor` 写死 `null`——不在本清单里，所以「发不发
+    // 游标」没有任何证据；现在它是命名构建器，键与 `GameDistributionListResponse` 逐键比对。
+    fn: 'public_games_payload',
+    ts: 'GameDistributionListResponse',
+    mustEmit: ['games', 'nextCursor'],
+  },
+  {
+    // 公开共创主题列表：`themes` / `nextCursor` 两个键都必须发出（末页 `nextCursor: null`）。
+    // 单条的形状由 `public_theme_summary_payload` 拼，这里只证明顶层键与 TS 契约一致。
+    fn: 'public_themes_payload',
+    ts: 'GameDistributionThemeListResponse',
+    mustEmit: ['themes', 'nextCursor'],
+  },
+  {
+    // 公开共创主题详情：顶层扁平（与 `GET /games/{gameId}` 同形），**七个**键都由这一条路径发出。
+    // `memberCount`（真实可见成员数，不截断）与 `rootsTruncated`（这份 `roots` 有没有被响应体积
+    // 上限截断）是两个独立口径，缺了后者客户端就只能靠「两个数不相等」去猜自己是否少看了。
+    // `roots` 逐条复用公开目录同一份 `public_game_payload`（不是第二套作品摘要）。
+    fn: 'public_theme_detail_payload',
+    ts: 'GameDistributionThemeDetail',
+    mustEmit: [
+      'themeId',
+      'name',
+      'summary',
+      'badge',
+      'memberCount',
+      'roots',
+      'rootsTruncated',
+    ],
+  },
+  {
+    // 主题条目（列表单条与详情头部共用）：`public_themes_payload` 里逐条调用它，`roots` 之外
+    // 的嵌套对象在顶层键解析里看不到，所以单独登记，让「条目到底发哪几个键」有独立证据。
+    fn: 'public_theme_summary_payload',
+    ts: 'GameDistributionThemeSummary',
+    mustEmit: ['themeId', 'name', 'summary', 'badge', 'memberCount'],
+  },
+  {
+    // 作品详情 `themes` 增量的单条：`{ themeId, name, badge }`（不含简介与成员数——那是主题页的事）。
+    // 它是**数组元素**，顶层键解析抓不到它，因此单独登记，让这条增量条目的形状也有证据。
+    fn: 'theme_reference_payload',
+    ts: 'GameDistributionThemeReference',
+    mustEmit: ['themeId', 'name', 'badge'],
+  },
+  {
+    // 后台主题条目：`admin_themes_payload` 逐条调用它，且它比公开的 `GameDistributionThemeSummary`
+    // 多出 `sortOrder` / `status` / 时间戳、`memberCount` 口径也不同（成员**行**总数），
+    // 因此单独建类型、单独登记——后台 UI 落地时形状漂移会被这里抓住。
+    fn: 'admin_theme_payload',
+    ts: 'GameDistributionAdminTheme',
+    mustEmit: [
+      'themeId',
+      'name',
+      'summary',
+      'badge',
+      'sortOrder',
+      'status',
+      'memberCount',
+      'createdAt',
+      'updatedAt',
+    ],
+  },
+  {
+    // 后台主题列表：只有一个顶层键 `themes`（**没有** `nextCursor`：这条路径不分页）。
+    fn: 'admin_themes_payload',
+    ts: 'GameDistributionAdminThemeListResponse',
+    mustEmit: ['themes'],
+  },
+  {
+    // 后台创建 / 更新的响应：`{ theme, replayed }`。`theme` 的值是函数调用而不是对象字面量，
+    // 所以不能用 `nested` 比对；条目形状由上面 `admin_theme_payload` 那条独立覆盖。
+    fn: 'admin_theme_mutation_payload',
+    ts: 'GameDistributionAdminThemeMutationResponse',
+    mustEmit: ['theme', 'replayed'],
+  },
+  {
+    // 后台成员写入的响应：`{ themeId, rootGameId, sortOrder, createdAt }`。
+    fn: 'admin_theme_member_payload',
+    ts: 'GameDistributionAdminThemeMemberResponse',
+    mustEmit: ['themeId', 'rootGameId', 'sortOrder', 'createdAt'],
+  },
+  {
+    // 后台移除成员的响应：`{ themeId, rootGameId }`（刻意不含「之前存不存在」，重复调用逐字节相同）。
+    fn: 'admin_theme_member_removal_payload',
+    ts: 'GameDistributionAdminThemeMemberRemovalResponse',
+    mustEmit: ['themeId', 'rootGameId'],
+  },
+  {
+    // 后台成员**读**接口的列表响应：`totalMembers` 是**成员行总数**（含当前不可见的行、不受分页
+    // 影响），`nextCursor` 必须发出（末页为 `null`，不是省略）——缺了它客户端会把末页当成
+    // 「还有下一页」并死循环翻页。
+    fn: 'admin_theme_members_payload',
+    ts: 'GameDistributionAdminThemeMemberListResponse',
+    mustEmit: ['themeId', 'totalMembers', 'members', 'nextCursor'],
+  },
+  {
+    // 后台成员行的单条形状：`visibility` 与 `visible` 是两个独立字段（前者回答「为什么」、后者
+    // 回答「此刻公开侧会不会出现」），`title` 在游戏行不存在时为 `null` 但**键必须发出**。
+    // 它是数组元素，顶层键解析抓不到它，因此单独登记。
+    fn: 'admin_theme_member_row_payload',
+    ts: 'GameDistributionAdminThemeMemberRow',
+    mustEmit: [
+      'rootGameId',
+      'title',
+      'sortOrder',
+      'createdAt',
+      'visible',
+      'visibility',
+    ],
+  },
+  {
+    // 公开详情里的血缘摘要（`GET /games/{gameId}` 的 `lineage`）。TS 里 `parentAuthorName` 是可选的
+    // （表达「历史响应可能缺键」），但这条路径**必须恒发该键**（值为 `null` 也要发）：它是溯源条
+    // 「父作品 · 作者名」的唯一来源，「缺键」与「null」在前端是两种渲染分支，不能靠 optional 表达。
+    // 这条登记同时把「builder 发出的键 == DTO 字段」钉住，防止再出现「加了字段忘了发」。
+    fn: 'lineage_payload',
+    ts: 'GameDistributionLineage',
+    mustEmit: ['parentAuthorName'],
+  },
 ];
 
 function camelCase(value) {
diff --git a/scripts/check-project-bundle-policy-parity.mjs b/scripts/check-project-bundle-policy-parity.mjs
new file mode 100644
index 000000000..ccb9c061e
--- /dev/null
+++ b/scripts/check-project-bundle-policy-parity.mjs
@@ -0,0 +1,435 @@
+#!/usr/bin/env node
+// 检查 AGC 工程源包打包器（客户端）与服务端校验器的排除规则 / 规模上限是否逐条一致。
+//
+// 为什么需要它：同一套「源码包能装什么」的规则有两份实现——客户端 Rust 打包器
+// （`apps/ai-game-creator-shell/src-tauri/src/project_bundle.rs`）负责**先拦**，服务端校验器
+// （`server-rs/crates/module-game-distribution/src/project_bundle.rs`）负责**最终把关**。两份已经
+// 真实漂移过一次（凭据清单缺 `.map` / 单文件上限比服务端宽 4 倍，客户端会打出服务端必然 422 的包）。
+//
+// 比对口径（服务端是权威）：
+//   1. 规模上限：一一对应且必须**相等**（客户端更宽 = 白传一趟被拒；客户端更严 = 合法工程打不出来）；
+//   2. 规则 token：服务端每一条都必须在客户端存在（客户端可以先拦，绝不能漏拦）；
+//   3. 客户端额外项（`game/dist`、`game/build`、`.godot`、`exports`、`memory`）：只打印，不算失败，
+//      它们是客户端策略，不改变服务端会接受什么。
+//
+// 抽不到 token / 数值一律报错退出：正则失配导致的「空集合」绝不能被当成绿灯。
+
+import fs from 'node:fs';
+
+const CLIENT_FILE =
+  'apps/ai-game-creator-shell/src-tauri/src/project_bundle.rs';
+const SERVER_FILE =
+  'server-rs/crates/module-game-distribution/src/project_bundle.rs';
+
+// [服务端常量名, 客户端常量名]
+const LIMIT_PAIRS = [
+  ['MAX_PROJECT_BUNDLE_BYTES', 'PROJECT_BUNDLE_MAX_ARCHIVE_BYTES'],
+  ['MAX_PROJECT_EXPANDED_BYTES', 'PROJECT_BUNDLE_MAX_EXPANDED_BYTES'],
+  ['MAX_PROJECT_FILE_BYTES', 'PROJECT_BUNDLE_MAX_FILE_BYTES'],
+  ['MAX_PROJECT_FILE_COUNT', 'PROJECT_BUNDLE_MAX_FILES'],
+  ['MAX_PROJECT_COMPRESSION_RATIO', 'PROJECT_BUNDLE_MAX_COMPRESSION_RATIO'],
+];
+
+function readFile(path) {
+  if (!fs.existsSync(path)) {
+    throw new Error(`文件不存在：${path}`);
+  }
+  return fs.readFileSync(path, 'utf8');
+}
+
+/// 取出一个函数的正文（从 `fn NAME` 到下一个顶层 `fn `），用于限定 token 的抓取范围。
+function functionBody(source, name) {
+  const start = source.indexOf(`fn ${name}`);
+  if (start < 0) {
+    throw new Error(`找不到函数 ${name}`);
+  }
+  const rest = source.slice(start);
+  const next = rest.indexOf('\nfn ', 1);
+  return next < 0 ? rest : rest.slice(0, next);
+}
+
+/// 把 Rust 里的正整数字面量表达式（只允许数字、下划线与乘号）算成数值。
+function evaluateInteger(expression, label) {
+  const normalized = expression.replaceAll('_', '').trim();
+  if (!/^[\d*\s]+$/u.test(normalized)) {
+    throw new Error(`${label} 的取值不是可解析的整数表达式：${expression}`);
+  }
+  return normalized
+    .split('*')
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .reduce((product, part) => product * Number(part), 1);
+}
+
+/// 抓取 `const NAME: 类型 = 表达式;` 的数值。
+function rustConstant(source, name, file) {
+  const match = new RegExp(
+    `const\\s+${name}\\s*:\\s*\\w+\\s*=\\s*([\\d_*\\s]+);`,
+  ).exec(source);
+  if (!match) {
+    throw new Error(`${file} 里找不到常量 ${name}`);
+  }
+  return evaluateInteger(match[1], `${file} 的 ${name}`);
+}
+
+/// 抓取 `const NAME: &[&str] = &[...];` / `[&str; N] = [...]` 里的字符串集合。
+function rustStringArray(source, name, file) {
+  const match = new RegExp(
+    `const\\s+${name}\\s*:\\s*(?:&)?\\[&str(?:;\\s*\\d+)?\\]\\s*=\\s*(?:&)?\\[([\\s\\S]*?)\\];`,
+  ).exec(source);
+  if (!match) {
+    throw new Error(`${file} 里找不到字符串数组常量 ${name}`);
+  }
+  return [...match[1].matchAll(/"([^"]*)"/gu)].map((entry) => entry[1]);
+}
+
+/// 抓取某段代码里所有 `X.starts_with("...")` / `ends_with` / `==` 的字符串字面量。
+function stringLiteralsAfter(source, method) {
+  const pattern =
+    method === '=='
+      ? /(?:^|\W)\w+\s*==\s*"([^"]*)"/gu
+      : new RegExp(`\\w+\\.${method}\\("([^"]*)"\\)`, 'gu');
+  return [...source.matchAll(pattern)].map((entry) => entry[1]);
+}
+
+/// 抓取 `const NAME: &[char] = &['a', 'b'];` / `[char; N] = [...]` 里的字符字面量（按源码文本比较）。
+function rustCharArray(source, name, file) {
+  const match = new RegExp(
+    `const\\s+${name}\\s*:\\s*(?:&)?\\[char(?:;\\s*\\d+)?\\]\\s*=\\s*(?:&)?\\[([\\s\\S]*?)\\];`,
+  ).exec(source);
+  if (!match) {
+    throw new Error(`${file} 里找不到字符数组常量 ${name}`);
+  }
+  return [...match[1].matchAll(/'((?:\\.|[^'\\])*)'/gu)].map(
+    (entry) => entry[1],
+  );
+}
+
+/// 抓取某段代码里匹配给定正则的字符字面量（用于 `.ends_with('x')` / `.contains('x')` /
+/// `matches!(expr, 'a' | 'b')` 这三种路径形状写法）。比较的是**源码文本**（例如反斜杠是 `\\`），
+/// 因此两侧必须用同一种写法。
+function charLiteralsMatching(source, pattern) {
+  return [...source.matchAll(pattern)].flatMap((entry) =>
+    [...entry[0].matchAll(/'((?:\\.|[^'\\])*)'/gu)].map(
+      (literal) => literal[1],
+    ),
+  );
+}
+
+/// `matches!(<expr>, 'a' | 'b' | ...)`：只取第二个参数里的字符字面量。
+function matchesMacroChars(source) {
+  return charLiteralsMatching(source, /matches!\([^,]*,\s*[^)]*\)/gu);
+}
+
+/// 抓取 `const NAME: &str = "...";` 的字面量（两侧必须完全一致的那类常量）。
+function rustStringConst(source, name, file) {
+  const match = new RegExp(
+    `const\\s+${name}\\s*:\\s*&str\\s*=\\s*"([^"]*)"\\s*;`,
+  ).exec(source);
+  if (!match) {
+    throw new Error(`${file} 里找不到字符串常量 ${name}`);
+  }
+  return match[1];
+}
+
+/// 抓取某段代码里所有 `b"..."` 字节串字面量的**源码文本**（magic bytes 比对用）。
+function byteStringLiterals(source) {
+  return unique(
+    [...source.matchAll(/b"((?:\\.|[^"\\])*)"/gu)].map((entry) => entry[1]),
+  );
+}
+
+function unique(values) {
+  return [...new Set(values)].sort();
+}
+
+function reportExtras(label, serverTokens, clientTokens) {
+  const known = new Set(serverTokens);
+  const extras = clientTokens.filter((token) => !known.has(token));
+  if (extras.length > 0) {
+    console.log(`  · ${label}：客户端额外项（允许）→ ${extras.join(', ')}`);
+  }
+}
+
+function requireCovered(label, serverTokens, clientTokens, failures) {
+  if (serverTokens.length === 0) {
+    throw new Error(`${label}：服务端 token 抽取为空，比对不可信`);
+  }
+  const client = new Set(clientTokens);
+  for (const token of unique(serverTokens)) {
+    if (!client.has(token)) {
+      failures.push(
+        `${label}：服务端有「${token}」，客户端没有（客户端会漏拦该内容）`,
+      );
+    }
+  }
+}
+
+const failures = [];
+const client = readFile(CLIENT_FILE);
+const server = readFile(SERVER_FILE);
+
+// 1. 规模上限：逐项相等。
+const clientLimits = new Map();
+for (const [serverName, clientName] of LIMIT_PAIRS) {
+  const clientValue = rustConstant(client, clientName, CLIENT_FILE);
+  const serverValue = rustConstant(server, serverName, SERVER_FILE);
+  clientLimits.set(clientName, clientValue);
+  if (clientValue !== serverValue) {
+    failures.push(
+      `规模上限不一致：服务端 ${serverName}=${serverValue}，客户端 ${clientName}=${clientValue}`,
+    );
+  }
+}
+
+// 2. 规则 token：服务端每一条都必须在客户端存在。
+const serverRejectBlock = functionBody(server, 'reject_forbidden_path');
+const serverSensitiveBlock = functionBody(server, 'is_sensitive_file_name');
+
+const serverAnyLevelDirs = unique(
+  stringLiteralsAfter(serverRejectBlock, 'eq_ignore_ascii_case'),
+);
+const serverRootBuildDirs = unique(
+  rustStringArray(server, 'ROOT_BUILD_DIRS', SERVER_FILE),
+);
+const serverRootIdeDirs = unique(
+  rustStringArray(server, 'ROOT_IDE_DIRS', SERVER_FILE),
+);
+const serverPrefixes = unique(
+  stringLiteralsAfter(serverSensitiveBlock, 'starts_with'),
+);
+const serverSuffixes = unique([
+  ...stringLiteralsAfter(serverSensitiveBlock, 'ends_with'),
+  ...stringLiteralsAfter(serverRejectBlock, 'ends_with'),
+]);
+const serverNames = unique(stringLiteralsAfter(serverSensitiveBlock, '=='));
+
+const clientAnyLevelDirs = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_ANY_LEVEL_DIRS', CLIENT_FILE),
+);
+const clientRootBuildDirs = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_ROOT_BUILD_DIRS', CLIENT_FILE),
+);
+const clientRootIdeDirs = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_ROOT_IDE_DIRS', CLIENT_FILE),
+);
+const clientGameBuildDirs = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_GAME_BUILD_DIRS', CLIENT_FILE),
+);
+const clientRootAgcDirs = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_ROOT_AGC_DIRS', CLIENT_FILE),
+);
+const clientPrefixes = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_FILE_PREFIXES', CLIENT_FILE),
+);
+const clientSuffixes = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_FILE_SUFFIXES', CLIENT_FILE),
+);
+const clientNames = unique(
+  rustStringArray(client, 'BUNDLE_EXCLUDED_FILE_NAMES', CLIENT_FILE),
+);
+
+requireCovered(
+  '任意层级目录',
+  serverAnyLevelDirs,
+  clientAnyLevelDirs,
+  failures,
+);
+requireCovered(
+  '项目根首层构建产物目录',
+  serverRootBuildDirs,
+  clientRootBuildDirs,
+  failures,
+);
+requireCovered(
+  '项目根首层 IDE 目录',
+  serverRootIdeDirs,
+  clientRootIdeDirs,
+  failures,
+);
+requireCovered(
+  '文件名前缀（凭据/隐私）',
+  serverPrefixes,
+  clientPrefixes,
+  failures,
+);
+requireCovered(
+  '文件名后缀（凭据/隐私/嵌套压缩包）',
+  serverSuffixes,
+  clientSuffixes,
+  failures,
+);
+requireCovered('文件名全名（凭据）', serverNames, clientNames, failures);
+
+// 客户端的目录 token 合并比对：任何一类里已经排掉即算覆盖。
+const clientAllDirs = unique([
+  ...clientAnyLevelDirs,
+  ...clientRootBuildDirs,
+  ...clientRootIdeDirs,
+  ...clientGameBuildDirs,
+  ...clientRootAgcDirs,
+]);
+
+console.log(
+  `[check:project-bundle-policy-parity] 服务端规则：任意层级目录 ${serverAnyLevelDirs.join('/')}；` +
+    `根级构建 ${serverRootBuildDirs.join('/')}；根级 IDE ${serverRootIdeDirs.join('/')}；` +
+    `前缀 ${serverPrefixes.join('/')}；后缀 ${serverSuffixes.join('/')}；全名 ${serverNames.join('/')}`,
+);
+console.log(
+  `[check:project-bundle-policy-parity] 客户端规则：任意层级目录 ${clientAnyLevelDirs.join('/')}；` +
+    `根级构建 ${clientRootBuildDirs.join('/')}；根级 IDE ${clientRootIdeDirs.join('/')}；` +
+    `game 构建 ${clientGameBuildDirs.join('/')}；AGC 生成目录 ${clientRootAgcDirs.join('/')}；` +
+    `前缀 ${clientPrefixes.join('/')}；后缀 ${clientSuffixes.join('/')}；全名 ${clientNames.join('/')}`,
+);
+reportExtras(
+  '目录',
+  [...serverAnyLevelDirs, ...serverRootBuildDirs, ...serverRootIdeDirs],
+  clientAllDirs,
+);
+reportExtras('文件名前缀', serverPrefixes, clientPrefixes);
+reportExtras('文件名后缀', serverSuffixes, clientSuffixes);
+reportExtras('文件名全名', serverNames, clientNames);
+
+// 3. 路径形状规则：服务端 `normalize_archive_path` 的拒绝形状，必须被客户端打包器的
+//    `BUNDLE_FORBIDDEN_*` 常量逐 token 覆盖。
+//
+// 为什么单独加这一维：过去只比目录名/文件名/数值，于是「客户端能打出、服务端必拒」的路径
+// 形状完全没人管——macOS/Linux 上 `src/a?.ts`、`x.`、`a//b` 这类名字客户端放行、服务端 422，
+// 作者白传一趟。服务端 `normalize_archive_path` 是权威：段命中哨兵（`.` / `..`）、段以空格或
+// 点结尾、段含 `:<>"|?*` 或反斜杠、路径以 `/` 开头，一律拒。
+//
+// 客户端对应的检查在打包器里（`bundle_entry_path_shape_error`），规则以三个常量表达，
+// 因此这里比对的是「服务端的字面量」⊆「客户端的常量」。抽不到一律报错。
+const SERVER_PACKAGE_FILE =
+  'server-rs/crates/module-game-distribution/src/package.rs';
+const serverPackage = readFile(SERVER_PACKAGE_FILE);
+const serverPathBlock = functionBody(serverPackage, 'normalize_archive_path');
+const clientPathBlock = functionBody(client, 'bundle_entry_path_shape_error');
+
+const serverPathSegments = unique(stringLiteralsAfter(serverPathBlock, '=='));
+const serverPathSuffixChars = unique(
+  charLiteralsMatching(serverPathBlock, /\.ends_with\('(?:\\.|[^'\\])*'\)/gu),
+);
+const serverPathForbiddenChars = unique([
+  ...charLiteralsMatching(serverPathBlock, /\.contains\('(?:\\.|[^'\\])*'\)/gu),
+  ...matchesMacroChars(serverPathBlock),
+]);
+
+const clientPathSegments = unique(
+  rustStringArray(client, 'BUNDLE_FORBIDDEN_PATH_SEGMENTS', CLIENT_FILE),
+);
+const clientPathSuffixChars = unique(
+  rustCharArray(client, 'BUNDLE_FORBIDDEN_PATH_SUFFIX_CHARS', CLIENT_FILE),
+);
+const clientPathForbiddenChars = unique(
+  rustCharArray(client, 'BUNDLE_FORBIDDEN_PATH_CHARS', CLIENT_FILE),
+);
+
+requireCovered('路径段哨兵', serverPathSegments, clientPathSegments, failures);
+requireCovered(
+  '路径段结尾字符',
+  serverPathSuffixChars,
+  clientPathSuffixChars,
+  failures,
+);
+requireCovered(
+  '路径段禁止字符',
+  serverPathForbiddenChars,
+  clientPathForbiddenChars,
+  failures,
+);
+
+// 两侧都必须拒「以 / 开头的绝对路径」与「反斜杠」：这两条在服务端是独立分支，
+// 客户端如果只靠常量表覆盖不到（`/` 是分隔符、不能进禁止字符集），所以单独钉一次。
+for (const [label, block] of [
+  ['服务端 normalize_archive_path', serverPathBlock],
+  ['客户端 bundle_entry_path_shape_error', clientPathBlock],
+]) {
+  if (!/starts_with\('\/'\)/u.test(block)) {
+    failures.push(
+      `${label} 必须显式拒绝以 / 开头的绝对路径（starts_with('/')）`,
+    );
+  }
+  if (!/contains\('\\\\'\)/u.test(block)) {
+    failures.push(`${label} 必须显式拒绝反斜杠路径（contains('\\\\')）`);
+  }
+}
+
+console.log(
+  `[check:project-bundle-policy-parity] 路径形状：哨兵 ${serverPathSegments.join('/')}；` +
+    `结尾字符 ${serverPathSuffixChars.join(' ')}；禁止字符 ${serverPathForbiddenChars.join(' ')}`,
+);
+
+// 4. 凭据内容嗅探与嵌套包 magic bytes：这两套规则集也必须两端一致。
+//
+// 为什么单独一维（复核 §12 的最后一处空白）：内容嗅探与 magic 嗅探是「换名字也拦得住」的那一层，
+// 但它们只靠常量表表达；常量表一旦只改一侧，门禁过去完全看不见。这里把六个常量做成
+// **必须逐字相等**的对，并把 `nested_archive_format` 里的 `b"..."` magic 字面量做成
+// 「服务端 ⊆ 客户端」（客户端可以先拦，绝不能漏拦），空集合一律报错。
+const SECRET_EQUAL_PAIRS = [
+  // [服务端常量, 客户端常量, 抓取方式]；抓取方式：array=字符串数组集合相等，int=整数相等，str=字符串相等
+  ['SECRET_CONTENT_TEXT_EXTENSIONS', 'SECRET_CONTENT_TEXT_EXTENSIONS', 'array'],
+  ['SECRET_CONTENT_MAX_SNIFF_BYTES', 'SECRET_CONTENT_MAX_SNIFF_BYTES', 'int'],
+  ['SECRET_CONTENT_SIGNATURES', 'SECRET_CONTENT_SIGNATURES', 'array'],
+  ['SECRET_AWS_ACCESS_KEY_PREFIX', 'SECRET_AWS_ACCESS_KEY_PREFIX', 'str'],
+  ['PEM_PRIVATE_KEY_LINE_PREFIX', 'PEM_PRIVATE_KEY_LINE_PREFIX', 'str'],
+  ['PEM_PRIVATE_KEY_MARKER', 'PEM_PRIVATE_KEY_MARKER', 'str'],
+  ['NESTED_ARCHIVE_SNIFF_BYTES', 'NESTED_ARCHIVE_SNIFF_BYTES', 'int'],
+];
+
+for (const [serverName, clientName, kind] of SECRET_EQUAL_PAIRS) {
+  let serverValue;
+  let clientValue;
+  if (kind === 'array') {
+    serverValue = rustStringArray(server, serverName, SERVER_FILE)
+      .sort()
+      .join('|');
+    clientValue = rustStringArray(client, clientName, CLIENT_FILE)
+      .sort()
+      .join('|');
+  } else if (kind === 'int') {
+    serverValue = rustConstant(server, serverName, SERVER_FILE);
+    clientValue = rustConstant(client, clientName, CLIENT_FILE);
+  } else {
+    serverValue = rustStringConst(server, serverName, SERVER_FILE);
+    clientValue = rustStringConst(client, clientName, CLIENT_FILE);
+  }
+  if (serverValue !== clientValue) {
+    failures.push(
+      `嗅探规则不一致：服务端 ${serverName}=${serverValue}，客户端 ${clientName}=${clientValue}`,
+    );
+  }
+}
+
+const serverMagicBytes = byteStringLiterals(
+  functionBody(server, 'nested_archive_format'),
+);
+const clientMagicBytes = byteStringLiterals(
+  functionBody(client, 'nested_archive_format'),
+);
+requireCovered(
+  '嵌套包 magic bytes',
+  serverMagicBytes,
+  clientMagicBytes,
+  failures,
+);
+if (clientMagicBytes.length === 0) {
+  throw new Error('嵌套包 magic bytes：客户端 token 抽取为空，比对不可信');
+}
+
+console.log(
+  `[check:project-bundle-policy-parity] 嗅探：内容特征 ${rustStringArray(server, 'SECRET_CONTENT_SIGNATURES', SERVER_FILE).join('/')} + ${rustStringConst(server, 'SECRET_AWS_ACCESS_KEY_PREFIX', SERVER_FILE)}… + PEM 标记；` +
+    `magic bytes ${serverMagicBytes.join(' ')}；嗅探窗口 ${rustConstant(server, 'NESTED_ARCHIVE_SNIFF_BYTES', SERVER_FILE)} 字节`,
+);
+
+if (failures.length > 0) {
+  console.error('[check:project-bundle-policy-parity] 不一致：');
+  for (const failure of failures) {
+    console.error(`  - ${failure}`);
+  }
+  process.exit(1);
+}
+console.log(
+  `[check:project-bundle-policy-parity] OK：${LIMIT_PAIRS.length} 项规模上限相等，` +
+    `服务端规则 ${serverAnyLevelDirs.length + serverRootBuildDirs.length + serverRootIdeDirs.length + serverPrefixes.length + serverSuffixes.length + serverNames.length} 条全部在客户端覆盖。`,
+);
diff --git a/scripts/dev-all.mjs b/scripts/dev-all.mjs
index 448b33cc9..851c28988 100644
--- a/scripts/dev-all.mjs
+++ b/scripts/dev-all.mjs
@@ -15,6 +15,13 @@ const agcDataDir = resolve(
 );
 const agcDataDirArgument = 'server-rs/.spacetimedb/ai-game-creator/data';
 const devStackStatePath = resolve(repoRoot, '.app/dev-stack.json');
+// AGC 配套本地库的 schema 冲突识别：SpacetimeDB 拒绝自动迁移时会在服务端日志里留下这两类特征串
+// （`… needs manual migration` / `Reordering table <name> requires a manual migration`）。
+const localSchemaConflictPattern = /manual migration|Reordering table/i;
+// 唯一允许「冲突即清库」的显式开关：dev:all 默认写死 --preserve-database（不删库），
+// 只有调用方显式传 --clear-database（dev.mjs 既有语义：preserve=false → -c=on-conflict）才清库。
+const clearDatabaseOption = '--clear-database';
+const spacetimeStartLogName = 'logs/dev-spacetime-start.log';
 const rootReadyTimeoutMs = 660_000;
 const rootReadyPollMs = 500;
 const childGracefulTimeoutMs = 2_500;
@@ -75,8 +82,47 @@ function validateDevAllArgs(argv = []) {
   }
 }
 
+/// 判定根栈失败是否由「本地库 schema 与源码不一致」造成（纯函数，供单测钉住）。
+export function isLocalSchemaConflictOutput(output = '') {
+  return localSchemaConflictPattern.test(String(output ?? ''));
+}
+
+/// 读 SpacetimeDB 启动日志尾部（失败诊断用）：文件不存在或读取失败都返回空串，绝不抛。
+function readSpacetimeStartLogTail(dataDir = agcDataDir, maxBytes = 64 * 1024) {
+  const logPath = resolve(dataDir, spacetimeStartLogName);
+  if (!existsSync(logPath)) {
+    return '';
+  }
+  try {
+    const text = readFileSync(logPath, 'utf8');
+    return text.length > maxBytes ? text.slice(-maxBytes) : text;
+  } catch {
+    return '';
+  }
+}
+
+/// 生成可操作提示（纯函数）：库名与 data dir 打实际值，给出两条出路，并明确清库会丢本地数据。
+export function buildLocalSchemaConflictHint({
+  database = agcDatabase,
+  dataDir = agcDataDirArgument,
+} = {}) {
+  return [
+    '[dev:all] 本地 SpacetimeDB schema 与源码不一致：本次 publish 需要手动迁移而被拒（不是代码问题）。',
+    `  目标库：${database}`,
+    `  数据目录：${dataDir}`,
+    '  两条出路：',
+    `    ① 清库重建后重跑：npm run dev:all -- ${clearDatabaseOption}`,
+    `    ② 只想先起根栈自愈：npm run dev -- --database ${database} --spacetime-data-dir ${dataDir}（不带 --preserve-database）`,
+    '  ⚠ ① 与 ② 都会丢弃该本地库里的数据（仅本地开发数据，生产库不受影响）。',
+    '  ⚠ 默认不加开关时 dev:all 会保留该库，冲突不会自愈——这是有意为之，避免误清库。',
+  ].join('\n');
+}
+
 function buildRootDevArgs(argv = []) {
   validateDevAllArgs(argv);
+  // 默认继续写死 --preserve-database（不改默认，避免误清库）；
+  // 只有调用方显式传 --clear-database 时才交给根栈按 dev.mjs 既有语义（preserve=false → -c=on-conflict）清库。
+  const wantsClearDatabase = argv.includes(clearDatabaseOption);
   return [
     'run',
     'dev',
@@ -85,7 +131,7 @@ function buildRootDevArgs(argv = []) {
     agcDatabase,
     '--spacetime-data-dir',
     agcDataDirArgument,
-    '--preserve-database',
+    ...(wantsClearDatabase ? [] : ['--preserve-database']),
     '--no-interactive',
     ...argv,
   ];
@@ -538,14 +584,24 @@ async function runDevAll(argv = process.argv.slice(2), dependencies = {}) {
     );
     rootChild = spawnProcess(npmCommand, rootArgs, env);
     const rootExit = waitForChildExit(rootChild);
-    const rootState = await waitForRoot(rootChild, {
-      readState,
-      expected: {
-        expectedRepoRoot: repoRoot,
-        expectedDatabase: agcDatabase,
-        expectedDataDir: agcDataDir,
-      },
-    });
+    let rootState;
+    try {
+      rootState = await waitForRoot(rootChild, {
+        readState,
+        expected: {
+          expectedRepoRoot: repoRoot,
+          expectedDatabase: agcDatabase,
+          expectedDataDir: agcDataDir,
+        },
+      });
+    } catch (error) {
+      // 根栈失败原因常常只在 SpacetimeDB 启动日志里（子进程 stdio 是 inherit，dev:all 抓不到它的 stdout）：
+      // 命中「本地库 schema 需手动迁移」时补一段可操作提示，否则原样抛出。
+      if (isLocalSchemaConflictOutput(readSpacetimeStartLogTail())) {
+        console.error(buildLocalSchemaConflictHint());
+      }
+      throw error;
+    }
     if (rootChild.exitCode !== null || rootChild.signalCode !== null) {
       throw new Error('根开发栈已退出，不能启动 AGC');
     }
diff --git a/scripts/dev-all.test.ts b/scripts/dev-all.test.ts
index be5f2c37e..ebe5e6804 100644
--- a/scripts/dev-all.test.ts
+++ b/scripts/dev-all.test.ts
@@ -10,10 +10,12 @@ import {
   agcDataDir,
   buildDevAllBaseEnvironment,
   buildDevAllEnvironment,
+  buildLocalSchemaConflictHint,
   buildManagedSpawnOptions,
   buildRootDevArgs,
   buildStartupSummary,
   isHttpReady,
+  isLocalSchemaConflictOutput,
   isSharedRootStackReady,
   renderStartupTable,
   runDevAll,
@@ -249,4 +251,58 @@ describe('dev:all 参数和共享开发栈合同', () => {
     expect(children).toHaveLength(2);
     expect(stopCalls).toEqual([children[1], children[0]]);
   });
+
+  test('默认仍固定保留 AGC 本地库（不改变默认行为）', () => {
+    const args = buildRootDevArgs(['--watch']);
+    expect(args).toContain('--preserve-database');
+    expect(args).not.toContain('--clear-database');
+  });
+
+  test('显式 --clear-database 时不再固定 --preserve-database，开关逐字透传给根栈', () => {
+    const args = buildRootDevArgs(['--clear-database']);
+    expect(args).not.toContain('--preserve-database');
+    expect(
+      args.filter((argument) => argument === '--clear-database'),
+    ).toHaveLength(1);
+    expect(args).toEqual([
+      'run',
+      'dev',
+      '--',
+      '--database',
+      agcDatabase,
+      '--spacetime-data-dir',
+      'server-rs/.spacetimedb/ai-game-creator/data',
+      '--no-interactive',
+      '--clear-database',
+    ]);
+  });
+
+  test('识别本地库 schema 冲突的服务端输出', () => {
+    expect(isLocalSchemaConflictOutput('… needs manual migration')).toBe(true);
+    expect(
+      isLocalSchemaConflictOutput(
+        'Reordering table game_distribution_game requires a manual migration',
+      ),
+    ).toBe(true);
+    expect(
+      isLocalSchemaConflictOutput(
+        'Aborting publish due to required manual migration.',
+      ),
+    ).toBe(true);
+    expect(
+      isLocalSchemaConflictOutput('Finished `dev` profile [unoptimized]'),
+    ).toBe(false);
+    expect(isLocalSchemaConflictOutput(undefined)).toBe(false);
+  });
+
+  test('本地库 schema 冲突提示含库名/data dir/两条出路/丢数据警告', () => {
+    const hint = buildLocalSchemaConflictHint();
+    expect(hint).toContain(agcDatabase);
+    expect(hint).toContain('server-rs/.spacetimedb/ai-game-creator/data');
+    expect(hint).toContain('npm run dev:all -- --clear-database');
+    expect(hint).toContain('不带 --preserve-database');
+    expect(hint).toContain('都会丢弃该本地库里的数据');
+    expect(hint).toContain('不是代码问题');
+    expect(hint).not.toContain('undefined');
+  });
 });
diff --git a/scripts/dev.mjs b/scripts/dev.mjs
index aae03d3b2..042052ed4 100644
--- a/scripts/dev.mjs
+++ b/scripts/dev.mjs
@@ -435,6 +435,15 @@ function normalizeServiceName(rawName) {
 }
 
 function resolveDevStackStatePath(root = repoRoot) {
+  // 状态文件默认写在仓库根的 `.app/dev-stack.json`。允许用环境变量把**这一份**栈的状态文件
+  // 指到别处（隔离 e2e 栈用）：否则隔离栈会覆盖用户正在用的标记，让用户的 dev 栈误以为自己
+  // 被替换而自行退出（2026-10-07 实测踩到）。
+  const override = String(
+    process.env.GENARRATIVE_DEV_STACK_STATE_PATH ?? '',
+  ).trim();
+  if (override) {
+    return resolve(override);
+  }
   return join(root, '.app/dev-stack.json');
 }
 
@@ -1234,6 +1243,10 @@ function stopWindowsWorktreeBackendProcesses({
   if (process.platform !== 'win32') {
     return [];
   }
+  if (isIsolatedDevStackRun()) {
+    // 同上：隔离栈不做按 exe 路径的本工作树清扫，避免误杀用户栈（两者共用同一个二进制路径）。
+    return [];
+  }
 
   const stopped = stopWindowsWorktreeProcesses({
     apiServerExePath: resolveWindowsApiServerExePath(),
@@ -2564,10 +2577,22 @@ class DevRunner {
   }
 }
 
+function isIsolatedDevStackRun() {
+  // 隔离栈（e2e 用）：状态文件被指到临时目录。它的清扫动作不能碰**用户正在跑的那套栈**——
+  // 用户栈与本栈跑的是同一个 `server-rs/target/debug/api-server.exe`，按 exe 路径扫会误杀。
+  return Boolean(
+    String(process.env.GENARRATIVE_DEV_STACK_STATE_PATH ?? '').trim(),
+  );
+}
+
 function stopExistingWindowsApiServer(logStream) {
   if (process.platform !== 'win32') {
     return;
   }
+  if (isIsolatedDevStackRun()) {
+    // 隔离栈不做「按 exe 路径清旧 api-server」的兜底：它没有权限判断哪些进程属于自己。
+    return;
+  }
 
   const apiServerExePath = resolveWindowsApiServerExePath();
   const snapshot = readWindowsProcessSnapshot();
diff --git a/server-rs/crates/api-server/src/modules/game_distribution.rs b/server-rs/crates/api-server/src/modules/game_distribution.rs
index 781614d87..a0526aa52 100644
--- a/server-rs/crates/api-server/src/modules/game_distribution.rs
+++ b/server-rs/crates/api-server/src/modules/game_distribution.rs
@@ -2,7 +2,7 @@ use std::{
     collections::{BTreeMap, HashMap, VecDeque},
     future::Future,
     io::Write,
-    sync::{Arc, Mutex, OnceLock},
+    sync::{LazyLock, Mutex},
     time::{Instant, SystemTime, UNIX_EPOCH},
 };
 
@@ -20,11 +20,16 @@ use axum::{
 };
 use flate2::{Compression as GzipCompression, write::GzEncoder};
 use module_game_distribution::{
-    MAX_GAME_PRICE_MUD_POINTS, MAX_PACKAGE_BYTES, ReleaseAssetError, ReleasePackageError,
-    ReleasePackageManifest, compute_request_digest, extract_release_asset,
-    normalize_game_price_mud_points, normalize_review_comment, normalize_review_moderation_reason,
-    release_asset_content_type, resolve_version_number, validate_release_zip,
-    validate_review_list_status,
+    GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT, GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_MAX,
+    GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_DEFAULT, GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_MAX,
+    GAME_DISTRIBUTION_THEME_PAGE_LIMIT_DEFAULT, GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX,
+    MAX_GAME_PRICE_MUD_POINTS, MAX_PACKAGE_BYTES, MAX_PROJECT_BUNDLE_BYTES, ProjectBundleError,
+    ProjectBundleManifest, ReleaseAssetError, ReleasePackageError, ReleasePackageManifest,
+    compute_request_digest, extract_release_asset, game_distribution_catalog_page_limit,
+    game_distribution_collection_page_limit, game_distribution_theme_admin_status_filter_valid,
+    game_distribution_theme_page_limit, normalize_game_price_mud_points, normalize_review_comment,
+    normalize_review_moderation_reason, release_asset_content_type, resolve_version_number,
+    validate_project_bundle_zip, validate_release_zip, validate_review_list_status,
 };
 use platform_auth::read_refresh_session_token;
 use platform_oss::{
@@ -41,30 +46,54 @@ use shared_contracts::admin::{
     AdminGameReviewsResponse,
 };
 use shared_contracts::game_distribution::{
-    GAME_DISTRIBUTION_CATEGORIES, GameDistributionAuthor, GameDistributionInputMode,
-    GameDistributionMyReviewResponse, GameDistributionOrientation,
-    GameDistributionPlaySessionResponse, GameDistributionPurchase, GameDistributionPurchaseRequest,
-    GameDistributionPurchaseResponse, GameDistributionRatingSummary, GameDistributionReview,
-    GameDistributionReviewsResponse, GameDistributionSaveReviewRequest,
-    GameDistributionSaveReviewResponse, GameDistributionUpdateGameMetadataRequest, GameMetadata,
+    GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR, GAME_DISTRIBUTION_CATEGORIES,
+    GAME_DISTRIBUTION_THEME_BAD_REQUEST, GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT,
+    GAME_DISTRIBUTION_THEME_INVALID_CURSOR, GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND,
+    GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT, GAME_DISTRIBUTION_THEME_NOT_FOUND,
+    GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT, GameDistributionAuthor,
+    GameDistributionCollectionState, GameDistributionContributionChild,
+    GameDistributionContributionGeneration, GameDistributionContributionResponse,
+    GameDistributionContributionTotals, GameDistributionCreateGameRequest,
+    GameDistributionCreateThemeRequest, GameDistributionCreateVersionRequest,
+    GameDistributionDerivedResponse, GameDistributionForkAuthorization, GameDistributionForkSource,
+    GameDistributionForkSourceKind, GameDistributionForkSourceResponse, GameDistributionInputMode,
+    GameDistributionLineageNode, GameDistributionLineageResponse, GameDistributionMyReviewResponse,
+    GameDistributionOrientation, GameDistributionPlaySessionResponse, GameDistributionPurchase,
+    GameDistributionPurchaseRequest, GameDistributionPurchaseResponse,
+    GameDistributionRatingSummary, GameDistributionReview, GameDistributionReviewsResponse,
+    GameDistributionSaveReviewRequest, GameDistributionSaveReviewResponse,
+    GameDistributionSetForkAuthorizationRequest, GameDistributionThemeStatus,
+    GameDistributionUpdateGameMetadataRequest, GameDistributionUpdateThemeRequest,
+    GameDistributionUpsertThemeMemberRequest, GameDistributionVisibility, GameMetadata,
 };
 use shared_contracts::game_distribution_publish::NewGameVersionRequest;
 use spacetime_client::{
     GameDistributionAdminGameListRecordInput, GameDistributionAdminGameRecord,
+    GameDistributionAdminThemeListRecordInput, GameDistributionAdminThemeMemberListRecordInput,
+    GameDistributionAdminThemeMemberRecord, GameDistributionAdminThemeMemberRowRecord,
+    GameDistributionAdminThemeMutationRecord, GameDistributionAdminThemeRecord,
     GameDistributionAdminUserReviewListRecordInput, GameDistributionAdminUserReviewRecord,
     GameDistributionAdminVersionRecord, GameDistributionApproveRecordInput,
-    GameDistributionCancelVersionRecordInput, GameDistributionDeleteGameRecordInput,
+    GameDistributionCancelVersionRecordInput, GameDistributionCollectGameRecordInput,
+    GameDistributionCreateThemeRecordInput, GameDistributionDeleteGameRecordInput,
+    GameDistributionDerivedGamesRecord, GameDistributionForkSourceRecord,
     GameDistributionGameRecord, GameDistributionGetGameRecordInput,
+    GameDistributionLineageNodeRecord, GameDistributionLineageTreeRecord,
     GameDistributionOwnerGameRecord, GameDistributionPublicGameListRecordInput,
     GameDistributionPublicGameRecord, GameDistributionPurchaseRecordInput,
     GameDistributionRatingSummaryRecord, GameDistributionRejectRecordInput,
     GameDistributionRestoreRecordInput, GameDistributionReviewGameListRecordInput,
     GameDistributionReviewModerationOperationRecord, GameDistributionReviewModerationRecordInput,
-    GameDistributionSubmitReviewRecordInput, GameDistributionSuspendRecordInput,
-    GameDistributionUnpublishRecordInput, GameDistributionUpdateMetadataRecordInput,
+    GameDistributionSetForkAuthorizationRecordInput, GameDistributionSubmitReviewRecordInput,
+    GameDistributionSuspendRecordInput, GameDistributionThemeDetailRecord,
+    GameDistributionThemeMemberRemoveRecordInput, GameDistributionThemeMemberUpsertRecordInput,
+    GameDistributionThemeReferenceRecord, GameDistributionThemeSummaryRecord,
+    GameDistributionUncollectGameRecordInput, GameDistributionUnpublishRecordInput,
+    GameDistributionUpdateMetadataRecordInput, GameDistributionUpdateThemeRecordInput,
     GameDistributionUserReviewRecord, GameDistributionVersionRecord, SpacetimeClientError,
 };
 use tracing::{debug, info, warn};
+use uuid::Uuid;
 
 use crate::{
     admin::{AuthenticatedAdmin, require_admin_auth, try_authenticate_admin_from_headers},
@@ -95,11 +124,18 @@ pub(crate) const MAX_PUBLISH_MULTIPART_BYTES: usize =
 pub(crate) const PACKAGE_UPLOAD_CHUNK_BYTES: usize = 8 * 1024 * 1024;
 /// 分片路由的请求体放行量：分片大小 + 1 KiB 头部余量。
 pub(crate) const MAX_PACKAGE_CHUNK_REQUEST_BODY_BYTES: usize = PACKAGE_UPLOAD_CHUNK_BYTES + 1024;
+/// 工程源包整包 PUT 的请求体放行量：上限与发行包同值（两者共用同一条上传链路，反代与
+/// Pingora 的放行量就是按 200 MiB 校准的），只多留 1 KiB 头部余量。
+pub(crate) const MAX_PROJECT_BUNDLE_REQUEST_BODY_BYTES: usize =
+    MAX_PROJECT_BUNDLE_BYTES as usize + 1024;
 /// 分片偏移由客户端显式声明，服务端以对象当前长度为唯一权威。
 const PACKAGE_UPLOAD_OFFSET_HEADER: &str = "x-genarrative-upload-offset";
 const MAX_LIST_LIMIT: u32 = 48;
 /// 后台游戏管理页全量列表上限，与 spacetime-module 的 admin game list limit 保持同口径。
 const MAX_ADMIN_GAME_LIST_LIMIT: u32 = 200;
+/// 后台共创主题列表上限，与 spacetime-module 的 admin theme list limit 保持同口径
+/// （事务侧还会再截断一次；这里只是为了日志里的 `limit` 就是真正生效的条数）。
+const MAX_ADMIN_THEME_LIST_LIMIT: u32 = 200;
 /// 后台作品状态过滤的白名单；`deleted` 表示已软删除的作品。
 const ADMIN_GAME_LIST_STATUSES: [&str; 4] = ["published", "unpublished", "suspended", "deleted"];
 const MAX_IDEMPOTENCY_KEY_CHARS: usize = 128;
@@ -126,21 +162,24 @@ const RELEASE_STORAGE_BOOTSTRAP: &str = concat!(
 ///
 /// 单个资源取自整个 ZIP，若每个请求都重新下载整包会拖垮发行网关；缓存只保存已通过
 /// 校验的私有包字节，键是对象键，超出条目或字节预算时按插入顺序淘汰。
-static RELEASE_PACKAGE_CACHE: OnceLock<Mutex<ReleasePackageCache>> = OnceLock::new();
+/// 值用 `Bytes` 而不是 `Vec<u8>`：整包下发（M2a 取件通道）要直接把缓存里的字节交给响应体，
+/// `Bytes::clone` 只加引用计数，不会为了一个 200 MiB 的包再复制一份。
+static RELEASE_PACKAGE_CACHE: LazyLock<Mutex<ReleasePackageCache>> =
+    LazyLock::new(|| Mutex::new(ReleasePackageCache::default()));
 
 #[derive(Default)]
 struct ReleasePackageCache {
-    packages: HashMap<String, Arc<Vec<u8>>>,
+    packages: HashMap<String, Bytes>,
     order: VecDeque<String>,
     total_bytes: usize,
 }
 
 impl ReleasePackageCache {
-    fn get(&self, object_key: &str) -> Option<Arc<Vec<u8>>> {
+    fn get(&self, object_key: &str) -> Option<Bytes> {
         self.packages.get(object_key).cloned()
     }
 
-    fn insert(&mut self, object_key: String, bytes: Arc<Vec<u8>>) {
+    fn insert(&mut self, object_key: String, bytes: Bytes) {
         self.insert_with_limits(
             object_key,
             bytes,
@@ -152,7 +191,7 @@ impl ReleasePackageCache {
     fn insert_with_limits(
         &mut self,
         object_key: String,
-        bytes: Arc<Vec<u8>>,
+        bytes: Bytes,
         max_entries: usize,
         max_bytes: usize,
     ) {
@@ -179,6 +218,11 @@ impl ReleasePackageCache {
     }
 }
 
+/// 公开游戏目录的查询串：关键词 / 分类 / 作者 / `forkable` 过滤 + `limit` + `cursor`。
+///
+/// 分页口径独立于 `/my-collections`（20 / 50）与主题列表（20 / 50）：目录是广场首屏，缺省保持
+/// 既有的 **48**、上限 **100**（都是模块侧常量，这里不抄第二份数字）。`cursor` 只透传字符串——
+/// 解析在事务里（模块侧纯函数），handler 自己解析会让「HTTP 挡住的」与「落库挡住的」长出两套判据。
 #[derive(Debug, Deserialize)]
 struct GameListQuery {
     #[serde(alias = "keyword")]
@@ -186,6 +230,15 @@ struct GameListQuery {
     category: Option<String>,
     #[serde(rename = "authorId")]
     author_id: Option<String>,
+    limit: Option<u32>,
+    cursor: Option<String>,
+    /// `forkable` = 只返回可被共创的作品（AGC「共创」页用）。
+    ///
+    /// 这里刻意收成 `Option<String>` 而不是 `Option<bool>`：serde 的 `bool` 解析会把
+    /// `forkable=abc` 变成 axum 的 400 纯文本（连平台信封都没有），而本参数的既定口径是
+    /// **宽容降级**（非法取值按「不过滤」处理，见 `parse_forkable_flag`）。用字符串接收、
+    /// 再用一个可单测的纯函数解释，才能让「拼错一个可选参数」回到现状而不是让整个公开目录 400。
+    forkable: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -255,6 +308,49 @@ struct AdminGameListQuery {
     cursor: Option<String>,
 }
 
+/// 「我的收藏（收录）」列表的查询串：`limit` + `cursor`。
+///
+/// 分页口径与后台列表**同构但数值不同**：默认 20（网格一屏）、上限 50（约束单响应体积）。
+/// 两处口径不必相等——后台是运营表格视图，需要一次扫读更多行；用户态网格按屏取数。
+/// 数值本身只在 `module_game_distribution` 里定义一次，这里引用常量而不是再抄一遍。
+#[derive(Debug, Deserialize)]
+struct MyCollectionsQuery {
+    limit: Option<u32>,
+    cursor: Option<String>,
+}
+
+/// 公开共创主题列表的查询串：`limit` + `cursor`。
+///
+/// 与 `/my-collections` 同一套数值与处理方式（默认 20 / 上限 50 / 超界截断 / 非法游标 400）——
+/// 两条都是公开网格列表，没有理由用两套分页口径。数值只在 `module_game_distribution` 定义一次。
+#[derive(Debug, Deserialize)]
+struct ThemeListQuery {
+    limit: Option<u32>,
+    cursor: Option<String>,
+}
+
+/// 后台共创主题列表的查询串：`limit` + `status`，**没有游标**。
+///
+/// 与后台作品列表同口径的 `limit`（缺省与上限 200、超界截断）；`status` 白名单是
+/// `all` / `draft` / `published` / `archived`（缺省 = 全量），校验走模块侧那个纯函数，
+/// 不在 handler 里再抄一份白名单。
+#[derive(Debug, Deserialize)]
+struct AdminThemeListQuery {
+    limit: Option<u32>,
+    status: Option<String>,
+}
+
+/// 后台主题**成员名单**的查询串：`limit` + `cursor`。
+///
+/// 与其它游标列表同一套数值与处理方式（缺省 20 / 上限 50 / `0` 取默认 / 超界截断 / 非法游标 400）——
+/// 后台名单同样是一页页翻的表格，没有理由用第二套分页口径。游标解析在事务里（模块侧纯函数），
+/// 这里只透传字符串：handler 自己解析会让「HTTP 挡住的」与「落库挡住的」长出两套判据。
+#[derive(Debug, Deserialize)]
+struct AdminThemeMemberListQuery {
+    limit: Option<u32>,
+    cursor: Option<String>,
+}
+
 /// 作者软删除游戏：CAS 修订号走查询串，删除本身没有请求体。
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -483,12 +579,74 @@ pub fn router(state: AppState) -> Router<AppState> {
             get(list_user_reviews),
         )
         .route_layer(middleware::from_fn(add_no_store_response_headers));
+    // Fork 取件通道（M2a/M2b）：要求 Bearer 登录，但**不叠加发布灰度**——灰度只针对「发布」，
+    // 任何登录用户都应该能改编已授权的作品。三个 handler 共用同一条校验，规则只写一遍；
+    // `/project` 失败关闭：只有选定资产确为工程源包时才服务，绝不悄悄回落成品包。
+    let fork_sources = Router::new()
+        .route(
+            "/api/game-distribution/games/{game_id}/fork-source",
+            get(get_fork_source),
+        )
+        .route(
+            "/api/game-distribution/games/{game_id}/fork-source/package",
+            get(get_fork_source_package),
+        )
+        .route(
+            "/api/game-distribution/games/{game_id}/fork-source/project",
+            get(get_fork_source_project),
+        )
+        .route_layer(middleware::from_fn_with_state(
+            state.clone(),
+            require_bearer_auth,
+        ))
+        .route_layer(middleware::from_fn(add_no_store_response_headers));
+    // 贡献归集（作者视角只读）：要求 Bearer（未登录 / 失效 → 401），但**不叠加发布灰度**
+    // ——它不是发布动作，只是作者查看自己血缘子树的账目。响应是 per-author 的商业敏感数据，
+    // 整组 `no-store`；归属判定在事务里（非作者 → 403 / 不存在 → 404，见 handler 注释）。
+    let contribution = Router::new()
+        .route(
+            "/api/game-distribution/games/{game_id}/contribution",
+            get(get_game_contribution),
+        )
+        .route_layer(middleware::from_fn_with_state(
+            state.clone(),
+            require_bearer_auth,
+        ))
+        .route_layer(middleware::from_fn(add_no_store_response_headers));
+    // 收藏（收录）：登录用户的真实用户态投影，绝不虚构收藏状态。
+    // - PUT 需要 `Idempotency-Key`（重放与「重复收藏」要靠收据区分）；
+    // - DELETE 按确定性主键 `{userId}:{gameId}` 删除，天然幂等，所以**不要求**幂等键；
+    // - 读路径是 per-user 数据，整组 `no-store`，不给任何共享缓存留缝。
+    let collections = Router::new()
+        .route(
+            "/api/game-distribution/games/{game_id}/collection",
+            put(collect_game).delete(uncollect_game),
+        )
+        .route(
+            "/api/game-distribution/my-collections",
+            get(list_my_collections),
+        )
+        .route_layer(middleware::from_fn_with_state(
+            state.clone(),
+            require_bearer_auth,
+        ))
+        .route_layer(middleware::from_fn(add_no_store_response_headers));
     let protected = Router::new()
         .route(
             "/api/game-distribution/versions",
             post(super::game_distribution_publish::publish_version)
                 .layer(DefaultBodyLimit::max(MAX_PUBLISH_MULTIPART_BYTES)),
         )
+        // 旧两步发布路径（创建作品 / 追加版本）与统一发布路径并存：旧路径服务共创血缘写入
+        // 与既有调用方，统一路径是新增入口；两条路径最终都落到同一套 SpacetimeDB 事务。
+        .route(
+            "/api/game-distribution/games",
+            post(create_game).layer(DefaultBodyLimit::max(MAX_PUBLISH_MULTIPART_BYTES)),
+        )
+        .route(
+            "/api/game-distribution/games/{game_id}/versions",
+            post(create_version).layer(DefaultBodyLimit::max(MAX_PUBLISH_MULTIPART_BYTES)),
+        )
         .route(
             "/api/game-distribution/versions/{version_id}/package",
             put(upload_package).layer(DefaultBodyLimit::max(MAX_PACKAGE_REQUEST_BODY_BYTES)),
@@ -510,6 +668,31 @@ pub fn router(state: AppState) -> Router<AppState> {
             "/api/game-distribution/versions/{version_id}/package/reset",
             post(reset_package_upload),
         )
+        // 工程源包上行族（M2b）：与发行包族逐条对齐，只是资产换成作者的工程源包。
+        // 载体类型一律 `application/octet-stream`（见技术方案 §3.4），分片边界与偏移头
+        // 直接复用发行包那一套——两者上限同值，客户端只能有一套偏移语义。
+        .route(
+            "/api/game-distribution/versions/{version_id}/project-bundle",
+            put(upload_project_bundle)
+                .layer(DefaultBodyLimit::max(MAX_PROJECT_BUNDLE_REQUEST_BODY_BYTES)),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}/project-bundle/upload-state",
+            get(project_bundle_upload_state),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}/project-bundle/chunk",
+            put(upload_project_bundle_chunk)
+                .layer(DefaultBodyLimit::max(MAX_PACKAGE_CHUNK_REQUEST_BODY_BYTES)),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}/project-bundle/complete",
+            post(complete_project_bundle_upload),
+        )
+        .route(
+            "/api/game-distribution/versions/{version_id}/project-bundle/reset",
+            post(reset_project_bundle_upload),
+        )
         .route(
             "/api/game-distribution/versions/{version_id}/submit",
             post(submit_version),
@@ -534,6 +717,10 @@ pub fn router(state: AppState) -> Router<AppState> {
             "/api/game-distribution/games/{game_id}/unpublish",
             post(unpublish_game),
         )
+        .route(
+            "/api/game-distribution/games/{game_id}/fork-authorization",
+            put(set_fork_authorization),
+        )
         .route(
             "/api/game-distribution/games/{game_id}/purchase",
             post(purchase_game),
@@ -569,6 +756,30 @@ pub fn router(state: AppState) -> Router<AppState> {
             "/admin/api/game-distribution/games/{game_id}/restore",
             post(admin_restore_game),
         )
+        // 共创主题后台族：与同组其它后台路由共用同一条 `require_admin_auth`（handler 取
+        // `Extension<AuthenticatedAdmin>`），不自造第二套鉴权。
+        // - 创建 / 更新要求 `Idempotency-Key`（同键重放 `replayed: true`，同键不同请求 409）；
+        // - 成员 PUT 靠确定性主键幂等、DELETE 靠「不存在也算成功」，两条都不需要幂等键；
+        // - 列表含 `draft` / `archived`，无游标（主题是运营维护的小集合）。
+        .route(
+            "/admin/api/game-distribution/themes",
+            get(admin_list_themes).post(admin_create_theme),
+        )
+        .route(
+            "/admin/api/game-distribution/themes/{theme_id}",
+            put(admin_update_theme),
+        )
+        // 成员**读**接口：与成员写接口同一前缀、同一条 `require_admin_auth`。
+        // 它返回**全部成员行**（含当前对外不可见的）且 `draft` / `archived` 主题照常可读——
+        // 后台运营要在发布前核对名单，而公开投影只服务已发布主题（原缺口正是这里）。
+        .route(
+            "/admin/api/game-distribution/themes/{theme_id}/members",
+            get(admin_list_theme_members),
+        )
+        .route(
+            "/admin/api/game-distribution/themes/{theme_id}/members/{root_game_id}",
+            put(admin_upsert_theme_member).delete(admin_remove_theme_member),
+        )
         .route_layer(middleware::from_fn_with_state(
             state.clone(),
             require_admin_auth,
@@ -577,10 +788,28 @@ pub fn router(state: AppState) -> Router<AppState> {
     let public_games = Router::new()
         .route("/api/game-distribution/games", get(list_games))
         .route("/api/game-distribution/games/{game_id}", get(get_game))
+        .route(
+            "/api/game-distribution/games/{game_id}/lineage",
+            get(get_game_lineage),
+        )
+        .route(
+            "/api/game-distribution/games/{game_id}/derived",
+            get(get_game_derived_games),
+        )
         .route(
             "/api/game-distribution/games/{game_id}/plays",
             post(record_game_play),
         )
+        // 共创主题（公开族）：与公开目录同一支，匿名可读、整组 `no-store`。
+        // - 列表沿用 `/my-collections` 的游标惯例（默认 20 / 上限 50 / 非法游标 400）；
+        // - 详情顶层扁平，主题不存在 / 未发布 404，**不**返回空壳；
+        // - 作品详情的 `themes` 增量挂在既有 `GET /games/{game_id}` 上（见 `get_game`），
+        //   不新增第四个公开路由。
+        .route("/api/game-distribution/themes", get(list_public_themes))
+        .route(
+            "/api/game-distribution/themes/{theme_id}",
+            get(get_public_theme),
+        )
         .route(
             "/api/game-distribution/media/read-url",
             get(read_game_distribution_media_url),
@@ -662,6 +891,9 @@ pub fn router(state: AppState) -> Router<AppState> {
         .merge(protected)
         .merge(play_sessions)
         .merge(user_reviews)
+        .merge(fork_sources)
+        .merge(contribution)
+        .merge(collections)
         .merge(admin_user_reviews)
         .merge(admin)
 }
@@ -1077,7 +1309,10 @@ where
     G: FnOnce(String) -> GFut,
     GFut: Future<Output = Result<Option<GameDistributionPublicGameRecord>, SpacetimeClientError>>,
     P: FnOnce(String, String) -> PFut,
-    PFut: Future<Output = Result<Arc<Vec<u8>>, AppError>>,
+    // 包字节用 `Bytes` 而不是 `Arc<Vec<u8>>`（本分支的零拷贝设计，见 `release_package_bytes`
+    // 的缓存注释）：整包下发最多 200 MiB，`Bytes::clone` 只加引用计数，不再复制一份。
+    // 合并 master 时这里曾被并成 `Arc<Vec<u8>>`，与调用方（返回 `Bytes`）不符而编译失败。
+    PFut: Future<Output = Result<Bytes, AppError>>,
 {
     // 发行文件必须由独立来源提供。带上平台 Cookie 的请求说明它正落在主站来源上，
     // 此时同源脚本可以读到平台会话，必须直接关闭而不是降级服务。
@@ -1333,15 +1568,18 @@ fn inject_release_storage_bootstrap(content: Vec<u8>, content_type: &str) -> Vec
     result
 }
 
-/// 读取（并按对象键缓存）已确认的私有发行包。
-async fn release_package_bytes(
+/// 读取（并按**对象键**缓存）已确认的私有资产。
+///
+/// 缓存键就是对象键，因此资产种类天然分开：同一 (作品, 版本) 的成品包与工程源包落在不同
+/// 对象键上，各自取回自己那份字节，不会串味。上限由调用方给（发行包 200 MiB、工程源包
+/// 同为 200 MiB），`max_bytes` 是 OSS 读路径的硬闸门。
+async fn release_asset_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)) {
+    object_key: &str,
+    max_bytes: u64,
+) -> Result<Bytes, AppError> {
+    let cache = &*RELEASE_PACKAGE_CACHE;
+    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(|| {
@@ -1351,8 +1589,8 @@ async fn release_package_bytes(
         .get_object(
             state.editor_oss_http_client(),
             OssGetObjectRequest {
-                object_key: object_key.clone(),
-                max_bytes: MAX_PACKAGE_BYTES as usize,
+                object_key: object_key.to_string(),
+                max_bytes: max_bytes as usize,
             },
         )
         .await
@@ -1363,13 +1601,24 @@ async fn release_package_bytes(
                 map_oss_error(error, "aliyun-oss")
             }
         })?;
-    let bytes = Arc::new(bytes);
+    // `Bytes::from(Vec<u8>)` 直接接管所有权，不再复制整包；之后每次命中缓存只加引用计数。
+    let bytes = Bytes::from(bytes);
     if let Ok(mut guard) = cache.lock() {
-        guard.insert(object_key, bytes.clone());
+        guard.insert(object_key.to_string(), bytes.clone());
     }
     Ok(bytes)
 }
 
+/// 读取（并按对象键缓存）已确认的私有发行包；键与上限与既有行为逐字节一致。
+async fn release_package_bytes(
+    state: &AppState,
+    game_id: &str,
+    version_id: &str,
+) -> Result<Bytes, AppError> {
+    let object_key = game_distribution_package_object_key(game_id, version_id);
+    release_asset_bytes(state, &object_key, MAX_PACKAGE_BYTES).await
+}
+
 fn release_asset_response_with_cache(
     content: Vec<u8>,
     content_type: &'static str,
@@ -1449,6 +1698,16 @@ fn release_asset_not_modified_response(etag: &str, cache_control: &'static str)
     response
 }
 
+/// 公开游戏目录：`GET /api/game-distribution/games?search=&category=&authorId=&limit=&cursor=&forkable=`。
+///
+/// 匿名可读；只含公开可玩的作品。**真游标分页**：`limit` 缺省 48（保持既有首屏语义）、上限 100、
+/// 超界**截断**（客户端拿到一个完整页，而不是一个需要重试的错误）；游标格式非法由模块侧报错，
+/// 这里透传成 400 + 稳定码 `CATALOG_INVALID_CURSOR`（不吞掉、也不自己造一种 200 的空页）。
+/// `forkable` 为真时只返回可被共创的作品；过滤在事务里、**切页之前**完成，本层只解析参数
+/// （口径见 `parse_forkable_flag`）。
+///
+/// 修正前这里写死 `limit = 48` 且把 `nextCursor` 恒置 `null`：库里第 49 条起的作品（含最老的
+/// 母版与主干）在 HTTP 面永久不可见。`nextCursor` 现在由事务给出的真实游标决定，末页为 `null`。
 async fn list_games(
     State(state): State<AppState>,
     Extension(ctx): Extension<RequestContext>,
@@ -1462,24 +1721,84 @@ async fn list_games(
         .map_err(|error| {
             AppError::from_status(StatusCode::BAD_REQUEST).with_message(error.to_string())
         })?;
-    let games = state
+    // 与模块侧同一套归一化（同一函数），因此日志里的 `limit` 就是事务真正生效的页大小。
+    let limit = public_games_page_limit(query.limit);
+    let cursor = normalize_optional(query.cursor);
+    // `forkable` 的过滤**不在这一层做**：逐页过滤返回结果会让被滤掉的行凭空占掉页名额，下一页
+    // 游标又指回过滤前的序列，于是每翻一页都漏掉自己的若干条。这里只把「要不要过滤」的结论
+    // 交给事务，过滤与切页在同一处、同一序（见 `list_public_game_distribution_games_tx`）。
+    let forkable = parse_forkable_flag(query.forkable.as_deref());
+    let (games, next_cursor) = state
         .spacetime_client()
         .list_game_distribution_games(GameDistributionPublicGameListRecordInput {
             search: normalize_optional(query.search),
             category: normalize_optional(query.category),
-            limit: MAX_LIST_LIMIT,
+            limit,
             author_id,
+            cursor: cursor.clone(),
+            forkable,
         })
         .await
         .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_catalog_listed",
+        games = games.len(),
+        limit,
+        max_limit = GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_MAX,
+        has_cursor = cursor.is_some(),
+        has_more = next_cursor.is_some(),
+        forkable,
+        elapsed_ms = ctx.elapsed(),
+        "读取公开游戏目录"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        public_games_payload(games, next_cursor),
+    ))
+}
+
+/// 公开游戏目录响应：`{ games: [...], nextCursor }`。
+///
+/// `nextCursor` 是**真实**游标：还有下一页时给出，最后一页为 `null`，客户端据此决定是否继续拉。
+/// 同步纯函数：既是 handler 的组装点，也是 DTO parity 脚本登记的响应构建器。
+fn public_games_payload(
+    games: Vec<GameDistributionPublicGameRecord>,
+    next_cursor: Option<String>,
+) -> Value {
     let games = games
         .into_iter()
         .map(|game| public_game_payload(game, &GameViewerContext::default()))
         .collect::<Vec<_>>();
-    Ok(json_success_body(
-        Some(&ctx),
-        json!({ "games": games, "nextCursor": Value::Null }),
-    ))
+    json!({ "games": games, "nextCursor": next_cursor })
+}
+
+/// 查询串的 `limit` → 生效页大小：缺省取默认 48（既有首屏语义），超界截断到上限 100（`0` 也取默认）。
+///
+/// 归一化委托 `module_game_distribution::game_distribution_catalog_page_limit`，与事务里真正切页
+/// 用的是**同一个函数**，避免「日志写 100、实际发了 48」这类漂移——上一版的硬上限缺陷正长在这里。
+fn public_games_page_limit(limit: Option<u32>) -> u32 {
+    game_distribution_catalog_page_limit(
+        limit.unwrap_or(GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT),
+    ) as u32
+}
+
+/// 查询串 `forkable` → 「只返回可被共创的作品」开关：真值（`1` / `true`，大小写不敏感、先 trim）
+/// 为 `true`；**其余一切取值一律 `false` = 不过滤**。
+///
+/// 「其余」包括省略、空串、`0` / `false`、以及拼错的取值（`abc`、`yes`、`2`）。
+///
+/// 为什么非法取值**宽容降级**而不是像 `status` 白名单那样 400：目录是**公开只读列表**，而
+/// `forkable` 是**可选**的展示过滤，不是一个能改变权限或可见性的开关。客户端（尤其是旧版 AGC
+/// 外壳）把参数拼错一次就让整个游戏广场 400，代价远大于收益；而「不过滤」正好等于这个参数
+/// 出现之前的既有行为，因此降级既不会多吐出任何东西（相对现状只会少列、不会多列），也不会改变
+/// 任何既有调用方的语义——它只是把这个可选参数忽略掉。相比之下失败关闭在这里表达不出任何安全
+/// 意图，只会把「参数拼错」升级成「目录不可用」。
+fn parse_forkable_flag(value: Option<&str>) -> bool {
+    matches!(
+        value.map(str::trim).map(str::to_ascii_lowercase).as_deref(),
+        Some("1") | Some("true")
+    )
 }
 
 /// 解析公开投影的查看者：可选鉴权读取当前用户，决定 `purchased` 与付费入口可见性。
@@ -1543,22 +1862,971 @@ async fn game_viewer_context(
 async fn get_game(
     State(state): State<AppState>,
     Extension(ctx): Extension<RequestContext>,
-    Path(game_id): Path<String>,
     headers: HeaderMap,
+    Path(game_id): Path<String>,
 ) -> Result<Json<Value>, AppError> {
     let game = state
         .spacetime_client()
-        .get_public_game_distribution_game(game_id)
+        .get_public_game_distribution_game(game_id.clone())
         .await
         .map_err(map_spacetime_error)?
         .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
+    // 观看者上下文：一次解出「是谁」（管理员 / 作者 / 是否已购买），公开详情的付费入口
+    // 与下面的 `collected` 都从它派生——**不要**再单独解一次 token。
     let viewer = game_viewer_context(&state, &ctx, &headers, &game.game).await;
+    // 可选登录态：登录时才追加 `collected`（真实投影，不是前端本地状态）。
+    //
+    // 无效 / 过期 token 按**匿名**处理（与 `record_game_play` 同一取舍）：公开详情是匿名可读的，
+    // 不能因为客户端带着一个过期 token 就把整页变成 401；客户端刷新 token 后会重新拉取。
+    // 这也意味着「带了 token 但被按匿名处理」时返回的响应与纯匿名完全相同——即**不带**该键。
+    //
+    // `viewer.user_id` 正是「有效登录用户」，无效 token 与匿名都落成 `None`，因此这里不需要
+    // 自己再解一次 bearer，两者语义必然一致（购买态与收藏态不会各算各的）。
+    let collected = match viewer.user_id.as_deref() {
+        Some(user_id) => Some(
+            state
+                .spacetime_client()
+                .is_game_distribution_collected(game_id.clone(), user_id.to_string())
+                .await
+                .map_err(map_spacetime_error)?,
+        ),
+        None => None,
+    };
+    // 所属公开主题：对匿名与登录**都**下发（主题入口是公开页的一部分，不是 per-user 数据）。
+    // 事务内部先取该作品的根再按根反查，因此第 N 代作品也能拿到它所属根的主题；没有所属主题时
+    // 是空数组（不是缺键）——「没有主题」与「没登录」因此不会被混成同一种缺键。
+    let themes = state
+        .spacetime_client()
+        .list_game_distribution_theme_refs_for_root(game_id.clone())
+        .await
+        .map_err(map_spacetime_error)?;
     Ok(json_success_body(
         Some(&ctx),
-        public_game_payload(game, &viewer),
+        public_game_detail_payload(game, &viewer, collected, themes),
     ))
 }
 
+/// 公开详情负载：在公开目录那条 `public_game_payload` 之上按可选登录态追加 `collected`，
+/// 并追加该作品所属的公开主题 `themes`（匿名也发）。
+///
+/// 抽成函数而不是写在 handler 里，一是让「登录才加 `collected`、`themes` 恒发」能被单测钉住，
+/// 二是它同时是 DTO parity 脚本登记的响应构建器（证明这条路径确实会发出这两个键）。
+///
+/// `collected == None`（匿名 / 无效 token 按匿名）时**不加键**，而不是发 `false`：`false` 会把
+/// 「未登录」说成「没收藏」，客户端无法区分，会渲染出错误的收藏按钮态。
+fn public_game_detail_payload(
+    game: GameDistributionPublicGameRecord,
+    viewer: &GameViewerContext,
+    collected: Option<bool>,
+    themes: Vec<GameDistributionThemeReferenceRecord>,
+) -> Value {
+    let mut payload = public_game_payload(game, viewer);
+    let Some(object) = payload.as_object_mut() else {
+        return payload;
+    };
+    if let Some(collected) = collected {
+        object.insert("collected".to_string(), json!(collected));
+    }
+    // 没有所属主题时发空数组：展示层据此不渲染空容器，也不会把缺键误读成「加载失败」。
+    object.insert(
+        "themes".to_string(),
+        Value::Array(themes.iter().map(theme_reference_payload).collect()),
+    );
+    payload
+}
+
+/// 收藏（收录）的请求摘要：只绑定 `(user_id, game_id)`。
+///
+/// 服务端的收据键是 `(user_id, action, idempotency_key)`，而 `Idempotency-Key` 由客户端生成、
+/// 可能在不同作品之间复用。摘要里带上这对组合，才让「同一个 key 撞到**不同作品**」被判成同键
+/// 不同请求（409），而不是把另一个作品的收藏结果重放给当前请求者。
+///
+/// **同键换用户不会是 409、也不会互相命中**：收据键本身含 `user_id`，两个用户各带相同
+/// `Idempotency-Key` 时读到的是各自（不存在）的收据，各自按新请求处理并 200 成功——端到端
+/// 实测如此（`spacetime-module` 侧同步写明「不同用户 / 不同作品即使共用同一个
+/// `Idempotency-Key` 也不会互相命中」）；本条注释曾把「换用户」一并错写成 409。
+fn collection_request_digest(user_id: &str, game_id: &str) -> Result<String, AppError> {
+    Ok(compute_request_digest(
+        &serde_json::to_vec(&(user_id, game_id)).map_err(|error| internal(error.to_string()))?,
+    ))
+}
+
+/// 收藏（收录）某作品：`PUT /games/{gameId}/collection`。
+///
+/// 幂等语义：必须带 `Idempotency-Key`。同键重放返回同一结果并带 `replayed = true`；
+/// 同键**换作品**是 409（摘要绑定 `(user_id, game_id)`）；同键**换用户**是 200 各自成功
+/// （收据键 `(user_id, action, idempotency_key)` 按用户隔离，两个用户不会命中彼此的收据）；
+/// 重复收藏（不同键）不会产生第二行，仍然成功。
+async fn collect_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let user_id = auth.claims().user_id().to_string();
+    let idempotency_key = idempotency_key(&headers)?;
+    let request_digest = collection_request_digest(user_id.as_str(), game_id.as_str())?;
+    let collection = state
+        .spacetime_client()
+        .set_game_distribution_collection(GameDistributionCollectGameRecordInput {
+            game_id: game_id.clone(),
+            user_id: user_id.clone(),
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_collection_set",
+        game_id = %game_id,
+        replayed = collection.replayed,
+        elapsed_ms = ctx.elapsed(),
+        "收藏游戏作品"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        GameDistributionCollectionState {
+            collected: collection.collected,
+            replayed: Some(collection.replayed),
+        },
+    ))
+}
+
+/// 取消收藏（收录）：`DELETE /games/{gameId}/collection`。
+///
+/// **不要求 `Idempotency-Key`**：删除按确定性主键 `{userId}:{gameId}` 执行，重复调用结果完全
+/// 相同（不存在也算成功），没有「重放 vs 新意图」需要区分——幂等键只在请求本身无法表达意图时
+/// 才有意义。也**不要求作品仍公开**：下架后拒绝取消只会给用户留下清理不掉的脏行。
+async fn uncollect_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let user_id = auth.claims().user_id().to_string();
+    let collection = state
+        .spacetime_client()
+        .unset_game_distribution_collection(GameDistributionUncollectGameRecordInput {
+            game_id: game_id.clone(),
+            user_id,
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_collection_unset",
+        game_id = %game_id,
+        elapsed_ms = ctx.elapsed(),
+        "取消收藏游戏作品"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        GameDistributionCollectionState {
+            collected: collection.collected,
+            // 取消没有幂等键，因此不下发 `replayed`（`skip_serializing_if` 会略过该键）。
+            replayed: None,
+        },
+    ))
+}
+
+/// 「我的收藏（收录）」：`GET /my-collections?limit=&cursor=`。
+///
+/// 逐条用公开目录同一份 `public_game_payload` 组装，形状与公开目录一致（`games` + `nextCursor`）。
+/// 只返回当前公开可读的作品；已下架 / 软删除的收藏**只是不在响应里**，行不删除——作品重新
+/// 公开后会自动回来。
+///
+/// 分页：默认 20、上限 50，超界**截断**（与后台列表一致：客户端拿到一个完整页，而不是重试错误）；
+/// 游标格式非法由模块侧报错并在这里透传成 400（不吞掉、也不自己造一种 200 的空页）。
+async fn list_my_collections(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    Query(query): Query<MyCollectionsQuery>,
+) -> Result<Json<Value>, AppError> {
+    let user_id = auth.claims().user_id().to_string();
+    // 与模块侧同一套归一化（同一函数），因此日志里的 `limit` 就是真正生效的页大小。
+    let limit = my_collections_page_limit(query.limit);
+    let cursor = normalize_optional(query.cursor);
+    let (games, next_cursor) = state
+        .spacetime_client()
+        .list_game_distribution_collections(user_id, limit, cursor.clone())
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_collections_listed",
+        games = games.len(),
+        limit,
+        max_limit = GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_MAX,
+        has_cursor = cursor.is_some(),
+        has_more = next_cursor.is_some(),
+        elapsed_ms = ctx.elapsed(),
+        "读取我的收藏列表"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        my_collections_payload(games, next_cursor),
+    ))
+}
+
+/// 「我的收藏」响应负载：分页字段与公开目录逐字一致（`games` + `nextCursor`）。
+///
+/// `nextCursor` 是**真实**游标：还有下一页时给出，最后一页为 `null`，客户端据此决定是否继续拉。
+///
+/// 同步纯函数：既是 handler 的组装点，也是 DTO parity 脚本登记的响应构建器。
+fn my_collections_payload(
+    games: Vec<GameDistributionPublicGameRecord>,
+    next_cursor: Option<String>,
+) -> Value {
+    let games = games
+        .into_iter()
+        .map(|game| public_game_payload(game, &GameViewerContext::default()))
+        .collect::<Vec<_>>();
+    json!({ "games": games, "nextCursor": next_cursor })
+}
+
+/// 查询串的 `limit` → 生效页大小：缺省取默认 20，超界截断到上限 50（`0` 也取默认）。
+///
+/// 归一化本身委托给 `module_game_distribution::game_distribution_collection_page_limit`，
+/// 与事务里真正切页用的是**同一个函数**，避免「日志写 50、实际发了 20」这类漂移。
+fn my_collections_page_limit(limit: Option<u32>) -> u32 {
+    game_distribution_collection_page_limit(
+        limit.unwrap_or(GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_DEFAULT),
+    ) as u32
+}
+
+/// 公开共创主题列表：`GET /api/game-distribution/themes?limit=&cursor=`。
+///
+/// 匿名可读；只含已发布主题。分页口径与 `/my-collections` 完全一致：默认 20、上限 50、超界
+/// **截断**（客户端拿到一个完整页，而不是一个需要重试的错误）；游标格式非法由模块侧报错，
+/// 这里透传成 400（不吞掉、也不自己造一种 200 的空页）。
+async fn list_public_themes(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Query(query): Query<ThemeListQuery>,
+) -> Result<Json<Value>, AppError> {
+    // 与模块侧同一套归一化（同一函数），因此日志里的 `limit` 就是真正生效的页大小。
+    let limit = themes_page_limit(query.limit);
+    let cursor = normalize_optional(query.cursor);
+    let (themes, next_cursor) = state
+        .spacetime_client()
+        .list_game_distribution_themes(limit, cursor.clone())
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_themes_listed",
+        themes = themes.len(),
+        limit,
+        max_limit = GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX,
+        has_cursor = cursor.is_some(),
+        has_more = next_cursor.is_some(),
+        elapsed_ms = ctx.elapsed(),
+        "读取公开共创主题列表"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        public_themes_payload(themes, next_cursor),
+    ))
+}
+
+/// 公开共创主题详情：`GET /api/game-distribution/themes/{theme_id}`。
+///
+/// 匿名可读。主题不存在 / 未发布一律 404（模块侧回同一条「主题不存在」文案，由既有映射落 404），
+/// **不返回空壳主题**——空壳会让客户端把「不存在」渲染成一个空白但正常的主题页。
+/// 已发布但可见成员为空是正常结果（200 + 空 `roots`），展示层按空态而不是错误渲染。
+async fn get_public_theme(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Path(theme_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let theme = state
+        .spacetime_client()
+        .get_game_distribution_theme_detail(theme_id.clone())
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_theme_read",
+        theme_id = %theme_id,
+        roots = theme.roots.len(),
+        elapsed_ms = ctx.elapsed(),
+        "读取公开共创主题详情"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        public_theme_detail_payload(theme),
+    ))
+}
+
+/// 公开主题列表响应：`{ themes: [...], nextCursor }`。
+///
+/// `nextCursor` 是**真实**游标：还有下一页时给出，最后一页为 `null`，客户端据此决定是否继续拉。
+/// 同步纯函数：既是 handler 的组装点，也是 DTO parity 脚本登记的响应构建器。
+fn public_themes_payload(
+    themes: Vec<GameDistributionThemeSummaryRecord>,
+    next_cursor: Option<String>,
+) -> Value {
+    json!({
+        "themes": themes
+            .into_iter()
+            .map(public_theme_summary_payload)
+            .collect::<Vec<_>>(),
+        "nextCursor": next_cursor,
+    })
+}
+
+/// 主题条目：`{ themeId, name, summary, badge, memberCount }`（列表与详情头部共用同一形状）。
+///
+/// `memberCount` 是**真实可见成员数**（与详情响应的 `memberCount` 同一个数，不截断）：回报
+/// 「成员行总数」会让运营通过计数变化探测到「存在草稿或被下架成员」。它**不是**详情 `roots` 的
+/// 长度——详情 `roots` 受响应体积上限约束，「被截断」由详情响应上的 `rootsTruncated` 表达。
+fn public_theme_summary_payload(theme: GameDistributionThemeSummaryRecord) -> Value {
+    json!({
+        "themeId": theme.theme_id,
+        "name": theme.name,
+        "summary": theme.summary,
+        "badge": theme.badge,
+        "memberCount": theme.member_count,
+    })
+}
+
+/// 公开主题详情响应：顶层扁平（与 `GET /games/{gameId}` 同形，不引入第二套包装），
+/// `roots` 逐条是公开目录**同一份** `public_game_payload` 投影。
+///
+/// `memberCount`（真实可见成员数，不截断）与 `rootsTruncated`（这份 `roots` 有没有被响应体积上限
+/// 截断）是两个独立键：可见成员 > 50 时 `memberCount` 照实报、`roots` 只回前 50 条并置
+/// `rootsTruncated: true`，与族谱响应的 `truncated` 同一种约定，客户端据此决定要不要提示
+/// 「仅显示前 50 个」。**不要**用 `memberCount === roots.length` 当不变式。
+fn public_theme_detail_payload(theme: GameDistributionThemeDetailRecord) -> Value {
+    json!({
+        "themeId": theme.theme_id,
+        "name": theme.name,
+        "summary": theme.summary,
+        "badge": theme.badge,
+        "memberCount": theme.member_count,
+        "roots": theme
+            .roots
+            .into_iter()
+            .map(|game| public_game_payload(game, &GameViewerContext::default()))
+            .collect::<Vec<_>>(),
+        "rootsTruncated": theme.roots_truncated,
+    })
+}
+
+/// 作品详情 `themes` 增量的单条：`{ themeId, name, badge }`。
+///
+/// 只够渲染一个跳转入口：简介与成员数在主题页取，避免详情页为每个主题多查一次成员投影。
+fn theme_reference_payload(theme: &GameDistributionThemeReferenceRecord) -> Value {
+    json!({
+        "themeId": theme.theme_id,
+        "name": theme.name,
+        "badge": theme.badge,
+    })
+}
+
+/// 主题列表查询串的 `limit` → 生效页大小：缺省取默认 20，超界截断到上限 50（`0` 也取默认）。
+///
+/// 归一化委托给 `module_game_distribution::game_distribution_theme_page_limit`，与事务里真正切页
+/// 用的是**同一个函数**，避免「日志写 50、实际发了 20」这类漂移。
+fn themes_page_limit(limit: Option<u32>) -> u32 {
+    game_distribution_theme_page_limit(limit.unwrap_or(GAME_DISTRIBUTION_THEME_PAGE_LIMIT_DEFAULT))
+        as u32
+}
+
+/// 后台共创主题的 400：带稳定错误码 `THEME_BAD_REQUEST`（与事务侧同一串），不是裸文案。
+///
+/// 两处用它：① `status` 过滤值不在白名单；② 请求体反序列化失败（未知 `status` 枚举值 / 坏 JSON）。
+/// ②尤其重要——不接管的话 axum 会回 422 纯文本，而契约里这一格写的是 400。
+fn theme_bad_request(message: impl Into<String>) -> AppError {
+    AppError::from_status(StatusCode::BAD_REQUEST)
+        .with_code(GAME_DISTRIBUTION_THEME_BAD_REQUEST)
+        .with_message(message)
+}
+
+/// 后台创建主题：`POST /admin/api/game-distribution/themes`。
+///
+/// `theme_id` 由**服务端**生成（请求体里没有这个字段，外部无法指定）；`created_by_user_id` 取
+/// admin 会话主体。幂等语义与既有后台写接口一致：同键同摘要 → `replayed: true` 且回库里那一行，
+/// 同键不同请求 → 409。
+///
+/// 请求摘要刻意**只覆盖客户端可见的请求体**（不含每次重试都会重新生成的 `theme_id`）：否则同一次
+/// 重试会算出不同摘要，把合法的重试变成 409。
+async fn admin_create_theme(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(admin): Extension<AuthenticatedAdmin>,
+    headers: HeaderMap,
+    payload: Result<Json<GameDistributionCreateThemeRequest>, JsonRejection>,
+) -> Result<Json<Value>, AppError> {
+    let Json(payload) = payload.map_err(|_| theme_bad_request("主题请求体不合法"))?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let theme_id = format!("theme-{}", Uuid::new_v4().simple());
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&payload).map_err(|error| internal(error.to_string()))?,
+    );
+    let status = theme_status_value(payload.status);
+    let admin_user_id = admin.session().subject.clone();
+    let log_theme_id = theme_id.clone();
+    let log_status = status.clone();
+    let record = state
+        .spacetime_client()
+        .create_game_distribution_theme(GameDistributionCreateThemeRecordInput {
+            theme_id,
+            name: payload.name,
+            summary: payload.summary,
+            badge: payload.badge,
+            sort_order: payload.sort_order,
+            status,
+            admin_user_id: admin_user_id.clone(),
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_theme_created",
+        theme_id = %log_theme_id,
+        admin_user_id = %admin_user_id,
+        status = %log_status,
+        replayed = record.replayed,
+        elapsed_ms = ctx.elapsed(),
+        "后台创建共创主题"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        admin_theme_mutation_payload(&record),
+    ))
+}
+
+/// 后台整体覆盖主题字段：`PUT /admin/api/game-distribution/themes/{theme_id}`。
+///
+/// `theme_id` 不存在由事务回带码错误（`THEME_NOT_FOUND` → 404）；字段非法（空名 / 超长 / 未知状态）
+/// → 400。同键不同请求 409，同键重放 `replayed: true`（且不写库、不刷新 `updated_at`）。
+async fn admin_update_theme(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(admin): Extension<AuthenticatedAdmin>,
+    headers: HeaderMap,
+    Path(theme_id): Path<String>,
+    payload: Result<Json<GameDistributionUpdateThemeRequest>, JsonRejection>,
+) -> Result<Json<Value>, AppError> {
+    let Json(payload) = payload.map_err(|_| theme_bad_request("主题请求体不合法"))?;
+    let idempotency_key = idempotency_key(&headers)?;
+    // 主题 ID 在路径里，因此摘要带上它是稳定的（重试仍是同一个 ID）。
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(theme_id.as_str(), &payload))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let status = theme_status_value(payload.status);
+    let admin_user_id = admin.session().subject.clone();
+    let log_theme_id = theme_id.clone();
+    let log_status = status.clone();
+    let record = state
+        .spacetime_client()
+        .update_game_distribution_theme(GameDistributionUpdateThemeRecordInput {
+            theme_id,
+            name: payload.name,
+            summary: payload.summary,
+            badge: payload.badge,
+            sort_order: payload.sort_order,
+            status,
+            admin_user_id: admin_user_id.clone(),
+            idempotency_key,
+            request_digest,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_theme_updated",
+        theme_id = %log_theme_id,
+        admin_user_id = %admin_user_id,
+        status = %log_status,
+        replayed = record.replayed,
+        elapsed_ms = ctx.elapsed(),
+        "后台更新共创主题"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        admin_theme_mutation_payload(&record),
+    ))
+}
+
+/// 后台增 / 改主题成员：`PUT …/themes/{theme_id}/members/{root_game_id}`。
+///
+/// **不要求幂等键**：成员身份完全由路径给出，确定性主键保证「同主题同根一行」，重复调用只更新
+/// `sort_order`（`created_at` 不变）。只允许根作品（非根 → 409）；不做「作品必须公开」的前置校验。
+async fn admin_upsert_theme_member(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(_admin): Extension<AuthenticatedAdmin>,
+    Path((theme_id, root_game_id)): Path<(String, String)>,
+    payload: Result<Json<GameDistributionUpsertThemeMemberRequest>, JsonRejection>,
+) -> Result<Json<Value>, AppError> {
+    // body 只承载运营权重（`sortOrder` 缺省 0，`{}` 即「不排序」）；坏 JSON / 未知字段仍然 400，
+    // 不静默当成 `{}`——那会把客户端的拼写错误变成一次「看起来成功」的写入。
+    let Json(payload) = payload.map_err(|_| theme_bad_request("主题成员请求体不合法"))?;
+    let log_theme_id = theme_id.clone();
+    let log_root_game_id = root_game_id.clone();
+    let member = state
+        .spacetime_client()
+        .upsert_game_distribution_theme_member(GameDistributionThemeMemberUpsertRecordInput {
+            theme_id,
+            root_game_id,
+            sort_order: payload.sort_order,
+            now_micros: now_micros(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_theme_member_upserted",
+        theme_id = %log_theme_id,
+        root_game_id = %log_root_game_id,
+        sort_order = member.sort_order,
+        elapsed_ms = ctx.elapsed(),
+        "后台挂载 / 调整共创主题成员"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        admin_theme_member_payload(&member),
+    ))
+}
+
+/// 后台移除主题成员：`DELETE …/themes/{theme_id}/members/{root_game_id}`。
+///
+/// **不要求幂等键**：按确定性主键删除，成员不存在也算成功（200）。响应刻意不含「之前存不存在」，
+/// 重复调用的响应因此逐字节相同。主题不存在仍是 404（那是路径里的主题 ID 错了）。
+async fn admin_remove_theme_member(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(_admin): Extension<AuthenticatedAdmin>,
+    Path((theme_id, root_game_id)): Path<(String, String)>,
+) -> Result<Json<Value>, AppError> {
+    let log_theme_id = theme_id.clone();
+    let log_root_game_id = root_game_id.clone();
+    state
+        .spacetime_client()
+        .remove_game_distribution_theme_member(GameDistributionThemeMemberRemoveRecordInput {
+            theme_id: theme_id.clone(),
+            root_game_id: root_game_id.clone(),
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_theme_member_removed",
+        theme_id = %log_theme_id,
+        root_game_id = %log_root_game_id,
+        elapsed_ms = ctx.elapsed(),
+        "后台移除共创主题成员"
+    );
+    // 幂等：删掉的与「本来就没有」回同一个形状，客户端不可能据此推断成员是否曾经存在。
+    Ok(json_success_body(
+        Some(&ctx),
+        admin_theme_member_removal_payload(&theme_id, &root_game_id),
+    ))
+}
+
+/// 后台主题列表：`GET /admin/api/game-distribution/themes?limit=&status=`（含 `draft` / `archived`）。
+///
+/// `status` 非法（不在 `all` / `draft` / `published` / `archived` 里）→ 400，由模块侧的纯函数判定；
+/// 事务里还会再判一次，保证非 HTTP 调用方也不会拿到一份「悄悄按全量返回」的列表。
+async fn admin_list_themes(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(_admin): Extension<AuthenticatedAdmin>,
+    Query(query): Query<AdminThemeListQuery>,
+) -> Result<Json<Value>, AppError> {
+    let limit = query
+        .limit
+        .unwrap_or(MAX_ADMIN_THEME_LIST_LIMIT)
+        .min(MAX_ADMIN_THEME_LIST_LIMIT);
+    let status = normalize_optional(query.status);
+    if let Some(status) = status.as_deref() {
+        if !game_distribution_theme_admin_status_filter_valid(status) {
+            return Err(theme_bad_request(
+                "后台主题状态过滤只支持 all / draft / published / archived",
+            ));
+        }
+    }
+    let themes = state
+        .spacetime_client()
+        .list_admin_game_distribution_themes(GameDistributionAdminThemeListRecordInput {
+            status: status.clone(),
+            limit,
+        })
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "admin_game_themes_listed",
+        themes = themes.len(),
+        limit,
+        status = status.as_deref().unwrap_or("all"),
+        elapsed_ms = ctx.elapsed(),
+        "后台读取共创主题列表"
+    );
+    Ok(json_success_body(Some(&ctx), admin_themes_payload(&themes)))
+}
+
+/// 后台读取主题成员名单：
+/// `GET /admin/api/game-distribution/themes/{theme_id}/members?limit=&cursor=`。
+///
+/// **全部成员行**（含当前对外不可见的）+ **`draft` / `archived` 主题照常可读**——这正是本接口存在的
+/// 理由：公开投影只服务已发布主题，后台借道它时草稿 / 归档主题根本列不出成员，运营没法在发布前
+/// 核对。每行带 `visible`（此刻公开投影会不会包含它）与 `visibility`（更细的状态），两者刻意独立。
+///
+/// 分页与其它列表同一口径（`limit` 缺省 20 / 上限 50 / `0` 取默认 / 超界截断；游标
+/// `"{sortOrder}:{memberId}"`），归一化复用 `themes_page_limit`（同一函数 ⇒ 日志里的 `limit` 就是
+/// 事务真正生效的页大小）；非法游标由事务回稳定码错误 → 400 `THEME_INVALID_CURSOR`；主题不存在 →
+/// 404 `THEME_NOT_FOUND`。
+async fn admin_list_theme_members(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(_admin): Extension<AuthenticatedAdmin>,
+    Path(theme_id): Path<String>,
+    Query(query): Query<AdminThemeMemberListQuery>,
+) -> Result<Json<Value>, AppError> {
+    let limit = themes_page_limit(query.limit);
+    let cursor = normalize_optional(query.cursor);
+    let record = state
+        .spacetime_client()
+        .list_admin_game_distribution_theme_members(
+            GameDistributionAdminThemeMemberListRecordInput {
+                theme_id: theme_id.clone(),
+                limit,
+                cursor: cursor.clone(),
+            },
+        )
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "admin_game_theme_members_listed",
+        theme_id = %theme_id,
+        members = record.members.len(),
+        total_members = record.total_members,
+        limit,
+        has_cursor = cursor.is_some(),
+        has_more = record.next_cursor.is_some(),
+        elapsed_ms = ctx.elapsed(),
+        "后台读取共创主题成员名单"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        admin_theme_members_payload(
+            &theme_id,
+            record.total_members,
+            &record.members,
+            record.next_cursor,
+        ),
+    ))
+}
+
+/// DTO 枚举 → 线上字符串：只此一处转换（`serde` 的 `camelCase` 与模块侧白名单同值，有单测钉住）。
+fn theme_status_value(status: GameDistributionThemeStatus) -> String {
+    match status {
+        GameDistributionThemeStatus::Draft => "draft",
+        GameDistributionThemeStatus::Published => "published",
+        GameDistributionThemeStatus::Archived => "archived",
+    }
+    .to_string()
+}
+
+/// 后台主题条目：`{ themeId, name, summary, badge, sortOrder, status, memberCount, createdAt, updatedAt }`。
+///
+/// `memberCount` 是**成员行总数**（含当前对外不可见的成员）：后台没有「不该被探测」的顾虑，
+/// 运营需要知道这个主题挂了几行；公开投影里的同名键则是当前可见成员数。
+fn admin_theme_payload(theme: &GameDistributionAdminThemeRecord) -> Value {
+    json!({
+        "themeId": theme.theme_id,
+        "name": theme.name,
+        "summary": theme.summary,
+        "badge": theme.badge,
+        "sortOrder": theme.sort_order,
+        "status": theme.status,
+        "memberCount": theme.member_count,
+        "createdAt": theme.created_at,
+        "updatedAt": theme.updated_at,
+    })
+}
+
+/// 后台主题列表响应：`{ themes: [...] }`（**没有** `nextCursor`：这条路径不分页）。
+fn admin_themes_payload(themes: &[GameDistributionAdminThemeRecord]) -> Value {
+    json!({
+        "themes": themes.iter().map(admin_theme_payload).collect::<Vec<_>>(),
+    })
+}
+
+/// 后台创建 / 更新主题的响应：`{ theme, replayed }`。
+///
+/// `replayed` 必须原样发出：客户端据此区分「这次真的写了」与「同键重放，库里没动」。
+fn admin_theme_mutation_payload(record: &GameDistributionAdminThemeMutationRecord) -> Value {
+    json!({
+        "theme": admin_theme_payload(&record.theme),
+        "replayed": record.replayed,
+    })
+}
+
+/// 后台成员写入的响应：`{ themeId, rootGameId, sortOrder, createdAt }`。
+///
+/// `createdAt` 是**首次挂载**的时间：重复 PUT 只改 `sortOrder`，不会刷新它。
+fn admin_theme_member_payload(member: &GameDistributionAdminThemeMemberRecord) -> Value {
+    json!({
+        "themeId": member.theme_id,
+        "rootGameId": member.root_game_id,
+        "sortOrder": member.sort_order,
+        "createdAt": member.created_at,
+    })
+}
+
+/// 后台移除成员的响应：`{ themeId, rootGameId }`。
+///
+/// 抽成命名构建器（而不是留在 handler 里的内联 `json!`）是为了让 DTO parity 能看到它：
+/// 内联字面量不在 `RESPONSE_BUILDERS` 的证据范围内，形状漂移不会有门禁变红。
+///
+/// 刻意不含「之前存不存在」：删掉的与本来就没有的回同一个形状，重复调用逐字节相同。
+fn admin_theme_member_removal_payload(theme_id: &str, root_game_id: &str) -> Value {
+    json!({ "themeId": theme_id, "rootGameId": root_game_id })
+}
+
+/// 后台成员名单里的一行：
+/// `{ rootGameId, title, sortOrder, createdAt, visible, visibility }`。
+///
+/// `title` 取游戏行标题，游戏行不存在时发 `null`——**键必须发出**（不是省略）：省略会让
+/// 「这个成员的作品查不到了」与「服务端忘了发这个键」长得一样。
+///
+/// `visible` 与 `visibility` 是两个独立口径，都必须原样发出：前者是「此刻公开投影会不会包含它」，
+/// 后者是「为什么」（`published` / `unpublished` / `suspended` / `deleted` / `missing`）。因此
+/// `visibility == "published"` 而没有当前公开版本时 `visible == false` 是**刻意**的。
+fn admin_theme_member_row_payload(member: &GameDistributionAdminThemeMemberRowRecord) -> Value {
+    json!({
+        "rootGameId": member.root_game_id,
+        "title": member.title,
+        "sortOrder": member.sort_order,
+        "createdAt": member.created_at,
+        "visible": member.visible,
+        "visibility": member.visibility,
+    })
+}
+
+/// 后台成员名单响应：`{ themeId, totalMembers, members, nextCursor }`。
+///
+/// `totalMembers` 是**成员行总数**（含当前对外不可见的行、**不受分页影响**）：它与 `members.length`
+/// 刻意不是一回事（后者只是这一页），运营据此知道「翻页有没有翻完」。
+///
+/// `nextCursor` **必须发出**（末页为 `null`，不是省略）：缺了它客户端无法区分「末页」与「服务端
+/// 这次没给游标」，会把最后一页当成还有下一页而反复翻同一个请求。
+fn admin_theme_members_payload(
+    theme_id: &str,
+    total_members: u64,
+    members: &[GameDistributionAdminThemeMemberRowRecord],
+    next_cursor: Option<String>,
+) -> Value {
+    json!({
+        "themeId": theme_id,
+        "totalMembers": total_members,
+        "members": members
+            .iter()
+            .map(admin_theme_member_row_payload)
+            .collect::<Vec<_>>(),
+        "nextCursor": next_cursor,
+    })
+}
+
+/// 读接口的「不可读即 404」：族谱与衍生列表的锚点必须公开可读，否则按「不存在」处理。
+///
+/// 抽成函数是为了让这条映射可被单测钉住（不可读 → 404），而不是散落在两个 handler 里。
+fn lineage_read_or_not_found<T>(value: Option<T>) -> Result<T, AppError> {
+    value.ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))
+}
+
+/// 公开创作族谱：以该作品的母版为顶返回整棵树。公开只读、匿名可读。
+///
+/// 锚点必须公开可读：不存在、未公开或已软删除一律 404，与公开详情同一口径。这里**不**
+/// 用「空标题节点」代替 404——那等于对外确认该 gameId 存在、它是第几代、它在血缘里的位置。
+async fn get_game_lineage(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let tree = lineage_read_or_not_found(
+        state
+            .spacetime_client()
+            .get_game_distribution_lineage(game_id)
+            .await
+            .map_err(map_spacetime_error)?,
+    )?;
+    Ok(json_success_body(Some(&ctx), lineage_tree_payload(tree)))
+}
+
+/// 公开「被改编」列表：该作品的直接衍生作品（只含未软删除且已公开的直接子代）。
+///
+/// 与公开详情 `forkCount` 同口径，因此条数与「被改编 N」一致；锚点不可公开读取时 404。
+async fn get_game_derived_games(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let derived = lineage_read_or_not_found(
+        state
+            .spacetime_client()
+            .list_game_distribution_derived_games(game_id)
+            .await
+            .map_err(map_spacetime_error)?,
+    )?;
+    Ok(json_success_body(
+        Some(&ctx),
+        derived_games_payload(derived),
+    ))
+}
+
+/// 线上可见性字符串 → DTO 枚举；未知取值按「未公开」保守解释，不会因此多暴露任何信息。
+fn game_distribution_visibility(value: &str) -> GameDistributionVisibility {
+    match value {
+        "published" => GameDistributionVisibility::Published,
+        "suspended" => GameDistributionVisibility::Suspended,
+        _ => GameDistributionVisibility::Unpublished,
+    }
+}
+
+fn lineage_node_payload(node: GameDistributionLineageNodeRecord) -> GameDistributionLineageNode {
+    GameDistributionLineageNode {
+        game_id: node.game_id,
+        title: node.title,
+        author_name: node.author_name,
+        generation: node.generation,
+        parent_game_id: node.parent_game_id,
+        play_count: node.play_count,
+        status: game_distribution_visibility(node.status.as_str()),
+        cover_object_key: node.cover_object_key,
+    }
+}
+
+/// 族谱 / 衍生列表走结构化 DTO 而不是手拼 JSON：节点字段本来就少且固定，
+/// 用 DTO 才能让「不发对象键、不发素材键」由类型保证，而不是靠人肉回忆。
+fn lineage_tree_payload(
+    tree: GameDistributionLineageTreeRecord,
+) -> GameDistributionLineageResponse {
+    GameDistributionLineageResponse {
+        root_game_id: tree.root_game_id,
+        root: tree.root.map(lineage_node_payload),
+        nodes: tree.nodes.into_iter().map(lineage_node_payload).collect(),
+        truncated: tree.truncated,
+    }
+}
+
+fn derived_games_payload(
+    derived: GameDistributionDerivedGamesRecord,
+) -> GameDistributionDerivedResponse {
+    GameDistributionDerivedResponse {
+        game_id: derived.game_id,
+        nodes: derived
+            .nodes
+            .into_iter()
+            .map(lineage_node_payload)
+            .collect(),
+        truncated: derived.truncated,
+    }
+}
+
+fn contribution_totals_payload(
+    totals: spacetime_client::GameDistributionContributionTotalsRecord,
+) -> GameDistributionContributionTotals {
+    GameDistributionContributionTotals {
+        play_count: totals.play_count,
+    }
+}
+
+/// 贡献归集响应的字段映射（契约形状由 DTO parity 门禁逐字段比对）。
+///
+/// 逐字段搬运、不做任何重算：数字的唯一来源是模块侧纯函数
+/// `module_game_distribution::build_contribution_breakdown`，这一层只负责把它折成对外 DTO。
+fn contribution_payload(
+    record: spacetime_client::GameDistributionContributionRecord,
+) -> GameDistributionContributionResponse {
+    GameDistributionContributionResponse {
+        game_id: record.game_id,
+        own: contribution_totals_payload(record.own),
+        inherited: contribution_totals_payload(record.inherited),
+        total: contribution_totals_payload(record.total),
+        by_generation: record
+            .by_generation
+            .into_iter()
+            .map(|entry| GameDistributionContributionGeneration {
+                generation: entry.generation,
+                game_count: entry.game_count,
+                own: contribution_totals_payload(entry.own),
+                inherited: contribution_totals_payload(entry.inherited),
+                total: contribution_totals_payload(entry.total),
+            })
+            .collect(),
+        direct_children: record
+            .direct_children
+            .into_iter()
+            .map(|entry| GameDistributionContributionChild {
+                game_id: entry.game_id,
+                generation: entry.generation,
+                own: contribution_totals_payload(entry.own),
+                inherited: contribution_totals_payload(entry.inherited),
+                total: contribution_totals_payload(entry.total),
+            })
+            .collect(),
+        node_count: record.node_count,
+        truncated: record.truncated,
+        truncated_reason: record.truncated_reason,
+    }
+}
+
+/// 作者视角读取自己作品的贡献归集与归因（子代所有的都算父代的）。
+///
+/// 鉴权与状态码口径（**只有作者本人**；与 `get_owner_game` 那类「不存在与不是你的都 404」
+/// 的做法**刻意不同**）：
+/// - 未登录 / 令牌失效 → **401**（`require_bearer_auth` 在路由层挡下，不进入业务）；
+/// - 作品不存在或已软删除 → **404**（`found = false`）；
+/// - 作品存在但不属于当前主体 → **403**（事务报 `游戏 owner 不匹配`，命中 `map_spacetime_error`
+///   既有的 owner-mismatch → FORBIDDEN 分支）。
+///
+/// 选 403 而不是「非作者折 404」的理由（代价也一并写下）：① 沿用仓库既有 owner-mismatch 惯例
+/// ——`map_spacetime_error` 早就把这类文案映射成 FORBIDDEN，作者侧写路由与 owner 读路径同源；
+/// ② 这是作者账目页：客户端必须能分辨「我没有权限看」（停手 / 换账号 / 回我的作品）与
+/// 「作品没了」（回列表刷新），两者折成同一个 404 只能靠再猜一次；
+/// ③ 代价明确且被接受：登录用户可用 403/404 之分辨别某个 gameId 是否存在——已公开作品本就能
+/// 从公开目录枚举，未公开作品则多出一个存在性预言机；本接口只服务作者本人，
+/// 这里显式记录该取舍，不假装它不存在。
+async fn get_game_contribution(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let owner_user_id = auth.claims().user_id().to_string();
+    let record = contribution_read_or_not_found(
+        state
+            .spacetime_client()
+            .get_game_distribution_contribution(game_id, owner_user_id)
+            .await
+            .map_err(map_spacetime_error)?,
+    )?;
+    Ok(json_success_body(Some(&ctx), contribution_payload(record)))
+}
+
+/// 贡献归集读不到（`found = false`：作品不存在或已软删除）→ 404。
+///
+/// 抽成函数是为了让这条映射可被单测钉住（不可读 → 404），而不是把 `ok_or_else` 散在 handler 里；
+/// 与族谱读路径的 `lineage_read_or_not_found` 同一种折叠方式。
+fn contribution_read_or_not_found<T>(value: Option<T>) -> Result<T, AppError> {
+    value.ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))
+}
+
 /// 一次游玩上报的请求体；只有匿名身份需要 `clientId`，登录身份由 bearer 决定。
 #[derive(Debug, Default, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -1709,10 +2977,16 @@ async fn get_owner_game(
         .await
         .map_err(map_spacetime_error)?
         .ok_or_else(|| AppError::from_status(StatusCode::NOT_FOUND))?;
-    let versions = load_owner_game_versions(&state, owner_user_id, &game_id).await?;
+    let (versions, fork_count) = load_owner_game_versions(&state, owner_user_id, &game_id).await?;
     Ok(json_success_body(
         Some(&ctx),
-        json!({ "game": owner_game_entry_payload(GameDistributionOwnerGameRecord { game, versions }) }),
+        json!({
+            "game": owner_game_entry_payload(GameDistributionOwnerGameRecord {
+                game,
+                versions,
+                fork_count,
+            }),
+        }),
     ))
 }
 
@@ -1725,7 +2999,7 @@ async fn load_owner_game_versions(
     state: &AppState,
     owner_user_id: String,
     game_id: &str,
-) -> Result<Vec<GameDistributionVersionRecord>, AppError> {
+) -> Result<(Vec<GameDistributionVersionRecord>, u64), AppError> {
     let games = state
         .spacetime_client()
         .list_owner_game_distribution_games(
@@ -1739,13 +3013,17 @@ async fn load_owner_game_versions(
     Ok(games
         .into_iter()
         .find(|entry| entry.game.game_id == game_id)
-        .map(|entry| entry.versions)
+        // 「被改编 N」与版本列表来自同一份 owner 聚合投影，详情页与列表页因此不会各算一套。
+        .map(|entry| (entry.versions, entry.fork_count))
         .unwrap_or_default())
 }
 
 /// 把资料编辑请求映射成统一发布资料，以复用同一套资料校验与素材归属解析。
 ///
 /// 身份字段（`gameId` / `projectKey`）只属于外层发布请求，展示资料里不再携带。
+/// `localProjectId` 只属于创建语义，编辑资料不参与游戏身份复用，因此固定为空；
+/// 改编来源同理——资料编辑不是建立血缘的入口（血缘在创建作品时一次性写入且不可变），
+/// 所以 `fork` 也固定为 `None`。
 fn game_metadata_update_as_create_request(
     payload: &GameDistributionUpdateGameMetadataRequest,
 ) -> GameMetadata {
@@ -1760,6 +3038,10 @@ fn game_metadata_update_as_create_request(
         device_support: payload.device_support.clone(),
         input_modes: payload.input_modes.clone(),
         orientation: payload.orientation,
+        // 这两个字段只服务创建语义：资料编辑既不建立血缘也不改授权档位（授权只能靠
+        // `set_fork_authorization` 单向提升），所以复用创建校验时固定取默认值。
+        fork_authorization: GameDistributionForkAuthorization::Forbidden,
+        fork: None,
     }
 }
 
@@ -1982,6 +3264,199 @@ async fn delete_owner_game(
     ))
 }
 
+async fn create_game(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    multipart: Multipart,
+) -> Result<Json<Value>, AppError> {
+    // 未知共创档位（例如 `"allowed"`）在进入业务前就被 serde 拦下：必须映射成平台信封的 400，
+    // 而不是回框架的默认拒绝文本（前端错误处理依赖信封）。框架文本只用来选文案，绝不回传：至少
+    // 不会把「请求体里哪一段长什么样」透给客户端。
+    ensure_publish_enabled(&state, Some(auth.claims().user_id())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let PublishMultipart {
+        metadata,
+        cover,
+        screenshots,
+    } = parse_publish_multipart(multipart).await?;
+    let payload: GameDistributionCreateGameRequest =
+        serde_json::from_value(metadata).map_err(|error| {
+            // serde 未知枚举值的文案会列出该枚举的全部合法取值，`nonCommercial` 是共创档位独有的
+            // 取值，据此把「档位不合法」与其它字段不合法分成两条文案。
+            if error.to_string().contains("nonCommercial") {
+                bad_request("共创授权档位不合法，只接受 forbidden / nonCommercial / full")
+            } else {
+                bad_request("创建作品请求字段不合法")
+            }
+        })?;
+    validate_game_creation_metadata(&payload)?;
+    let now = now_micros();
+    let game_id = format!("game_{}", Uuid::new_v4().simple());
+    let owner_user_id = auth.claims().user_id().to_string();
+    // 幂等摘要只覆盖请求内容（元数据 + 图片字节），不含服务端生成的 objectKey，
+    // 这样重放同一个 Idempotency-Key 时摘要稳定、命中既有结果；血缘声明也在 metadata 里，
+    // 因此同样被摘要覆盖。
+    let request_digest = publish_request_digest(&payload, cover.as_ref(), screenshots.as_slice())?;
+    // 先在接触对象存储前完成所有会让用户输入失败的转换：normalize_local_project_id 与血缘声明
+    // 的读取都要在这里求值——留到 create_game_distribution_game 的实参里，`?` 会在上传之后才返回，
+    // 传完的封面/截图就成了孤儿。
+    let local_project_id = normalize_local_project_id(payload.local_project_id.as_deref())?;
+    let forked_from_game_id = payload
+        .fork
+        .as_ref()
+        .map(|fork| fork.parent_game_id.clone());
+    let forked_from_version_id = payload
+        .fork
+        .as_ref()
+        .map(|fork| fork.parent_version_id.clone());
+    let (cover_object_key, resolved_screenshots, uploaded_media) = resolve_publish_media(
+        &state,
+        game_id.as_str(),
+        payload.cover_object_key.clone(),
+        &payload.screenshots,
+        cover,
+        screenshots,
+        None,
+    )
+    .await?;
+    let game = cleanup_uncommitted_publish_media(
+        &state,
+        &uploaded_media,
+        state
+            .spacetime_client()
+            .create_game_distribution_game(
+                spacetime_client::GameDistributionCreateGameRecordInput {
+                    game_id,
+                    owner_user_id,
+                    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_object_key: Some(cover_object_key),
+                    screenshots_json: Some(
+                        serde_json::to_string(&resolved_screenshots)
+                            .map_err(|error| internal(error.to_string()))?,
+                    ),
+                    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: orientation_wire_value(payload.orientation)?,
+                    // 只对**母版**生效：带 `fork` 声明时，新作品的档位由事务从父作品行继承（创建时
+                    // 快照），这里原样透传的客户端取值会被忽略且不报错——旧客户端在衍生作品上惯常
+                    // 带默认档位。
+                    fork_authorization: fork_authorization_value(payload.fork_authorization),
+                    idempotency_key,
+                    request_digest,
+                    now_micros: now,
+                    local_project_id,
+                    forked_from_game_id,
+                    forked_from_version_id,
+                },
+            )
+            .await,
+    )
+    .await?;
+    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>,
+    multipart: Multipart,
+) -> Result<Json<Value>, AppError> {
+    ensure_publish_enabled(&state, Some(auth.claims().user_id())).await?;
+    let idempotency_key = idempotency_key(&headers)?;
+    let owner_user_id = auth.claims().user_id().to_string();
+    let PublishMultipart {
+        metadata,
+        cover,
+        screenshots,
+    } = parse_publish_multipart(multipart).await?;
+    let payload: GameDistributionCreateVersionRequest =
+        serde_json::from_value(metadata).map_err(|_| bad_request("metadata 字段不合法"))?;
+    validate_legacy_version_declaration(&payload)?;
+    validate_game_creation_metadata(&payload.game_metadata)?;
+    let current = state
+        .spacetime_client()
+        .get_game_distribution_game(GameDistributionGetGameRecordInput {
+            game_id: 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 now = now_micros();
+    let version_id = format!("gamever_{}", Uuid::new_v4().simple());
+    let request_digest = publish_request_digest(
+        &(game_id.as_str(), &payload),
+        cover.as_ref(),
+        screenshots.as_slice(),
+    )?;
+    // 与 create_game 同理：用户输入相关的失败必须在 resolve_publish_media 上传之前发生，
+    // 否则 `?` 会在 cleanup_uncommitted_publish_media 之前返回，留下孤儿媒体对象。
+    let local_project_id = normalize_local_project_id(payload.local_project_id.as_deref())?;
+    let (cover_object_key, resolved_screenshots, uploaded_media) = resolve_publish_media(
+        &state,
+        game_id.as_str(),
+        payload.game_metadata.cover_object_key.clone(),
+        &payload.game_metadata.screenshots,
+        cover,
+        screenshots,
+        Some(&current),
+    )
+    .await?;
+    let version_metadata = GameMetadata::from(&payload.game_metadata);
+    let metadata_json = resolve_version_metadata_json(
+        &version_metadata,
+        cover_object_key.as_str(),
+        resolved_screenshots.as_slice(),
+        payload.price_mud_points,
+    )
+    .await?;
+    let version = cleanup_uncommitted_publish_media(
+        &state,
+        &uploaded_media,
+        state
+            .spacetime_client()
+            .create_game_distribution_version(
+                spacetime_client::GameDistributionCreateVersionRecordInput {
+                    game_id,
+                    owner_user_id,
+                    version_id,
+                    version_number: payload.version_number,
+                    metadata_json,
+                    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,
+                    idempotency_key,
+                    request_digest,
+                    now_micros: now,
+                    // 原样透传（未 trim、未校验）：规则只在写入事务里判定一次，HTTP 层不做第二套判据。
+                    change_summary: payload.change_summary.clone(),
+                },
+            )
+            .await,
+    )
+    .await?;
+    Ok(json_success_body(
+        Some(&ctx),
+        private_version_payload(&version.0),
+    ))
+}
+
 /// 买断制购买：扣泥点与写购买记录在同一事务内完成，`Idempotency-Key` 保证双击与重试只扣一次。
 ///
 /// 只接受普通用户 bearer：管理员令牌与用户令牌共用同一 JWT 签名密钥，
@@ -2297,12 +3772,12 @@ async fn upload_package_chunk(
     Path(version_id): Path<String>,
     body: Bytes,
 ) -> Result<Json<Value>, AppError> {
-    require_octet_stream_content_type(&headers)?;
+    require_octet_stream_content_type(&headers, "发行包分片必须使用 application/octet-stream")?;
     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 offset = package_upload_offset(&headers)?;
+    let offset = package_upload_offset(&headers, "发行包")?;
     if body.is_empty() {
         return Err(bad_request("发行包分片内容不能为空"));
     }
@@ -2561,6 +4036,505 @@ async fn reset_package_upload(
     ))
 }
 
+/// 工程源包上传的阶段门：5 条路由共用这一条规则，禁止在 handler 里各写一遍。
+///
+/// 两道判定缺一不可：
+/// - **先判「已确认过工程包」**（`project_bundle_bytes > 0`）→ 409，文案必须含「已存在」，
+///   与 `map_spacetime_error` 的「已存在」子串映射同口径。顺序不能颠倒：确认工程包**不驱动**
+///   版本状态机，已确认的版本仍可能停在 `awaiting_upload`，只判状态会把它当成可写，放任第二次
+///   上传覆盖已确认的摘要与字节。
+/// - **再判阶段**：只有 `awaiting_upload` / `upload_failed` 能写（与发行包确认同一道门）；
+///   已提交、验证中、待审核、已拒绝、已公开、已撤回、已取消一律 409——版本不可变。
+fn ensure_project_bundle_uploadable(
+    version: &GameDistributionVersionRecord,
+) -> Result<(), AppError> {
+    if version.project_bundle_bytes > 0 {
+        return Err(AppError::from_status(StatusCode::CONFLICT)
+            .with_code("PROJECT_BUNDLE_ALREADY_EXISTS")
+            .with_message("同一版本已存在工程源包，换内容必须新建版本"));
+    }
+    if !matches!(version.status.as_str(), "awaiting_upload" | "upload_failed") {
+        return Err(AppError::from_status(StatusCode::CONFLICT)
+            .with_code("PROJECT_BUNDLE_UPLOAD_NOT_ALLOWED")
+            .with_message(format!(
+                "版本状态 {} 不允许上传工程源包，未公开前才能写一次",
+                version.status
+            )));
+    }
+    Ok(())
+}
+
+/// 工程源包校验失败的映射：与发行包同形（422 + 稳定错误码 + 具体原因），只是错误码换成工程包。
+fn map_project_bundle_error(error: ProjectBundleError) -> AppError {
+    AppError::from_status(StatusCode::UNPROCESSABLE_ENTITY)
+        .with_code("PROJECT_BUNDLE_VALIDATION_FAILED")
+        .with_details(json!({ "provider": "game-distribution", "reason": format!("{error:?}") }))
+}
+
+/// 工程源包整包上传（一次 PUT）：语义逐条镜像发行包整包上传，只是资产与对象键换成工程源包。
+///
+/// 载体类型是 `application/octet-stream`（技术方案 §3.4）：作者侧打包器已经产出 zip 字节，
+/// 不需要客户端再声明 `application/zip`；**服务端仍独立跑工程包门禁**，不信任客户端。
+async fn upload_project_bundle(
+    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_octet_stream_content_type(&headers, "工程源包必须使用 application/octet-stream")?;
+    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 =
+        load_owner_version_or_404(&state, owner_user_id.clone(), version_id.clone()).await?;
+    ensure_project_bundle_uploadable(&expected)?;
+    let manifest = match validate_project_bundle_zip(&body) {
+        Ok(manifest) => manifest,
+        Err(error) => {
+            let reason = format!("{error:?}");
+            warn!(
+                request_id = ctx.request_id(),
+                operation = "project_bundle_rejected",
+                game_id = %expected.game_id,
+                version_id = %version_id,
+                code = "PROJECT_BUNDLE_VALIDATION_FAILED",
+                reason = %reason,
+                uploaded_bytes = body.len(),
+                elapsed_ms = ctx.elapsed(),
+                "工程源包校验失败"
+            );
+            let mapped = map_project_bundle_error(error);
+            record_upload_failure(
+                &state,
+                &owner_user_id,
+                &version_id,
+                &idempotency_key,
+                "PROJECT_BUNDLE_VALIDATION_FAILED",
+                reason,
+            )
+            .await;
+            return Err(mapped);
+        }
+    };
+    let bundle_object_key =
+        game_distribution_project_bundle_object_key(&expected.game_id, &version_id);
+    let oss = game_distribution_oss_client(&state)?;
+    let existing = oss
+        .head_internal_object(state.editor_oss_http_client(), &bundle_object_key)
+        .await
+        .map_err(|error| map_oss_error(error, "aliyun-oss"))?;
+    let skipped = match existing {
+        Some(existing) if existing.content_length == manifest.bundle_bytes => true,
+        Some(_) => {
+            let error = AppError::from_status(StatusCode::CONFLICT)
+                .with_code("PROJECT_BUNDLE_OBJECT_MISMATCH")
+                .with_message("工程源包对象已存在但体积不一致");
+            record_upload_failure(
+                &state,
+                &owner_user_id,
+                &version_id,
+                &idempotency_key,
+                "PROJECT_BUNDLE_OBJECT_MISMATCH",
+                "工程源包对象已存在但体积不一致".to_string(),
+            )
+            .await;
+            return Err(error);
+        }
+        None => false,
+    };
+    if !skipped {
+        // 重试口径与发行包一致：只重试 platform-oss 认定的可重试分类（传输/超时/408/429/5xx）。
+        oss.put_internal_object_with_retry(
+            state.editor_oss_http_client(),
+            OssInternalPutObjectRequest {
+                object_key: bundle_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"))?;
+    }
+    confirm_validated_project_bundle(
+        &state,
+        &ctx,
+        &owner_user_id,
+        &version_id,
+        &expected.game_id,
+        &manifest,
+        bundle_object_key,
+        &idempotency_key,
+        skipped,
+    )
+    .await
+}
+
+/// 工程源包校验通过后的共同收口：整包 PUT 与分片 complete 共用这条路径。
+///
+/// 幂等摘要的组织方式与发行包 complete 同形（`(version_id, sha256)` 序列化后取摘要），
+/// 只是字段换成工程源包；同 key 重放由模块事务按摘要识别并返回 `replayed = true`。
+#[allow(clippy::too_many_arguments)]
+async fn confirm_validated_project_bundle(
+    state: &AppState,
+    ctx: &RequestContext,
+    owner_user_id: &str,
+    version_id: &str,
+    game_id: &str,
+    manifest: &ProjectBundleManifest,
+    bundle_object_key: String,
+    idempotency_key: &str,
+    oss_put_skipped: bool,
+) -> Result<Json<Value>, AppError> {
+    let request_digest = compute_request_digest(
+        &serde_json::to_vec(&(version_id, manifest.bundle_sha256.as_str()))
+            .map_err(|error| internal(error.to_string()))?,
+    );
+    let log_bundle_bytes = manifest.bundle_bytes;
+    let log_file_count = u32::try_from(manifest.files.len()).unwrap_or(u32::MAX);
+    let log_sha_prefix = manifest.bundle_sha256.chars().take(12).collect::<String>();
+    let confirmed = state
+        .spacetime_client()
+        .confirm_game_distribution_project_bundle(
+            spacetime_client::GameDistributionConfirmProjectBundleRecordInput {
+                version_id: version_id.to_string(),
+                owner_user_id: owner_user_id.to_string(),
+                project_bundle_object_key: bundle_object_key,
+                project_bundle_bytes: manifest.bundle_bytes,
+                project_bundle_sha256: manifest.bundle_sha256.clone(),
+                idempotency_key: idempotency_key.to_string(),
+                request_digest,
+                updated_at_micros: now_micros(),
+            },
+        )
+        .await
+        .map_err(map_spacetime_error)?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "project_bundle_confirmed",
+        game_id = %game_id,
+        version_id = %confirmed.0.version_id,
+        project_bundle_bytes = log_bundle_bytes,
+        file_count = log_file_count,
+        sha256_prefix = %log_sha_prefix,
+        replayed = confirmed.1,
+        oss_put_skipped,
+        elapsed_ms = ctx.elapsed(),
+        "工程源包已确认"
+    );
+    Ok(json_success_body(
+        Some(ctx),
+        json!({ "versionId": confirmed.0.version_id, "status": confirmed.0.status }),
+    ))
+}
+
+/// 工程源包分片续传的状态查询：已收字节同样取自 OSS 对象事实，因此进程重启、换机器或换网络
+/// 后都能从权威偏移继续。工程源包没有「创建版本时预登记的大小」，因此响应里没有 declared* 键。
+async fn project_bundle_upload_state(
+    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();
+    ensure_publish_enabled(&state, Some(owner_user_id.as_str())).await?;
+    let version = load_owner_version_or_404(&state, owner_user_id, version_id.clone()).await?;
+    ensure_project_bundle_uploadable(&version)?;
+    let oss = game_distribution_oss_client(&state)?;
+    let object_key = game_distribution_project_bundle_object_key(&version.game_id, &version_id);
+    let received_bytes = staged_package_bytes(&state, oss, &object_key).await?;
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({
+            "versionId": version_id,
+            "status": version.status,
+            "chunkBytes": PACKAGE_UPLOAD_CHUNK_BYTES,
+            "receivedBytes": received_bytes,
+        }),
+    ))
+}
+
+/// 工程源包分片写入：偏移语义、分片边界与并发处理逐条对齐发行包分片。
+///
+/// 工程源包没有预登记大小，因此「不得超过」的闸门是合同上限 `MAX_PROJECT_BUNDLE_BYTES`
+/// （与发行包上限同值）；真实体积由 complete 时的整包校验确定。
+async fn upload_project_bundle_chunk(
+    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_octet_stream_content_type(&headers, "工程源包分片必须使用 application/octet-stream")?;
+    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 offset = package_upload_offset(&headers, "工程源包")?;
+    if body.is_empty() {
+        return Err(bad_request("工程源包分片内容不能为空"));
+    }
+    if body.len() > PACKAGE_UPLOAD_CHUNK_BYTES {
+        return Err(AppError::from_status(StatusCode::PAYLOAD_TOO_LARGE)
+            .with_code("PROJECT_BUNDLE_CHUNK_TOO_LARGE")
+            .with_message("工程源包分片超过服务端下发的大小"));
+    }
+    let version = load_owner_version_or_404(&state, owner_user_id, version_id.clone()).await?;
+    ensure_project_bundle_uploadable(&version)?;
+    let chunk_bytes = u64::try_from(body.len()).unwrap_or(u64::MAX);
+    let end = offset
+        .checked_add(chunk_bytes)
+        .ok_or_else(|| bad_request("工程源包分片偏移溢出"))?;
+    if end > MAX_PROJECT_BUNDLE_BYTES {
+        return Err(AppError::from_status(StatusCode::CONFLICT)
+            .with_code("PROJECT_BUNDLE_UPLOAD_EXCEEDS_LIMIT")
+            .with_details(json!({
+                "provider": "game-distribution",
+                "maxProjectBundleBytes": MAX_PROJECT_BUNDLE_BYTES,
+                "receivedBytes": offset,
+                "message": "分片写入会超过工程源包体积上限",
+            })));
+    }
+    let oss = game_distribution_oss_client(&state)?;
+    let object_key = game_distribution_project_bundle_object_key(&version.game_id, &version_id);
+    let received_bytes = staged_package_bytes(&state, oss, &object_key).await?;
+    if offset != received_bytes {
+        warn!(
+            request_id = ctx.request_id(),
+            operation = "project_bundle_chunk_offset_mismatch",
+            game_id = %version.game_id,
+            version_id = %version_id,
+            declared_offset = offset,
+            received_bytes,
+            "工程源包分片偏移与服务端已收字节不一致"
+        );
+        return Err(AppError::from_status(StatusCode::CONFLICT)
+            .with_code("PROJECT_BUNDLE_UPLOAD_OFFSET_MISMATCH")
+            .with_message("分片偏移与服务端已收字节不一致，请按权威偏移续传")
+            .with_details(json!({
+                "provider": "game-distribution",
+                "receivedBytes": received_bytes,
+            })));
+    }
+    let append_result = oss
+        .append_internal_object_with_retry(
+            state.editor_oss_http_client(),
+            OssAppendInternalObjectRequest {
+                object_key: object_key.clone(),
+                content_type: Some("application/zip".to_string()),
+                access: OssObjectAccess::Private,
+                position: offset,
+                body: body.to_vec(),
+            },
+            GAME_DISTRIBUTION_OSS_PUT_MAX_ATTEMPTS,
+            &GAME_DISTRIBUTION_OSS_PUT_RETRY_DELAYS_MS,
+        )
+        .await;
+    let appended = match append_result {
+        Ok(appended) => appended,
+        Err(error) => {
+            // 同偏移的并发写入可能先赢了一片：只要权威长度已经前进，就按偏移冲突返回，
+            // 让客户端按权威偏移续传，而不是把一个可恢复的并发结果报成上游故障。
+            if let Ok(authoritative) = staged_package_bytes(&state, oss, &object_key).await
+                && authoritative > offset
+            {
+                warn!(
+                    request_id = ctx.request_id(),
+                    operation = "project_bundle_chunk_offset_lost_race",
+                    game_id = %version.game_id,
+                    version_id = %version_id,
+                    declared_offset = offset,
+                    received_bytes = authoritative,
+                    "并发写入已推进已收字节，按偏移冲突返回权威位置"
+                );
+                return Err(AppError::from_status(StatusCode::CONFLICT)
+                    .with_code("PROJECT_BUNDLE_UPLOAD_OFFSET_MISMATCH")
+                    .with_message("分片偏移与服务端已收字节不一致，请按权威偏移续传")
+                    .with_details(json!({
+                        "provider": "game-distribution",
+                        "receivedBytes": authoritative,
+                    })));
+            }
+            return Err(map_oss_error(error, "aliyun-oss"));
+        }
+    };
+    info!(
+        request_id = ctx.request_id(),
+        operation = "project_bundle_chunk_stored",
+        game_id = %version.game_id,
+        version_id = %version_id,
+        offset,
+        chunk_bytes = appended.appended_bytes,
+        received_bytes = appended.next_position,
+        elapsed_ms = ctx.elapsed(),
+        "工程源包分片已写入"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({
+            "versionId": version_id,
+            "chunkBytes": PACKAGE_UPLOAD_CHUNK_BYTES,
+            "receivedBytes": appended.next_position,
+        }),
+    ))
+}
+
+/// 工程源包分片续传的完成动作：全部字节到齐后才回读整包、独立校验并确认。
+///
+/// 校验失败时照抄发行包 complete 的处理：删除半包对象、记一次上传失败、返回既有错误形状
+/// （422 + `PROJECT_BUNDLE_VALIDATION_FAILED`），避免半包留在对象键上拖住后续重传。
+async fn complete_project_bundle_upload(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(version_id): Path<String>,
+) -> 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?;
+    ensure_project_bundle_uploadable(&version)?;
+    let oss = game_distribution_oss_client(&state)?;
+    let object_key = game_distribution_project_bundle_object_key(&version.game_id, &version_id);
+    let received_bytes = staged_package_bytes(&state, oss, &object_key).await?;
+    if received_bytes == 0 {
+        return Err(AppError::from_status(StatusCode::CONFLICT)
+            .with_code("PROJECT_BUNDLE_UPLOAD_NOT_STARTED")
+            .with_details(json!({
+                "provider": "game-distribution",
+                "receivedBytes": 0,
+                "message": "该版本还没有任何已收工程源包分片",
+            })));
+    }
+    let body = oss
+        .get_object(
+            state.editor_oss_http_client(),
+            OssGetObjectRequest {
+                object_key: object_key.clone(),
+                max_bytes: MAX_PROJECT_BUNDLE_BYTES as usize,
+            },
+        )
+        .await
+        .map_err(|error| map_oss_error(error, "aliyun-oss"))?;
+    // 工程源包没有预登记大小，「收齐」只能由「HEAD 的权威长度 == 读回的字节数」证明；
+    // 两者不一致说明读回期间对象被并发改写，按未收齐拒绝，让客户端重新对齐偏移。
+    if u64::try_from(body.len()).unwrap_or(u64::MAX) != received_bytes {
+        return Err(AppError::from_status(StatusCode::CONFLICT)
+            .with_code("PROJECT_BUNDLE_UPLOAD_INCOMPLETE")
+            .with_message("工程源包分片尚未收齐")
+            .with_details(json!({
+                "provider": "game-distribution",
+                "receivedBytes": received_bytes,
+                "readBytes": body.len(),
+            })));
+    }
+    let manifest = match validate_project_bundle_zip(&body) {
+        Ok(manifest) => manifest,
+        Err(error) => {
+            let reason = format!("{error:?}");
+            warn!(
+                request_id = ctx.request_id(),
+                operation = "project_bundle_rejected",
+                game_id = %version.game_id,
+                version_id = %version_id,
+                code = "PROJECT_BUNDLE_VALIDATION_FAILED",
+                reason = %reason,
+                uploaded_bytes = body.len(),
+                elapsed_ms = ctx.elapsed(),
+                "工程源包校验失败"
+            );
+            let mapped = map_project_bundle_error(error);
+            if let Err(delete_error) = oss
+                .delete_object(
+                    state.editor_oss_http_client(),
+                    OssDeleteObjectRequest {
+                        object_key: object_key.clone(),
+                    },
+                )
+                .await
+            {
+                warn!(
+                    request_id = ctx.request_id(),
+                    operation = "project_bundle_staging_delete_failed",
+                    version_id = %version_id,
+                    error = %delete_error,
+                    "校验失败的半包对象删除失败，需要人工确认对象键状态"
+                );
+            }
+            record_upload_failure(
+                &state,
+                &owner_user_id,
+                &version_id,
+                &idempotency_key,
+                "PROJECT_BUNDLE_VALIDATION_FAILED",
+                reason,
+            )
+            .await;
+            return Err(mapped);
+        }
+    };
+    confirm_validated_project_bundle(
+        &state,
+        &ctx,
+        &owner_user_id,
+        &version_id,
+        &version.game_id,
+        &manifest,
+        object_key,
+        &idempotency_key,
+        true,
+    )
+    .await
+}
+
+/// 显式重置工程源包分片会话：删除暂存对象并把已收字节归零。
+///
+/// 与发行包 reset 同一道门（共用 `ensure_project_bundle_uploadable`）：只有尚未确认过工程源包
+/// 且仍处于上传档位的版本能重置；已确认的版本换内容必须新建版本。
+async fn reset_project_bundle_upload(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(version_id): Path<String>,
+) -> 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, version_id.clone()).await?;
+    ensure_project_bundle_uploadable(&version)?;
+    let oss = game_distribution_oss_client(&state)?;
+    let object_key = game_distribution_project_bundle_object_key(&version.game_id, &version_id);
+    oss.delete_object(
+        state.editor_oss_http_client(),
+        OssDeleteObjectRequest {
+            object_key: object_key.clone(),
+        },
+    )
+    .await
+    .map_err(|error| map_oss_error(error, "aliyun-oss"))?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "project_bundle_upload_reset",
+        game_id = %version.game_id,
+        version_id = %version_id,
+        elapsed_ms = ctx.elapsed(),
+        "工程源包分片会话已重置"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        json!({ "versionId": version_id, "receivedBytes": 0 }),
+    ))
+}
+
 fn game_distribution_oss_client(state: &AppState) -> Result<&platform_oss::OssClient, AppError> {
     state.project_snapshot_oss_client().ok_or_else(|| {
         AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_message("游戏发行包 OSS 未配置")
@@ -2571,6 +4545,16 @@ fn game_distribution_package_object_key(game_id: &str, version_id: &str) -> Stri
     format!("{GAME_DISTRIBUTION_OBJECT_PREFIX}{game_id}/{version_id}.zip")
 }
 
+/// 工程源包对象键。
+///
+/// **必须**与发行包键（`…/{version_id}.zip`）不同：同一 (作品, 版本) 的两份资产（成品包与
+/// 工程源包）会先后上传，共用键会让后传的那份覆盖前一份，已确认的摘要与字节随即变成谎话，
+/// 发行网关与取件通道也会读到另一份资产。这里靠 `.project.zip` 后缀区分，两个键都在同一
+/// 前缀族下，便于生命周期策略统一。
+fn game_distribution_project_bundle_object_key(game_id: &str, version_id: &str) -> String {
+    format!("{GAME_DISTRIBUTION_OBJECT_PREFIX}{game_id}/{version_id}.project.zip")
+}
+
 /// 已收字节的权威来源：对象存在时的长度；确定不存在时是 0，其它失败按上游错误上报。
 async fn staged_package_bytes(
     state: &AppState,
@@ -2584,7 +4568,12 @@ async fn staged_package_bytes(
     Ok(head.map(|object| object.content_length).unwrap_or(0))
 }
 
-fn require_octet_stream_content_type(headers: &HeaderMap) -> Result<(), AppError> {
+/// `application/octet-stream` 是发行包分片与工程源包（整包与分片）共同的载体类型；
+/// 错误文案由调用方给，避免把「发行包分片」这句话安在工程源包上。
+fn require_octet_stream_content_type(
+    headers: &HeaderMap,
+    message: &'static str,
+) -> Result<(), AppError> {
     let content_type = headers
         .get(header::CONTENT_TYPE)
         .and_then(|value| value.to_str().ok())
@@ -2597,20 +4586,22 @@ fn require_octet_stream_content_type(headers: &HeaderMap) -> Result<(), AppError
                 .to_ascii_lowercase()
         });
     if content_type.as_deref() != Some("application/octet-stream") {
-        return Err(bad_request("发行包分片必须使用 application/octet-stream"));
+        return Err(bad_request(message));
     }
     Ok(())
 }
 
-fn package_upload_offset(headers: &HeaderMap) -> Result<u64, AppError> {
+/// 分片偏移头：发行包分片与工程源包分片共用同一个头名与解析口径（两者上限同值，客户端
+/// 只能有一套偏移语义）；`asset` 只用于错误文案，避免把「发行包」安在工程源包上。
+fn package_upload_offset(headers: &HeaderMap, asset: &'static str) -> Result<u64, AppError> {
     let raw = headers
         .get(PACKAGE_UPLOAD_OFFSET_HEADER)
         .and_then(|value| value.to_str().ok())
         .map(str::trim)
         .filter(|value| !value.is_empty())
-        .ok_or_else(|| bad_request("缺少发行包分片偏移"))?;
+        .ok_or_else(|| bad_request(format!("缺少{asset}分片偏移")))?;
     raw.parse::<u64>()
-        .map_err(|_| bad_request("发行包分片偏移必须是非负整数"))
+        .map_err(|_| bad_request(format!("{asset}分片偏移必须是非负整数")))
 }
 
 async fn submit_version(
@@ -2833,6 +4824,283 @@ async fn unpublish_game(
     ))
 }
 
+/// 作者修改作品的共创授权档位。**只有母版**可提升：只升不降，降级与未知档位由领域层拒绝；
+/// 衍生作品（存在血缘行）的档位由创建时继承父作品决定，是终态，一律 409
+/// `FORK_AUTHORIZATION_INHERITED`（含传同值的幂等重试）。
+async fn set_fork_authorization(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Extension(auth): Extension<AuthenticatedAccessToken>,
+    headers: HeaderMap,
+    Path(game_id): Path<String>,
+    payload: Result<Json<GameDistributionSetForkAuthorizationRequest>, JsonRejection>,
+) -> Result<Json<Value>, AppError> {
+    // 未知档位（例如 `"allowed"`）在进入业务前就被 serde 拦下：这里必须把它映射成平台信封的
+    // 400，而不是让 axum 的默认 `JsonRejection` 直接回 422 纯文本——合同要求未知档位是 400，
+    // 且前端错误处理依赖信封（同文件的评价保存、评价管理两处同写法）。
+    // 领域层的 `FORK_AUTHORIZATION_UNKNOWN`（map_spacetime_error 里映射 400）仍然可达：
+    // procedure 路径读到库里存的未知档位字符串时依旧由它兜底。
+    let Json(payload) = payload.map_err(|_| {
+        AppError::from_status(StatusCode::BAD_REQUEST)
+            .with_message("共创授权档位不合法，只接受 forbidden / nonCommercial / full")
+    })?;
+    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_fork_authorization,
+            payload.fork_authorization,
+        ))
+        .map_err(|error| internal(error.to_string()))?,
+    );
+    let game = state
+        .spacetime_client()
+        .set_game_distribution_fork_authorization(GameDistributionSetForkAuthorizationRecordInput {
+            game_id,
+            owner_user_id,
+            fork_authorization: fork_authorization_value(payload.fork_authorization),
+            expected_fork_authorization: fork_authorization_value(
+                payload.expected_fork_authorization,
+            ),
+            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 }),
+    ))
+}
+
+/// 取件校验通过后的目标：内容下发只需要**选定资产**的版本身份与摘要。
+#[derive(Debug, PartialEq, Eq)]
+struct ForkSourceTarget {
+    version_id: String,
+    /// 选定资产：有工程源包时 `Project`（优先），否则回落 `Package`。
+    source: GameDistributionForkSourceKind,
+    sha256: String,
+    bytes: u64,
+}
+
+/// 取件校验的纯映射：把「读到了什么」折成 HTTP 语义。
+///
+/// 顺序即合同顺序，也与 procedure 侧创建血缘时的判定顺序一致：行不存在 → 404；行存在但不可作
+/// 来源（已软删除 / 未公开 / 没有当前公开版本）→ 409；授权为禁止或**未知档位** → 403
+/// （未知按「禁止共创」解释，与 `resolve_game_distribution_fork_declaration_tx` 同口径）。
+/// 抽成纯函数是为了让这条映射可被单测钉住，而不是散落在两个 handler 里各写一遍。
+///
+/// 选定资产（M2b）：`project_bundle_bytes > 0 && project_bundle_sha256.is_some()` 才算「有工程
+/// 源包」，此时优先 `Project`；否则回落 `Package`。**失败关闭**：工程包的字节数与摘要必须成对
+/// ——「字节数 > 0 但摘要为空」这种半写行按「没有工程包」处理并回落成品包，而不是把取件指向一个
+/// 摘不出来、客户端也无法校验的资产；没有任何可用资产时 409，不发半截信息。
+fn fork_source_target(
+    record: GameDistributionForkSourceRecord,
+) -> Result<ForkSourceTarget, AppError> {
+    if !record.found {
+        return Err(AppError::from_status(StatusCode::NOT_FOUND).with_code("FORK_SOURCE_NOT_FOUND"));
+    }
+    if !record.available {
+        return Err(
+            AppError::from_status(StatusCode::CONFLICT).with_code("FORK_SOURCE_NOT_AVAILABLE")
+        );
+    }
+    let authorization =
+        module_game_distribution::ForkAuthorization::parse(record.fork_authorization.as_str())
+            .unwrap_or(module_game_distribution::ForkAuthorization::Forbidden);
+    if !authorization.allows_fork() {
+        return Err(AppError::from_status(StatusCode::FORBIDDEN).with_code("FORK_NOT_AUTHORIZED"));
+    }
+    let Some(version_id) = record.version_id else {
+        return Err(
+            AppError::from_status(StatusCode::CONFLICT).with_code("FORK_SOURCE_NOT_AVAILABLE")
+        );
+    };
+    // 有工程源包（字节数与摘要成对）→ 优先取源码包；半写行与缺失都按「没有工程包」处理。
+    if let (Some(sha256), bytes) = (record.project_bundle_sha256, record.project_bundle_bytes)
+        && bytes > 0
+    {
+        return Ok(ForkSourceTarget {
+            version_id,
+            source: GameDistributionForkSourceKind::Project,
+            sha256,
+            bytes,
+        });
+    }
+    // 回落成品包：同样要求字节数与摘要成对，否则失败关闭。
+    let (Some(sha256), Some(bytes)) = (record.package_sha256, record.package_bytes) else {
+        return Err(
+            AppError::from_status(StatusCode::CONFLICT).with_code("FORK_SOURCE_NOT_AVAILABLE")
+        );
+    };
+    Ok(ForkSourceTarget {
+        version_id,
+        source: GameDistributionForkSourceKind::Package,
+        sha256,
+        bytes,
+    })
+}
+
+/// 取件通道的公共校验：两个 handler 都走它，规则只写一遍。
+async fn resolve_fork_source(
+    state: &AppState,
+    game_id: &str,
+) -> Result<ForkSourceTarget, AppError> {
+    let record = state
+        .spacetime_client()
+        .get_game_distribution_fork_source(game_id.to_string())
+        .await
+        .map_err(map_spacetime_error)?;
+    fork_source_target(record)
+}
+
+/// 游戏标识必须能安全落在 URL 路径段里；发行入口与取件下载路径共用同一条判据。
+fn is_path_safe_game_id(game_id: &str) -> bool {
+    !game_id.is_empty()
+        && game_id.chars().all(|character| {
+            character.is_ascii_alphanumeric() || character == '-' || character == '_'
+        })
+}
+
+/// 取件下载路径：同源相对路径，**绝不下发 OSS 对象键**；路径按选定资产指向对应资产。
+fn build_fork_source_download_path(
+    game_id: &str,
+    source: GameDistributionForkSourceKind,
+) -> Result<String, AppError> {
+    if !is_path_safe_game_id(game_id) {
+        return Err(internal("游戏标识不适用于取件路径"));
+    }
+    let asset = match source {
+        GameDistributionForkSourceKind::Project => "project",
+        GameDistributionForkSourceKind::Package => "package",
+    };
+    Ok(format!(
+        "/api/game-distribution/games/{game_id}/fork-source/{asset}"
+    ))
+}
+
+/// 取件元数据响应：只含版本身份与**选定资产**的摘要，对象键留在服务端。
+fn fork_source_payload(
+    game_id: &str,
+    target: &ForkSourceTarget,
+) -> Result<GameDistributionForkSourceResponse, AppError> {
+    Ok(GameDistributionForkSourceResponse {
+        fork_source: GameDistributionForkSource {
+            game_id: game_id.to_string(),
+            version_id: target.version_id.clone(),
+            source: target.source,
+            sha256: target.sha256.clone(),
+            bytes: target.bytes,
+            download_path: build_fork_source_download_path(game_id, target.source)?,
+        },
+    })
+}
+
+/// Fork 取件元数据：告诉客户端「能改编哪一版、摘要多少、去哪儿取」。
+///
+/// 受鉴权（Bearer）但不叠加发布灰度：任何登录用户都应该能改编已授权的作品。
+async fn get_fork_source(
+    State(state): State<AppState>,
+    Extension(ctx): Extension<RequestContext>,
+    Path(game_id): Path<String>,
+) -> Result<Json<Value>, AppError> {
+    let target = resolve_fork_source(&state, &game_id).await?;
+    info!(
+        request_id = ctx.request_id(),
+        operation = "game_fork_source_metadata",
+        game_id = %game_id,
+        version_id = %target.version_id,
+        source = ?target.source,
+        bytes = target.bytes,
+        elapsed_ms = ctx.elapsed(),
+        "下发 Fork 取件元数据"
+    );
+    Ok(json_success_body(
+        Some(&ctx),
+        fork_source_payload(&game_id, &target)?,
+    ))
+}
+
+/// Fork 取件本体：直接回该版本发行包 ZIP 的字节。
+///
+/// 复用发行网关那条读包路径（`release_package_bytes`：整包读入内存 + 进程内缓存，上限 4 条 /
+/// 256 MiB），不新造 OSS 客户端或第二条读包通道；缓存值是 `Bytes`，因此这里把整包交给响应体
+/// 只加一次引用计数，不复制。**不做**发行网关的引用归一化与 bootstrap 注入——那是给在线试玩
+/// 用的，取件下发的是原始构建产物，客户端要按摘要校验后离线解压，任何改写都会让摘要对不上。
+async fn get_fork_source_package(
+    State(state): State<AppState>,
+    Path(game_id): Path<String>,
+) -> Result<Response, AppError> {
+    let target = resolve_fork_source(&state, &game_id).await?;
+    let package = release_package_bytes(&state, &game_id, &target.version_id).await?;
+    Ok(fork_source_package_response(
+        &game_id,
+        &target.version_id,
+        package,
+    ))
+}
+
+/// Fork 取件本体（源码级）：直接回该版本工程源包 ZIP 的字节。
+///
+/// 与 `/fork-source/package` 走同一套 `resolve_fork_source` 校验，差别只有一处且是**失败关闭**：
+/// 选定资产不是 `Project` 时返回 409 `FORK_SOURCE_NOT_AVAILABLE`，绝不悄悄回落成品包——客户端
+/// 按 `source` 决定建项形态，在这里回一份成品包会让客户端按源码解压并直接失败。
+/// 读路径复用发行包的整包读入 + 进程内缓存，但对象键换成工程源包，缓存键因此天然带资产维度。
+/// 与成品包一样**不做**引用归一化与 bootstrap 注入：下发的是原始工程包，客户端要按摘要校验。
+async fn get_fork_source_project(
+    State(state): State<AppState>,
+    Path(game_id): Path<String>,
+) -> Result<Response, AppError> {
+    let target = resolve_fork_source(&state, &game_id).await?;
+    if target.source != GameDistributionForkSourceKind::Project {
+        return Err(
+            AppError::from_status(StatusCode::CONFLICT).with_code("FORK_SOURCE_NOT_AVAILABLE")
+        );
+    }
+    let object_key = game_distribution_project_bundle_object_key(&game_id, &target.version_id);
+    let bundle = release_asset_bytes(&state, &object_key, MAX_PROJECT_BUNDLE_BYTES).await?;
+    Ok(fork_source_project_response(
+        &game_id,
+        &target.version_id,
+        bundle,
+    ))
+}
+
+/// 取件包的响应头：ZIP + 长度 + 附件文件名 + no-store。两种资产只有文件名后缀不同。
+fn fork_source_bundle_response(file_name: String, bundle: Bytes) -> Response {
+    let content_length = bundle.len();
+    let mut response = Response::new(Body::from(bundle));
+    let headers = response.headers_mut();
+    headers.insert(
+        header::CONTENT_TYPE,
+        HeaderValue::from_static("application/zip"),
+    );
+    headers.insert(
+        header::CONTENT_LENGTH,
+        HeaderValue::from_str(&content_length.to_string())
+            .unwrap_or_else(|_| HeaderValue::from_static("0")),
+    );
+    // 文件名只由路径段安全的两个 ID 拼成，不含用户输入的自由文本。
+    headers.insert(
+        header::CONTENT_DISPOSITION,
+        HeaderValue::from_str(&format!("attachment; filename=\"{file_name}\""))
+            .unwrap_or_else(|_| HeaderValue::from_static("attachment")),
+    );
+    headers.insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+    response
+}
+
+fn fork_source_package_response(game_id: &str, version_id: &str, package: Bytes) -> Response {
+    fork_source_bundle_response(format!("{game_id}-{version_id}.zip"), package)
+}
+
+fn fork_source_project_response(game_id: &str, version_id: &str, bundle: Bytes) -> Response {
+    fork_source_bundle_response(format!("{game_id}-{version_id}-project.zip"), bundle)
+}
+
 async fn admin_list_reviews(
     State(state): State<AppState>,
     Extension(ctx): Extension<RequestContext>,
@@ -3357,11 +5625,7 @@ async fn derive_release_entry_url(state: &AppState, version_id: &str) -> Result<
 
 /// 发行入口固定走平台同源路径，游戏标识必须能安全落在路径段里。
 fn build_release_entry_url(game_id: &str) -> Result<String, AppError> {
-    if game_id.is_empty()
-        || !game_id.chars().all(|character| {
-            character.is_ascii_alphanumeric() || character == '-' || character == '_'
-        })
-    {
+    if !is_path_safe_game_id(game_id) {
         return Err(internal("游戏标识不适用于发行路径"));
     }
     Ok(format!("/games/{game_id}/"))
@@ -3518,6 +5782,27 @@ pub(crate) fn normalize_project_key(value: Option<&str>) -> Result<Option<String
 }
 
 /// 方向枚举的线上取值：serde 序列化成带引号的 JSON 字符串，这里剥掉引号只留值。
+/// 本地项目标识只用于同一作者复用游戏身份；它必须是短标识，不能充当路径或所有权凭证。
+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()))
+}
+
 pub(crate) fn orientation_wire_value(
     orientation: GameDistributionOrientation,
 ) -> Result<String, AppError> {
@@ -3572,7 +5857,7 @@ pub(crate) fn validate_version_declaration(
     payload: &NewGameVersionRequest,
 ) -> Result<(), AppError> {
     // 版本号必填且 >= 1：`0` 走普通 400，不做最大值比较（自然幂等键由版本号参与）。
-    resolve_version_number(payload.version_number)
+    resolve_version_number(0, Some(payload.version_number))
         .map_err(|error| bad_request(error.to_string()))?;
     // 价格随版本冻结，非法价格必须在建版本前拒绝，而不是等到审核通过才失败。
     normalize_game_price_mud_points(payload.price_mud_points)
@@ -3599,6 +5884,47 @@ pub(crate) fn validate_version_declaration(
     validate_game_metadata(&payload.game_metadata)
 }
 
+/// 旧两步发布路径的创建资料校验适配：统一发布重构后资料校验只认 `GameMetadata`，
+/// 旧请求体字段集与之一致（仅多外层身份 `local_project_id`），因此克隆成等价资料后复用同一套判据。
+fn validate_game_creation_metadata(
+    payload: &GameDistributionCreateGameRequest,
+) -> Result<(), AppError> {
+    validate_game_metadata(&GameMetadata::from(payload))
+}
+
+/// 旧两步发布路径的版本声明校验：字段口径与统一请求一致，只是 `versionNumber` 可缺省
+/// （旧客户端兼容，缺省时由写入事务按已有最大值 +1），派生作品的 `changeSummary` 由事务校验。
+fn validate_legacy_version_declaration(
+    payload: &GameDistributionCreateVersionRequest,
+) -> Result<(), AppError> {
+    if let Some(version_number) = payload.version_number {
+        resolve_version_number(0, Some(version_number))
+            .map_err(|error| bad_request(error.to_string()))?;
+    }
+    normalize_game_price_mud_points(payload.price_mud_points)
+        .map_err(|error| bad_request(error.to_string()))?;
+    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_creation_metadata(&payload.game_metadata)
+}
+
 fn require_zip_content_type(headers: &HeaderMap) -> Result<(), AppError> {
     let content_type = headers
         .get(header::CONTENT_TYPE)
@@ -3685,6 +6011,18 @@ fn public_game_payload(
             "ratingSummary".to_string(),
             json!(rating_summary_payload(game.rating_summary)),
         );
+        object.insert("forkCount".to_string(), json!(game.fork_count));
+        // 「共创次数」= 该作品子树里公开可见的**全部后代**数（不含自己），与 `forkCount`
+        // （只数直接子代）刻意并存：网页端共创页卡片优先读这个键、缺省时回退 `forkCount`。
+        // 计数由 spacetime 事务在同一份公开投影里现算，api-server 只发键、不遍历。
+        object.insert("coCreationCount".to_string(), json!(game.co_creation_count));
+        object.insert(
+            "lineage".to_string(),
+            game.lineage
+                .as_ref()
+                .map(lineage_payload)
+                .unwrap_or(Value::Null),
+        );
     }
     payload
 }
@@ -3704,6 +6042,10 @@ fn admin_game_payload(game: &GameDistributionAdminGameRecord) -> Value {
         "playCount": game.play_count,
         "activeVersionId": game.active_version_id,
         "publicationRevision": game.publication_revision,
+        "forkAuthorization": game.fork_authorization,
+        "generation": game.lineage_generation,
+        "forkedFromGameId": game.forked_from_game_id,
+        "derivedCount": game.derived_count,
         "createdAt": game.created_at,
         "updatedAt": game.updated_at,
         "deletedAt": game.deleted_at,
@@ -3763,6 +6105,7 @@ pub(crate) fn game_payload(game: &GameDistributionGameRecord) -> Value {
         "inputModes": input_modes,
         "orientation": game.orientation,
         "status": game.visibility,
+        "forkAuthorization": game.fork_authorization,
         "publicationRevision": game.publication_revision,
         "playCount": game.play_count,
         "createdAt": game.created_at,
@@ -3799,9 +6142,32 @@ fn owner_game_entry_payload(entry: GameDistributionOwnerGameRecord) -> Value {
         versions.first().cloned().unwrap_or(Value::Null),
     );
     object.insert("versions".to_string(), Value::Array(versions));
+    // 「被改编 N」：与公开详情 `forkCount` 同口径（只算未软删除且已公开的直接子代），
+    // 作者页入口据此展示；未公开作品的行内入口不会渲染，因为衍生列表要求锚点公开可读。
+    object.insert("forkCount".to_string(), json!(entry.fork_count));
     payload
 }
 
+/// 公开血缘摘要的响应形状。独立成函数是为了让公开投影保持「只用 object.insert 追加键」
+/// 的形态，DTO 一致性检查据此逐键比对 TS 契约。
+fn lineage_payload(lineage: &spacetime_client::GameDistributionLineageRecord) -> Value {
+    json!({
+        "generation": lineage.generation,
+        "rootGameId": lineage.root_game_id,
+        "rootTitle": lineage.root_title,
+        "parentGameId": lineage.parent_game_id,
+        "parentTitle": lineage.parent_title,
+        "parentAuthorName": lineage.parent_author_name,
+    })
+}
+
+/// 公开版本摘要。
+///
+/// `changeSummary` 是本版相对来源作品的核心改动说明：衍生作品必有、母版为 `null`。它是公开投影的
+/// 一部分（详情页 / 族谱溯源展示「每一代的差异」），不含任何私有字段，因此不随查看者变化。
+///
+/// 注意：`scripts/check-game-distribution-dto-parity.mjs` 按「键前面必须是 `{` 或 `,`」抓顶层键，
+/// 且不剥注释，因此 `json!` 字面量里不要插注释行——否则该键会被判成缺失。
 fn version_summary_payload(version: &GameDistributionVersionRecord) -> Value {
     json!({
         "id": version.version_id,
@@ -3810,6 +6176,7 @@ fn version_summary_payload(version: &GameDistributionVersionRecord) -> Value {
         "sha256": version.package_sha256,
         "publishedAt": version.updated_at,
         "controls": [],
+        "changeSummary": version.change_summary,
     })
 }
 
@@ -3823,6 +6190,11 @@ fn frozen_version_price_mud_points(version: &GameDistributionVersionRecord) -> O
         .filter(|price| *price <= MAX_GAME_PRICE_MUD_POINTS)
 }
 
+/// 作者侧版本 payload。
+///
+/// 工程源包只回摘要与字节数（作者面板展示「已上传 / 未上传」），**对象键不出服务端**。
+/// 注意：`scripts/check-game-distribution-dto-parity.mjs` 按「键前面必须是 `{` 或 `,`」抓顶层键，
+/// 且不剥注释，因此 `json!` 字面量里不要插注释行——否则该键会被判成缺失。
 pub(crate) fn private_version_payload(version: &GameDistributionVersionRecord) -> Value {
     json!({
         "versionId": version.version_id,
@@ -3837,6 +6209,8 @@ pub(crate) fn private_version_payload(version: &GameDistributionVersionRecord) -
         "priceMudPoints": frozen_version_price_mud_points(version).unwrap_or(0),
         "reviewReason": version.review_reason,
         "entryUrl": version.entry_url,
+        "projectBundleBytes": version.project_bundle_bytes,
+        "projectBundleSha256": version.project_bundle_sha256,
         "createdAt": version.created_at,
         "updatedAt": version.updated_at,
     })
@@ -4188,6 +6562,27 @@ fn map_package_error(error: ReleasePackageError) -> AppError {
         .with_details(json!({ "provider": "game-distribution", "reason": format!("{error:?}") }))
 }
 
+/// DTO 档位 → 领域档位：字符串值只在一处定义（`module-game-distribution`）。
+fn to_domain_fork_authorization(
+    value: GameDistributionForkAuthorization,
+) -> module_game_distribution::ForkAuthorization {
+    match value {
+        GameDistributionForkAuthorization::Forbidden => {
+            module_game_distribution::ForkAuthorization::Forbidden
+        }
+        GameDistributionForkAuthorization::NonCommercial => {
+            module_game_distribution::ForkAuthorization::NonCommercial
+        }
+        GameDistributionForkAuthorization::Full => {
+            module_game_distribution::ForkAuthorization::Full
+        }
+    }
+}
+
+fn fork_authorization_value(value: GameDistributionForkAuthorization) -> String {
+    to_domain_fork_authorization(value).as_str().to_string()
+}
+
 /// 购买失败的错误映射。
 ///
 /// 余额不足 400 `INSUFFICIENT_MUD_POINTS`（前端据此引导充值）；价格已被新版本改变 409；
@@ -4222,6 +6617,128 @@ fn map_purchase_error(error: SpacetimeClientError) -> AppError {
 
 pub(crate) fn map_spacetime_error(error: SpacetimeClientError) -> AppError {
     match error {
+        SpacetimeClientError::Procedure(message)
+            if message.starts_with(GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT) =>
+        {
+            AppError::from_status(StatusCode::CONFLICT)
+                .with_code("VERSION_NUMBER_CONFLICT")
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
+        // 共创相关错误以稳定错误码开头。这一段必须先于下面的「不匹配 / 不存在 / 状态」
+        // 子串分支，否则血缘错误会被误映射成通用 409 或 404。
+        SpacetimeClientError::Procedure(message) if message.contains("FORK_") => {
+            let code = message
+                .split(':')
+                .next()
+                .map(str::trim)
+                .filter(|code| code.starts_with("FORK_"))
+                .unwrap_or("FORK_ERROR");
+            let (status, code) = match code {
+                "FORK_NOT_AUTHORIZED" => (StatusCode::FORBIDDEN, "FORK_NOT_AUTHORIZED"),
+                "FORK_SOURCE_NOT_FOUND" => (StatusCode::NOT_FOUND, "FORK_SOURCE_NOT_FOUND"),
+                "FORK_SOURCE_NOT_AVAILABLE" => (StatusCode::CONFLICT, "FORK_SOURCE_NOT_AVAILABLE"),
+                "FORK_SOURCE_VERSION_MISMATCH" => {
+                    (StatusCode::CONFLICT, "FORK_SOURCE_VERSION_MISMATCH")
+                }
+                "FORK_DECLARATION_ON_EXISTING_GAME" => {
+                    (StatusCode::CONFLICT, "FORK_DECLARATION_ON_EXISTING_GAME")
+                }
+                "FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED" => (
+                    StatusCode::CONFLICT,
+                    "FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED",
+                ),
+                // 衍生作品的档位是终态（创建时继承父作品），任何 PUT 都拒：与「只升不降」同为 409，
+                // 但语义不同——客户端要按「这个入口对衍生作品不存在」处理，而不是刷新后重试。
+                module_game_distribution::GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE => (
+                    StatusCode::CONFLICT,
+                    module_game_distribution::GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE,
+                ),
+                "FORK_AUTHORIZATION_UNKNOWN" => {
+                    (StatusCode::BAD_REQUEST, "FORK_AUTHORIZATION_UNKNOWN")
+                }
+                // 共创发布（衍生作品必填的核心改动说明）：两类失败都是**请求非法**（400）——
+                // 客户端补一句说明或改短重试即可，不该按 409 去刷新状态后重放。
+                "FORK_CHANGE_SUMMARY_REQUIRED" => {
+                    (StatusCode::BAD_REQUEST, "FORK_CHANGE_SUMMARY_REQUIRED")
+                }
+                "FORK_CHANGE_SUMMARY_INVALID" => {
+                    (StatusCode::BAD_REQUEST, "FORK_CHANGE_SUMMARY_INVALID")
+                }
+                _ => (StatusCode::CONFLICT, "FORK_ERROR"),
+            };
+            AppError::from_status(status)
+                .with_code(code)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
+        // 共创主题（`THEME_*`）错误码：与上一段同构，同样必须先于下面的「不匹配 / 不存在 /
+        // 状态」子串分支，否则主题错误会被误映射成通用 409 / 404。
+        //
+        // 映射顺序同时决定了两条文案约束（都有单测钉住）：落 404 的文案**不得**含「状态」，
+        // 否则会先命中 409 分支；落 409 的文案**不得**含「不存在」，否则会先命中 404 分支。
+        // 公开侧刻意不发这些码（不存在 / 未发布一律只回「主题不存在」文案）。
+        SpacetimeClientError::Procedure(message) if message.contains("THEME_") => {
+            let code = message
+                .split(':')
+                .next()
+                .map(str::trim)
+                .filter(|code| code.starts_with("THEME_"))
+                .unwrap_or("THEME_ERROR");
+            let (status, code) = match code {
+                GAME_DISTRIBUTION_THEME_NOT_FOUND => {
+                    (StatusCode::NOT_FOUND, GAME_DISTRIBUTION_THEME_NOT_FOUND)
+                }
+                GAME_DISTRIBUTION_THEME_BAD_REQUEST => {
+                    (StatusCode::BAD_REQUEST, GAME_DISTRIBUTION_THEME_BAD_REQUEST)
+                }
+                GAME_DISTRIBUTION_THEME_INVALID_CURSOR => (
+                    StatusCode::BAD_REQUEST,
+                    GAME_DISTRIBUTION_THEME_INVALID_CURSOR,
+                ),
+                GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT => (
+                    StatusCode::CONFLICT,
+                    GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT,
+                ),
+                GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT => (
+                    StatusCode::CONFLICT,
+                    GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT,
+                ),
+                GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND => (
+                    StatusCode::NOT_FOUND,
+                    GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND,
+                ),
+                // 未登记的码按「请求非法」保守处理：主题错误里参数类占多数，400 比 409 更少
+                // 误导客户端去重试；无论如何都不会落到 axum 默认的 422 纯文本。
+                _ => (StatusCode::BAD_REQUEST, "THEME_ERROR"),
+            };
+            AppError::from_status(status)
+                .with_code(code)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
+        // 公开游戏目录（`CATALOG_*`）错误码：与上两段同构，码由**前缀**决定而不是由文案里的中文
+        // 子串决定，因此必须排在下面的「不匹配 / 不存在 / 状态」等 `contains` 分支**之前**——
+        // 排在后面时，任何一条恰好含那些子串的 `CATALOG_` 文案都会被它们抢走（落 404 / 409）。
+        // 同理，`FORK_` / `THEME_` 两个更早的 `contains` 分支要求目录文案**不含**这两个前缀，
+        // 这一点由模块侧单测与本文件的可达性枚举测试同时钉住。
+        //
+        // 未登记的 `CATALOG_` 码按「请求非法」（400）保守处理，不会落到 axum 默认的 422 纯文本。
+        SpacetimeClientError::Procedure(message) if message.contains("CATALOG_") => {
+            let code = message
+                .split(':')
+                .next()
+                .map(str::trim)
+                .filter(|code| code.starts_with("CATALOG_"))
+                .unwrap_or("CATALOG_ERROR");
+            let (status, code) = match code {
+                GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR => (
+                    StatusCode::BAD_REQUEST,
+                    GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR,
+                ),
+                _ => (StatusCode::BAD_REQUEST, "CATALOG_ERROR"),
+            };
+            AppError::from_status(status)
+                .with_code(code)
+                .with_details(json!({ "provider": "game-distribution", "message": message }))
+        }
         SpacetimeClientError::Procedure(message) if message.contains("owner 不匹配") => {
             AppError::from_status(StatusCode::FORBIDDEN)
                 .with_details(json!({ "provider": "game-distribution", "message": message }))
@@ -4267,7 +6784,10 @@ pub(crate) fn map_spacetime_error(error: SpacetimeClientError) -> AppError {
 #[cfg(test)]
 mod tests {
     use super::*;
+    // `Arc` 只被测试里的 loader 桩用到（生产侧包字节走 `Bytes` 零拷贝），因此放在测试模块内：
+    // 放在文件顶部会让 bin 目标报 `unused import`。
     use shared_contracts::game_distribution::GameDistributionDeviceSupport;
+    use std::sync::Arc;
 
     #[tokio::test]
     async fn user_review_routes_validate_pagination_and_require_personal_auth() {
@@ -4734,6 +7254,8 @@ mod tests {
             },
             input_modes: vec![GameDistributionInputMode::Keyboard],
             orientation: GameDistributionOrientation::Landscape,
+            fork_authorization: GameDistributionForkAuthorization::Forbidden,
+            fork: None,
         }
     }
 
@@ -4754,6 +7276,33 @@ mod tests {
         assert!(MAX_PACKAGE_REQUEST_BODY_BYTES > MAX_PACKAGE_BYTES as usize);
     }
 
+    #[test]
+    fn project_bundle_limits_mirror_the_package_pipeline() {
+        // 工程源包与发行包共用同一条上传链路（反代 / Pingora 的放行量按 200 MiB 校准），
+        // 因此三个上限必须逐项相等；请求体放行量同样要盖过包体上限，否则合法工程包会在
+        // `DefaultBodyLimit` 处被 413，`validate_project_bundle_zip` 根本没机会执行。
+        assert_eq!(MAX_PROJECT_BUNDLE_BYTES, MAX_PACKAGE_BYTES);
+        assert_eq!(
+            MAX_PROJECT_BUNDLE_BYTES,
+            shared_contracts::game_distribution::GAME_DISTRIBUTION_MAX_PACKAGE_BYTES,
+        );
+        assert!(MAX_PROJECT_BUNDLE_REQUEST_BODY_BYTES > MAX_PROJECT_BUNDLE_BYTES as usize);
+        assert!(PACKAGE_UPLOAD_CHUNK_BYTES < MAX_PROJECT_BUNDLE_BYTES as usize);
+        assert!(MAX_PACKAGE_CHUNK_REQUEST_BODY_BYTES > PACKAGE_UPLOAD_CHUNK_BYTES);
+    }
+
+    #[test]
+    fn project_bundle_validation_errors_are_unprocessable() {
+        // 与发行包同形：422 + 稳定错误码 + 具体原因，客户端按 code 决策、按 reason 定位。
+        let error = map_project_bundle_error(ProjectBundleError::EmptyBundle);
+        assert_eq!(error.status_code(), StatusCode::UNPROCESSABLE_ENTITY);
+        assert_eq!(error.code(), "PROJECT_BUNDLE_VALIDATION_FAILED");
+        assert_eq!(
+            error.details().and_then(|details| details.get("reason")),
+            Some(&Value::String("EmptyBundle".to_string()))
+        );
+    }
+
     #[test]
     fn publish_multipart_body_limit_covers_metadata_and_all_images() {
         // 发布资料是三段式 multipart，Axum 默认 2 MiB 会在带图请求上先切 413：
@@ -4777,40 +7326,66 @@ mod tests {
     #[test]
     fn package_upload_offset_requires_non_negative_integer() {
         let mut headers = HeaderMap::new();
-        assert!(package_upload_offset(&headers).is_err());
+        assert!(package_upload_offset(&headers, "发行包").is_err());
 
         headers.insert(PACKAGE_UPLOAD_OFFSET_HEADER, HeaderValue::from_static("  "));
-        assert!(package_upload_offset(&headers).is_err());
+        assert!(package_upload_offset(&headers, "发行包").is_err());
 
         headers.insert(PACKAGE_UPLOAD_OFFSET_HEADER, HeaderValue::from_static("-1"));
-        assert!(package_upload_offset(&headers).is_err());
+        assert!(package_upload_offset(&headers, "发行包").is_err());
 
         headers.insert(
             PACKAGE_UPLOAD_OFFSET_HEADER,
             HeaderValue::from_static("8388608"),
         );
         assert_eq!(
-            package_upload_offset(&headers).expect("合法偏移"),
+            package_upload_offset(&headers, "发行包").expect("合法偏移"),
             PACKAGE_UPLOAD_CHUNK_BYTES as u64
         );
+
+        // 工程源包分片共用同一个头名与解析口径，只是错误文案换成工程源包。
+        let mut project_headers = HeaderMap::new();
+        assert_eq!(
+            package_upload_offset(&project_headers, "工程源包")
+                .expect_err("缺少偏移头必须报错")
+                .message(),
+            "缺少工程源包分片偏移"
+        );
+        project_headers.insert(PACKAGE_UPLOAD_OFFSET_HEADER, HeaderValue::from_static("-1"));
+        assert!(package_upload_offset(&project_headers, "工程源包").is_err());
     }
 
     #[test]
     fn package_chunk_content_type_must_be_octet_stream() {
+        let message = "发行包分片必须使用 application/octet-stream";
         let mut headers = HeaderMap::new();
-        assert!(require_octet_stream_content_type(&headers).is_err());
+        assert!(require_octet_stream_content_type(&headers, message).is_err());
 
         headers.insert(
             header::CONTENT_TYPE,
             HeaderValue::from_static("application/zip"),
         );
-        assert!(require_octet_stream_content_type(&headers).is_err());
+        assert!(require_octet_stream_content_type(&headers, message).is_err());
 
         headers.insert(
             header::CONTENT_TYPE,
             HeaderValue::from_static("application/octet-stream"),
         );
-        assert!(require_octet_stream_content_type(&headers).is_ok());
+        assert!(require_octet_stream_content_type(&headers, message).is_ok());
+
+        // 工程源包整包上传同样只认 octet-stream；错误文案取自调用方。
+        let project_message = "工程源包必须使用 application/octet-stream";
+        let mut project_headers = HeaderMap::new();
+        project_headers.insert(
+            header::CONTENT_TYPE,
+            HeaderValue::from_static("application/zip"),
+        );
+        assert_eq!(
+            require_octet_stream_content_type(&project_headers, project_message)
+                .expect_err("工程源包不接受 application/zip")
+                .message(),
+            project_message
+        );
     }
 
     #[test]
@@ -4894,6 +7469,7 @@ mod tests {
             project_key: None,
             cover_object_key: Some("generated/game-cover.png".to_string()),
             screenshots_json: Some(r#"["generated/shot-1.png"]"#.to_string()),
+            fork_authorization: "forbidden".to_string(),
             price_mud_points: 0,
         };
         let payload = game_payload(&game);
@@ -4917,11 +7493,28 @@ mod tests {
                         average_score,
                         rating_count,
                     },
+                    fork_count: 0,
+                    co_creation_count: 0,
+                    lineage: None,
                 },
                 &GameViewerContext::default(),
             );
+            // 「无子代」也必须**恒发**两个键（键在、值为 0），不能靠缺键表达 0：展示层把缺键
+            // 当成旧响应而回退，把 0 当成真实计数，两者语义不同。
+            assert_eq!(
+                payload["forkCount"],
+                Value::Number(0.into()),
+                "forkCount 恒发"
+            );
+            assert_eq!(
+                payload["coCreationCount"],
+                Value::Number(0.into()),
+                "coCreationCount 恒发（与 forkCount 并存）"
+            );
             let summary: shared_contracts::game_distribution::GameDistributionGameSummary =
                 serde_json::from_value(payload).expect("公开游戏响应应可解析");
+            assert_eq!(summary.fork_count, 0);
+            assert_eq!(summary.co_creation_count, 0);
             assert_eq!(
                 summary.rating_summary,
                 Some(GameDistributionRatingSummary {
@@ -4932,6 +7525,22 @@ mod tests {
         }
     }
 
+    /// 公开 payload 里两个计数**并存且口径不同**：`forkCount` 只数直接子代（3），
+    /// `coCreationCount` 数整棵子树的可见后代（4）。两者都必须真实发出、能被契约结构体解析。
+    #[test]
+    fn public_payload_emits_co_creation_count_alongside_fork_count() {
+        let mut record = public_game_record_fixture();
+        record.fork_count = 3;
+        record.co_creation_count = 4;
+        let payload = public_game_payload(record, &GameViewerContext::default());
+        assert_eq!(payload["forkCount"], Value::Number(3.into()));
+        assert_eq!(payload["coCreationCount"], Value::Number(4.into()));
+        let summary: shared_contracts::game_distribution::GameDistributionGameSummary =
+            serde_json::from_value(payload).expect("公开游戏响应应可解析");
+        assert_eq!(summary.fork_count, 3, "forkCount = 直接子代数");
+        assert_eq!(summary.co_creation_count, 4, "coCreationCount = 全部后代数");
+    }
+
     #[test]
     fn version_detail_payload_exposes_frozen_metadata_to_owner() {
         let game = GameDistributionGameRecord {
@@ -4958,6 +7567,7 @@ mod tests {
             project_key: None,
             cover_object_key: Some("generated/game-cover.png".to_string()),
             screenshots_json: None,
+            fork_authorization: "forbidden".to_string(),
             price_mud_points: 0,
         };
         let mut version = GameDistributionVersionRecord {
@@ -4979,6 +7589,11 @@ mod tests {
                 r#"{"coverObjectKey":"generated/game-cover.png","screenshots":["generated/shot.png"]}"#
                     .to_string(),
             ),
+            project_bundle_object_key: None,
+            project_bundle_bytes: 0,
+            project_bundle_sha256: None,
+            // 这份夹具是母版版本：核心改动说明恒为 `None`。
+            change_summary: None,
         };
 
         let payload = version_detail_payload(&version, &game);
@@ -5047,6 +7662,7 @@ mod tests {
             project_key: None,
             cover_object_key: None,
             screenshots_json: None,
+            fork_authorization: "forbidden".to_string(),
             price_mud_points: 0,
         };
         let version = GameDistributionVersionRecord {
@@ -5065,6 +7681,10 @@ mod tests {
             created_at: "2026-09-20T00:00:00Z".to_string(),
             updated_at: "2026-09-20T00:00:00Z".to_string(),
             metadata_json: None,
+            project_bundle_object_key: None,
+            project_bundle_bytes: 0,
+            project_bundle_sha256: None,
+            change_summary: None,
         };
 
         let public = game_payload(&game);
@@ -5074,8 +7694,10 @@ mod tests {
         let entry = owner_game_entry_payload(GameDistributionOwnerGameRecord {
             game,
             versions: vec![version],
+            fork_count: 2,
         });
         assert_eq!(entry["status"], Value::String("unpublished".to_string()));
+        assert_eq!(entry["forkCount"], Value::Number(2.into()));
         assert_eq!(
             entry["versions"][0]["status"],
             Value::String("rejected".to_string())
@@ -5292,6 +7914,7 @@ mod tests {
         );
 
         let unauthenticated_delete = app
+            .clone()
             .oneshot(
                 Request::builder()
                     .method("DELETE")
@@ -5303,6 +7926,948 @@ mod tests {
             .await
             .expect("路由响应");
         assert_eq!(unauthenticated_delete.status(), StatusCode::UNAUTHORIZED);
+
+        // 共创授权提升属于作者写入：未带 Bearer 必须在进入业务前被拒，且不能是 404/405，
+        // 否则说明路由没有挂进受保护区、被别的路径掩盖了。
+        let unauthenticated_fork = app
+            .oneshot(
+                Request::builder()
+                    .method("PUT")
+                    .uri("/api/game-distribution/games/game_1/fork-authorization")
+                    .header("content-type", "application/json")
+                    .body(Body::from(
+                        r#"{"expectedForkAuthorization":"forbidden","forkAuthorization":"nonCommercial"}"#,
+                    ))
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(unauthenticated_fork.status(), StatusCode::UNAUTHORIZED);
+    }
+
+    /// 未知共创档位必须在 HTTP 面回**平台信封的 400**，而不是让 serde 的拒绝直接变成 axum 默认的
+    /// 422 纯文本（合同要求 400，且前端错误处理依赖信封）。
+    ///
+    /// 关键点：反序列化失败发生在进入业务之前，所以两处档位字段（目标档位、期望档位）都要覆盖；
+    /// 这里用真实 handler + 注入的登录身份，断言不会触达数据库（被拒绝的请求在解析后就返回）。
+    #[tokio::test]
+    async fn set_fork_authorization_maps_unknown_authorization_to_envelope_bad_request() {
+        use axum::http::Request;
+        use platform_auth::{
+            AccessTokenClaims, AccessTokenClaimsInput, AuthProvider, BindingStatus,
+        };
+        use shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER;
+        use tower::ServiceExt;
+
+        let state = AppState::new(crate::config::AppConfig::default()).unwrap();
+        let claims = AccessTokenClaims::from_input(
+            AccessTokenClaimsInput {
+                user_id: "fork-author".into(),
+                session_id: "fork-session".into(),
+                provider: AuthProvider::Password,
+                roles: vec!["user".into()],
+                token_version: 1,
+                phone_verified: false,
+                binding_status: BindingStatus::Active,
+                display_name: None,
+            },
+            state.auth_jwt_config(),
+            time::OffsetDateTime::now_utc(),
+        )
+        .unwrap();
+        let app = Router::new()
+            .route(
+                "/api/game-distribution/games/{game_id}/fork-authorization",
+                put(set_fork_authorization),
+            )
+            .layer(Extension(AuthenticatedAccessToken::new(claims)))
+            // 用生产同一套 request context 中间件：错误 envelope 的 `ok` / `meta` 由它挂上的
+            // task-local 决定（直接手塞 Extension 只能拿到 legacy 形状，断言不到 envelope）。
+            .layer(middleware::from_fn(
+                crate::request_context::attach_request_context,
+            ))
+            .with_state(state);
+
+        for (payload, label) in [
+            (
+                r#"{"expectedForkAuthorization":"forbidden","forkAuthorization":"allowed"}"#,
+                "目标档位未知",
+            ),
+            (
+                r#"{"expectedForkAuthorization":"allowed","forkAuthorization":"full"}"#,
+                "期望档位未知",
+            ),
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .method("PUT")
+                        .uri("/api/game-distribution/games/game_1/fork-authorization")
+                        .header("content-type", "application/json")
+                        .header("idempotency-key", "fork-authorization-key-1")
+                        // 客户端要 envelope 时错误体才按 ApiErrorEnvelope 输出。
+                        .header(API_RESPONSE_ENVELOPE_HEADER, "v1")
+                        .body(Body::from(payload))
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(response.status(), StatusCode::BAD_REQUEST, "{label}");
+            let body = axum::body::to_bytes(response.into_body(), 32_768)
+                .await
+                .unwrap();
+            let text = String::from_utf8(body.to_vec()).expect("响应必须是 UTF-8");
+            assert!(
+                !text.contains("Failed to deserialize"),
+                "{label} 不得返回框架的纯文本拒绝：{text}"
+            );
+            let envelope: Value = serde_json::from_str(&text).expect("必须是平台信封 JSON");
+            assert_eq!(envelope["ok"], Value::Bool(false), "{label}");
+            assert_eq!(envelope["data"], Value::Null, "{label}");
+            assert_eq!(
+                envelope["error"]["code"],
+                Value::String("BAD_REQUEST".into()),
+                "{label}"
+            );
+            assert!(
+                envelope["error"]["message"]
+                    .as_str()
+                    .is_some_and(|message| message.contains("共创授权档位不合法")),
+                "{label} 的信封 message 应说明档位不合法：{text}"
+            );
+            assert!(
+                envelope["meta"]["apiVersion"].is_string(),
+                "{label} 的信封必须带 meta.apiVersion：{text}"
+            );
+        }
+    }
+
+    /// 族谱与衍生列表是公开只读路由：必须挂载、匿名可读、不缓存。
+    ///
+    /// 测试态没有可用数据库，所以证明点是「已挂载并走到 SpacetimeDB」（502），
+    /// 而不是 404 / 401 / 405；同时路由层必须带 `no-store`。
+    #[tokio::test]
+    async fn lineage_and_derived_routes_are_public_and_no_store() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app = crate::app::build_router(
+            crate::state::AppState::new(crate::config::AppConfig::default())
+                .expect("测试状态应可构建"),
+        );
+
+        for uri in [
+            "/api/game-distribution/games/game_1/lineage",
+            "/api/game-distribution/games/game_1/derived",
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .uri(uri)
+                        .body(Body::empty())
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(
+                response.status(),
+                StatusCode::BAD_GATEWAY,
+                "{uri} 必须挂载并走到 SpacetimeDB"
+            );
+            assert_eq!(
+                response
+                    .headers()
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("no-store"),
+                "{uri} 是公开读接口，必须不缓存"
+            );
+        }
+    }
+
+    /// 锚点不可读（未公开 / 已软删除 / 不存在）必须映射成 404，而不是 200 空树。
+    ///
+    /// 模块侧由 `lineage_anchor_readable` 判成 `found = false`，facade 折成 `None`，
+    /// 这一层把它折成 404；三段串起来才构成「未公开作品不泄露」的回归网。
+    #[test]
+    fn lineage_reads_map_unreadable_anchor_to_not_found() {
+        assert_eq!(
+            lineage_read_or_not_found::<u8>(None)
+                .expect_err("不可读锚点必须 404")
+                .status_code(),
+            StatusCode::NOT_FOUND
+        );
+        assert_eq!(lineage_read_or_not_found(Some(7)).expect("可读锚点透传"), 7);
+    }
+
+    /// 族谱 / 衍生列表的负载只发公开节点字段，且未知可见性按「未公开」保守解释。
+    #[test]
+    fn lineage_payloads_expose_only_public_node_fields() {
+        let root = GameDistributionLineageNodeRecord {
+            game_id: "game-root".to_string(),
+            title: "母版".to_string(),
+            author_name: Some("原作者".to_string()),
+            generation: 0,
+            parent_game_id: None,
+            play_count: 12,
+            status: "published".to_string(),
+            cover_object_key: Some("covers/root.png".to_string()),
+        };
+        let child = GameDistributionLineageNodeRecord {
+            game_id: "game-child".to_string(),
+            title: "衍生作品".to_string(),
+            author_name: None,
+            generation: 1,
+            // 父作品不在可见集合里：ID 原样回传，展示层据此降级，不猜测父作品内容。
+            parent_game_id: Some("game-removed".to_string()),
+            play_count: 3,
+            status: "mystery".to_string(),
+            // 无封面：键仍发出，值为 null（不是缺键，也不是空串占位）。
+            cover_object_key: None,
+        };
+        let tree = serde_json::to_value(lineage_tree_payload(GameDistributionLineageTreeRecord {
+            root_game_id: "game-root".to_string(),
+            root: Some(root.clone()),
+            nodes: vec![root, child],
+            truncated: true,
+        }))
+        .expect("族谱负载应可序列化");
+
+        assert_eq!(tree["rootGameId"], Value::String("game-root".to_string()));
+        assert_eq!(tree["truncated"], Value::Bool(true));
+        assert_eq!(tree["root"]["title"], Value::String("母版".to_string()));
+        assert_eq!(
+            tree["nodes"][1]["parentGameId"],
+            Value::String("game-removed".to_string())
+        );
+        assert_eq!(tree["nodes"][1]["authorName"], Value::Null);
+        assert_eq!(
+            tree["nodes"][1]["status"],
+            Value::String("unpublished".to_string())
+        );
+        // 带封面：对象键原样发出；无封面：键仍发出但为 null（两种负载都必须如实）。
+        assert_eq!(
+            tree["nodes"][0]["coverObjectKey"],
+            Value::String("covers/root.png".to_string())
+        );
+        assert_eq!(tree["nodes"][1]["coverObjectKey"], Value::Null);
+        // 节点键集合必须恰好是契约里的那八个：多一个键就意味着多泄露一类信息。
+        // serde_json 的 Map 按字母序输出，所以这里比较排序后的键集合而不是固定顺序。
+        let mut expected_keys = vec![
+            "gameId",
+            "title",
+            "authorName",
+            "generation",
+            "parentGameId",
+            "playCount",
+            "status",
+            "coverObjectKey",
+        ];
+        expected_keys.sort();
+        for index in [0usize, 1usize] {
+            let node = tree["nodes"][index].as_object().expect("节点必须是对象");
+            let mut node_keys = node.keys().cloned().collect::<Vec<_>>();
+            node_keys.sort();
+            assert_eq!(
+                node_keys, expected_keys,
+                "节点 {index} 的键集合必须恰好是白名单"
+            );
+            // 只有公开投影字段：私有素材 id / 对象键的别名一个都不许出现。
+            for forbidden in ["coverAssetId", "cover_asset_id", "coverAssetID"] {
+                assert!(
+                    !node.contains_key(forbidden),
+                    "节点 {index} 负载不得含私有 id 字段 {forbidden}"
+                );
+            }
+        }
+
+        let derived =
+            serde_json::to_value(derived_games_payload(GameDistributionDerivedGamesRecord {
+                game_id: "game-root".to_string(),
+                nodes: Vec::new(),
+                truncated: false,
+            }))
+            .expect("衍生列表负载应可序列化");
+        assert_eq!(derived["gameId"], Value::String("game-root".to_string()));
+        assert_eq!(derived["nodes"], Value::Array(Vec::new()));
+        assert_eq!(derived["truncated"], Value::Bool(false));
+
+        assert_eq!(
+            game_distribution_visibility("mystery"),
+            GameDistributionVisibility::Unpublished
+        );
+        assert_eq!(
+            game_distribution_visibility("suspended"),
+            GameDistributionVisibility::Suspended
+        );
+    }
+
+    /// 取件通道两个路由都必须在进入业务前要求登录态。
+    #[tokio::test]
+    async fn fork_source_routes_require_bearer_before_any_read() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app = crate::app::build_router(
+            crate::state::AppState::new(crate::config::AppConfig::default())
+                .expect("测试状态应可构建"),
+        );
+        for uri in [
+            "/api/game-distribution/games/game_1/fork-source",
+            "/api/game-distribution/games/game_1/fork-source/package",
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .uri(uri)
+                        .body(Body::empty())
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(response.status(), StatusCode::UNAUTHORIZED, "{uri}");
+        }
+    }
+
+    fn fork_source_record(
+        found: bool,
+        available: bool,
+        fork_authorization: &str,
+        version: Option<(&str, &str, u64)>,
+    ) -> GameDistributionForkSourceRecord {
+        GameDistributionForkSourceRecord {
+            found,
+            available,
+            fork_authorization: fork_authorization.to_string(),
+            version_id: version.map(|(version_id, _, _)| version_id.to_string()),
+            package_sha256: version.map(|(_, sha256, _)| sha256.to_string()),
+            package_bytes: version.map(|(_, _, bytes)| bytes),
+            project_bundle_sha256: None,
+            project_bundle_bytes: 0,
+        }
+    }
+
+    /// 在成品包记录上叠加工程源包两列：字节数与摘要分开给，才能构造「半写行」这种失败关闭用例。
+    fn fork_source_record_with_project(
+        base: GameDistributionForkSourceRecord,
+        project_bundle_sha256: Option<&str>,
+        project_bundle_bytes: u64,
+    ) -> GameDistributionForkSourceRecord {
+        GameDistributionForkSourceRecord {
+            project_bundle_sha256: project_bundle_sha256.map(str::to_string),
+            project_bundle_bytes,
+            ..base
+        }
+    }
+
+    /// 取件校验的 HTTP 映射：404 / 409 / 403 与通过逐个钉死。两个 handler 共用同一条，
+    /// 因此这一组断言同时覆盖元数据与内容本体两条路径。
+    #[test]
+    fn fork_source_target_maps_contract_status_codes() {
+        // 行不存在 → 404；此时其余字段无意义，不得被误判成 409/403。
+        let missing = fork_source_target(fork_source_record(false, false, "forbidden", None))
+            .expect_err("行不存在必须失败");
+        assert_eq!(missing.status_code(), StatusCode::NOT_FOUND);
+        assert_eq!(missing.code(), "FORK_SOURCE_NOT_FOUND");
+
+        // 行存在但不可用（已软删除 / 未公开 / 没有当前公开版本）→ 409，且**先于**授权判定：
+        // 未公开 + 允许共创仍然是 409，不能因为授权开放就暴露「这个 gameId 存在」。
+        for label in ["已软删除", "未公开", "没有当前公开版本"] {
+            let unavailable =
+                fork_source_target(fork_source_record(true, false, "nonCommercial", None))
+                    .expect_err("不可用作来源必须失败");
+            assert_eq!(unavailable.status_code(), StatusCode::CONFLICT, "{label}");
+            assert_eq!(unavailable.code(), "FORK_SOURCE_NOT_AVAILABLE", "{label}");
+        }
+
+        // 可用但授权为禁止 → 403。
+        let forbidden = fork_source_target(fork_source_record(
+            true,
+            true,
+            "forbidden",
+            Some(("version_1", "sha", 8)),
+        ))
+        .expect_err("禁止共创必须失败");
+        assert_eq!(forbidden.status_code(), StatusCode::FORBIDDEN);
+        assert_eq!(forbidden.code(), "FORK_NOT_AUTHORIZED");
+
+        // 未知档位按「禁止共创」解释，与 procedure 侧创建血缘同口径。
+        let unknown = fork_source_target(fork_source_record(
+            true,
+            true,
+            "allowed",
+            Some(("version_1", "sha", 8)),
+        ))
+        .expect_err("未知档位必须失败");
+        assert_eq!(unknown.status_code(), StatusCode::FORBIDDEN);
+        assert_eq!(unknown.code(), "FORK_NOT_AUTHORIZED");
+
+        // 通过：版本元数据按行原值带出。
+        let target = fork_source_target(fork_source_record(
+            true,
+            true,
+            "nonCommercial",
+            Some(("version_1", "a".repeat(64).as_str(), 2048)),
+        ))
+        .expect("允许共创且已公开应通过");
+        assert_eq!(target.version_id, "version_1");
+        assert_eq!(target.source, GameDistributionForkSourceKind::Package);
+        assert_eq!(target.sha256, "a".repeat(64));
+        assert_eq!(target.bytes, 2048);
+
+        // 失败关闭：可用却没有版本元数据时按不可用处理，不发半截信息。
+        let incomplete = fork_source_target(fork_source_record(true, true, "full", None))
+            .expect_err("缺版本元数据必须失败关闭");
+        assert_eq!(incomplete.status_code(), StatusCode::CONFLICT);
+        assert_eq!(incomplete.code(), "FORK_SOURCE_NOT_AVAILABLE");
+    }
+
+    /// 元数据响应：摘要与字节数取自版本行，下载路径是同源相对路径，响应体不含对象键。
+    #[test]
+    fn fork_source_payload_carries_row_digest_without_object_key() {
+        let target = fork_source_target(fork_source_record(
+            true,
+            true,
+            "nonCommercial",
+            Some(("version_9", "b".repeat(64).as_str(), 4096)),
+        ))
+        .expect("应通过");
+        let payload = fork_source_payload("game_1", &target).expect("payload");
+        assert_eq!(payload.fork_source.game_id, "game_1");
+        assert_eq!(payload.fork_source.version_id, "version_9");
+        assert_eq!(payload.fork_source.sha256, "b".repeat(64));
+        assert_eq!(payload.fork_source.bytes, 4096);
+        assert_eq!(
+            payload.fork_source.source,
+            GameDistributionForkSourceKind::Package
+        );
+        assert_eq!(
+            payload.fork_source.download_path,
+            "/api/game-distribution/games/game_1/fork-source/package"
+        );
+
+        // 不外泄对象键：序列化结果里不得出现对象键前缀或对象键字段名。
+        let body = serde_json::to_string(&payload).expect("序列化");
+        assert!(!body.contains("project-snapshots"), "{body}");
+        assert!(!body.contains("objectKey"), "{body}");
+        assert!(!body.contains(".zip"), "{body}");
+
+        // 路径段不安全的 gameId 宁可失败，也不拼进下载路径。
+        assert!(
+            build_fork_source_download_path("../escape", GameDistributionForkSourceKind::Package)
+                .is_err()
+        );
+        assert!(
+            build_fork_source_download_path("", GameDistributionForkSourceKind::Package).is_err()
+        );
+    }
+
+    /// 取件包响应头：ZIP + 长度 + 附件文件名 + no-store，长度与内容一致。
+    #[tokio::test]
+    async fn fork_source_package_response_sets_zip_download_headers() {
+        let target = fork_source_target(fork_source_record(
+            true,
+            true,
+            "full",
+            Some(("version_3", "c".repeat(64).as_str(), 2048)),
+        ))
+        .expect("应通过");
+        let response = fork_source_package_response(
+            "game_1",
+            &target.version_id,
+            Bytes::from(vec![7_u8; 2048]),
+        );
+        assert_eq!(
+            response.headers()[header::CONTENT_TYPE],
+            HeaderValue::from_static("application/zip")
+        );
+        assert_eq!(
+            response.headers()[header::CACHE_CONTROL],
+            HeaderValue::from_static("no-store")
+        );
+        assert_eq!(
+            response.headers()[header::CONTENT_DISPOSITION],
+            HeaderValue::from_static("attachment; filename=\"game_1-version_3.zip\"")
+        );
+        // Content-Length 与响应体实际字节一致；同一条 fixture 里它也等于版本行的 package_bytes。
+        assert_eq!(
+            response.headers()[header::CONTENT_LENGTH],
+            HeaderValue::from_str(&target.bytes.to_string()).expect("长度头")
+        );
+        let body = axum::body::to_bytes(response.into_body(), 32_768)
+            .await
+            .expect("读取响应体");
+        assert_eq!(body.len() as u64, target.bytes);
+    }
+
+    /// 工程源包上行族 5 条 + 源码级取件 1 条：都必须在进入业务前要求登录态。
+    ///
+    /// 这条测试只证「没带 Bearer 一律 401」，不碰 OSS / SpacetimeDB；成功路径留给 dev 栈端到端。
+    #[tokio::test]
+    async fn project_bundle_routes_require_bearer_before_any_work() {
+        use axum::{
+            body::Body,
+            http::{Method, Request},
+        };
+        use tower::ServiceExt;
+
+        let app = crate::app::build_router(
+            crate::state::AppState::new(crate::config::AppConfig::default())
+                .expect("测试状态应可构建"),
+        );
+        for (method, uri) in [
+            (
+                Method::PUT,
+                "/api/game-distribution/versions/version_1/project-bundle",
+            ),
+            (
+                Method::GET,
+                "/api/game-distribution/versions/version_1/project-bundle/upload-state",
+            ),
+            (
+                Method::PUT,
+                "/api/game-distribution/versions/version_1/project-bundle/chunk",
+            ),
+            (
+                Method::POST,
+                "/api/game-distribution/versions/version_1/project-bundle/complete",
+            ),
+            (
+                Method::POST,
+                "/api/game-distribution/versions/version_1/project-bundle/reset",
+            ),
+            (
+                Method::GET,
+                "/api/game-distribution/games/game_1/fork-source/project",
+            ),
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .method(method.clone())
+                        .uri(uri)
+                        .body(Body::empty())
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(
+                response.status(),
+                StatusCode::UNAUTHORIZED,
+                "{method} {uri}"
+            );
+        }
+    }
+
+    fn version_record_for_stage_gate(
+        status: &str,
+        project_bundle_bytes: u64,
+    ) -> GameDistributionVersionRecord {
+        GameDistributionVersionRecord {
+            version_id: "version_1".to_string(),
+            game_id: "game_1".to_string(),
+            owner_user_id: "user_1".to_string(),
+            version_number: 1,
+            package_sha256: "a".repeat(64),
+            package_bytes: 1024,
+            package_file_count: 1,
+            package_entry_path: "index.html".to_string(),
+            status: status.to_string(),
+            review_reason: None,
+            entry_url: None,
+            publication_revision: 1,
+            created_at: "2026-10-05T00:00:00Z".to_string(),
+            updated_at: "2026-10-05T00:00:00Z".to_string(),
+            metadata_json: None,
+            project_bundle_object_key: None,
+            project_bundle_bytes,
+            project_bundle_sha256: None,
+            change_summary: None,
+        }
+    }
+
+    /// 阶段门：只有「未确认过工程包」且处于两个上传档位的版本能写；其余一律 409。
+    ///
+    /// 「已确认过」必须先判：确认工程包不驱动状态机，已确认的版本仍可能停在 `awaiting_upload`，
+    /// 只判状态会把它当成可写，放任二次上传覆盖已确认的摘要与字节。
+    #[test]
+    fn project_bundle_stage_gate_only_allows_unconfirmed_upload_states() {
+        for status in ["awaiting_upload", "upload_failed"] {
+            ensure_project_bundle_uploadable(&version_record_for_stage_gate(status, 0))
+                .unwrap_or_else(|error| panic!("{status} 应放行：{error:?}"));
+        }
+        for status in [
+            "uploaded",
+            "validating",
+            "pending_review",
+            "rejected",
+            "published",
+            "revoked",
+            "cancelled",
+        ] {
+            let error = ensure_project_bundle_uploadable(&version_record_for_stage_gate(status, 0))
+                .expect_err("非上传档位必须 409");
+            assert_eq!(error.status_code(), StatusCode::CONFLICT, "{status}");
+            assert_eq!(
+                error.code(),
+                "PROJECT_BUNDLE_UPLOAD_NOT_ALLOWED",
+                "{status}"
+            );
+        }
+        // 已确认过工程包：即使状态仍是 `awaiting_upload` 也必须 409，且文案含「已存在」，
+        // 与 `map_spacetime_error` 的 409 子串映射同口径。
+        let error = ensure_project_bundle_uploadable(&version_record_for_stage_gate(
+            "awaiting_upload",
+            2048,
+        ))
+        .expect_err("已确认工程包必须 409");
+        assert_eq!(error.status_code(), StatusCode::CONFLICT);
+        assert_eq!(error.code(), "PROJECT_BUNDLE_ALREADY_EXISTS");
+        assert!(error.message().contains("已存在"), "{:?}", error.message());
+    }
+
+    /// 选定资产：有工程包（字节数与摘要成对）走 `project` 且下载路径指向 `/project`；没有则回落
+    /// `package`；「字节数 > 0 但摘要为空」的半写行按没有工程包处理，绝不把取件指向取不到的资产。
+    #[test]
+    fn fork_source_target_prefers_project_bundle_and_falls_back_to_package() {
+        let package_sha = "a".repeat(64);
+        let package_version = Some(("version_1", package_sha.as_str(), 2048));
+
+        // ① 有工程包 → Project，摘要 / 字节数取工程包那份，下载路径走 /project。
+        let project_sha = "b".repeat(64);
+        let with_project = fork_source_target(fork_source_record_with_project(
+            fork_source_record(true, true, "full", package_version),
+            Some(project_sha.as_str()),
+            4096,
+        ))
+        .expect("有工程包应通过");
+        assert_eq!(with_project.source, GameDistributionForkSourceKind::Project);
+        assert_eq!(with_project.sha256, project_sha);
+        assert_eq!(with_project.bytes, 4096);
+        let project_payload = fork_source_payload("game_1", &with_project).expect("payload");
+        assert_eq!(
+            project_payload.fork_source.source,
+            GameDistributionForkSourceKind::Project
+        );
+        assert_eq!(project_payload.fork_source.sha256, project_sha);
+        assert_eq!(project_payload.fork_source.bytes, 4096);
+        assert_eq!(
+            project_payload.fork_source.download_path,
+            "/api/game-distribution/games/game_1/fork-source/project"
+        );
+
+        // ② 无工程包 → Package，下载路径走 /package。
+        let without_project =
+            fork_source_target(fork_source_record(true, true, "full", package_version))
+                .expect("无工程包应回落到成品包");
+        assert_eq!(
+            without_project.source,
+            GameDistributionForkSourceKind::Package
+        );
+        assert_eq!(without_project.sha256, "a".repeat(64));
+        assert_eq!(without_project.bytes, 2048);
+        assert_eq!(
+            fork_source_payload("game_1", &without_project)
+                .expect("payload")
+                .fork_source
+                .download_path,
+            "/api/game-distribution/games/game_1/fork-source/package"
+        );
+
+        // ③ 半写行：字节数 > 0 但摘要为空 → 按没有工程包处理，回落 Package。
+        let half_written = fork_source_target(fork_source_record_with_project(
+            fork_source_record(true, true, "full", package_version),
+            None,
+            4096,
+        ))
+        .expect("半写行必须回落成品包");
+        assert_eq!(half_written.source, GameDistributionForkSourceKind::Package);
+        assert_eq!(half_written.sha256, "a".repeat(64));
+        assert_eq!(half_written.bytes, 2048);
+
+        // 反向的半写行：摘要有了但字节数为 0，同样不算「有工程包」。
+        let empty_bytes = fork_source_target(fork_source_record_with_project(
+            fork_source_record(true, true, "full", package_version),
+            Some(project_sha.as_str()),
+            0,
+        ))
+        .expect("零字节工程包必须回落成品包");
+        assert_eq!(empty_bytes.source, GameDistributionForkSourceKind::Package);
+
+        // 只有工程包、没有成品包元数据时也走 Project（工程包本身是合法资产）。
+        let project_only = fork_source_target(fork_source_record_with_project(
+            fork_source_record(
+                true,
+                true,
+                "full",
+                Some(("version_1", "a".repeat(64).as_str(), 0)),
+            ),
+            Some(project_sha.as_str()),
+            4096,
+        ))
+        .expect("只有工程包也应可服务");
+        assert_eq!(project_only.source, GameDistributionForkSourceKind::Project);
+
+        // 两份资产都缺失 → 失败关闭 409，不发半截信息。
+        let neither = fork_source_target(fork_source_record_with_project(
+            fork_source_record(true, true, "full", None),
+            None,
+            0,
+        ))
+        .expect_err("没有任何可用资产必须失败关闭");
+        assert_eq!(neither.status_code(), StatusCode::CONFLICT);
+        assert_eq!(neither.code(), "FORK_SOURCE_NOT_AVAILABLE");
+    }
+
+    /// 两份资产必须落在不同对象键上，缓存按对象键分桶因此不会串味。
+    ///
+    /// 同一 (作品, 版本) 会先后上传成品包与工程源包：共用键会让后传的覆盖前一份，已确认的摘要
+    /// 与字节随即变成谎话；发行网关与取件通道也会读到另一份资产。
+    #[test]
+    fn project_bundle_key_and_cache_keep_assets_apart() {
+        let package_key = game_distribution_package_object_key("game_1", "version_1");
+        let project_key = game_distribution_project_bundle_object_key("game_1", "version_1");
+        // 发行包键的字符串必须逐字节不变（发行网关与既有缓存都按它取值）。
+        assert_eq!(
+            package_key,
+            format!("{GAME_DISTRIBUTION_OBJECT_PREFIX}game_1/version_1.zip")
+        );
+        assert_eq!(
+            project_key,
+            format!("{GAME_DISTRIBUTION_OBJECT_PREFIX}game_1/version_1.project.zip")
+        );
+        assert_ne!(package_key, project_key);
+
+        let mut cache = ReleasePackageCache::default();
+        cache.insert(package_key.clone(), Bytes::from(vec![1_u8; 8]));
+        cache.insert(project_key.clone(), Bytes::from(vec![2_u8; 16]));
+        assert_eq!(
+            cache.get(&package_key).map(|bytes| bytes.to_vec()),
+            Some(vec![1_u8; 8])
+        );
+        assert_eq!(
+            cache.get(&project_key).map(|bytes| bytes.to_vec()),
+            Some(vec![2_u8; 16])
+        );
+    }
+
+    /// 上架时的共创授权档位：缺省按「禁止共创」解释，显式传值原样保留，未知取值失败关闭。
+    ///
+    /// 一并钉住幂等摘要口径：创建请求的摘要是对整个请求体取的，所以 DTO 必须写成非 `Option`
+    /// + `#[serde(default)]`——这样「省略」与「显式传 forbidden」序列化结果相同、摘要相同，
+    /// 同一个 Idempotency-Key 才会被识别成重放而不是「同 key 不同请求」。
+    #[test]
+    fn create_game_request_defaults_fork_authorization_without_changing_digest() {
+        let base = json!({
+            "title": "星轨防线",
+            "summary": "守住最后一条航线。",
+            "category": "益智",
+            "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+            "inputModes": ["keyboard"],
+            "orientation": "responsive",
+        });
+
+        let omitted: GameDistributionCreateGameRequest =
+            serde_json::from_value(base.clone()).expect("省略档位应可解析");
+        assert_eq!(
+            omitted.fork_authorization,
+            GameDistributionForkAuthorization::Forbidden,
+            "缺省必须是禁止共创（与表列默认一致）"
+        );
+
+        let mut explicit_value = base.clone();
+        explicit_value["forkAuthorization"] = json!("forbidden");
+        let explicit: GameDistributionCreateGameRequest =
+            serde_json::from_value(explicit_value).expect("显式 forbidden 应可解析");
+        assert_eq!(
+            explicit.fork_authorization,
+            GameDistributionForkAuthorization::Forbidden
+        );
+        assert_eq!(
+            compute_request_digest(&serde_json::to_vec(&omitted).expect("序列化")),
+            compute_request_digest(&serde_json::to_vec(&explicit).expect("序列化")),
+            "省略与显式传默认档位必须得到同一条幂等摘要"
+        );
+
+        for (value, expected) in [
+            (
+                "nonCommercial",
+                GameDistributionForkAuthorization::NonCommercial,
+            ),
+            ("full", GameDistributionForkAuthorization::Full),
+        ] {
+            let mut payload = base.clone();
+            payload["forkAuthorization"] = json!(value);
+            let parsed: GameDistributionCreateGameRequest =
+                serde_json::from_value(payload).expect("合法档位应可解析");
+            assert_eq!(parsed.fork_authorization, expected, "{value}");
+        }
+
+        let mut unknown = base;
+        unknown["forkAuthorization"] = json!("allowed");
+        assert!(
+            serde_json::from_value::<GameDistributionCreateGameRequest>(unknown).is_err(),
+            "未知档位必须失败关闭，不能静默落成 forbidden"
+        );
+    }
+
+    /// 创建作品遇到未知共创档位必须回**平台信封的 400**（JSON 负载走 multipart 的 `metadata`
+    /// 文本 part），而不是让 serde 的拒绝变成框架默认的非信封文本。
+    ///
+    /// 注意顺序：发布开关（`game-distribution:publish`）在 handler 里先于 metadata 解析执行，
+    /// 所以这里的 400 分支要求测试态显式放行该作者；开关未配置时整条写路径统一 503（见下），
+    /// 连 metadata 的解析都没走到——这仍然是「没有创建任何作品」的进程内证据。
+    #[tokio::test]
+    async fn create_game_rejects_unknown_fork_authorization_with_envelope_bad_request() {
+        use axum::http::Request;
+        use platform_auth::{
+            AccessTokenClaims, AccessTokenClaimsInput, AuthProvider, BindingStatus,
+        };
+        use shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER;
+        use tower::ServiceExt;
+
+        let state = AppState::new(crate::config::AppConfig::default()).unwrap();
+        let claims = AccessTokenClaims::from_input(
+            AccessTokenClaimsInput {
+                user_id: "game-author".into(),
+                session_id: "create-game-session".into(),
+                provider: AuthProvider::Password,
+                roles: vec!["user".into()],
+                token_version: 1,
+                phone_verified: false,
+                binding_status: BindingStatus::Active,
+                display_name: None,
+            },
+            state.auth_jwt_config(),
+            time::OffsetDateTime::now_utc(),
+        )
+        .unwrap();
+        let build_app = |state: &AppState, claims: AuthenticatedAccessToken| {
+            Router::new()
+                .route("/api/game-distribution/games", post(create_game))
+                .layer(Extension(claims))
+                .layer(middleware::from_fn(
+                    crate::request_context::attach_request_context,
+                ))
+                .with_state(state.clone())
+        };
+
+        let valid_body = json!({
+            "title": "星轨防线",
+            "summary": "守住最后一条航线。",
+            "category": "益智",
+            "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+            "inputModes": ["keyboard"],
+            "orientation": "responsive",
+        });
+        let unknown_fork_authorization = json!({
+            "title": "星轨防线",
+            "summary": "守住最后一条航线。",
+            "category": "益智",
+            "deviceSupport": { "desktop": true, "mobile": false, "touch": false },
+            "inputModes": ["keyboard"],
+            "orientation": "responsive",
+            "forkAuthorization": "allowed",
+        });
+
+        // 发布写路径统一收 `multipart/form-data`：`metadata` 文本 part 承载 JSON 负载，图片另走
+        // `cover` / `screenshot` 二进制 part（本条只关心 metadata 的解析口径）。
+        let boundary = "genarrative-create-game-boundary";
+        let multipart_request = |payload: &Value, idempotency_key: &str, envelope: bool| {
+            let mut builder = Request::builder()
+                .method("POST")
+                .uri("/api/game-distribution/games")
+                .header(
+                    "content-type",
+                    format!("multipart/form-data; boundary={boundary}"),
+                )
+                .header("idempotency-key", idempotency_key);
+            if envelope {
+                builder = builder.header(API_RESPONSE_ENVELOPE_HEADER, "v1");
+            }
+            builder
+                .body(Body::from(format!(
+                    "--{boundary}\r\nContent-Disposition: form-data; name=\"metadata\"\r\n\
+                     Content-Type: application/json\r\n\r\n{payload}\r\n--{boundary}--\r\n"
+                )))
+                .expect("请求")
+        };
+
+        // 发布开关未配置（测试态默认）：multipart 提取成功、metadata 还没解析就被开关拦下 → 503。
+        let gated = build_app(&state, AuthenticatedAccessToken::new(claims.clone()));
+        let gated_response = gated
+            .oneshot(multipart_request(&valid_body, "create-game-key-0", false))
+            .await
+            .expect("路由响应");
+        assert_eq!(gated_response.status(), StatusCode::SERVICE_UNAVAILABLE);
+
+        // 显式放行该作者后才会走到 metadata 解析：未知档位 / 缺字段各自命中对应的 400 文案。
+        state.set_test_feature_gate_config(vec![module_runtime::FeatureGateConfigSnapshot {
+            gate_key: module_runtime::GAME_DISTRIBUTION_PUBLISH_GATE_KEY.to_string(),
+            enabled: true,
+            rollout_percent: 0,
+            allow_user_ids: vec!["game-author".to_string()],
+            allow_user_tags: vec![],
+            deny_user_ids: vec![],
+            description: String::new(),
+            updated_at_micros: 1,
+        }]);
+        let app = build_app(&state, AuthenticatedAccessToken::new(claims));
+
+        for (payload, expected_message) in [
+            (unknown_fork_authorization, "共创授权档位不合法"),
+            // 缺字段而非档位问题的请求走另一条文案分支，避免把「所有解析失败」都说成档位问题。
+            (json!({ "title": "星轨防线" }), "创建作品请求字段不合法"),
+        ] {
+            let response = app
+                .clone()
+                .oneshot(multipart_request(&payload, "create-game-key-1", true))
+                .await
+                .expect("路由响应");
+            assert_eq!(response.status(), StatusCode::BAD_REQUEST, "{payload}");
+            let body = axum::body::to_bytes(response.into_body(), 32_768)
+                .await
+                .unwrap();
+            let text = String::from_utf8(body.to_vec()).expect("响应必须是 UTF-8");
+            assert!(
+                !text.contains("Failed to deserialize"),
+                "不得返回框架的纯文本拒绝：{text}"
+            );
+            let envelope: Value = serde_json::from_str(&text).expect("必须是平台信封 JSON");
+            assert_eq!(envelope["ok"], Value::Bool(false), "{text}");
+            assert_eq!(
+                envelope["error"]["code"],
+                Value::String("BAD_REQUEST".into()),
+                "{text}"
+            );
+            assert!(
+                envelope["error"]["message"]
+                    .as_str()
+                    .is_some_and(|message| message.contains(expected_message)),
+                "期望 message 含「{expected_message}」：{text}"
+            );
+        }
+
+        // 合法 metadata 不会被解析层误拒：它走到媒体解析那一层，才因为「没有封面」被拒。这条同时
+        // 钉住「metadata 解析位于开关之后、媒体解析之前」的顺序。
+        let valid = app
+            .clone()
+            .oneshot(multipart_request(&valid_body, "create-game-key-2", true))
+            .await
+            .expect("路由响应");
+        assert_eq!(valid.status(), StatusCode::BAD_REQUEST);
+        let body = axum::body::to_bytes(valid.into_body(), 32_768)
+            .await
+            .unwrap();
+        let text = String::from_utf8(body.to_vec()).expect("响应必须是 UTF-8");
+        assert!(
+            text.contains("发布游戏必须提供封面"),
+            "合法 metadata 应通过解析、在媒体层被拒：{text}"
+        );
     }
 
     #[test]
@@ -5755,6 +9320,9 @@ mod tests {
                         average_score: None,
                         rating_count: 0,
                     },
+                    fork_count: 0,
+                    co_creation_count: 0,
+                    lineage: None,
                 }),
                 "index.html",
                 StatusCode::NOT_FOUND,
@@ -5783,7 +9351,7 @@ mod tests {
                             .lock()
                             .expect("reads lock")
                             .push((game_id, version_id));
-                        Ok(Arc::new(Vec::new()))
+                        Ok(Bytes::from(Vec::new()))
                     }
                 },
             )
@@ -5825,7 +9393,7 @@ mod tests {
                             .lock()
                             .expect("reads lock")
                             .push((game_id, version_id));
-                        Ok(Arc::new(package))
+                        Ok(Bytes::from(package))
                     }
                 }
             },
@@ -6073,23 +9641,23 @@ mod tests {
     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]));
+            cache.insert(format!("key-{index}"), Bytes::from(vec![0_u8; 8]));
         }
         assert!(cache.get("key-0").is_some());
-        cache.insert("overflow".to_string(), Arc::new(vec![0_u8; 8]));
+        cache.insert("overflow".to_string(), Bytes::from(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);
+        byte_budget.insert_with_limits("big".to_string(), Bytes::from(vec![0_u8; 8]), 8, 16);
+        byte_budget.insert_with_limits("second".to_string(), Bytes::from(vec![0_u8; 8]), 8, 16);
+        byte_budget.insert_with_limits("third".to_string(), Bytes::from(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);
+        oversized.insert_with_limits("kept".to_string(), Bytes::from(vec![0_u8; 4]), 8, 16);
+        oversized.insert_with_limits("huge".to_string(), Bytes::from(vec![0_u8; 17]), 8, 16);
         assert!(oversized.get("huge").is_none(), "超预算包本身不得进入缓存");
         assert!(
             oversized.get("kept").is_some(),
@@ -6168,6 +9736,10 @@ mod tests {
             created_at: "2026-09-18T08:00:00Z".to_string(),
             updated_at: "2026-09-20T10:00:00Z".to_string(),
             deleted_at: Some("2026-09-21T10:00:00Z".to_string()),
+            fork_authorization: "nonCommercial".to_string(),
+            lineage_generation: 1,
+            forked_from_game_id: Some("game_parent".to_string()),
+            derived_count: 0,
             versions: Vec::new(),
         };
         let payload = admin_game_payload(&record);
@@ -6261,6 +9833,574 @@ mod tests {
         assert_eq!(user_agent_tag(&headers), "test-agent");
     }
 
+    /// 收藏三条路由都必须先过登录门禁，并整组 `no-store`（用户态读接口不得被任何共享缓存复用）。
+    ///
+    /// 测试态没有可用数据库，所以证明点是「已挂载且被认证中间件挡下」（401 + no-store），
+    /// 而不是 404 / 405；成功路径留给 dev 栈端到端。
+    #[tokio::test]
+    async fn collection_routes_require_bearer_and_are_no_store() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app =
+            crate::app::build_router(AppState::new(crate::config::AppConfig::default()).unwrap());
+        for (method, uri) in [
+            ("PUT", "/api/game-distribution/games/game_1/collection"),
+            ("DELETE", "/api/game-distribution/games/game_1/collection"),
+            ("GET", "/api/game-distribution/my-collections"),
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .method(method)
+                        .uri(uri)
+                        .header("idempotency-key", "collection-key-1")
+                        .body(Body::empty())
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(
+                response.status(),
+                StatusCode::UNAUTHORIZED,
+                "{method} {uri}"
+            );
+            assert_eq!(
+                response
+                    .headers()
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("no-store"),
+                "{method} {uri} 是用户态接口，必须不缓存"
+            );
+        }
+    }
+
+    /// 收藏的错误码：作品不存在 → 404；状态不允许收藏 → 409；同键不同摘要 → 409。
+    ///
+    /// 这条测试是「文案 ↔ HTTP 语义」的唯一连结处：模块侧只发文案，映射在这一层，
+    /// 所以这里必须钉住 `状态` 子串不被 `不存在` / `已被删除` / `FORK_` 抢先命中。
+    #[test]
+    fn collection_errors_map_to_not_found_and_conflict() {
+        let conflict_message =
+            shared_contracts::game_distribution::GAME_DISTRIBUTION_COLLECTION_STATE_CONFLICT;
+        assert!(
+            conflict_message.contains("状态"),
+            "409 依赖 `状态` 子串命中冲突分支"
+        );
+        assert!(
+            !conflict_message.contains("不存在")
+                && !conflict_message.contains("已被删除")
+                && !conflict_message.contains("FORK_"),
+            "冲突文案不得抢先命中 404 / 共创分支：{conflict_message}"
+        );
+        for (message, expected) in [
+            ("作品不存在".to_string(), StatusCode::NOT_FOUND),
+            (conflict_message.to_string(), StatusCode::CONFLICT),
+            (
+                "幂等键对应的请求摘要不一致".to_string(),
+                StatusCode::CONFLICT,
+            ),
+        ] {
+            assert_eq!(
+                map_spacetime_error(SpacetimeClientError::Procedure(message.clone())).status_code(),
+                expected,
+                "{message}"
+            );
+        }
+    }
+
+    /// 幂等摘要必须绑定 `(user_id, game_id)`：不同作品 / 不同用户得到不同摘要——换作品会被
+    /// 判成同键不同请求（409），换用户不会（收据键含 `user_id`，两个用户各走各自的新请求）。
+    #[test]
+    fn collection_request_digest_binds_user_and_game() {
+        let baseline = collection_request_digest("usr_1", "game_a").expect("摘要可算");
+        assert_eq!(
+            baseline,
+            collection_request_digest("usr_1", "game_a").expect("摘要可算")
+        );
+        assert_ne!(
+            baseline,
+            collection_request_digest("usr_1", "game_b").expect("摘要可算")
+        );
+        assert_ne!(
+            baseline,
+            collection_request_digest("usr_2", "game_a").expect("摘要可算")
+        );
+    }
+
+    /// PUT / DELETE 的响应形状：`collected` 一定在；`replayed` 只有 PUT 发。
+    #[test]
+    fn collection_state_payload_shape_matches_contract() {
+        let put = serde_json::to_value(GameDistributionCollectionState {
+            collected: true,
+            replayed: Some(false),
+        })
+        .expect("PUT 响应应可序列化");
+        assert_eq!(put, json!({ "collected": true, "replayed": false }));
+        let delete = serde_json::to_value(GameDistributionCollectionState {
+            collected: false,
+            replayed: None,
+        })
+        .expect("DELETE 响应应可序列化");
+        assert_eq!(delete, json!({ "collected": false }));
+    }
+
+    /// `limit` 口径：缺省 20、超界截断到 50、`0` 取默认；都不是报错。
+    ///
+    /// 这条测试同时钉住「api-server 与模块侧同源」：归一化函数就是模块里的那一个，
+    /// 因此 handler 记的 `limit` 与事务真正用的页大小不可能对不上。
+    #[test]
+    fn my_collections_limit_defaults_and_truncates() {
+        assert_eq!(my_collections_page_limit(None), 20);
+        assert_eq!(my_collections_page_limit(Some(0)), 20);
+        assert_eq!(my_collections_page_limit(Some(5)), 5);
+        assert_eq!(my_collections_page_limit(Some(50)), 50);
+        assert_eq!(
+            my_collections_page_limit(Some(51)),
+            50,
+            "超界截断而不是报错"
+        );
+        assert_eq!(my_collections_page_limit(Some(u32::MAX)), 50);
+        // 与后台列表口径**不必相等**，但两个数都必须是「正数且有界」。
+        assert!(my_collections_page_limit(None) > 0);
+        assert!(GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_MAX <= 200);
+    }
+
+    /// 响应形状：`games` 与 `nextCursor` 两个键一定发出；游标是真实值，最后一页为 `null`。
+    #[test]
+    fn my_collections_payload_carries_real_next_cursor() {
+        let with_more = my_collections_payload(Vec::new(), Some("100:usr_1:game_a".to_string()));
+        assert_eq!(
+            with_more,
+            json!({ "games": [], "nextCursor": "100:usr_1:game_a" })
+        );
+        let last_page = my_collections_payload(Vec::new(), None);
+        assert_eq!(last_page, json!({ "games": [], "nextCursor": Value::Null }));
+        // 有内容时 `games` 走公开目录同一份投影，而不是另造一种条目形状。
+        let page = my_collections_payload(vec![public_game_record_fixture()], None);
+        assert_eq!(page["games"].as_array().map(Vec::len), Some(1));
+        assert_eq!(page["games"][0]["id"], "game_1");
+    }
+
+    /// 非法游标必须落 400：模块侧文案经 `map_spacetime_error` 兜底分支，不得被 404 / 409 子串抢先命中。
+    #[test]
+    fn my_collections_invalid_cursor_maps_to_bad_request() {
+        let message =
+            module_game_distribution::parse_game_distribution_collection_cursor("不是游标")
+                .expect_err("非法游标必须报错");
+        assert!(message.contains("格式无效"), "{message}");
+        for forbidden in [
+            "不存在",
+            "已被删除",
+            "状态",
+            "不匹配",
+            "幂等",
+            "已存在",
+            "FORK_",
+        ] {
+            assert!(
+                !message.contains(forbidden),
+                "游标错误文案不得含「{forbidden}」：{message}"
+            );
+        }
+        assert_eq!(
+            map_spacetime_error(SpacetimeClientError::Procedure(message.clone())).status_code(),
+            StatusCode::BAD_REQUEST,
+            "{message}"
+        );
+    }
+
+    /// 公开目录 `limit` 口径：缺省 **48**（保持既有首屏语义）、上限 **100**、`0` 取默认、超界截断。
+    ///
+    /// 归一化就是模块里的那一个函数，因此 handler 记的 `limit` 与事务真正用的页大小不可能对不上。
+    /// 48 从此只是**默认值**：上一版的硬上限缺陷正是 handler 写死 `limit = 48` + 响应写死
+    /// `nextCursor: null`，库里第 49 条起的作品因此永久不可见。
+    #[test]
+    fn public_games_limit_defaults_and_truncates() {
+        assert_eq!(public_games_page_limit(None), 48);
+        assert_eq!(public_games_page_limit(Some(0)), 48);
+        assert_eq!(public_games_page_limit(Some(5)), 5);
+        assert_eq!(public_games_page_limit(Some(48)), 48);
+        assert_eq!(public_games_page_limit(Some(100)), 100);
+        assert_eq!(
+            public_games_page_limit(Some(101)),
+            100,
+            "超界截断而不是报错"
+        );
+        assert_eq!(public_games_page_limit(Some(u32::MAX)), 100);
+        assert_eq!(GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT, 48);
+        assert_eq!(GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_MAX, 100);
+    }
+
+    /// 查询串 `forkable` 的口径：真值 = `1` / `true`（大小写不敏感、先 trim）；**其余一律 false**
+    /// （省略 / 空 / `0` / `false` / 拼错），因此非法取值不会让公开目录 400，而是回到现状。
+    #[test]
+    fn public_games_forkable_flag_is_lenient_about_every_other_value() {
+        for truthy in ["1", "true", "TRUE", "True", " true ", "1 ", "\ttrue"] {
+            assert!(
+                parse_forkable_flag(Some(truthy)),
+                "真值必须开过滤：{truthy:?}"
+            );
+        }
+        for falsy in [
+            None,
+            Some(""),
+            Some("   "),
+            Some("0"),
+            Some("false"),
+            Some("FALSE"),
+            Some("abc"),
+            Some("yes"),
+            Some("2"),
+            Some("-1"),
+            Some("true,false"),
+        ] {
+            assert!(
+                !parse_forkable_flag(falsy),
+                "非真值一律按「不过滤」（= 现状行为）：{falsy:?}"
+            );
+        }
+    }
+
+    /// `forkable=1` 的目录**先过滤、再切页**：禁止共创与不可见的作品都不占页名额，翻页不重不漏、
+    /// 末页 `nextCursor` 为 `null`；非法取值 `abc` 的返回集合与「不带该参数」**完全相同**。
+    ///
+    /// api-server 的单测不起真库，因此这里与既有「51 条翻到底」那条用同一手法：用 handler 自己的
+    /// `public_games_page_limit` 与共享纯函数复现事务里的顺序（可见性过滤 → forkable 过滤 →
+    /// 排序切页），逐页过一遍 `public_games_payload` 断言响应形状。
+    #[test]
+    fn public_games_forkable_filters_before_paging_and_degrades_on_bad_values() {
+        // (game_id, created_at, 授权, 公开可见)
+        let rows = vec![
+            ("game_forbidden_newest", 9_800, "forbidden", true),
+            ("game_full", 9_700, "full", true),
+            ("game_draft_full", 9_650, "full", false), // 未公开
+            ("game_non_commercial", 9_600, "nonCommercial", true),
+            ("game_deleted_full", 9_550, "full", false), // 已软删除
+            ("game_forbidden_middle", 9_500, "forbidden", true),
+            ("game_no_version_full", 9_450, "full", false), // 没有当前公开版本
+            ("game_full_oldest", 9_400, "full", true),
+        ];
+        let visible = rows
+            .into_iter()
+            .filter(|(_, _, _, visible)| *visible)
+            .map(|(game_id, created_at_micros, authorization, _)| {
+                module_game_distribution::GameDistributionCatalogPageItem {
+                    game_id: game_id.to_string(),
+                    created_at_micros,
+                    payload: (game_id.to_string(), authorization.to_string()),
+                }
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(visible.len(), 5, "8 条里 5 条公开可见");
+
+        let page_size = public_games_page_limit(Some(2));
+        assert_eq!(page_size, 2);
+
+        // 按参数的**解析结论**驱动同一段翻页逻辑：过滤在切页之前。
+        let page_all = |forkable: bool| {
+            let items =
+                module_game_distribution::filter_public_game_distribution_catalog_by_forkable(
+                    visible.clone(),
+                    forkable,
+                    |row: &(String, String)| row.1.as_str(),
+                );
+            let mut seen: Vec<String> = Vec::new();
+            let mut cursors: Vec<Option<String>> = Vec::new();
+            let mut cursor = None;
+            loop {
+                let (page, next_cursor) =
+                    module_game_distribution::page_public_game_distribution_catalog(
+                        items.clone(),
+                        cursor,
+                        page_size,
+                    );
+                let body = public_games_payload(Vec::new(), next_cursor.clone());
+                assert!(
+                    body.get("games").is_some() && body.get("nextCursor").is_some(),
+                    "每页都必须带 games 与 nextCursor：{body}"
+                );
+                if next_cursor.is_none() {
+                    assert_eq!(
+                        body["nextCursor"],
+                        Value::Null,
+                        "末页 nextCursor 必须是 null"
+                    );
+                }
+                seen.extend(page.into_iter().map(|row| row.0));
+                cursors.push(next_cursor.clone());
+                match next_cursor {
+                    Some(value) => {
+                        cursor = Some(
+                            module_game_distribution::parse_game_distribution_catalog_cursor(
+                                &value,
+                            )
+                            .expect("服务端产出的游标必须能被自己解析"),
+                        )
+                    }
+                    None => break,
+                }
+            }
+            (seen, cursors)
+        };
+
+        let (forkable_seen, forkable_cursors) = page_all(parse_forkable_flag(Some("1")));
+        assert_eq!(
+            forkable_seen,
+            vec!["game_full", "game_non_commercial", "game_full_oldest",],
+            "只含允许共创的作品，且顺序仍是创建时间倒序、不重不漏"
+        );
+        assert_eq!(
+            forkable_cursors,
+            vec![Some("9600:game_non_commercial".to_string()), None],
+            "游标只指向这一页真正回传的最后一条；forbidden 与不可见行都不参与定位"
+        );
+        for dropped in [
+            "game_forbidden_newest",
+            "game_forbidden_middle",
+            "game_draft_full",
+            "game_deleted_full",
+            "game_no_version_full",
+        ] {
+            assert!(
+                !forkable_seen.iter().any(|game_id| game_id == dropped),
+                "禁止共创 / 不可见的作品不得出现在任何一页：{dropped}"
+            );
+        }
+
+        // ① 不带 `forkable`（与 `0` / `false` / 非法取值同一支）在**可见集**上与改动前逐条相同。
+        let (unfiltered_seen, _) = page_all(parse_forkable_flag(None));
+        assert_eq!(
+            unfiltered_seen,
+            vec![
+                "game_forbidden_newest",
+                "game_full",
+                "game_non_commercial",
+                "game_forbidden_middle",
+                "game_full_oldest",
+            ],
+            "不传 `forkable` 必须等于既有目录行为（forbidden 照旧在列）"
+        );
+        for falsy in [Some("0"), Some("false"), Some("abc"), Some("")] {
+            assert_eq!(
+                page_all(parse_forkable_flag(falsy)).0,
+                unfiltered_seen,
+                "非真值必须按未过滤处理：{falsy:?}"
+            );
+        }
+    }
+
+    /// 公开目录响应形状：`games` 与 `nextCursor` 两个键一定发出；游标是真实值，最后一页为 `null`。
+    #[test]
+    fn public_games_payload_carries_real_next_cursor() {
+        let with_more = public_games_payload(Vec::new(), Some("100:game_a".to_string()));
+        assert_eq!(
+            with_more,
+            json!({ "games": [], "nextCursor": "100:game_a" })
+        );
+        let last_page = public_games_payload(Vec::new(), None);
+        assert_eq!(last_page, json!({ "games": [], "nextCursor": Value::Null }));
+        // 有内容时 `games` 走公开目录同一份投影，而不是另造一种条目形状。
+        let page = public_games_payload(vec![public_game_record_fixture()], None);
+        assert_eq!(page["games"].as_array().map(Vec::len), Some(1));
+        assert_eq!(page["games"][0]["id"], "game_1");
+    }
+
+    /// 非法目录游标必须落 400 **且带稳定码 `CATALOG_INVALID_CURSOR`**。
+    ///
+    /// 模块产出的文案必须以契约定长码开头，否则 `CATALOG_` 分支不命中，会落兜底 400 + 通用
+    /// `BAD_REQUEST`——客户端只能去匹配中文。文案也不得含更早命中的 `FORK_` / `THEME_` 前缀。
+    #[test]
+    fn catalog_list_invalid_cursor_maps_to_bad_request_with_stable_code() {
+        let message = module_game_distribution::parse_game_distribution_catalog_cursor("不是游标")
+            .expect_err("非法游标必须报错");
+        assert!(message.contains("格式无效"), "{message}");
+        for forbidden in ["FORK_", "THEME_"] {
+            assert!(
+                !message.contains(forbidden),
+                "游标错误文案不得含「{forbidden}」（那两个 contains 分支排在 CATALOG_ 之前，会被抢走）：{message}"
+            );
+        }
+        let error = map_spacetime_error(SpacetimeClientError::Procedure(message.clone()));
+        assert_eq!(error.status_code(), StatusCode::BAD_REQUEST, "{message}");
+        assert_eq!(
+            error.code(),
+            GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR,
+            "非法游标必须映射出契约里的稳定码，否则客户端只能匹配中文文案：{message}"
+        );
+    }
+
+    /// **可达性**：模块真实产出的每个目录码都必须映射出契约里的 (状态码, 稳定码)。
+    ///
+    /// 与主题侧那条枚举测试同一个理由：`format!("{code}: 原因")` 这类**合成**文案只能证明「映射
+    /// 表里有这一行」，证明不了「模块真的会产出这个前缀」——上一轮 `THEME_INVALID_CURSOR` 就是
+    /// 这么变成死代码的。这里用模块真实产出的文案，并逐码比对模块常量与 `shared-contracts` 常量
+    /// 是同一组字符串（两侧改字都会红）；将来新增 `CATALOG_*` 码必须一并进这张表。
+    #[test]
+    fn catalog_error_codes_are_reachable_from_module_messages() {
+        let cases = [(
+            module_game_distribution::parse_game_distribution_catalog_cursor("不是游标")
+                .expect_err("非法游标必须报错"),
+            module_game_distribution::GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR_CODE,
+            GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR,
+            StatusCode::BAD_REQUEST,
+        )];
+        for (message, module_code, contract_code, expected_status) in &cases {
+            assert_eq!(
+                module_code, contract_code,
+                "模块常量与 shared-contracts 常量必须是同一组字符串：{message}"
+            );
+            assert!(
+                message.starts_with(contract_code),
+                "模块产出的文案必须以契约码开头（否则 HTTP 面不可达）：{message}"
+            );
+            let error = map_spacetime_error(SpacetimeClientError::Procedure(message.clone()));
+            assert_eq!(error.status_code(), *expected_status, "{message}");
+            assert_eq!(
+                error.code(),
+                *contract_code,
+                "稳定码必须原样透传到 HTTP 面：{message}"
+            );
+        }
+        // 覆盖完整性：本模块一共只有这一个目录码；将来新增的码必须一并进这张表。
+        for code in [module_game_distribution::GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR_CODE] {
+            assert!(
+                cases.iter().any(|(_, covered, _, _)| *covered == code),
+                "目录码 {code} 未被这条枚举测试覆盖"
+            );
+        }
+    }
+
+    /// **缺陷回归**：51 条公开作品按 handler 的真实链路翻页必须能翻到**最老那条**，且未公开 /
+    /// 已软删除 / 没有当前公开版本的作品不出现在任何一页。
+    ///
+    /// api-server 的单测不起真库，因此这里用 handler 自己的 `public_games_page_limit` 复现「先过滤、
+    /// 再排序切页」的顺序（与事务里的顺序一致），并逐页过一遍 `public_games_payload`：这样一条测试
+    /// 同时钉住页大小归一化、游标格式、每页的响应形状与「不可见作品不占名额」。
+    #[test]
+    fn public_games_paging_walks_to_the_oldest_and_hides_invisible_rows() {
+        // 可见作品 51 条（`game_00` 最新、`game_50` 最老），另有三种不可见行混在同一批输入里。
+        let mut rows = (0..51)
+            .map(|index| {
+                (
+                    format!("game_{index:02}"),
+                    10_000 - index as i64,
+                    true, // published + 未软删 + 有当前公开版本
+                )
+            })
+            .collect::<Vec<_>>();
+        rows.push(("game_draft".to_string(), 9_999, false)); // 未公开
+        rows.push(("game_deleted".to_string(), 9_998, false)); // 已软删除
+        rows.push(("game_no_version".to_string(), 9_997, false)); // 没有当前公开版本
+        let visible = rows
+            .into_iter()
+            .filter(|(_, _, visible)| *visible)
+            .map(|(game_id, created_at_micros, _)| {
+                module_game_distribution::GameDistributionCatalogPageItem {
+                    payload: game_id.clone(),
+                    game_id,
+                    created_at_micros,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let mut seen: Vec<String> = Vec::new();
+        let mut cursor = None;
+        let mut pages = 0;
+        loop {
+            let (page, next_cursor) =
+                module_game_distribution::page_public_game_distribution_catalog(
+                    visible.clone(),
+                    cursor,
+                    public_games_page_limit(None),
+                );
+            let body = public_games_payload(Vec::new(), next_cursor.clone());
+            assert!(
+                body.get("games").is_some() && body.get("nextCursor").is_some(),
+                "每页都必须带 games 与 nextCursor：{body}"
+            );
+            if next_cursor.is_none() {
+                assert_eq!(
+                    body["nextCursor"],
+                    Value::Null,
+                    "末页 nextCursor 必须是 null"
+                );
+            }
+            seen.extend(page);
+            pages += 1;
+            match next_cursor {
+                Some(value) => {
+                    cursor = Some(
+                        module_game_distribution::parse_game_distribution_catalog_cursor(&value)
+                            .expect("服务端产出的游标必须能被自己解析"),
+                    )
+                }
+                None => break,
+            }
+        }
+        assert_eq!(pages, 2, "51 条按默认 48 分页应为 2 页");
+        let expected = (0..51)
+            .map(|index| format!("game_{index:02}"))
+            .collect::<Vec<_>>();
+        assert_eq!(
+            seen, expected,
+            "翻页顺序必须严格是「创建时间倒序」且不重不漏"
+        );
+        assert_eq!(
+            seen.last().map(String::as_str),
+            Some("game_50"),
+            "最老的那条必须能翻到——这正是本次修复的目标"
+        );
+        for invisible in ["game_draft", "game_deleted", "game_no_version"] {
+            assert!(
+                !seen.iter().any(|game_id| game_id == invisible),
+                "不可见作品不得出现在任何一页：{invisible}"
+            );
+        }
+    }
+
+    fn public_game_record_fixture() -> GameDistributionPublicGameRecord {
+        GameDistributionPublicGameRecord {
+            game: GameDistributionGameRecord {
+                game_id: "game_1".to_string(),
+                owner_user_id: "user_1".to_string(),
+                title: "收藏测试作品".to_string(),
+                summary: "摘要".to_string(),
+                description: "描述".to_string(),
+                category: "益智".to_string(),
+                tags_json: "[]".to_string(),
+                author_name: None,
+                author_avatar_url: None,
+                device_support_desktop: true,
+                device_support_mobile: false,
+                device_support_touch: false,
+                input_modes_json: "[]".to_string(),
+                orientation: "responsive".to_string(),
+                publication_revision: 1,
+                active_version_id: Some("version_1".to_string()),
+                visibility: "published".to_string(),
+                play_count: 0,
+                created_at: "2026-09-20T00:00:00Z".to_string(),
+                updated_at: "2026-09-20T00:00:00Z".to_string(),
+                project_key: None,
+                cover_object_key: None,
+                screenshots_json: None,
+                fork_authorization: "forbidden".to_string(),
+                price_mud_points: 0,
+            },
+            current_version: None,
+            rating_summary: GameDistributionRatingSummaryRecord {
+                average_score: None,
+                rating_count: 0,
+            },
+            fork_count: 0,
+            co_creation_count: 0,
+            lineage: None,
+        }
+    }
+
     #[test]
     fn owner_media_object_key_is_authorized_by_game_namespace_not_current_row() {
         let prefix = shared_contracts::game_distribution::GAME_DISTRIBUTION_MEDIA_PREFIX;
@@ -6314,6 +10454,7 @@ mod tests {
             project_key: None,
             cover_object_key: None,
             screenshots_json: None,
+            fork_authorization: "forbidden".to_string(),
             price_mud_points,
         }
     }
@@ -6338,6 +10479,19 @@ mod tests {
             created_at: "2026-09-20T00:00:00Z".to_string(),
             updated_at: "2026-09-20T00:00:00Z".to_string(),
             metadata_json: metadata_json.map(str::to_string),
+            // M2b 工程源包：这份夹具说的是「只有发行包」的作品，因此三项都为空。
+            project_bundle_object_key: None,
+            project_bundle_bytes: 0,
+            project_bundle_sha256: None,
+            change_summary: None,
+        }
+    }
+
+    /// 衍生作品的公开版本夹具：只比上者多一条核心改动说明（母版恒为 `None`）。
+    fn public_derivative_version_record(change_summary: &str) -> GameDistributionVersionRecord {
+        GameDistributionVersionRecord {
+            change_summary: Some(change_summary.to_string()),
+            ..public_version_record(None, None)
         }
     }
 
@@ -6352,6 +10506,1070 @@ mod tests {
                 average_score: None,
                 rating_count: 0,
             },
+            fork_count: 0,
+            co_creation_count: 0,
+            lineage: None,
+        }
+    }
+
+    /// 公开详情的 `collected` 可见性：登录才加键；匿名**不加键**（不是 `false`）。
+    ///
+    /// `false` 会把「未登录」说成「没收藏」，客户端无法区分，会渲染出错误的按钮态。
+    /// `themes` 与之相反：**匿名与登录都发**（主题入口是公开页的一部分，不是 per-user 数据），
+    /// 没有所属主题时是空数组而不是缺键——「没有主题」与「没登录」因此不会被混成同一种缺键。
+    #[test]
+    fn public_game_detail_payload_adds_collected_only_when_signed_in_and_always_adds_themes() {
+        let anonymous = public_game_detail_payload(
+            public_game_record_fixture(),
+            &GameViewerContext::default(),
+            None,
+            Vec::new(),
+        );
+        assert!(
+            anonymous.get("collected").is_none(),
+            "匿名请求不得带 collected：{anonymous}"
+        );
+        assert_eq!(
+            anonymous["themes"],
+            Value::Array(Vec::new()),
+            "没有所属主题时必须发空数组（不是缺键）：{anonymous}"
+        );
+        // 匿名负载 = 公开目录负载 + 一个恒发的 `themes` 键（这条路径不引入任何 per-user 字段）。
+        let mut expected =
+            public_game_payload(public_game_record_fixture(), &GameViewerContext::default());
+        expected
+            .as_object_mut()
+            .expect("公开目录负载是对象")
+            .insert("themes".to_string(), Value::Array(Vec::new()));
+        assert_eq!(anonymous, expected);
+
+        let collected = public_game_detail_payload(
+            public_game_record_fixture(),
+            &GameViewerContext::default(),
+            Some(true),
+            Vec::new(),
+        );
+        assert_eq!(collected["collected"], Value::Bool(true));
+        let not_collected = public_game_detail_payload(
+            public_game_record_fixture(),
+            &GameViewerContext::default(),
+            Some(false),
+            Vec::new(),
+        );
+        assert_eq!(not_collected["collected"], Value::Bool(false));
+        // 收藏态只加这一个键，不会顺手把别的私有字段带出去。
+        assert_eq!(
+            not_collected.as_object().map(|object| object.len()),
+            anonymous.as_object().map(|object| object.len() + 1)
+        );
+        // `themes` 逐条只发跳转入口需要的三个键：简介与成员数属于主题页，详情页不发（也不多查一次）。
+        let with_themes = public_game_detail_payload(
+            public_game_record_fixture(),
+            &GameViewerContext::default(),
+            None,
+            vec![theme_reference_fixture("theme_a")],
+        );
+        assert_eq!(
+            with_themes["themes"],
+            json!([{ "themeId": "theme_a", "name": "主题 theme_a", "badge": "精选" }])
+        );
+        let mut reference_keys = with_themes["themes"][0]
+            .as_object()
+            .expect("条目必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        reference_keys.sort();
+        assert_eq!(reference_keys, vec!["badge", "name", "themeId"]);
+    }
+
+    fn theme_summary_fixture(
+        theme_id: &str,
+        member_count: u64,
+    ) -> GameDistributionThemeSummaryRecord {
+        GameDistributionThemeSummaryRecord {
+            theme_id: theme_id.to_string(),
+            name: format!("主题 {theme_id}"),
+            summary: "运营简介".to_string(),
+            badge: "精选".to_string(),
+            member_count,
+        }
+    }
+
+    fn theme_reference_fixture(theme_id: &str) -> GameDistributionThemeReferenceRecord {
+        GameDistributionThemeReferenceRecord {
+            theme_id: theme_id.to_string(),
+            name: format!("主题 {theme_id}"),
+            badge: "精选".to_string(),
+        }
+    }
+
+    /// 主题列表 `limit` 口径：与 `/my-collections` 同值（缺省 20 / 超界截断到 50 / `0` 取默认）。
+    ///
+    /// 归一化就是模块里的那一个函数，因此 handler 记的 `limit` 与事务真正用的页大小不可能对不上。
+    #[test]
+    fn themes_limit_defaults_and_truncates_like_collections() {
+        assert_eq!(themes_page_limit(None), 20);
+        assert_eq!(themes_page_limit(Some(0)), 20);
+        assert_eq!(themes_page_limit(Some(5)), 5);
+        assert_eq!(themes_page_limit(Some(50)), 50);
+        assert_eq!(themes_page_limit(Some(51)), 50, "超界截断而不是报错");
+        assert_eq!(themes_page_limit(Some(u32::MAX)), 50);
+        assert_eq!(GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX, 50);
+        assert_eq!(GAME_DISTRIBUTION_THEME_PAGE_LIMIT_DEFAULT, 20);
+    }
+
+    /// 主题列表非法游标必须落 400 **且带稳定码 `THEME_INVALID_CURSOR`**。
+    ///
+    /// 这条测试是那次真缺陷的回归网：模块侧曾经只回中文串「主题列表游标格式无效」，不含 `THEME_`，
+    /// 于是 `THEME_` 映射分支不命中，落兜底 400 + 通用 `BAD_REQUEST`——契约里的稳定码在 HTTP 面上
+    /// **不可达**，客户端只能匹配中文文案。现在两头都钉住：模块产出前缀（模块侧枚举测试），
+    /// 这里钉「HTTP 面真的映射出那个码」。
+    ///
+    /// 文案不得含 `FORK_`：`FORK_` 分支排在 `THEME_` **之前**，只要文案里出现 `FORK_`，这条错误
+    /// 就会被 FORK 分支抢走（其余「不存在」「状态」等子串都在 `THEME_` 之后，抢不到了）。
+    #[test]
+    fn theme_list_invalid_cursor_maps_to_bad_request() {
+        let message = module_game_distribution::parse_game_distribution_theme_cursor("不是游标")
+            .expect_err("非法游标必须报错");
+        assert!(message.contains("格式无效"), "{message}");
+        assert!(
+            !message.contains("FORK_"),
+            "游标错误文案不得含 `FORK_`（FORK 分支排在 THEME 之前，会被它抢走）：{message}"
+        );
+        let error = map_spacetime_error(SpacetimeClientError::Procedure(message.clone()));
+        assert_eq!(error.status_code(), StatusCode::BAD_REQUEST, "{message}");
+        assert_eq!(
+            error.code(),
+            GAME_DISTRIBUTION_THEME_INVALID_CURSOR,
+            "非法游标必须映射出契约里的稳定码，否则客户端只能匹配中文文案：{message}"
+        );
+    }
+
+    /// **可达性**：6 个主题码里每一个都必须能从**模块真实产出的文案**映射出 (状态码, 稳定码)。
+    ///
+    /// 这是那次真缺陷的根因所在的另一面：`theme_errors_map_to_documented_status_codes` 用的是
+    /// `format!("{code}: 具体原因")` 这类**合成**文案，只能证明「映射表里有这条」，证明不了「模块
+    /// 真的会产出这个前缀」——`THEME_INVALID_CURSOR` 就此成了死代码。这条测试改用模块真实产出的
+    /// 消息（5 个领域变体的 `Display` + 游标解析的裸字符串），顺带比对模块常量与 `shared-contracts`
+    /// 常量是同一组字符串（两侧改字都会红）。
+    #[test]
+    fn theme_error_codes_are_reachable_from_module_messages() {
+        use module_game_distribution::GameDistributionError as DomainError;
+
+        let cases = [
+            (
+                DomainError::ThemeNotFound.to_string(),
+                module_game_distribution::GAME_DISTRIBUTION_THEME_NOT_FOUND_CODE,
+                GAME_DISTRIBUTION_THEME_NOT_FOUND,
+                StatusCode::NOT_FOUND,
+            ),
+            (
+                DomainError::ThemeBadRequest {
+                    reason: "主题名不能为空".to_string(),
+                }
+                .to_string(),
+                module_game_distribution::GAME_DISTRIBUTION_THEME_BAD_REQUEST_CODE,
+                GAME_DISTRIBUTION_THEME_BAD_REQUEST,
+                StatusCode::BAD_REQUEST,
+            ),
+            (
+                module_game_distribution::parse_game_distribution_theme_cursor("不是游标")
+                    .expect_err("非法游标必须报错"),
+                module_game_distribution::GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE,
+                GAME_DISTRIBUTION_THEME_INVALID_CURSOR,
+                StatusCode::BAD_REQUEST,
+            ),
+            (
+                DomainError::ThemeIdempotencyConflict.to_string(),
+                module_game_distribution::GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT_CODE,
+                GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT,
+                StatusCode::CONFLICT,
+            ),
+            (
+                DomainError::ThemeMemberNotRoot {
+                    game_id: "game_child".to_string(),
+                }
+                .to_string(),
+                module_game_distribution::GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT_CODE,
+                GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT,
+                StatusCode::CONFLICT,
+            ),
+            (
+                DomainError::ThemeMemberGameNotFound {
+                    game_id: "game_missing".to_string(),
+                }
+                .to_string(),
+                module_game_distribution::GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND_CODE,
+                GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND,
+                StatusCode::NOT_FOUND,
+            ),
+        ];
+        for (message, module_code, contract_code, expected_status) in &cases {
+            assert_eq!(
+                module_code, contract_code,
+                "模块常量与 shared-contracts 常量必须是同一组字符串：{message}"
+            );
+            assert!(
+                message.starts_with(contract_code),
+                "模块产出的文案必须以契约码开头（否则 HTTP 面不可达）：{message}"
+            );
+            let error = map_spacetime_error(SpacetimeClientError::Procedure(message.clone()));
+            assert_eq!(error.status_code(), *expected_status, "{message}");
+            assert_eq!(
+                error.code(),
+                *contract_code,
+                "稳定码必须原样透传到 HTTP 面：{message}"
+            );
+        }
+    }
+
+    /// **可达性（Fork 一族）**：模块产出的每一条 `FORK_*` 文案都必须映射出契约里的码与状态码。
+    ///
+    /// 这一条是 2026-10-06「衍生作品发布必填核心改动说明」补的：新增的
+    /// `FORK_CHANGE_SUMMARY_REQUIRED` / `_INVALID` 若只写进映射表而没写进模块真正产出的文案
+    /// （或反过来），都会在这里红。后续新增的 `FORK_AUTHORIZATION_INHERITED`（衍生作品授权终态）
+    /// 同样纳入本枚举，理由相同。用的是**模块真实产出**的 `Display` 文案，而不是
+    /// `format!("{code}: 具体原因")` 这类合成串——合成串只能证明「映射表里有这一行」，证明不了
+    /// 「模块真的会产出这个前缀」，上一轮 `THEME_INVALID_CURSOR` 就是这么变成死代码的。
+    ///
+    /// 断言 `error.code()` 与期望码相等同时钉住了「登记进映射表」：未登记的码会落到
+    /// `FORK_ERROR` 兜底分支（409），与期望的 400/403/404 不等。
+    #[test]
+    fn fork_error_codes_are_reachable_from_module_messages() {
+        use module_game_distribution::GameDistributionError as DomainError;
+
+        let cases = [
+            (
+                DomainError::ForkAuthorizationUnknown {
+                    value: "x".to_string(),
+                },
+                StatusCode::BAD_REQUEST,
+                "FORK_AUTHORIZATION_UNKNOWN",
+            ),
+            (
+                DomainError::ForkAuthorizationDowngradeNotAllowed {
+                    current: "full".to_string(),
+                    requested: "forbidden".to_string(),
+                },
+                StatusCode::CONFLICT,
+                "FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED",
+            ),
+            // 衍生作品的终端授权：任何 PUT 都拒，与降级同为 409 但码不同（客户端据此区分
+            // 「刷新后重试」与「这个入口对衍生作品不存在」）。
+            (
+                DomainError::ForkAuthorizationInherited,
+                StatusCode::CONFLICT,
+                module_game_distribution::GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE,
+            ),
+            (
+                DomainError::ForkNotAuthorized,
+                StatusCode::FORBIDDEN,
+                "FORK_NOT_AUTHORIZED",
+            ),
+            (
+                DomainError::ForkSourceNotFound,
+                StatusCode::NOT_FOUND,
+                "FORK_SOURCE_NOT_FOUND",
+            ),
+            (
+                DomainError::ForkSourceNotAvailable,
+                StatusCode::CONFLICT,
+                "FORK_SOURCE_NOT_AVAILABLE",
+            ),
+            (
+                DomainError::ForkSourceVersionMismatch,
+                StatusCode::CONFLICT,
+                "FORK_SOURCE_VERSION_MISMATCH",
+            ),
+            (
+                DomainError::ForkDeclarationOnExistingGame,
+                StatusCode::CONFLICT,
+                "FORK_DECLARATION_ON_EXISTING_GAME",
+            ),
+            (
+                DomainError::ForkChangeSummaryRequired,
+                StatusCode::BAD_REQUEST,
+                "FORK_CHANGE_SUMMARY_REQUIRED",
+            ),
+            (
+                DomainError::ForkChangeSummaryInvalid,
+                StatusCode::BAD_REQUEST,
+                "FORK_CHANGE_SUMMARY_INVALID",
+            ),
+        ];
+        for (error, expected_status, expected_code) in cases {
+            let message = error.to_string();
+            assert!(
+                message.starts_with(&format!("{expected_code}:")),
+                "模块产出的文案必须以契约码 + 冒号开头（否则 HTTP 面不可达）：{message}"
+            );
+            let mapped = map_spacetime_error(SpacetimeClientError::Procedure(message.clone()));
+            assert_eq!(mapped.status_code(), expected_status, "{message}");
+            assert_eq!(
+                mapped.code(),
+                expected_code,
+                "稳定码必须原样透传到 HTTP 面（未登记的码会退化成 FORK_ERROR/409）：{message}"
+            );
+        }
+
+        // 新增的两个码必须是**模块导出的常量**本身，而不是在本文件里再抄一遍字面量：
+        // 常量改名或改字时，这条断言与上面的枚举一起把两侧同时钉住。
+        assert_eq!(
+            module_game_distribution::GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE,
+            "FORK_CHANGE_SUMMARY_REQUIRED"
+        );
+        assert_eq!(
+            module_game_distribution::GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE,
+            "FORK_CHANGE_SUMMARY_INVALID"
+        );
+        assert_eq!(
+            module_game_distribution::GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE,
+            "FORK_AUTHORIZATION_INHERITED"
+        );
+
+        // 未登记的 Fork 码会落到兜底分支（409 `FORK_ERROR`）：这正是上面那条断言有意义的原因。
+        let unknown = map_spacetime_error(SpacetimeClientError::Procedure(
+            "FORK_BRAND_NEW: 未登记".to_string(),
+        ));
+        assert_eq!(unknown.status_code(), StatusCode::CONFLICT);
+        assert_eq!(unknown.code(), "FORK_ERROR");
+    }
+
+    /// 主题列表响应形状：`themes` / `nextCursor` 一定发出；游标是真实值，最后一页为 `null`；
+    /// 单条只有契约里那五个键（`memberCount` 是可见成员数，不是成员行总数）。
+    #[test]
+    fn public_themes_payload_shape_matches_contract() {
+        let with_more = public_themes_payload(
+            vec![theme_summary_fixture("theme_a", 2)],
+            Some("100:theme_a".to_string()),
+        );
+        assert_eq!(
+            with_more,
+            json!({
+                "themes": [
+                    {
+                        "themeId": "theme_a",
+                        "name": "主题 theme_a",
+                        "summary": "运营简介",
+                        "badge": "精选",
+                        "memberCount": 2,
+                    }
+                ],
+                "nextCursor": "100:theme_a",
+            })
+        );
+        let last_page = public_themes_payload(Vec::new(), None);
+        assert_eq!(
+            last_page,
+            json!({ "themes": [], "nextCursor": Value::Null })
+        );
+        let mut item_keys = with_more["themes"][0]
+            .as_object()
+            .expect("条目必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        item_keys.sort();
+        assert_eq!(
+            item_keys,
+            vec!["badge", "memberCount", "name", "summary", "themeId"]
+        );
+    }
+
+    /// 主题详情响应：顶层扁平（**七个**键），`roots` 走公开目录**同一份**投影，不另造条目形状；
+    /// `rootsTruncated` 与 `memberCount` 是两个独立键（空成员时前者为 `false`，不是缺键）。
+    #[test]
+    fn public_theme_detail_payload_is_flat_and_reuses_public_game_projection() {
+        let detail = public_theme_detail_payload(GameDistributionThemeDetailRecord {
+            theme_id: "theme_a".to_string(),
+            name: "主题 theme_a".to_string(),
+            summary: "运营简介".to_string(),
+            badge: "精选".to_string(),
+            member_count: 1,
+            roots: vec![public_game_record_fixture()],
+            roots_truncated: false,
+        });
+        let mut keys = detail
+            .as_object()
+            .expect("详情负载是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        keys.sort();
+        assert_eq!(
+            keys,
+            vec![
+                "badge",
+                "memberCount",
+                "name",
+                "roots",
+                "rootsTruncated",
+                "summary",
+                "themeId"
+            ],
+            "顶层必须是契约里那七个键：`rootsTruncated` 是「这份 roots 被上限截断」的独立信号"
+        );
+        assert_eq!(detail["themeId"], "theme_a");
+        assert_eq!(detail["memberCount"], 1);
+        assert_eq!(detail["rootsTruncated"], Value::Bool(false));
+        // `roots` 的条目与公开目录逐字节一致：同一条投影链路，不存在第二套作品摘要。
+        assert_eq!(
+            detail["roots"][0],
+            public_game_payload(public_game_record_fixture(), &GameViewerContext::default())
+        );
+        // 已发布但可见成员为空：200 + 空 `roots`（不是 404、不是缺键），且 `rootsTruncated` 必须
+        // 显式是 `false`——空清单没什么可截断的，缺键会让客户端只能靠 `undefined` 猜。
+        let empty = public_theme_detail_payload(GameDistributionThemeDetailRecord {
+            theme_id: "theme_b".to_string(),
+            name: "主题 theme_b".to_string(),
+            summary: String::new(),
+            badge: String::new(),
+            member_count: 0,
+            roots: Vec::new(),
+            roots_truncated: false,
+        });
+        assert_eq!(empty["memberCount"], 0);
+        assert_eq!(empty["roots"], Value::Array(Vec::new()));
+        assert_eq!(empty["rootsTruncated"], Value::Bool(false));
+        // 截断路径：`memberCount` 照实报真实可见数（120），`roots` 只有 1 条并置 `true`——
+        // 两个键口径独立，任何「用其中一个推另一个」的改动都会在这里红。
+        let truncated = public_theme_detail_payload(GameDistributionThemeDetailRecord {
+            theme_id: "theme_c".to_string(),
+            name: "主题 theme_c".to_string(),
+            summary: String::new(),
+            badge: String::new(),
+            member_count: 120,
+            roots: vec![public_game_record_fixture()],
+            roots_truncated: true,
+        });
+        assert_eq!(truncated["memberCount"], 120);
+        assert_eq!(truncated["rootsTruncated"], Value::Bool(true));
+        assert_eq!(
+            truncated["roots"].as_array().map(Vec::len),
+            Some(1),
+            "截断只影响 roots 的条数，不影响 memberCount"
+        );
+    }
+
+    /// 主题公开路由必须挂载且整组 `no-store`：匿名可读（没有鉴权层），未连库时走到 SpacetimeDB
+    /// 才失败（502），而不是 404 / 401 / 405。
+    #[tokio::test]
+    async fn theme_routes_are_public_and_no_store() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app = crate::app::build_router(
+            crate::state::AppState::new(crate::config::AppConfig::default())
+                .expect("测试状态应可构建"),
+        );
+
+        for uri in [
+            "/api/game-distribution/themes",
+            "/api/game-distribution/themes/theme_a",
+            "/api/game-distribution/themes?limit=5&cursor=100%3Atheme_a",
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .uri(uri)
+                        .body(Body::empty())
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(
+                response.status(),
+                StatusCode::BAD_GATEWAY,
+                "{uri} 必须挂载并走到 SpacetimeDB"
+            );
+            assert_eq!(
+                response
+                    .headers()
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("no-store"),
+                "{uri} 是公开读接口，必须不缓存"
+            );
+        }
+    }
+
+    /// 主题错误码映射：公开侧「主题不存在」落 404；`THEME_*` 码逐条落表里那个状态码，
+    /// 且**不**落到 axum 默认的 422 纯文本。
+    ///
+    /// 顺序约束是这段映射的前提：先于「状态」（409）与「不存在」（404）两个子串分支。
+    #[test]
+    fn theme_errors_map_to_documented_status_codes() {
+        // 公开侧：不存在 / 未发布共用同一句文案，落 404。
+        let public_not_found =
+            map_spacetime_error(SpacetimeClientError::Procedure("主题不存在".to_string()));
+        assert_eq!(public_not_found.status_code(), StatusCode::NOT_FOUND);
+
+        for (code, expected) in [
+            (GAME_DISTRIBUTION_THEME_NOT_FOUND, StatusCode::NOT_FOUND),
+            (GAME_DISTRIBUTION_THEME_BAD_REQUEST, StatusCode::BAD_REQUEST),
+            (
+                GAME_DISTRIBUTION_THEME_INVALID_CURSOR,
+                StatusCode::BAD_REQUEST,
+            ),
+            (
+                GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT,
+                StatusCode::CONFLICT,
+            ),
+            (
+                GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT,
+                StatusCode::CONFLICT,
+            ),
+            (
+                GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND,
+                StatusCode::NOT_FOUND,
+            ),
+        ] {
+            let error =
+                map_spacetime_error(SpacetimeClientError::Procedure(format!("{code}: 具体原因")));
+            assert_eq!(error.status_code(), expected, "{code}");
+            assert_eq!(error.code(), code, "{code} 的错误码必须原样透传");
+        }
+
+        // 未登记的码按请求非法保守处理，并给出可检索的稳定码（不是 axum 的 422 纯文本）。
+        let unknown = map_spacetime_error(SpacetimeClientError::Procedure(
+            "THEME_NEW: 未登记".to_string(),
+        ));
+        assert_eq!(unknown.status_code(), StatusCode::BAD_REQUEST);
+        assert_eq!(unknown.code(), "THEME_ERROR");
+
+        // 顺序约束：`THEME_*` 分支排在所有子串分支之前，因此主题错误码的语义永远不会被
+        // 「不存在 / 状态 / 不匹配」这类字样抢走（用一个刻意带污染字样的码证明这一点）。
+        let not_root = map_spacetime_error(SpacetimeClientError::Procedure(
+            "THEME_MEMBER_NOT_ROOT: 目标作品有血缘行（不是根；它不能说“不存在”）".to_string(),
+        ));
+        assert_eq!(not_root.status_code(), StatusCode::CONFLICT);
+        assert_eq!(not_root.code(), GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT);
+        // 反过来，**不带**前缀的文案会落到子串规则上，而分支顺序是「不存在」在「不匹配 / 状态」之前：
+        // ① 409 语义的文案一旦带上「不存在」就会被映射成 404——所以模块侧写 409 文案时必须避开它；
+        // ② 公开侧的 404 文案因为含「不存在」，即使多写一个「状态」也稳落 404（不会翻成 409）。
+        assert_eq!(
+            map_spacetime_error(SpacetimeClientError::Procedure(
+                "成员状态不匹配".to_string()
+            ))
+            .status_code(),
+            StatusCode::CONFLICT,
+            "「不匹配」子串落在 409 分支"
+        );
+        assert_eq!(
+            map_spacetime_error(SpacetimeClientError::Procedure(
+                "成员状态冲突：目标作品不存在".to_string()
+            ))
+            .status_code(),
+            StatusCode::NOT_FOUND,
+            "含「不存在」的文案先命中 404：409 文案不得含「不存在」"
+        );
+        assert_eq!(
+            map_spacetime_error(SpacetimeClientError::Procedure(
+                "主题不存在（状态已归档）".to_string()
+            ))
+            .status_code(),
+            StatusCode::NOT_FOUND,
+            "公开侧 404 文案含「不存在」，多写「状态」也不会被抢到 409"
+        );
+    }
+
+    /// 领域错误类型产出的文案必须被 HTTP 映射认出来：两半契约（`module-game-distribution` 写码、
+    /// api-server 映射状态码）在这里缝合。任何一侧改字都会红。
+    #[test]
+    fn domain_theme_errors_map_to_the_documented_http_status_codes() {
+        use module_game_distribution::GameDistributionError;
+        let cases = [
+            (
+                GameDistributionError::ThemeNotFound,
+                StatusCode::NOT_FOUND,
+                GAME_DISTRIBUTION_THEME_NOT_FOUND,
+            ),
+            (
+                GameDistributionError::ThemeBadRequest {
+                    reason: "主题名不能为空".to_string(),
+                },
+                StatusCode::BAD_REQUEST,
+                GAME_DISTRIBUTION_THEME_BAD_REQUEST,
+            ),
+            (
+                GameDistributionError::ThemeIdempotencyConflict,
+                StatusCode::CONFLICT,
+                GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT,
+            ),
+            (
+                GameDistributionError::ThemeMemberNotRoot {
+                    game_id: "game_child".to_string(),
+                },
+                StatusCode::CONFLICT,
+                GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT,
+            ),
+            (
+                GameDistributionError::ThemeMemberGameNotFound {
+                    game_id: "game_missing".to_string(),
+                },
+                StatusCode::NOT_FOUND,
+                GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND,
+            ),
+        ];
+        for (error, status, code) in cases {
+            let mapped = map_spacetime_error(SpacetimeClientError::Procedure(error.to_string()));
+            assert_eq!(mapped.status_code(), status, "{error}");
+            assert_eq!(mapped.code(), code, "{error}");
+        }
+    }
+
+    /// DTO 的 `status` 枚举取值必须与模块侧白名单**逐一相等**：枚举是 HTTP 入参的唯一来源，
+    /// 白名单是事务落库的唯一判据，两者一旦分叉就会出现「请求收下了、落库判非法」的 500 级事故。
+    #[test]
+    fn theme_status_values_match_the_module_whitelist() {
+        let mut values = [
+            theme_status_value(GameDistributionThemeStatus::Draft),
+            theme_status_value(GameDistributionThemeStatus::Published),
+            theme_status_value(GameDistributionThemeStatus::Archived),
+        ];
+        values.sort();
+        let mut whitelist = module_game_distribution::GAME_DISTRIBUTION_THEME_STATUSES;
+        whitelist.sort();
+        assert_eq!(values, whitelist);
+    }
+
+    /// 后台主题 payload：键集合与契约一一对应（`memberCount` 是成员行总数），列表**不带**
+    /// `nextCursor`（这条路径不分页），写接口的 `replayed` 必须原样发出。
+    #[test]
+    fn admin_theme_payloads_match_the_documented_shape() {
+        let record = GameDistributionAdminThemeRecord {
+            theme_id: "theme_1".to_string(),
+            name: "共创主题".to_string(),
+            summary: "简介".to_string(),
+            badge: "精选".to_string(),
+            sort_order: 7,
+            status: "draft".to_string(),
+            member_count: 3,
+            created_at: "2026-10-06T00:00:00Z".to_string(),
+            updated_at: "2026-10-06T01:00:00Z".to_string(),
+        };
+        let payload = admin_theme_payload(&record);
+        let mut keys = payload
+            .as_object()
+            .expect("主题条目必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        keys.sort();
+        assert_eq!(
+            keys,
+            vec![
+                "badge",
+                "createdAt",
+                "memberCount",
+                "name",
+                "sortOrder",
+                "status",
+                "summary",
+                "themeId",
+                "updatedAt"
+            ]
+        );
+        // 后台不套公开可见性过滤：`draft` 原样出现（这正是「后台列表含 draft」的可断言部分）。
+        assert_eq!(payload["status"], "draft");
+        assert_eq!(payload["memberCount"], 3);
+        assert_eq!(payload["sortOrder"], 7);
+
+        // 列表：只有 `themes` 一个键（无游标），且逐条形状与单条一致。
+        let list = admin_themes_payload(std::slice::from_ref(&record));
+        let mut list_keys = list
+            .as_object()
+            .expect("列表必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        list_keys.sort();
+        assert_eq!(list_keys, vec!["themes"]);
+        assert_eq!(list["themes"][0], payload);
+
+        // 写接口：`theme` + `replayed`；重放与新建的差异只在 `replayed`。
+        let mutation = admin_theme_mutation_payload(&GameDistributionAdminThemeMutationRecord {
+            theme: record.clone(),
+            replayed: true,
+        });
+        assert_eq!(mutation["theme"], payload);
+        assert_eq!(mutation["replayed"], true);
+
+        // 成员写入：不含「之前存不存在」，因此重复 PUT / DELETE 的响应逐字节相同。
+        let member = admin_theme_member_payload(&GameDistributionAdminThemeMemberRecord {
+            theme_id: "theme_1".to_string(),
+            root_game_id: "game_1".to_string(),
+            sort_order: 2,
+            created_at: "2026-10-06T00:00:00Z".to_string(),
+        });
+        let mut member_keys = member
+            .as_object()
+            .expect("成员条目必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        member_keys.sort();
+        assert_eq!(
+            member_keys,
+            vec!["createdAt", "rootGameId", "sortOrder", "themeId"]
+        );
+    }
+
+    /// `theme_bad_request` 必须带稳定码 `THEME_BAD_REQUEST`：与事务侧同一串，客户端可据此分支。
+    #[test]
+    fn theme_bad_request_carries_the_shared_machine_code() {
+        let error = theme_bad_request("主题名不能为空");
+        assert_eq!(error.status_code(), StatusCode::BAD_REQUEST);
+        assert_eq!(error.code(), GAME_DISTRIBUTION_THEME_BAD_REQUEST);
+    }
+
+    /// 五条后台主题路由未带 admin 会话一律 401（与同组既有后台路由同码同形）：鉴权复用既有的
+    /// `require_admin_auth`，不自造第二套。
+    #[tokio::test]
+    async fn admin_theme_routes_require_admin_authentication() {
+        use axum::http::Request;
+        use tower::ServiceExt;
+        let app = crate::app::build_router(
+            AppState::new(crate::config::AppConfig {
+                admin_username: Some("theme-owner".into()),
+                admin_password: Some("theme-test-password".into()),
+                ..Default::default()
+            })
+            .expect("state should build"),
+        );
+        for (method, uri) in [
+            ("GET", "/admin/api/game-distribution/themes"),
+            ("POST", "/admin/api/game-distribution/themes"),
+            ("PUT", "/admin/api/game-distribution/themes/theme_1"),
+            ("GET", "/admin/api/game-distribution/themes/theme_1/members"),
+            (
+                "PUT",
+                "/admin/api/game-distribution/themes/theme_1/members/game_1",
+            ),
+            (
+                "DELETE",
+                "/admin/api/game-distribution/themes/theme_1/members/game_1",
+            ),
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .method(method)
+                        .uri(uri)
+                        .header(shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER, "1")
+                        .body(Body::empty())
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(
+                response.status(),
+                StatusCode::UNAUTHORIZED,
+                "{method} {uri}"
+            );
+            let body = axum::body::to_bytes(response.into_body(), 32_768)
+                .await
+                .unwrap();
+            let body: Value = serde_json::from_slice(&body).expect("必须是平台信封 JSON");
+            assert_eq!(body["ok"], false, "{method} {uri}");
+            assert_eq!(body["error"]["code"], "UNAUTHORIZED", "{method} {uri}");
+        }
+    }
+
+    /// 后台主题 handler 的 400 路径：坏 JSON / 缺必填字段 / 未知 `status` 枚举值 / 非法 `status`
+    /// 过滤值。全部是**平台信封 + 稳定码**，绝不是 axum 默认的 422 纯文本。
+    ///
+    /// 这些分支都在触达 SpacetimeDB 之前返回，因此在没有真库的 host 测试里可断言。
+    #[tokio::test]
+    async fn admin_theme_handlers_reject_malformed_input_with_theme_bad_request() {
+        use axum::http::Request;
+        use shared_contracts::admin::{AdminAccountRole, AdminSessionPayload};
+        use tower::ServiceExt;
+        let admin = AuthenticatedAdmin::new(AdminSessionPayload {
+            subject: "authenticated-admin".into(),
+            username: "theme-admin".into(),
+            display_name: "主题管理员".into(),
+            roles: vec!["admin".into()],
+            account_role: AdminAccountRole::Owner,
+            tab_permissions: vec![],
+            action_permissions: vec![],
+            issued_at: "2026-10-01T00:00:00Z".into(),
+            expires_at: "2026-10-02T00:00:00Z".into(),
+        });
+        let app = Router::new()
+            .route("/themes", get(admin_list_themes).post(admin_create_theme))
+            .route("/themes/{theme_id}", put(admin_update_theme))
+            .route(
+                "/themes/{theme_id}/members/{root_game_id}",
+                put(admin_upsert_theme_member).delete(admin_remove_theme_member),
+            )
+            .layer(Extension(admin))
+            // 与生产同一套 request context 中间件：错误信封的 `ok` / `meta` 由它决定。
+            .layer(middleware::from_fn(
+                crate::request_context::attach_request_context,
+            ))
+            .with_state(AppState::new(crate::config::AppConfig::default()).expect("state"));
+
+        for (method, uri, body) in [
+            // 未知 status 取值：DTO 枚举在反序列化阶段就挡下（不得落到 axum 422）。
+            ("POST", "/themes", r#"{"name":"主题","status":"hidden"}"#),
+            ("POST", "/themes", "{"),
+            ("POST", "/themes", r#"{"summary":"缺少 name"}"#),
+            (
+                "PUT",
+                "/themes/theme_1",
+                r#"{"name":"主题","status":"draft"}"#,
+            ),
+            ("PUT", "/themes/theme_1/members/game_1", "{"),
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .method(method)
+                        .uri(uri)
+                        .header(header::CONTENT_TYPE, "application/json")
+                        .header("idempotency-key", "theme-test-key")
+                        .header(shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER, "1")
+                        .body(Body::from(body))
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(
+                response.status(),
+                StatusCode::BAD_REQUEST,
+                "{method} {uri} {body}"
+            );
+            let bytes = axum::body::to_bytes(response.into_body(), 32_768)
+                .await
+                .unwrap();
+            let text = String::from_utf8(bytes.to_vec()).expect("响应必须是 UTF-8");
+            assert!(
+                !text.contains("Failed to deserialize"),
+                "{method} {uri} 不得返回框架的纯文本拒绝：{text}"
+            );
+            let envelope: Value = serde_json::from_str(&text).expect("必须是平台信封 JSON");
+            assert_eq!(
+                envelope["error"]["code"],
+                Value::String(GAME_DISTRIBUTION_THEME_BAD_REQUEST.into()),
+                "{method} {uri} {body}"
+            );
+        }
+
+        // 非法 status 过滤值：在打数据库之前就挡住（否则会变成 5xx，把 400 契约掩盖掉）。
+        let response = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/themes?status=hidden")
+                    .header(shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER, "1")
+                    .body(Body::empty())
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+        let bytes = axum::body::to_bytes(response.into_body(), 32_768)
+            .await
+            .unwrap();
+        let envelope: Value = serde_json::from_str(&String::from_utf8(bytes.to_vec()).unwrap())
+            .expect("必须是平台信封 JSON");
+        assert_eq!(
+            envelope["error"]["code"],
+            Value::String(GAME_DISTRIBUTION_THEME_BAD_REQUEST.into())
+        );
+
+        // 缺 `Idempotency-Key` 沿用既有写接口的既有口径（`BAD_REQUEST`），不为主题另开一套。
+        let response = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .method("POST")
+                    .uri("/themes")
+                    .header(header::CONTENT_TYPE, "application/json")
+                    .header(shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER, "1")
+                    .body(Body::from(r#"{"name":"主题"}"#))
+                    .expect("请求"),
+            )
+            .await
+            .expect("路由响应");
+        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+        let bytes = axum::body::to_bytes(response.into_body(), 32_768)
+            .await
+            .unwrap();
+        let envelope: Value = serde_json::from_str(&String::from_utf8(bytes.to_vec()).unwrap())
+            .expect("必须是平台信封 JSON");
+        assert_eq!(
+            envelope["error"]["code"],
+            Value::String("BAD_REQUEST".into())
+        );
+    }
+
+    /// 后台成员名单的两个领域错误必须落**契约里的状态码与稳定码**。
+    ///
+    /// 用**模块真实产出**的文案（成员游标那层薄封装委托的解析器、事务用的领域错误），而不是合成
+    /// 字符串：上一轮的真缺陷正是「契约码在 HTTP 面不可达」，合成文案证明不了可达性。
+    /// 文案不得含 `FORK_`：`FORK_` 分支排在 `THEME_` **之前**，会被它抢走。
+    #[test]
+    fn admin_theme_member_list_maps_its_two_domain_errors() {
+        let cursor_message =
+            module_game_distribution::parse_game_distribution_theme_member_cursor("不是游标")
+                .expect_err("非法游标必须报错");
+        assert!(cursor_message.contains("格式无效"), "{cursor_message}");
+        assert!(!cursor_message.contains("FORK_"), "{cursor_message}");
+        let cursor_error =
+            map_spacetime_error(SpacetimeClientError::Procedure(cursor_message.clone()));
+        assert_eq!(
+            cursor_error.status_code(),
+            StatusCode::BAD_REQUEST,
+            "{cursor_message}"
+        );
+        assert_eq!(
+            cursor_error.code(),
+            GAME_DISTRIBUTION_THEME_INVALID_CURSOR,
+            "非法游标必须映射出契约里的稳定码，否则客户端只能匹配中文文案：{cursor_message}"
+        );
+
+        let not_found = map_spacetime_error(SpacetimeClientError::Procedure(
+            module_game_distribution::GameDistributionError::ThemeNotFound.to_string(),
+        ));
+        assert_eq!(
+            not_found.status_code(),
+            StatusCode::NOT_FOUND,
+            "主题不存在必须是 404（draft / archived 不是：后台要看得见）"
+        );
+        assert_eq!(not_found.code(), GAME_DISTRIBUTION_THEME_NOT_FOUND);
+    }
+
+    /// 后台成员名单的两条响应形状：列表四个键、单条六个键，且 `title` / `nextCursor` 的 `null`
+    /// **必须发出去**（省略会让「查不到作品」与「服务端忘了发键」长得一样）。
+    #[test]
+    fn admin_theme_member_payloads_match_the_documented_shape() {
+        let row = GameDistributionAdminThemeMemberRowRecord {
+            root_game_id: "game_root".to_string(),
+            title: None,
+            sort_order: 3,
+            created_at: "2026-10-06T00:00:00Z".to_string(),
+            // 「已公开但没有当前公开版本」：两个字段刻意独立，值必须原样发出。
+            visible: false,
+            visibility: "published".to_string(),
+        };
+        let payload = admin_theme_member_row_payload(&row);
+        let mut keys = payload
+            .as_object()
+            .expect("成员行必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        keys.sort();
+        assert_eq!(
+            keys,
+            vec![
+                "createdAt",
+                "rootGameId",
+                "sortOrder",
+                "title",
+                "visibility",
+                "visible",
+            ]
+        );
+        assert_eq!(
+            payload["title"],
+            Value::Null,
+            "游戏行不存在时 title 发 null，不是省略键"
+        );
+        assert_eq!(payload["visible"], false);
+        assert_eq!(payload["visibility"], "published");
+        assert_eq!(payload["sortOrder"], 3);
+
+        let list = admin_theme_members_payload("theme_1", 12, std::slice::from_ref(&row), None);
+        let mut list_keys = list
+            .as_object()
+            .expect("名单必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        list_keys.sort();
+        assert_eq!(
+            list_keys,
+            vec!["members", "nextCursor", "themeId", "totalMembers"]
+        );
+        assert_eq!(
+            list["totalMembers"], 12,
+            "totalMembers 是成员行总数，与这一页回了几个无关"
+        );
+        assert_eq!(list["themeId"], "theme_1");
+        assert_eq!(list["members"][0], payload);
+        assert_eq!(
+            list["nextCursor"],
+            Value::Null,
+            "末页游标必须发 null（不是省略），否则客户端会反复翻同一页"
+        );
+
+        // 末页之外：游标原样发出，客户端据此继续翻页。
+        let more = admin_theme_members_payload(
+            "theme_1",
+            12,
+            std::slice::from_ref(&row),
+            Some("3:theme_1:game_root".to_string()),
+        );
+        assert_eq!(more["nextCursor"], "3:theme_1:game_root");
+    }
+
+    /// 非 admin 令牌 → **403**（不是 401）：鉴权复用既有 `require_admin_auth`，`roles` 里没有
+    /// `admin` 一律 403——本接口不自造第二套权限判定。
+    #[tokio::test]
+    async fn admin_theme_member_route_rejects_non_admin_roles_with_forbidden() {
+        use axum::http::Request;
+        use tower::ServiceExt;
+        let state = AppState::new(crate::config::AppConfig {
+            admin_username: Some("theme-owner".into()),
+            admin_password: Some("theme-test-password".into()),
+            ..Default::default()
+        })
+        .expect("state should build");
+        let token = {
+            let runtime = state.admin_runtime().expect("后台管理已启用");
+            let claims = runtime
+                .build_account_claims(
+                    "theme-member-account".into(),
+                    "theme-member".into(),
+                    "普通成员".into(),
+                    vec!["member".into()],
+                    1,
+                    time::OffsetDateTime::now_utc(),
+                )
+                .expect("claims should build");
+            runtime.sign_token(&claims).expect("token should sign")
+        };
+        let app = crate::app::build_router(state);
+        for uri in [
+            "/admin/api/game-distribution/themes/theme_1/members",
+            "/admin/api/game-distribution/themes",
+        ] {
+            let response = app
+                .clone()
+                .oneshot(
+                    Request::builder()
+                        .uri(uri)
+                        .header("authorization", format!("Bearer {token}"))
+                        .header(shared_contracts::api::API_RESPONSE_ENVELOPE_HEADER, "1")
+                        .body(Body::empty())
+                        .expect("请求"),
+                )
+                .await
+                .expect("路由响应");
+            assert_eq!(response.status(), StatusCode::FORBIDDEN, "{uri}");
+            let body = axum::body::to_bytes(response.into_body(), 32_768)
+                .await
+                .unwrap();
+            let body: Value = serde_json::from_slice(&body).expect("必须是平台信封 JSON");
+            assert_eq!(body["ok"], false, "{uri}");
+            assert_eq!(body["error"]["code"], "FORBIDDEN", "{uri}");
         }
     }
 
@@ -6380,7 +11598,12 @@ mod tests {
                 },
                 input_modes: vec![],
                 orientation: GameDistributionOrientation::Responsive,
+                // 这份夹具只关心价格校验：共创授权用默认「禁止共创」，也不声明改编来源。
+                fork_authorization: GameDistributionForkAuthorization::Forbidden,
+                fork: None,
             },
+            // 这份夹具不关心核心改动说明（派生判定与它无关的用例都留空）。
+            change_summary: None,
         }
     }
 
@@ -6495,6 +11718,98 @@ mod tests {
         assert_eq!(free["currentVersion"]["entryUrl"], json!("/games/game_1/"));
     }
 
+    /// 公开版本负载必须带出「本次核心改动说明」：详情页与族谱溯源据此展示每一代的差异。
+    ///
+    /// 两条路径都要过：`version_summary_payload`（列表/详情的版本摘要本体）与
+    /// `public_game_payload` 里那份 `currentVersion`（详情页用的就是它）。母版发 `null` 而不是
+    /// 缺键——「这一代没有来源作品」与「服务端忘了发这个字段」是两回事，客户端不该靠缺键猜。
+    #[test]
+    fn public_version_payload_carries_change_summary_for_derivatives_and_null_for_masters() {
+        let summary_text = "把跳台改成三段，并重画全部背景与角色立绘";
+
+        let master_summary =
+            version_summary_payload(&public_version_record(Some("/games/game_1/"), None));
+        assert_eq!(master_summary["changeSummary"], Value::Null);
+        assert_eq!(master_summary["id"], json!("version_1"));
+
+        let derivative_summary =
+            version_summary_payload(&public_derivative_version_record(summary_text));
+        assert_eq!(derivative_summary["changeSummary"], json!(summary_text));
+
+        // 详情页路径：`currentVersion` 用的是同一个构建器，因此母版与衍生都按同一口径发出。
+        let detail = public_game_payload(
+            public_game_record(
+                paid_game_record("user_author", 0),
+                public_derivative_version_record(summary_text),
+            ),
+            &GameViewerContext::default(),
+        );
+        assert_eq!(
+            detail["currentVersion"]["changeSummary"],
+            json!(summary_text)
+        );
+        let master_detail = public_game_payload(
+            public_game_record(
+                paid_game_record("user_author", 0),
+                public_version_record(Some("/games/game_1/"), None),
+            ),
+            &GameViewerContext::default(),
+        );
+        assert_eq!(
+            master_detail["currentVersion"]["changeSummary"],
+            Value::Null
+        );
+
+        // 契约层也要能读：公开负载反序列化回 shared-contracts 的版本摘要不留残差。
+        let parsed: shared_contracts::game_distribution::GameDistributionVersionSummary =
+            serde_json::from_value(detail["currentVersion"].clone())
+                .expect("公开版本摘要应能按契约解析");
+        assert_eq!(parsed.change_summary.as_deref(), Some(summary_text));
+    }
+
+    /// 核心改动说明是**版本级**字段：同一衍生作品的不同版本各带各的说明；公开投影只多出这一个
+    /// 键，不夹带对象键 / 素材 id 之类的私有字段。
+    #[test]
+    fn change_summary_is_version_scoped_and_never_leaks_private_keys() {
+        let first = public_derivative_version_record("第一版：加了二段跳");
+        let second = GameDistributionVersionRecord {
+            version_id: "version_2".to_string(),
+            version_number: 2,
+            change_summary: Some("第二版：修掉了落地判定".to_string()),
+            ..public_derivative_version_record("第一版：加了二段跳")
+        };
+        let first_payload = version_summary_payload(&first);
+        let second_payload = version_summary_payload(&second);
+        assert_eq!(first_payload["changeSummary"], json!("第一版：加了二段跳"));
+        assert_eq!(
+            second_payload["changeSummary"],
+            json!("第二版：修掉了落地判定")
+        );
+        assert_eq!(first_payload["version"], json!("1"));
+        assert_eq!(second_payload["version"], json!("2"));
+
+        // 键集合逐字钉住：多出任何一个私有字段（对象键 / 素材 id / 审核理由）都会被这条抓住。
+        let mut keys = first_payload
+            .as_object()
+            .expect("公开版本摘要必须是对象")
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        keys.sort();
+        assert_eq!(
+            keys,
+            vec![
+                "changeSummary".to_string(),
+                "controls".to_string(),
+                "entryUrl".to_string(),
+                "id".to_string(),
+                "publishedAt".to_string(),
+                "sha256".to_string(),
+                "version".to_string(),
+            ]
+        );
+    }
+
     /// 审核列表与版本详情都读版本冻结价；历史版本缺 `priceMudPoints` 一律按免费（0），
     /// 不回退游戏行价，与审核通过后实际生效的价格口径一致。
     #[test]
@@ -6817,4 +12132,225 @@ mod tests {
         assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
         assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
     }
+
+    /// 贡献归集路由：未登录必须在进入业务前被挡成 401，且整组 `no-store`。
+    #[tokio::test]
+    async fn contribution_route_requires_bearer_and_is_no_store() {
+        use axum::{body::Body, http::Request};
+        use tower::ServiceExt;
+
+        let app =
+            crate::app::build_router(AppState::new(crate::config::AppConfig::default()).unwrap());
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/api/game-distribution/games/game_1/contribution")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+    }
+
+    /// 贡献归集的两条读口径必须可分辨：非作者 403（沿用 owner-mismatch 惯例）、读不到 404。
+    #[test]
+    fn contribution_read_maps_owner_mismatch_to_forbidden_and_missing_to_not_found() {
+        // 事务报的 owner 不匹配文案必须原样命中既有映射，不在这里另写一套 403。
+        assert_eq!(
+            map_spacetime_error(SpacetimeClientError::Procedure(
+                "游戏 owner 不匹配".to_string()
+            ))
+            .status_code(),
+            StatusCode::FORBIDDEN
+        );
+        assert_eq!(
+            contribution_read_or_not_found::<u8>(None)
+                .expect_err("读不到必须 404")
+                .status_code(),
+            StatusCode::NOT_FOUND
+        );
+        assert_eq!(
+            contribution_read_or_not_found(Some(7)).expect("可读透传"),
+            7
+        );
+    }
+
+    fn contribution_node(
+        game_id: &str,
+        parent_game_id: Option<&str>,
+        generation: u32,
+        play_count: u64,
+    ) -> module_game_distribution::ContributionNode {
+        module_game_distribution::ContributionNode {
+            game_id: game_id.to_string(),
+            parent_game_id: parent_game_id.map(str::to_string),
+            generation,
+            totals: module_game_distribution::ContributionTotals::from_play_count(play_count),
+        }
+    }
+
+    /// 把纯函数结果**原样搬运**成客户端记录（不重算任何数字），用于证明
+    /// 「响应里的数字 == 纯函数的数字」打的是完整链路，而不是两份实现互相印证。
+    fn contribution_record(
+        breakdown: module_game_distribution::ContributionBreakdown,
+    ) -> spacetime_client::GameDistributionContributionRecord {
+        use spacetime_client::{
+            GameDistributionContributionChildRecord, GameDistributionContributionGenerationRecord,
+            GameDistributionContributionRecord, GameDistributionContributionTotalsRecord,
+        };
+
+        fn totals(
+            value: module_game_distribution::ContributionTotals,
+        ) -> GameDistributionContributionTotalsRecord {
+            GameDistributionContributionTotalsRecord {
+                play_count: value.play_count,
+            }
+        }
+
+        GameDistributionContributionRecord {
+            game_id: breakdown.game_id,
+            own: totals(breakdown.own),
+            inherited: totals(breakdown.inherited),
+            total: totals(breakdown.total),
+            by_generation: breakdown
+                .by_generation
+                .into_iter()
+                .map(|entry| GameDistributionContributionGenerationRecord {
+                    generation: entry.generation,
+                    game_count: entry.game_count,
+                    own: totals(entry.own),
+                    inherited: totals(entry.inherited),
+                    total: totals(entry.total),
+                })
+                .collect(),
+            direct_children: breakdown
+                .direct_children
+                .into_iter()
+                .map(|entry| GameDistributionContributionChildRecord {
+                    game_id: entry.game_id,
+                    generation: entry.generation,
+                    own: totals(entry.own),
+                    inherited: totals(entry.inherited),
+                    total: totals(entry.total),
+                })
+                .collect(),
+            node_count: breakdown.node_count,
+            truncated: breakdown.truncated,
+            truncated_reason: breakdown
+                .truncated_reason
+                .map(|reason| reason.as_str().to_string()),
+        }
+    }
+
+    fn contribution_total_of(entries: &[Value]) -> u64 {
+        entries
+            .iter()
+            .map(|entry| entry["total"]["playCount"].as_u64().expect("数字"))
+            .sum()
+    }
+
+    /// 贡献归集：响应数字必须与纯函数逐字段一致，两条分解之和都等于 `inherited`，
+    /// 截断时 `truncated` / `truncatedReason` 如实透传且已计入部分仍自洽。
+    #[test]
+    fn contribution_payload_matches_pure_function_and_keeps_truncation_reason() {
+        use module_game_distribution::{
+            GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT, GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT,
+            build_contribution_breakdown,
+        };
+
+        // 三层链路 + 一个并列分支：root → game_b → game_c，root → game_d。
+        let nodes = [
+            contribution_node("root", None, 0, 120),
+            contribution_node("game_b", Some("root"), 1, 70),
+            contribution_node("game_c", Some("game_b"), 2, 40),
+            contribution_node("game_d", Some("root"), 1, 230),
+        ];
+        let breakdown = build_contribution_breakdown(
+            &nodes,
+            "root",
+            GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT,
+            GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT,
+        )
+        .expect("根必须存在");
+        // 递归定义：inherited(root) = total(game_b) + total(game_d) = (70 + 40) + 230。
+        assert_eq!(breakdown.own.play_count, 120);
+        assert_eq!(breakdown.inherited.play_count, 340);
+        assert_eq!(breakdown.total.play_count, 460);
+        assert_eq!(breakdown.node_count, 3);
+        assert!(!breakdown.truncated);
+
+        let json = serde_json::to_value(contribution_payload(contribution_record(breakdown)))
+            .expect("负载应可序列化");
+        assert_eq!(json["gameId"], Value::String("root".to_string()));
+        assert_eq!(json["own"]["playCount"], 120);
+        assert_eq!(json["inherited"]["playCount"], 340);
+        assert_eq!(json["total"]["playCount"], 460);
+        assert_eq!(json["nodeCount"], 3);
+        assert_eq!(json["truncated"], Value::Bool(false));
+        assert_eq!(json["truncatedReason"], Value::Null);
+
+        let by_generation = json["byGeneration"].as_array().expect("按代际分解").clone();
+        assert_eq!(
+            by_generation
+                .iter()
+                .map(|entry| entry["generation"].as_u64().expect("代际"))
+                .collect::<Vec<_>>(),
+            vec![1, 2]
+        );
+        assert_eq!(by_generation[0]["gameCount"], 2);
+        assert_eq!(by_generation[0]["own"]["playCount"], 300);
+        assert_eq!(by_generation[1]["gameCount"], 1);
+        assert_eq!(by_generation[1]["own"]["playCount"], 40);
+        assert_eq!(contribution_total_of(&by_generation), 340);
+
+        let direct_children = json["directChildren"]
+            .as_array()
+            .expect("直接子代明细")
+            .clone();
+        assert_eq!(direct_children.len(), 2);
+        assert_eq!(direct_children[0]["gameId"], "game_b");
+        assert_eq!(direct_children[0]["generation"], 1);
+        assert_eq!(direct_children[0]["own"]["playCount"], 70);
+        assert_eq!(direct_children[0]["inherited"]["playCount"], 40);
+        assert_eq!(direct_children[0]["total"]["playCount"], 110);
+        assert_eq!(direct_children[1]["gameId"], "game_d");
+        assert_eq!(direct_children[1]["total"]["playCount"], 230);
+        assert_eq!(contribution_total_of(&direct_children), 340);
+
+        // 截断：标志与原因原样透传，且已计入部分的数字仍自洽（三条不变量在截断子树上成立）。
+        let truncated = build_contribution_breakdown(&nodes, "root", 1, 32).expect("根必须存在");
+        assert!(truncated.truncated);
+        let covered = truncated.inherited.play_count;
+        let truncated_json =
+            serde_json::to_value(contribution_payload(contribution_record(truncated)))
+                .expect("截断负载应可序列化");
+        assert_eq!(truncated_json["truncated"], Value::Bool(true));
+        assert_eq!(
+            truncated_json["truncatedReason"],
+            Value::String("node_limit".to_string())
+        );
+        assert_eq!(truncated_json["inherited"]["playCount"], covered);
+        assert_eq!(
+            contribution_total_of(
+                truncated_json["byGeneration"]
+                    .as_array()
+                    .expect("按代际分解")
+            ),
+            covered
+        );
+        assert_eq!(
+            contribution_total_of(
+                truncated_json["directChildren"]
+                    .as_array()
+                    .expect("直接子代明细")
+            ),
+            covered
+        );
+        assert_eq!(
+            truncated_json["total"]["playCount"].as_u64().expect("总量"),
+            truncated_json["own"]["playCount"].as_u64().expect("自身") + covered
+        );
+    }
 }
diff --git a/server-rs/crates/api-server/src/modules/game_distribution_publish.rs b/server-rs/crates/api-server/src/modules/game_distribution_publish.rs
index 5a3e7d0d8..ae3d81073 100644
--- a/server-rs/crates/api-server/src/modules/game_distribution_publish.rs
+++ b/server-rs/crates/api-server/src/modules/game_distribution_publish.rs
@@ -178,6 +178,8 @@ pub(crate) async fn publish_version(
         idempotency_key,
         request_digest,
         now_micros: now,
+        // 衍生作品的改动说明走同一条统一发布事务；母版由事务忽略。
+        change_summary: payload.change_summary.clone(),
     };
     // 收口发布事务：失败或幂等重放时，本次新传的媒体都不被结果引用，统一补偿删除。
     let published = state
diff --git a/server-rs/crates/module-game-distribution/src/application.rs b/server-rs/crates/module-game-distribution/src/application.rs
index 0242638ec..042e094a6 100644
--- a/server-rs/crates/module-game-distribution/src/application.rs
+++ b/server-rs/crates/module-game-distribution/src/application.rs
@@ -169,7 +169,7 @@ impl GameDistributionService {
         if state.versions.contains_key(&version_id) {
             return Err(GameDistributionError::VersionAlreadyExists);
         }
-        let version_number = resolve_version_number(input.version_number)?;
+        let version_number = resolve_version_number(0, Some(input.version_number))?;
         let snapshot = GameVersionSnapshot {
             version_id: version_id.clone(),
             game_id,
@@ -1423,15 +1423,15 @@ mod tests {
 
     #[test]
     fn version_number_is_required_and_only_rejects_zero() {
-        assert_eq!(resolve_version_number(1).expect("首版显式 1"), 1);
-        assert_eq!(resolve_version_number(3).expect("同号重放合法"), 3);
-        assert_eq!(resolve_version_number(2).expect("回退标签合法"), 2);
+        assert_eq!(resolve_version_number(0, Some(1)).expect("首版显式 1"), 1);
+        assert_eq!(resolve_version_number(0, Some(3)).expect("同号重放合法"), 3);
+        assert_eq!(resolve_version_number(0, Some(2)).expect("回退标签合法"), 2);
         assert_eq!(
-            resolve_version_number(u64::MAX).expect("极大标签合法"),
+            resolve_version_number(0, Some(u64::MAX)).expect("极大标签合法"),
             u64::MAX
         );
         assert_eq!(
-            resolve_version_number(0).expect_err("0 不是合法标签"),
+            resolve_version_number(0, Some(0)).expect_err("0 不是合法标签"),
             GameDistributionFieldError::InvalidVersionNumber
         );
     }
diff --git a/server-rs/crates/module-game-distribution/src/catalog.rs b/server-rs/crates/module-game-distribution/src/catalog.rs
new file mode 100644
index 000000000..762a624b6
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/catalog.rs
@@ -0,0 +1,633 @@
+//! 公开游戏目录（游戏广场 `/api/game-distribution/games`）的纯函数规则。
+//!
+//! 表与事务在 `spacetime-module::game_distribution`；这里只放能被不起 SpacetimeDB 的单测钉住的
+//! 规则：公开目录列表的页大小口径、游标编解码与「稳定全序排序 + 切页」。
+//!
+//! 为什么需要它：公开目录原先在事务里写死 `limit = 48` 且没有游标——库里第 49 条之后的作品
+//! （含最老的母版与主干）在 HTTP 面**永久不可见**，客户端只能显示「已检查最新 48 个作品」。
+//! 数据一直在、详情与 `/lineage` 都读得到，缺的只是「翻到下一页」的通道。这里补上游标分页，
+//! 并沿用仓库既有的 `"{i64}:{id}"` 游标惯例（与主题列表 / 收藏列表同一套），不另立第二套语义。
+
+use crate::domain::ForkAuthorization;
+
+/// 公开目录一页的默认条数。
+///
+/// 取 48 是**保持既有首屏语义**：现网 AGC 共创页首屏就是 48 条（客户端按这个数显示「已检查
+/// 最新 N 个作品」），改小会让首屏少一截、改大则与既有观测口径对不上。它只是**缺省值**，
+/// 不再是硬上限——正是「写死 48 且无游标」让第 49 条起的作品永远不可见。
+pub const GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT: u32 = 48;
+
+/// 公开目录单次响应回传的条数上限。
+///
+/// 与 `/my-collections`（50）/ 主题列表（50）不同值：公开目录的条目是完整公开投影（含当前版本
+/// 与评分摘要），而广场是首屏页面、一次要铺满网格，因此给到 100 仍然只是「单响应体量」的上限。
+/// 超界一律**截断**而不是报错——客户端拿到的是一个完整页，而不是一个需要重试的错误。
+pub const GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_MAX: u32 = 100;
+
+/// 公开目录游标格式非法的稳定码。
+///
+/// 文案必须以码开头（`"{CODE}: {中文说明}"`）：api-server 的 `CATALOG_` 映射分支要求消息含
+/// `CATALOG_` 且按冒号前的码查状态码表，少了前缀就静默退化成兜底的 400 + 通用 `BAD_REQUEST`，
+/// 客户端只能去匹配中文——这正是本项目在主题列表上出过一次的真缺陷（游标错误不是领域变体，
+/// 只是裸字符串，`Display` 的前缀测试覆盖不到它，所以 api-server 另有一条测试专门枚举全部
+/// `CATALOG_` 码，逐条从**模块真实产出的文案**映射）。
+///
+/// 与 `shared-contracts` 里的 `GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR` 是同一组字符串的两个
+/// 副本（本 crate 不依赖 `shared-contracts`），两侧由 api-server 的可达性枚举测试逐码比对。
+pub const GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR_CODE: &str = "CATALOG_INVALID_CURSOR";
+
+/// 请求里的 `limit` → 实际页大小：`0` 取默认 48，超界截断到上限 100。
+///
+/// 与主题列表 / 收藏列表同一套归一化口径（同一段 `if == 0 ... min(...)` 的形状），抽成独立函数
+/// 是为了让 api-server 记日志的「生效条数」与模块真正使用的页大小**同源**：两处各自写一遍迟早
+/// 会漂移，日志就会写 100 而实际只发 48。
+///
+/// `0` 取默认而不是「返回 0 条」是既有约定：`limit=0` 只可能是客户端「没填」的表达，回一个空页
+/// 会把「缺省」渲染成「没有作品」。
+pub fn game_distribution_catalog_page_limit(limit: u32) -> usize {
+    let resolved = if limit == 0 {
+        GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT
+    } else {
+        limit.min(GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_MAX)
+    };
+    resolved as usize
+}
+
+/// 公开目录分页序列里的一条：游标 / 排序所需的两个键 + 调用方自己的负载。
+///
+/// 泛型 `payload` 让「排序键」与「这一页要回传的东西」绑在同一个值上，纯函数切页时整条值一起
+/// 移动，因此不可能出现「按 A 排序、按 B 切页」的错位；模块侧把负载填成游戏行，测试里填成任意
+/// 轻量值。
+#[derive(Clone, Debug, PartialEq)]
+pub struct GameDistributionCatalogPageItem<T> {
+    /// 作品主键 `game-*`；作品表内唯一，因此可作全序兜底键。
+    pub game_id: String,
+    /// 作品创建时间（Unix 微秒），主排序键。
+    pub created_at_micros: i64,
+    pub payload: T,
+}
+
+/// 公开目录游标编码：`{created_at_micros}:{game_id}`。
+///
+/// 与主题列表 / 收藏列表 / 后台列表同一套 `"{micros}:{id}"` 惯例。`game_id` 由本领域签发
+/// （`game-*`）、**不含冒号**，因此这里比收藏列表（`collection_id` 自带冒号）更简单；解析仍只切
+/// **第一个**冒号，格式对将来更长的 ID 也不会退化。
+pub fn encode_game_distribution_catalog_cursor(created_at_micros: i64, game_id: &str) -> String {
+    format!("{created_at_micros}:{game_id}")
+}
+
+/// 公开目录游标解析；格式非法时返回带**稳定码**的 `Err`：`CATALOG_INVALID_CURSOR: …`。
+///
+/// 规则与主题列表游标解析逐条同构（切第一个冒号、`i64` 必须可解析、`game_id` 必须非空），因此
+/// 客户端的非法游标一律在事务里失败关闭、由 api-server 映射 **400 + 稳定码**，不会退化成
+/// 「200 + 空页」（后者会让客户端以为目录真的到底了）。
+///
+/// 文案刻意避开会被 api-server **更早的**分支抢走的子串：`FORK_` 与 `THEME_` 两个 `contains`
+/// 分支排在 `CATALOG_` 之前，文案里只要出现它们就会被抢先映射（甚至映射成 409）。这条约束由
+/// 单测与 api-server 的可达性枚举测试同时钉住。
+pub fn parse_game_distribution_catalog_cursor(value: &str) -> Result<(i64, String), String> {
+    let invalid = || {
+        format!(
+            "{}: 目录游标格式无效",
+            GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR_CODE
+        )
+    };
+    let (micros, game_id) = value.split_once(':').ok_or_else(invalid)?;
+    let micros = micros.parse::<i64>().map_err(|_| invalid())?;
+    if game_id.is_empty() {
+        return Err(invalid());
+    }
+    Ok((micros, game_id.to_string()))
+}
+
+/// 公开目录的稳定排序：`created_at` **倒序** + `game_id` **升序**兜底（与原先事务里的比较器
+/// **逐字同序**，因此这一改动不会让既有首页顺序发生任何变化）。
+///
+/// 为什么这个比较器必须是**全序**：`created_at` 相同的两条必须还能分出先后，否则同一页边界上的
+/// 项会在翻页时重复或漏掉——一批用同一次 `seed` 灌进库的演示作品完全可能共享创建时间。
+/// `game_id` 是主键、唯一，因此 `(created_at_micros, game_id)` 唯一决定顺序。
+pub fn sort_public_game_distribution_catalog<T>(
+    mut items: Vec<GameDistributionCatalogPageItem<T>>,
+) -> Vec<GameDistributionCatalogPageItem<T>> {
+    items.sort_by(|left, right| {
+        right
+            .created_at_micros
+            .cmp(&left.created_at_micros)
+            .then_with(|| left.game_id.cmp(&right.game_id))
+    });
+    items
+}
+
+/// 公开目录分页：按上面的比较器排序、跳过游标之前的位置、取 `limit` 条，并返回下一页游标
+/// （没有下一页时为 `None`）。
+///
+/// 调用方必须**先**按可见性过滤（作者 / `published` / 未软删 / 有当前公开版本 / 分类 / 关键词）、
+/// **再**把结果交给本函数：游标位置定义在已过滤的序列上。反过来先把未过滤序列切页、再逐页过滤，
+/// 被滤掉的行会凭空占掉名额，下一页的游标又指回过滤前的序列——每翻一页都漏掉自己的若干条
+/// （与 `/my-collections`、公开主题列表同一条纪律）。
+///
+/// `has_more` 用「多取一条」判定而不是 `len == limit`：`len == limit` 时无法区分「正好一页」与
+/// 「还有下一页」，前一种情况下发游标会让客户端多翻一次死页。`next_cursor` 只编码**这一页真正
+/// 回传的最后一条**，因此下一页从它之后开始，边界不重不漏。
+pub fn page_public_game_distribution_catalog<T>(
+    items: Vec<GameDistributionCatalogPageItem<T>>,
+    cursor: Option<(i64, String)>,
+    limit: u32,
+) -> (Vec<T>, Option<String>) {
+    let limit = game_distribution_catalog_page_limit(limit);
+    let mut items = sort_public_game_distribution_catalog(items);
+    if let Some((cursor_micros, cursor_id)) = cursor.as_ref() {
+        // 严格「在游标之后」：创建时间更早，或时间相同且 game_id 更大（升序方向）。
+        items.retain(|item| {
+            item.created_at_micros < *cursor_micros
+                || (item.created_at_micros == *cursor_micros
+                    && item.game_id.as_str() > cursor_id.as_str())
+        });
+    }
+    let has_more = items.len() > limit;
+    items.truncate(limit);
+    let next_cursor = if has_more {
+        items.last().map(|item| {
+            encode_game_distribution_catalog_cursor(item.created_at_micros, item.game_id.as_str())
+        })
+    } else {
+        None
+    };
+    (
+        items.into_iter().map(|item| item.payload).collect(),
+        next_cursor,
+    )
+}
+
+/// 公开目录的 `forkable` 过滤：`forkable` 为真时**只留下允许共创的作品**，否则原样返回。
+///
+/// 这是 `/api/game-distribution/games?forkable=1`（AGC「共创」页）的判据。它与可见性过滤同一条
+/// 纪律，**必须在切页之前**调用：先把序列按 `forkable` 收窄、再交给
+/// `page_public_game_distribution_catalog`，被滤掉的 `forbidden` 作品才不会凭空占掉名额、也不会
+/// 让下一页游标指回过滤前的序列（那种顺序会让每翻一页就漏掉自己的若干条）。
+///
+/// `authorization_of` 由调用方给出「这一条作品的原始档位字符串怎么取」——分页项对负载是泛型的，
+/// 本 crate 不依赖 SpacetimeDB 行类型；判据本身复用 [`ForkAuthorization::stored_allows_fork`]，
+/// 因此「未知档位按禁止解释」这一条与 fork 门禁同源、只有一份实现。
+///
+/// `forkable` 为假时**直接返回原序列**（不做一次空过滤）：`false` / 省略参数 / 非法取值在
+/// api-server 侧都归一成假，因此「不传 `forkable`」的行为就是本函数出现之前的既有目录行为。
+pub fn filter_public_game_distribution_catalog_by_forkable<T>(
+    items: Vec<GameDistributionCatalogPageItem<T>>,
+    forkable: bool,
+    authorization_of: impl Fn(&T) -> &str,
+) -> Vec<GameDistributionCatalogPageItem<T>> {
+    if !forkable {
+        return items;
+    }
+    items
+        .into_iter()
+        .filter(|item| ForkAuthorization::stored_allows_fork(authorization_of(&item.payload)))
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `limit` 语义：`0` 取默认 48（不是「返回 0 条」），超界截断到 100（不是报错）。
+    ///
+    /// 48 是**默认值而非硬上限**——这正是本次修复的核心：写死 48 会让第 49 条起的作品永久不可见。
+    #[test]
+    fn page_limit_defaults_zero_and_truncates_overflow() {
+        assert_eq!(game_distribution_catalog_page_limit(0), 48);
+        assert_eq!(game_distribution_catalog_page_limit(1), 1);
+        assert_eq!(game_distribution_catalog_page_limit(48), 48);
+        assert_eq!(game_distribution_catalog_page_limit(100), 100);
+        assert_eq!(
+            game_distribution_catalog_page_limit(101),
+            100,
+            "超界截断而不是报错"
+        );
+        assert_eq!(game_distribution_catalog_page_limit(u32::MAX), 100);
+        assert_eq!(GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT, 48);
+        assert_eq!(GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_MAX, 100);
+    }
+
+    /// 游标编解码：往返双射、解析只切第一个冒号、负数微秒可逆，各种非法输入一律 `Err`。
+    #[test]
+    fn cursor_round_trips_and_rejects_malformed_values() {
+        let cursor = encode_game_distribution_catalog_cursor(1_700_000_000_000_000, "game_a");
+        assert_eq!(cursor, "1700000000000000:game_a");
+        assert_eq!(
+            parse_game_distribution_catalog_cursor(&cursor).unwrap(),
+            (1_700_000_000_000_000, "game_a".to_string())
+        );
+        // 负数微秒（仅编码假设，仍必须可逆）。
+        assert_eq!(
+            parse_game_distribution_catalog_cursor("-5:game_a").unwrap(),
+            (-5, "game_a".to_string())
+        );
+        // 解析只切第一个冒号：micros 之后的整段（含更多冒号）都是 game_id。
+        assert_eq!(
+            parse_game_distribution_catalog_cursor("9:game:a").unwrap(),
+            (9, "game:a".to_string())
+        );
+
+        for malformed in ["", "not-a-cursor", "100", "abc:game_a", "100:", " :game_a"] {
+            assert!(
+                parse_game_distribution_catalog_cursor(malformed).is_err(),
+                "非法游标必须报错：{malformed:?}"
+            );
+        }
+    }
+
+    /// 非法游标文案必须以**稳定码**开头，且不含会被 api-server 更早分支抢走的子串。
+    ///
+    /// `map_spacetime_error` 里 `FORK_` 与 `THEME_` 两个 `contains` 分支都排在 `CATALOG_` 之前，
+    /// 文案里只要出现其中之一就会被抢先映射（`FORK_` 甚至落 409）。
+    #[test]
+    fn invalid_cursor_message_stays_in_the_bad_request_bucket() {
+        let message =
+            parse_game_distribution_catalog_cursor("不是游标").expect_err("非法游标必须报错");
+        assert!(
+            message.starts_with(GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR_CODE),
+            "游标错误必须以稳定码开头，否则 HTTP 面只能回通用 BAD_REQUEST：{message}"
+        );
+        // 前缀后面必须真的跟冒号：api-server 用 `split(':').next()` 取码，缺了冒号就会把整句
+        // 文案当成码，落到未登记分支变成通用 `CATALOG_ERROR` 之外的兜底。
+        assert!(
+            message.starts_with(&format!("{GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR_CODE}:")),
+            "稳定码后面必须跟冒号：{message}"
+        );
+        assert!(message.contains("格式无效"), "{message}");
+        for forbidden in [
+            "FORK_",
+            "THEME_",
+            "不存在",
+            "已被删除",
+            "状态",
+            "不匹配",
+            "幂等",
+            "已存在",
+        ] {
+            assert!(
+                !message.contains(forbidden),
+                "游标错误文案不得含「{forbidden}」：{message}"
+            );
+        }
+    }
+
+    fn item(game_id: &str, created_at_micros: i64) -> GameDistributionCatalogPageItem<String> {
+        GameDistributionCatalogPageItem {
+            game_id: game_id.to_string(),
+            created_at_micros,
+            payload: game_id.to_string(),
+        }
+    }
+
+    /// 不足一页：全部回传，且**没有**下一页游标（不能给一个指向空页的游标，否则客户端会多翻一次死页）。
+    #[test]
+    fn page_returns_everything_without_cursor_when_under_limit() {
+        let (page, next) = page_public_game_distribution_catalog(
+            vec![item("game_a", 300), item("game_b", 200)],
+            None,
+            20,
+        );
+        assert_eq!(page, vec!["game_a", "game_b"]);
+        assert_eq!(next, None);
+    }
+
+    /// 恰好一页：`has_more` 依赖「多取一条」，因此 `len == limit` 时不能再给游标。
+    #[test]
+    fn page_at_exact_limit_has_no_cursor() {
+        let (page, next) = page_public_game_distribution_catalog(
+            vec![item("game_a", 300), item("game_b", 200)],
+            None,
+            2,
+        );
+        assert_eq!(page.len(), 2);
+        assert_eq!(next, None);
+    }
+
+    /// **本次缺陷的回归网**：51 条公开作品用默认页大小（48）翻页，必须能翻到**最老那条**。
+    ///
+    /// 修正前 `limit` 写死 48 且没有游标：第一页给出最新 48 条，库里的第 49–51 条（含最老的母版
+    /// 与主干）在任何一页都拿不到。这里逐页翻到底，断言总条数 = 51、顺序严格是「创建时间倒序」、
+    /// 且最老的那条确实出现过。
+    #[test]
+    fn paging_walks_the_51_game_catalog_down_to_the_oldest() {
+        // `game_00` 最新、`game_50` 最老（创建时间等差递减）。
+        let entries = (0..51)
+            .map(|index| item(&format!("game_{index:02}"), 10_000 - index as i64))
+            .collect::<Vec<_>>();
+        let mut seen: Vec<String> = Vec::new();
+        let mut cursor = None;
+        let mut pages = 0;
+        loop {
+            let (page, next) = page_public_game_distribution_catalog(
+                entries.clone(),
+                cursor,
+                GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT,
+            );
+            assert!(!page.is_empty(), "非末页不得为空");
+            seen.extend(page);
+            pages += 1;
+            match next {
+                Some(value) => {
+                    cursor = Some(parse_game_distribution_catalog_cursor(&value).unwrap())
+                }
+                None => break,
+            }
+        }
+        assert_eq!(pages, 2, "51 条按默认 48 分页应为 2 页");
+        assert_eq!(seen.len(), 51);
+        let expected = (0..51)
+            .map(|index| format!("game_{index:02}"))
+            .collect::<Vec<_>>();
+        assert_eq!(
+            seen, expected,
+            "翻页顺序必须严格是「创建时间倒序」且不重不漏"
+        );
+        assert_eq!(
+            seen.last().map(String::as_str),
+            Some("game_50"),
+            "最老的那条必须能翻到——这正是本次修复的目标"
+        );
+    }
+
+    /// 同一 `created_at` 多条：`game_id` 升序兜底保证全序，翻页边界不重不漏。
+    ///
+    /// 这是唯一能钉住「排序是全序」的场景：若比较器在 `created_at` 相同时不稳定，三条同刻作品里
+    /// 的某一条就会被下一页重复返回或被整段跳过。
+    #[test]
+    fn page_tiebreaks_equal_created_at_by_game_id_ascending() {
+        let entries = vec![
+            item("game_c", 100),
+            item("game_a", 100),
+            item("game_d", 99),
+            item("game_b", 100),
+        ];
+        let (first, next) = page_public_game_distribution_catalog(entries.clone(), None, 2);
+        assert_eq!(first, vec!["game_a", "game_b"]);
+        let cursor = next.expect("还有同刻与更早的项");
+        assert_eq!(cursor, "100:game_b");
+        let (second, last) = page_public_game_distribution_catalog(
+            entries,
+            Some(parse_game_distribution_catalog_cursor(&cursor).unwrap()),
+            2,
+        );
+        assert_eq!(second, vec!["game_c", "game_d"]);
+        assert_eq!(last, None, "第二页就是最后一页");
+    }
+
+    /// **先过滤、再排序切页**：被滤掉的行不得凭空占掉名额，也不得出现在任何一页里。
+    ///
+    /// 用「可见性过滤在调用方、发生在切页之前」的结构模拟模块侧的真实顺序：把未公开 / 已软删 /
+    /// 无公开版本的行混在同一批输入里，先 `retain`，再交给分页函数；若顺序反过来（先切页再过滤），
+    /// 第一页就会因为不可见行占位而少回传，翻页也会漏项。
+    #[test]
+    fn visibility_filter_must_happen_before_paging() {
+        // game_b / game_d 是「不可见」的作品（未公开 / 已软删除），它们不该占页名额。
+        let raw = vec![
+            item("game_a", 500),
+            item("game_b", 400),
+            item("game_c", 300),
+            item("game_d", 200),
+            item("game_e", 100),
+        ];
+        let visible = raw
+            .into_iter()
+            .filter(|entry| entry.game_id != "game_b" && entry.game_id != "game_d")
+            .collect::<Vec<_>>();
+
+        let mut seen: Vec<String> = Vec::new();
+        let mut cursor = None;
+        loop {
+            let (page, next) = page_public_game_distribution_catalog(visible.clone(), cursor, 1);
+            if next.is_some() {
+                assert_eq!(page.len(), 1, "过滤后仍有余量时必须填满 limit 条");
+            }
+            seen.extend(page);
+            match next {
+                Some(value) => {
+                    cursor = Some(parse_game_distribution_catalog_cursor(&value).unwrap())
+                }
+                None => break,
+            }
+        }
+        assert_eq!(seen, vec!["game_a", "game_c", "game_e"]);
+        assert!(
+            !seen.iter().any(|id| id == "game_b" || id == "game_d"),
+            "不可见作品不得出现在任何一页"
+        );
+    }
+
+    /// 游标只指向这一页**真正回传的最后一条**：下一页从它之后开始，边界既不重复也不跳过。
+    #[test]
+    fn cursor_points_at_the_last_returned_item() {
+        let entries = vec![
+            item("game_a", 500),
+            item("game_b", 400),
+            item("game_c", 300),
+        ];
+        let (page, next) = page_public_game_distribution_catalog(entries.clone(), None, 2);
+        assert_eq!(page, vec!["game_a", "game_b"]);
+        assert_eq!(next.as_deref(), Some("400:game_b"));
+        let (rest, last) = page_public_game_distribution_catalog(
+            entries,
+            Some(parse_game_distribution_catalog_cursor(&next.unwrap()).unwrap()),
+            2,
+        );
+        assert_eq!(rest, vec!["game_c"]);
+        assert_eq!(last, None);
+    }
+
+    /// `forkable` 过滤的负载：`(game_id, 作品行里的原始授权档位字符串)`。
+    fn forkable_item(
+        game_id: &str,
+        created_at_micros: i64,
+        authorization: &str,
+    ) -> GameDistributionCatalogPageItem<(String, String)> {
+        GameDistributionCatalogPageItem {
+            game_id: game_id.to_string(),
+            created_at_micros,
+            payload: (game_id.to_string(), authorization.to_string()),
+        }
+    }
+
+    fn filter_forkable(
+        items: Vec<GameDistributionCatalogPageItem<(String, String)>>,
+        forkable: bool,
+    ) -> Vec<GameDistributionCatalogPageItem<(String, String)>> {
+        filter_public_game_distribution_catalog_by_forkable(items, forkable, |row| row.1.as_str())
+    }
+
+    fn game_ids(items: &[GameDistributionCatalogPageItem<(String, String)>]) -> Vec<String> {
+        items.iter().map(|item| item.payload.0.clone()).collect()
+    }
+
+    /// `forkable = false`（省略参数 / `0` / `false` / 非法取值在 api-server 侧都归一成假）
+    /// **就是本函数出现之前的既有行为**：一条不少、一条不多，连 `forbidden` 也照旧在列。
+    #[test]
+    fn forkable_filter_is_an_exact_no_op_when_unset() {
+        let items = vec![
+            forkable_item("game_a", 300, "forbidden"),
+            forkable_item("game_b", 200, "nonCommercial"),
+            forkable_item("game_c", 100, "full"),
+        ];
+        let kept = filter_forkable(items.clone(), false);
+        assert_eq!(
+            kept, items,
+            "不传 forkable 必须与改动前逐条相同（含 forbidden）"
+        );
+        assert_eq!(game_ids(&kept), vec!["game_a", "game_b", "game_c"]);
+    }
+
+    /// `forkable = true` 的集合**精确**等于「档位允许共创」的那些条目：`forbidden` 一条都不留，
+    /// 允许共创的档位一条都不少（不是「至少少了 forbidden」这种宽松断言）。
+    #[test]
+    fn forkable_filter_keeps_exactly_the_fork_enabled_rows() {
+        let items = vec![
+            forkable_item("game_forbidden", 500, "forbidden"),
+            forkable_item("game_non_commercial", 400, "nonCommercial"),
+            forkable_item("game_full", 300, "full"),
+            forkable_item("game_forbidden_oldest", 200, "forbidden"),
+        ];
+        let kept = filter_forkable(items, true);
+        assert_eq!(
+            game_ids(&kept),
+            vec!["game_non_commercial", "game_full"],
+            "过滤不排序：只收窄集合，顺序仍由 page_public_game_distribution_catalog 决定"
+        );
+        let kept_ids = kept
+            .iter()
+            .map(|item| item.payload.0.clone())
+            .collect::<std::collections::BTreeSet<_>>();
+        assert_eq!(
+            kept_ids,
+            ["game_non_commercial".to_string(), "game_full".to_string()]
+                .into_iter()
+                .collect::<std::collections::BTreeSet<_>>(),
+            "留下的集合必须与被允许共创的条目一一对应"
+        );
+    }
+
+    /// **未知档位失败关闭**：解析不出的档位按「禁止共创」解释，与 fork 门禁
+    /// （`FORK_NOT_AUTHORIZED`）同一判据——否则共创页会列出一个点进去必然 403 的作品。
+    #[test]
+    fn forkable_filter_fails_closed_on_unknown_authorization() {
+        for unknown in ["", " ", "allowed", "FULL", "non_commercial", "forbidden "] {
+            let items = vec![
+                forkable_item("game_known", 100, "full"),
+                forkable_item("game_unknown", 200, unknown),
+            ];
+            let kept = filter_forkable(items, true);
+            assert_eq!(
+                game_ids(&kept),
+                vec!["game_known"],
+                "未知档位必须按禁止处理：authorization={unknown:?}"
+            );
+        }
+        // 前后空白是 `ForkAuthorization::parse` 允许的写法，不算未知。
+        let kept = filter_forkable(vec![forkable_item("game_padded", 100, " full ")], true);
+        assert_eq!(game_ids(&kept), vec!["game_padded"]);
+    }
+
+    /// **先过滤、再切页**：`forbidden` 混在中间时不占页位，翻页不重不漏，末页游标为 `None`。
+    ///
+    /// 若顺序反过来（先切页再过滤），第一页会因 `forbidden` 占位而少回传，下一页的游标又指回
+    /// 过滤前的序列，于是每一页都漏掉自己的若干条。这里用 9 条（4 条 `forbidden` 夹在中间）
+    /// 逐页翻到底，断言总条数 = 5、顺序严格是「创建时间倒序」、且游标只指向真正回传的最后一条。
+    #[test]
+    fn forkable_filter_happens_before_paging_so_forbidden_rows_never_take_a_slot() {
+        let raw = vec![
+            forkable_item("game_00", 900, "forbidden"),
+            forkable_item("game_01", 800, "full"),
+            forkable_item("game_02", 700, "forbidden"),
+            forkable_item("game_03", 600, "nonCommercial"),
+            forkable_item("game_04", 500, "forbidden"),
+            forkable_item("game_05", 400, "full"),
+            forkable_item("game_06", 300, "forbidden"),
+            forkable_item("game_07", 200, "nonCommercial"),
+            forkable_item("game_08", 100, "full"),
+        ];
+        let visible = filter_forkable(raw, true);
+        assert_eq!(visible.len(), 5, "9 条里只有 5 条允许共创");
+
+        let mut seen: Vec<String> = Vec::new();
+        let mut nexts: Vec<Option<String>> = Vec::new();
+        let mut cursor = None;
+        loop {
+            let (page, next) = page_public_game_distribution_catalog(visible.clone(), cursor, 2);
+            let ids = page.iter().map(|row| row.0.clone()).collect::<Vec<_>>();
+            match next {
+                Some(_) => assert_eq!(ids.len(), 2, "过滤后仍有余量时必须填满 limit 条"),
+                None => assert_eq!(ids.len(), 1, "最后 1 条"),
+            }
+            seen.extend(ids);
+            nexts.push(next.clone());
+            match next {
+                Some(value) => {
+                    cursor = Some(parse_game_distribution_catalog_cursor(&value).unwrap())
+                }
+                None => break,
+            }
+        }
+        assert_eq!(nexts.len(), 3, "5 条按页大小 2 分页应为 3 页");
+        assert_eq!(
+            nexts,
+            vec![
+                Some("600:game_03".to_string()),
+                Some("200:game_07".to_string()),
+                None,
+            ],
+            "游标只指向这一页真正回传的最后一条，forbidden 不参与定位"
+        );
+        assert!(
+            nexts.last().expect("至少一页").is_none(),
+            "末页 nextCursor 必须是 null"
+        );
+        assert_eq!(
+            seen,
+            vec!["game_01", "game_03", "game_05", "game_07", "game_08"],
+            "翻页必须不重不漏"
+        );
+        let unique = seen.iter().collect::<std::collections::BTreeSet<_>>();
+        assert_eq!(unique.len(), seen.len(), "同一作品不得跨页重复");
+        for forbidden in ["game_00", "game_02", "game_04", "game_06"] {
+            assert!(
+                !seen.iter().any(|game_id| game_id == forbidden),
+                "禁止共创的作品不得出现在任何一页：{forbidden}"
+            );
+        }
+    }
+
+    /// `forkable` 不改变**可见性**口径：调用方先按可见性（已发布 / 未软删 / 有当前公开版本）
+    /// 过滤，再叠加 `forkable`，未公开 / 已软删 / 无公开版本的作品即使授权允许共创也不得出现。
+    #[test]
+    fn forkable_filter_does_not_resurrect_invisible_rows() {
+        let raw = vec![
+            // (game_id, created_at, 授权, 可见)
+            ("game_visible_full", 900, "full", true),
+            ("game_draft_full", 800, "full", false), // 未公开
+            ("game_deleted_full", 700, "full", false), // 已软删除
+            ("game_no_version_full", 600, "full", false), // 没有当前公开版本
+            ("game_visible_forbidden", 500, "forbidden", true),
+        ];
+        let visible = raw
+            .into_iter()
+            .filter(|(_, _, _, visible)| *visible)
+            .map(|(game_id, created_at_micros, authorization, _)| {
+                forkable_item(game_id, created_at_micros, authorization)
+            })
+            .collect::<Vec<_>>();
+        let kept = filter_forkable(visible, true);
+        assert_eq!(game_ids(&kept), vec!["game_visible_full"]);
+        for invisible in [
+            "game_draft_full",
+            "game_deleted_full",
+            "game_no_version_full",
+        ] {
+            assert!(
+                !game_ids(&kept).iter().any(|game_id| game_id == invisible),
+                "可见性口径不得被 forkable 放宽：{invisible}"
+            );
+        }
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/collection.rs b/server-rs/crates/module-game-distribution/src/collection.rs
new file mode 100644
index 000000000..84431ad77
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/collection.rs
@@ -0,0 +1,374 @@
+//! 收藏（收录）的纯函数规则。
+//!
+//! 表与事务在 `spacetime-module::game_distribution`；这里只放能被不起 SpacetimeDB 的单测钉住的
+//! 规则：确定性主键的构造、「收藏行是否出现在列表投影里」的可见性判定，以及
+//! 「我的收藏」列表的游标编解码与排序切页。
+
+/// 「我的收藏」一页的默认条数。
+///
+/// 取值 20 的理由：前端「我的收藏」是网格布局，一屏放得下 20 张卡片，首屏少一次往返。
+/// 与后台列表默认口径（`GAME_DISTRIBUTION_ADMIN_GAME_LIST_LIMIT` = 200）**不必相等**：
+/// 后台是运营用的表格视图、单行信息量小且需要批量扫读，用户态网格则按屏取数。
+pub const GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_DEFAULT: u32 = 20;
+
+/// 「我的收藏」单次响应回传的条数上限。
+///
+/// 取值 50 的理由：约束单个响应的体积（每条约等于一份公开游戏投影，含当前版本与评分摘要），
+/// 同时给「一屏 20 条」留出一次翻页拉满 2 页的余量。超界一律**截断**而不是报错——与后台列表
+/// 同一处理方式（客户端拿到的是一个完整页，而不是一个需要重试的错误）。
+pub const GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_MAX: u32 = 50;
+
+/// 收藏主键：`{user_id}:{game_id}`。
+///
+/// 与 `profile_save_archive.archive_id`（`spacetime-module` 的 `runtime/profile.rs`）同一写法：
+/// 平台签发的两个标识用冒号拼成确定性 ID。`user_id` 由平台签发（形如 `usr_*` / 微信侧标识），
+/// `game_id` 由本领域生成（`game-*`），两者都不含 `:`，因此组合是单射。
+///
+/// 用确定性主键而不是随机 ID，是为了让**去重由结构保证，而不是由流程保证**：同一
+/// (用户, 作品) 只可能有一行，这一点由主键约束本身成立。相对地，「事务里先查后写」只在
+/// 单写者假设下成立——将来分片或并发写同一对 (用户, 作品) 时，两个事务都可能先查到
+/// 「不存在」，然后各写一行。也正因为主键已经是那条约束，这张表**不需要**再建
+/// `(user_id, game_id)` 唯一索引。
+pub fn game_distribution_collection_id(user_id: &str, game_id: &str) -> String {
+    format!("{user_id}:{game_id}")
+}
+
+/// 收藏行是否应出现在「我的收藏（收录）」列表里。
+///
+/// 只看作品**当前**是否公开可读：未软删除、可见性为 `published`、且存在当前公开版本
+/// （`has_public_version` 由调用方按 `public_game_distribution_version` 命中给出）。
+///
+/// 判定只在**投影时**发生，收藏行本身不因此被删除：作品下架后该行只是不再出现在响应里，
+/// 作品重新公开后同一行会再次出现。把它做成纯函数，就能用「同一行、不同可见性」直接钉住
+/// 「已收藏 → 下架 → 列表不含 → 重新公开 → 列表又含」这条链路，不必起真库。
+pub fn game_distribution_collection_visible(
+    is_deleted: bool,
+    is_published: bool,
+    has_public_version: bool,
+) -> bool {
+    !is_deleted && is_published && has_public_version
+}
+
+/// 分页序列里的一条收藏：游标/排序所需的两个键 + 调用方自己的负载。
+///
+/// 泛型 `payload` 让「排序键」与「这一页要回传的东西」绑在同一个值上，纯函数切页时整条值一起移动，
+/// 因此不可能出现「按 A 排序、按 B 切页」的错位；模块侧把负载填成游戏行，测试里填成任意轻量值。
+#[derive(Clone, Debug, PartialEq)]
+pub struct GameDistributionCollectionPageItem<T> {
+    /// 收藏主键 `{user_id}:{game_id}`；同一用户范围内唯一，因此可作全序兜底键。
+    pub collection_id: String,
+    /// 收藏时间（Unix 微秒），主排序键。
+    pub created_at_micros: i64,
+    pub payload: T,
+}
+
+/// 收藏列表游标编码：`{created_at_micros}:{collection_id}`。
+///
+/// 与后台列表（`parse_admin_game_distribution_cursor`）同一套 `"{micros}:{id}"` 惯例。
+/// 注意 `collection_id` 本身由 `game_distribution_collection_id` 拼成、**含冒号**
+/// （`{user_id}:{game_id}`）：解析只切**第一个**冒号，`micros` 之后的整段（含更多冒号）都是
+/// collection_id，因此编解码仍然是双射（`encode` → `parse` 原样返回）。
+pub fn encode_game_distribution_collection_cursor(
+    created_at_micros: i64,
+    collection_id: &str,
+) -> String {
+    format!("{created_at_micros}:{collection_id}")
+}
+
+/// 收藏列表游标解析；格式非法时返回 `Err`（api-server 会把它透传成 400）。
+///
+/// 严格的错误文案是刻意的：它不得含「不存在」「已被删除」「状态」「不匹配」「幂等」等子串，
+/// 否则会被 api-server 的既有 `map_spacetime_error` 分支抢先映射成 404 / 409；「格式无效」
+/// 只会落到兜底的 400，这正是「客户端传了坏游标」的语义。
+pub fn parse_game_distribution_collection_cursor(value: &str) -> Result<(i64, String), String> {
+    let (micros, collection_id) = value
+        .split_once(':')
+        .ok_or_else(|| "收藏列表游标格式无效".to_string())?;
+    let micros = micros
+        .parse::<i64>()
+        .map_err(|_| "收藏列表游标格式无效".to_string())?;
+    if collection_id.is_empty() {
+        return Err("收藏列表游标格式无效".to_string());
+    }
+    Ok((micros, collection_id.to_string()))
+}
+
+/// 请求里的 `limit` → 实际页大小：`0` 取默认，超界截断到上限。
+///
+/// 抽成独立函数是为了让 api-server 记日志的「生效条数」与模块真正使用的页大小**同源**：
+/// 两处各自写一遍 `if == 0 ... min(...)` 迟早会漂移。
+pub fn game_distribution_collection_page_limit(limit: u32) -> usize {
+    let resolved = if limit == 0 {
+        GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_DEFAULT
+    } else {
+        limit.min(GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_MAX)
+    };
+    resolved as usize
+}
+
+/// 按「收藏时间倒序 + `collection_id` 升序兜底」排序、跳过游标之前的位置、取 `limit` 条，
+/// 并返回下一页游标（没有下一页时为 `None`）。
+///
+/// 为什么这个比较器是**全序**：`created_at` 相同的两条必须还能分出先后，否则同一页边界上
+/// 的项会在翻页时重复或漏掉。`collection_id` 是主键、在同一用户范围内唯一，因此
+/// `(created_at_micros, collection_id)` 唯一决定顺序 —— 相同 `created_at` 不会被吞掉。
+///
+/// 调用方必须**先**按可见性过滤、**再**把结果交给本函数：游标位置定义在已过滤的序列上。
+/// 反过来先把未过滤序列切页、再逐页过滤，会让被滤掉的行凭空占掉名额，并使下一页的游标指回
+/// 过滤前的序列——每翻一页都漏掉自己的若干条收藏。
+pub fn game_distribution_collection_page<T>(
+    mut items: Vec<GameDistributionCollectionPageItem<T>>,
+    cursor: Option<(i64, String)>,
+    limit: u32,
+) -> (Vec<T>, Option<String>) {
+    let limit = game_distribution_collection_page_limit(limit);
+    items.sort_by(|left, right| {
+        right
+            .created_at_micros
+            .cmp(&left.created_at_micros)
+            .then_with(|| left.collection_id.cmp(&right.collection_id))
+    });
+    if let Some((cursor_micros, cursor_id)) = cursor.as_ref() {
+        // 严格「在游标之后」：时间更早，或时间相同且 collection_id 更大（升序方向）。
+        items.retain(|item| {
+            item.created_at_micros < *cursor_micros
+                || (item.created_at_micros == *cursor_micros
+                    && item.collection_id.as_str() > cursor_id.as_str())
+        });
+    }
+    // 多取一条判断是否还有下一页；游标只指向这一页真正回传的最后一条。
+    let has_more = items.len() > limit;
+    items.truncate(limit);
+    let next_cursor = if has_more {
+        items.last().map(|item| {
+            encode_game_distribution_collection_cursor(
+                item.created_at_micros,
+                item.collection_id.as_str(),
+            )
+        })
+    } else {
+        None
+    };
+    (
+        items.into_iter().map(|item| item.payload).collect(),
+        next_cursor,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn collection_id_is_deterministic_and_pair_specific() {
+        assert_eq!(
+            game_distribution_collection_id("usr_1", "game_a"),
+            "usr_1:game_a"
+        );
+        // 同一对组合永远得到同一个键（幂等重放与「重复收藏只留一行」都依赖这一点）。
+        assert_eq!(
+            game_distribution_collection_id("usr_1", "game_a"),
+            game_distribution_collection_id("usr_1", "game_a")
+        );
+        // 主键派生必须对「用户」「作品」两个维度都敏感：漏掉任一维度，不同用户 / 不同作品的
+        // 收藏就会共用同一行而互相覆盖（这是结构防重的前提，与幂等收据的键无关）。
+        assert_ne!(
+            game_distribution_collection_id("usr_1", "game_a"),
+            game_distribution_collection_id("usr_2", "game_a")
+        );
+        assert_ne!(
+            game_distribution_collection_id("usr_1", "game_a"),
+            game_distribution_collection_id("usr_1", "game_b")
+        );
+    }
+
+    /// 「已收藏 → 作品下架 → 列表不含 → 重新公开 → 列表又含」。
+    ///
+    /// 收藏行在整条链路里都存在；变化的只是投影判定，因此同一行在两次判定间翻转，
+    /// 不需要删除再重建行。
+    #[test]
+    fn collection_row_survives_unpublish_and_returns_after_republish() {
+        // 已收藏且作品公开可读：出现在列表里。
+        assert!(game_distribution_collection_visible(false, true, true));
+        // 作者下架：行还在，但投影时被过滤。
+        assert!(!game_distribution_collection_visible(false, false, true));
+        // 管理员暂停 / 幽灵可见性同样不算公开可读。
+        assert!(!game_distribution_collection_visible(false, false, true));
+        // 软删除：作品不再公开可读。
+        assert!(!game_distribution_collection_visible(true, true, true));
+        // 可见性仍是 published 但没有当前公开版本（例如版本被撤回）也按不可读处理。
+        assert!(!game_distribution_collection_visible(false, true, false));
+        // 重新公开：同一行再次可见。
+        assert!(game_distribution_collection_visible(false, true, true));
+    }
+
+    fn item(
+        collection_id: &str,
+        created_at_micros: i64,
+    ) -> GameDistributionCollectionPageItem<String> {
+        GameDistributionCollectionPageItem {
+            collection_id: collection_id.to_string(),
+            created_at_micros,
+            payload: collection_id.to_string(),
+        }
+    }
+
+    /// 不足一页：全部回传，且**没有**下一页游标（不能给一个指向空页的游标，否则客户端会多翻一次死页）。
+    #[test]
+    fn page_returns_everything_without_cursor_when_under_limit() {
+        let (page, next) = game_distribution_collection_page(
+            vec![item("usr_1:game_a", 300), item("usr_1:game_b", 200)],
+            None,
+            20,
+        );
+        assert_eq!(page, vec!["usr_1:game_a", "usr_1:game_b"]);
+        assert_eq!(next, None);
+    }
+
+    /// 恰好一页：`has_more` 依赖「多取一条」，因此 `len == limit` 时不能再给游标。
+    #[test]
+    fn page_at_exact_limit_has_no_cursor() {
+        let (page, next) = game_distribution_collection_page(
+            vec![item("usr_1:game_a", 300), item("usr_1:game_b", 200)],
+            None,
+            2,
+        );
+        assert_eq!(page.len(), 2);
+        assert_eq!(next, None);
+    }
+
+    /// 连续翻页直到消耗完：每页**不重复**上一页的项，也**不跳过**任何项；最后一页游标为 `None`。
+    #[test]
+    fn paging_walks_the_whole_sequence_without_gaps_or_duplicates() {
+        let entries = vec![
+            item("usr_1:game_a", 500),
+            item("usr_1:game_b", 400),
+            item("usr_1:game_c", 300),
+            item("usr_1:game_d", 200),
+            item("usr_1:game_e", 100),
+        ];
+        let mut seen: Vec<String> = Vec::new();
+        let mut cursor = None;
+        let mut pages = 0;
+        loop {
+            let (page, next) = game_distribution_collection_page(entries.clone(), cursor, 2);
+            assert!(!page.is_empty(), "非末页不得为空");
+            if next.is_some() {
+                assert_eq!(page.len(), 2, "还有下一页时必须填满 limit 条");
+            }
+            seen.extend(page);
+            pages += 1;
+            match next {
+                Some(value) => {
+                    cursor = Some(parse_game_distribution_collection_cursor(&value).unwrap())
+                }
+                None => break,
+            }
+        }
+        assert_eq!(pages, 3);
+        assert_eq!(
+            seen,
+            vec![
+                "usr_1:game_a",
+                "usr_1:game_b",
+                "usr_1:game_c",
+                "usr_1:game_d",
+                "usr_1:game_e",
+            ],
+            "翻页顺序必须严格是「收藏时间倒序」且不重不漏"
+        );
+    }
+
+    /// 同一 `created_at` 多条：`collection_id` 升序兜底保证全序，翻页边界不重不漏。
+    ///
+    /// 这是唯一能钉住「排序是全序」的场景：若比较器在 `created_at` 相同时不稳定，三条同刻收藏
+    /// 里的某一条就会被下一页重复返回或被整段跳过。
+    #[test]
+    fn page_tiebreaks_equal_created_at_by_collection_id_ascending() {
+        let entries = vec![
+            item("usr_1:game_c", 100),
+            item("usr_1:game_a", 100),
+            item("usr_1:game_d", 99),
+            item("usr_1:game_b", 100),
+        ];
+        let (first, next) = game_distribution_collection_page(entries.clone(), None, 2);
+        assert_eq!(first, vec!["usr_1:game_a", "usr_1:game_b"]);
+        let cursor = next.expect("还有同刻与更早的项");
+        assert_eq!(cursor, "100:usr_1:game_b");
+        let (second, last) = game_distribution_collection_page(
+            entries,
+            Some(parse_game_distribution_collection_cursor(&cursor).unwrap()),
+            2,
+        );
+        assert_eq!(second, vec!["usr_1:game_c", "usr_1:game_d"]);
+        assert_eq!(last, None, "第二页就是最后一页");
+    }
+
+    /// `limit` 语义：`0` 取默认 20（不是「返回 0 条」），超界截断到 50（不是报错）。
+    #[test]
+    fn page_limit_defaults_zero_and_truncates_overflow() {
+        assert_eq!(game_distribution_collection_page_limit(0), 20);
+        assert_eq!(game_distribution_collection_page_limit(1), 1);
+        assert_eq!(game_distribution_collection_page_limit(50), 50);
+        assert_eq!(
+            game_distribution_collection_page_limit(51),
+            50,
+            "超界截断而不是报错"
+        );
+        assert_eq!(game_distribution_collection_page_limit(u32::MAX), 50);
+
+        let oversized = (0..25)
+            .map(|index| item(&format!("usr_1:game_{index:02}"), 1_000 - index))
+            .collect::<Vec<_>>();
+        let (page, next) = game_distribution_collection_page(oversized, None, 0);
+        assert_eq!(page.len(), 20, "limit=0 必须取默认 20 条");
+        assert!(next.is_some(), "25 条 > 20 条，必须有下一页游标");
+    }
+
+    /// 游标编解码：`collection_id` 自带冒号也只切第一个，因此是双射；格式非法一律 `Err`。
+    #[test]
+    fn cursor_round_trips_and_rejects_malformed_values() {
+        let cursor =
+            encode_game_distribution_collection_cursor(1_700_000_000_000_000, "usr_1:game_a");
+        assert_eq!(cursor, "1700000000000000:usr_1:game_a");
+        assert_eq!(
+            parse_game_distribution_collection_cursor(&cursor).unwrap(),
+            (1_700_000_000_000_000, "usr_1:game_a".to_string())
+        );
+        // 负数微秒（仅编码假设，仍必须可逆）。
+        assert_eq!(
+            parse_game_distribution_collection_cursor("-5:usr_1:game_a").unwrap(),
+            (-5, "usr_1:game_a".to_string())
+        );
+
+        for malformed in [
+            "",
+            "abc",
+            "1700000000000000",
+            "1700000000000000:",
+            ":usr_1:game_a",
+            "not-a-number:usr_1:game_a",
+        ] {
+            assert!(
+                parse_game_distribution_collection_cursor(malformed).is_err(),
+                "非法游标必须报错：{malformed}"
+            );
+        }
+        // 文案不得命中 api-server 的 404 / 409 子串分支，只能落到兜底 400。
+        let message = parse_game_distribution_collection_cursor("bad").unwrap_err();
+        for forbidden in [
+            "不存在",
+            "已被删除",
+            "状态",
+            "不匹配",
+            "幂等",
+            "已存在",
+            "FORK_",
+        ] {
+            assert!(
+                !message.contains(forbidden),
+                "游标错误文案不得含「{forbidden}」：{message}"
+            );
+        }
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/contribution.rs b/server-rs/crates/module-game-distribution/src/contribution.rs
new file mode 100644
index 000000000..55344468e
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/contribution.rs
@@ -0,0 +1,698 @@
+//! 贡献归集（rollup）与归因（attribution）的纯计算规则。
+//!
+//! 产品口径原话是「子代所有的都算父代的」，并要能回答「能溯源多少是子代给的、多少是自己的」。
+//! 递归定义（本文件是唯一实现，调用方只负责把行折叠成 [`ContributionNode`]）：
+//!
+//! ```text
+//! inherited(W) = Σ_{c ∈ 直接子代(W)} total(c)
+//! total(W)     = own(W) + inherited(W)
+//! ```
+//!
+//! 三条不可越过的口径：
+//! - **每个后代在它的每个祖先里只计一次**：同一棵子树上不存在重复计数（重复行按 `game_id`
+//!   去重），也不漏（只走「父在集合里」的边，见下条）。
+//! - **缺失 / 悬空行安全跳过**：父不在集合里的行（历史遗留、脏数据、自环）既不是根的后代，
+//!   也就不会被计进任何数字——不 panic，也不发「只有 ID 的半残节点」。
+//! - **截断如实标注且已计入部分仍自洽**：受节点上限与深度上限约束时返回
+//!   `truncated = true` 与 `truncated_reason`，且三条不变量在**截断后的子树**上依然成立
+//!   （见 [`ContributionBreakdown`]）。不静默给半个数。
+//!
+//! 指标集合刻意做成结构体 [`ContributionTotals`]（当前只有 `play_count`）：将来加点赞 / 收藏 /
+//! 收入只需加字段并在那一个合并函数里加一行，递归与归因的形状不用动。
+//!
+//! **本期只做计算**：本模块不含任何资金 / 分成 / 结算语义，输出里也没有它们的位置。
+
+use std::{
+    collections::{BTreeMap, HashMap, HashSet, VecDeque},
+    ops::{Add, AddAssign},
+};
+
+/// 单次归集最多计入多少个**后代**节点（根不计入）；超出时如实标注 `node_limit`。
+///
+/// 上限只拦「数量」：遍历按相对深度逐层推进、同层按 `gameId` 升序，因此被截掉的总是同一批
+/// 后缀节点，两次读之间不会漂移。
+pub const GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT: usize = 500;
+
+/// 相对深度上限（根为 0）：比这更深的节点不再计入并标注 `depth_limit`。
+///
+/// 血缘表的主键约束保证一个作品只有一个父，但整数「代际」字段本身不能阻止一条被脏数据写坏的
+/// 超长链；深度上限是遍历的硬边界，避免一次读取退化成无界递归。
+pub const GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT: u32 = 32;
+
+/// 截断原因：`truncated == false` 时为 `None`，不返回空串占位。
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ContributionTruncationReason {
+    /// 后代节点数达到 [`GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT`]。
+    NodeLimit,
+    /// 有节点的相对深度超过 [`GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT`]。
+    DepthLimit,
+}
+
+impl ContributionTruncationReason {
+    /// 对外字符串；与族谱接口 `truncated` 的既有约定一致（客户端按它分支提示）。
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::NodeLimit => "node_limit",
+            Self::DepthLimit => "depth_limit",
+        }
+    }
+}
+
+/// 可扩展的指标集合。
+///
+/// 当前只有 `play_count`；**将来加指标只需加字段**并在 [`ContributionTotals::merge`] 里加一行，
+/// 递归定义、归因分解与上限 / 截断语义都不需要改。
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ContributionTotals {
+    pub play_count: u64,
+}
+
+impl ContributionTotals {
+    /// 由作品行的游玩数构造。
+    pub fn from_play_count(play_count: u64) -> Self {
+        Self { play_count }
+    }
+
+    /// 唯一的合并方式：饱和相加，避免极端数据下溢出 panic（debug 构建下 `+` 会 panic）。
+    fn merge(&mut self, other: &Self) {
+        self.play_count = self.play_count.saturating_add(other.play_count);
+    }
+}
+
+impl AddAssign for ContributionTotals {
+    fn add_assign(&mut self, other: Self) {
+        self.merge(&other);
+    }
+}
+
+impl Add for ContributionTotals {
+    type Output = Self;
+
+    fn add(mut self, other: Self) -> Self {
+        self.merge(&other);
+        self
+    }
+}
+
+/// 归集输入：调用方把游戏行（指标 + 代际）与血缘行（父引用）折叠成这些事实。
+///
+/// `generation` 是**绝对代际**（与族谱一致，直接改编母版为 1），根自身用 0 占位即可——
+/// 根不参与任何按代际分解。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ContributionNode {
+    pub game_id: String,
+    pub parent_game_id: Option<String>,
+    pub generation: u32,
+    pub totals: ContributionTotals,
+}
+
+/// 按代际分解的一条：`byGeneration` **只含后代**（不含根自身），`generation` 是绝对代际。
+///
+/// 语义（与 [`ContributionBreakdown`] 的不变量绑定）：本条目是根节点 `inherited` 里
+/// **由这一代自己产生**的那一份，因此 `total` 即该代贡献、`inherited` 恒为 `0`——
+/// 该代从更深代际继承到的量已计入更深代际的那一条，再计一次会让分解之和大于根的 `inherited`
+/// （同一个后代会在多层分解里被重复计入，正是本功能要避免的事）。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ContributionGenerationBreakdown {
+    pub generation: u32,
+    /// 这一代计入分解的后代节点数。
+    pub game_count: u64,
+    pub own: ContributionTotals,
+    pub inherited: ContributionTotals,
+    pub total: ContributionTotals,
+}
+
+/// 直接子代明细的一条：`total` 是该直接子代**含它自己整棵子树**的值。
+///
+/// 这是「子代所有的都算父代的」最直白的证据面：`Σ directChildren.total == inherited(根)`。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ContributionChildBreakdown {
+    pub game_id: String,
+    pub generation: u32,
+    pub own: ContributionTotals,
+    pub inherited: ContributionTotals,
+    pub total: ContributionTotals,
+}
+
+/// 单个作品的归集与归因结果。
+///
+/// 不变量（截断后依然成立，单测逐条钉住）：
+/// - `inherited == Σ by_generation.total == Σ direct_children.total`；
+/// - `inherited == Σ over 参与计算的后代 own`（递归定义的等价形式）；
+/// - `total == own + inherited`；
+/// - `node_count == Σ by_generation.game_count`（= 参与计算的**后代**节点数，不含根）。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ContributionBreakdown {
+    pub game_id: String,
+    pub own: ContributionTotals,
+    pub inherited: ContributionTotals,
+    pub total: ContributionTotals,
+    /// 只含后代、按代际升序。
+    pub by_generation: Vec<ContributionGenerationBreakdown>,
+    /// 直接子代的整棵子树值，按 `gameId` 升序。
+    pub direct_children: Vec<ContributionChildBreakdown>,
+    /// 参与计算的后代节点数（不含根）。
+    pub node_count: u64,
+    pub truncated: bool,
+    pub truncated_reason: Option<ContributionTruncationReason>,
+}
+
+/// 计算以 `root_game_id` 为根的贡献归集与归因。
+///
+/// - `nodes`：子树候选节点集合（含根自身；多收的后代由本函数按上限截断）；
+/// - `node_limit`：后代节点上限；`0` 视为「不要任何后代」，不回退到默认值；
+/// - `depth_limit`：相对深度上限（根为 0）。
+///
+/// 根不在集合里时返回 `None`（调用方映射 404）；这里**不做**任何可见性过滤——入参没有可见性
+/// 字段，作者视角的归集口径就是「血缘上属于我的子树」，过滤规则要变必须显式加字段。
+pub fn build_contribution_breakdown(
+    nodes: &[ContributionNode],
+    root_game_id: &str,
+    node_limit: usize,
+    depth_limit: u32,
+) -> Option<ContributionBreakdown> {
+    // 重复行（同一 `game_id` 出现多次）只认第一次出现，后续行既不算节点也不算父边。
+    let mut canonical_index: HashMap<&str, usize> = HashMap::new();
+    for (index, node) in nodes.iter().enumerate() {
+        canonical_index
+            .entry(node.game_id.as_str())
+            .or_insert(index);
+    }
+    let is_canonical =
+        |index: usize| canonical_index.get(nodes[index].game_id.as_str()) == Some(&index);
+    let root_index = *canonical_index.get(root_game_id)?;
+
+    // 只保留「父仍在集合里」的边：悬空行（父被删 / 脏数据）、自环、根自身都不进子表，
+    // 因此它们永远不会被遍历到，也就不会被计进任何数字。
+    let mut children: HashMap<usize, Vec<usize>> = HashMap::new();
+    for (index, node) in nodes.iter().enumerate() {
+        if index == root_index || !is_canonical(index) {
+            continue;
+        }
+        let Some(parent_game_id) = node.parent_game_id.as_deref() else {
+            continue;
+        };
+        if parent_game_id == node.game_id.as_str() {
+            continue;
+        }
+        let Some(&parent_index) = canonical_index.get(parent_game_id) else {
+            continue;
+        };
+        children.entry(parent_index).or_default().push(index);
+    }
+    // 同层按 `gameId` 升序：截断点因此确定，两次读之间不会换一批节点。
+    for child_indexes in children.values_mut() {
+        child_indexes.sort_by(|left, right| nodes[*left].game_id.cmp(&nodes[*right].game_id));
+    }
+
+    let mut visited: HashSet<usize> = HashSet::new();
+    let mut order: Vec<usize> = vec![root_index];
+    visited.insert(root_index);
+    let mut queue: VecDeque<(usize, u32)> = VecDeque::new();
+    queue.push_back((root_index, 0));
+    let mut descendants: usize = 0;
+    let mut node_limited = false;
+    let mut depth_limited = false;
+    while let Some((index, depth)) = queue.pop_front() {
+        let Some(child_indexes) = children.get(&index) else {
+            continue;
+        };
+        for &child in child_indexes {
+            if visited.contains(&child) {
+                continue;
+            }
+            // 节点上限优先于深度上限：两种上限同时拦住同一批节点时，报资源上限更有指导性
+            // （调用方该去分页 / 收敛范围，而不是去怀疑血缘有 32 层）。
+            if descendants >= node_limit {
+                node_limited = true;
+                continue;
+            }
+            let child_depth = depth + 1;
+            if child_depth > depth_limit {
+                depth_limited = true;
+                continue;
+            }
+            visited.insert(child);
+            order.push(child);
+            descendants += 1;
+            queue.push_back((child, child_depth));
+        }
+    }
+
+    // 自底向上（逆 BFS 序保证后代先算）折叠；只累加**参与计算**的边，
+    // 因此截断后的数字与 `node_count` 是同一份子树的自洽结果。
+    let mut totals: Vec<ContributionTotals> = nodes.iter().map(|node| node.totals).collect();
+    let mut inherited: Vec<ContributionTotals> = vec![ContributionTotals::default(); nodes.len()];
+    for &index in order.iter().rev() {
+        let mut sum = ContributionTotals::default();
+        if let Some(child_indexes) = children.get(&index) {
+            for &child in child_indexes {
+                if visited.contains(&child) {
+                    sum += totals[child];
+                }
+            }
+        }
+        inherited[index] = sum;
+        totals[index] = nodes[index].totals + sum;
+    }
+
+    let mut generations: BTreeMap<u32, (u64, ContributionTotals)> = BTreeMap::new();
+    for &index in order.iter().skip(1) {
+        let entry = generations.entry(nodes[index].generation).or_default();
+        entry.0 += 1;
+        entry.1 += nodes[index].totals;
+    }
+    let by_generation = generations
+        .into_iter()
+        .map(
+            |(generation, (game_count, own))| ContributionGenerationBreakdown {
+                generation,
+                game_count,
+                own,
+                // 见 [`ContributionGenerationBreakdown`] 的说明：分解只计本代自身，
+                // 更深代际的量归它们自己那一条，避免重复计数。
+                inherited: ContributionTotals::default(),
+                total: own,
+            },
+        )
+        .collect();
+
+    let direct_children = children
+        .get(&root_index)
+        .map(|child_indexes| {
+            child_indexes
+                .iter()
+                .filter(|child| visited.contains(child))
+                .map(|&index| ContributionChildBreakdown {
+                    game_id: nodes[index].game_id.clone(),
+                    generation: nodes[index].generation,
+                    own: nodes[index].totals,
+                    inherited: inherited[index],
+                    total: totals[index],
+                })
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+
+    let truncated_reason = if node_limited {
+        Some(ContributionTruncationReason::NodeLimit)
+    } else if depth_limited {
+        Some(ContributionTruncationReason::DepthLimit)
+    } else {
+        None
+    };
+
+    Some(ContributionBreakdown {
+        game_id: root_game_id.to_string(),
+        own: nodes[root_index].totals,
+        inherited: inherited[root_index],
+        total: totals[root_index],
+        by_generation,
+        direct_children,
+        node_count: descendants as u64,
+        truncated: truncated_reason.is_some(),
+        truncated_reason,
+    })
+}
+
+#[cfg(test)]
+mod contribution_tests {
+    use super::*;
+
+    fn node(
+        game_id: &str,
+        parent_game_id: Option<&str>,
+        generation: u32,
+        play_count: u64,
+    ) -> ContributionNode {
+        ContributionNode {
+            game_id: game_id.to_string(),
+            parent_game_id: parent_game_id.map(str::to_string),
+            generation,
+            totals: ContributionTotals::from_play_count(play_count),
+        }
+    }
+
+    fn build(nodes: &[ContributionNode], root: &str) -> ContributionBreakdown {
+        build_contribution_breakdown(
+            nodes,
+            root,
+            GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT,
+            GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT,
+        )
+        .expect("根必须在节点集合里")
+    }
+
+    fn breakdown_play_counts(breakdown: &ContributionBreakdown) -> (u64, u64, u64) {
+        (
+            breakdown.own.play_count,
+            breakdown.inherited.play_count,
+            breakdown.total.play_count,
+        )
+    }
+
+    fn by_generation_total(breakdown: &ContributionBreakdown) -> u64 {
+        breakdown
+            .by_generation
+            .iter()
+            .map(|entry| entry.total.play_count)
+            .sum()
+    }
+
+    fn direct_children_total(breakdown: &ContributionBreakdown) -> u64 {
+        breakdown
+            .direct_children
+            .iter()
+            .map(|entry| entry.total.play_count)
+            .sum()
+    }
+
+    fn generation_game_count(breakdown: &ContributionBreakdown) -> u64 {
+        breakdown
+            .by_generation
+            .iter()
+            .map(|entry| entry.game_count)
+            .sum()
+    }
+
+    /// 技术方案里的三层链路 A → B → C 必须逐条对上，且三条不变量同时成立。
+    #[test]
+    fn three_generation_chain_matches_the_documented_invariants() {
+        let nodes = [
+            node("A", None, 0, 100),
+            node("B", Some("A"), 1, 30),
+            node("C", Some("B"), 2, 7),
+        ];
+        let breakdown = build(&nodes, "A");
+
+        assert_eq!(breakdown_play_counts(&breakdown), (100, 37, 137));
+        // A.inherited = B.own + C.own；B.inherited = C.own；C.inherited = 0。
+        assert_eq!(breakdown.inherited.play_count, 30 + 7);
+        assert_eq!(generation_game_count(&breakdown), 2);
+        assert_eq!(breakdown.node_count, 2);
+        assert!(!breakdown.truncated);
+        assert_eq!(breakdown.truncated_reason, None);
+
+        assert_eq!(
+            by_generation_total(&breakdown),
+            breakdown.inherited.play_count
+        );
+        assert_eq!(
+            direct_children_total(&breakdown),
+            breakdown.inherited.play_count
+        );
+        assert_eq!(direct_children_total(&breakdown), 37);
+        assert_eq!(breakdown.direct_children.len(), 1);
+        assert_eq!(breakdown.direct_children[0].game_id, "B");
+        assert_eq!(breakdown.direct_children[0].own.play_count, 30);
+        assert_eq!(breakdown.direct_children[0].inherited.play_count, 7);
+        assert_eq!(breakdown.direct_children[0].total.play_count, 37);
+    }
+
+    /// C 自身的归集：无子代 → `inherited = 0`，`total == own`。
+    #[test]
+    fn leaf_has_empty_inheritance() {
+        let nodes = [
+            node("A", None, 0, 100),
+            node("B", Some("A"), 1, 30),
+            node("C", Some("B"), 2, 7),
+        ];
+        let breakdown = build(&nodes, "C");
+        assert_eq!(breakdown_play_counts(&breakdown), (7, 0, 7));
+        assert_eq!(breakdown.node_count, 0);
+        assert!(breakdown.by_generation.is_empty());
+        assert!(breakdown.direct_children.is_empty());
+    }
+
+    /// 多分支：根带 3 个直接子代、其中一个再带孙代（每个后代只计一次）。
+    #[test]
+    fn multi_branch_tree_rolls_up_once_per_descendant() {
+        let nodes = [
+            node("root", None, 0, 10),
+            node("c1", Some("root"), 1, 1),
+            node("c2", Some("root"), 1, 2),
+            node("c3", Some("root"), 1, 3),
+            node("g1", Some("c2"), 2, 4),
+        ];
+        let breakdown = build(&nodes, "root");
+
+        assert_eq!(breakdown_play_counts(&breakdown), (10, 10, 20));
+        assert_eq!(breakdown.node_count, 4);
+        assert_eq!(generation_game_count(&breakdown), 4);
+        // 直接子代明细按 gameId 升序，且每项是「含整棵子树」的值。
+        assert_eq!(
+            breakdown
+                .direct_children
+                .iter()
+                .map(|entry| (entry.game_id.as_str(), entry.total.play_count))
+                .collect::<Vec<_>>(),
+            vec![("c1", 1), ("c2", 6), ("c3", 3)]
+        );
+        assert_eq!(direct_children_total(&breakdown), 10);
+        // 按代际分解：只含后代、绝对代际升序，逐条是「这一代自己产生的量」。
+        assert_eq!(
+            breakdown
+                .by_generation
+                .iter()
+                .map(|entry| (
+                    entry.generation,
+                    entry.game_count,
+                    entry.own.play_count,
+                    entry.inherited.play_count,
+                    entry.total.play_count
+                ))
+                .collect::<Vec<_>>(),
+            vec![(1, 3, 6, 0, 6), (2, 1, 4, 0, 4)]
+        );
+        assert_eq!(by_generation_total(&breakdown), 10);
+    }
+
+    /// 无子代：三个数字为 0 / 0 / own，分解为空数组（不是缺键、也不是占位行）。
+    #[test]
+    fn childless_root_has_empty_attribution() {
+        let breakdown = build(&[node("solo", None, 0, 42)], "solo");
+        assert_eq!(breakdown_play_counts(&breakdown), (42, 0, 42));
+        assert_eq!(breakdown.node_count, 0);
+        assert!(breakdown.by_generation.is_empty());
+        assert!(breakdown.direct_children.is_empty());
+        assert!(!breakdown.truncated);
+    }
+
+    /// 缺失 / 悬空行被安全跳过：父不在集合里、无父、自环、重复行都不参与任何数字。
+    #[test]
+    fn dangling_missing_and_duplicate_rows_are_skipped_safely() {
+        let nodes = [
+            node("root", None, 0, 5),
+            node("child", Some("root"), 1, 2),
+            // 父不在集合里（历史遗留脏数据）→ 不是 root 的后代。
+            node("orphan", Some("ghost"), 1, 99),
+            // 没有父但不是根 → 同样不可达。
+            node("floating", None, 1, 50),
+            // 自环 → 按悬空行处理，不得进入遍历。
+            node("selfloop", Some("selfloop"), 1, 77),
+            // 重复行（同 gameId）→ 只认第一次出现，不重复计数。
+            node("child", Some("root"), 1, 2),
+            // 连到被跳过节点上的孙子：其父虽在集合里，但从根不可达，也不得计入。
+            node("grandchild", Some("orphan"), 2, 11),
+        ];
+        let breakdown = build(&nodes, "root");
+
+        assert_eq!(breakdown_play_counts(&breakdown), (5, 2, 7));
+        assert_eq!(breakdown.node_count, 1);
+        assert_eq!(generation_game_count(&breakdown), 1);
+        assert_eq!(direct_children_total(&breakdown), 2);
+        assert_eq!(by_generation_total(&breakdown), 2);
+    }
+
+    /// 根不在节点集合里：返回 `None`（调用方映射 404），不返回空壳结果。
+    #[test]
+    fn missing_root_returns_none() {
+        assert!(
+            build_contribution_breakdown(
+                &[node("other", None, 0, 1)],
+                "root",
+                GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT,
+                GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT,
+            )
+            .is_none()
+        );
+    }
+
+    /// 代际取节点自带的**绝对**代际（与族谱一致），不是相对深度。
+    #[test]
+    fn generation_breakdown_uses_absolute_generations() {
+        let nodes = [
+            node("mid", None, 4, 1),
+            node("child", Some("mid"), 5, 2),
+            node("grandchild", Some("child"), 6, 3),
+        ];
+        let breakdown = build(&nodes, "mid");
+        assert_eq!(
+            breakdown
+                .by_generation
+                .iter()
+                .map(|entry| entry.generation)
+                .collect::<Vec<_>>(),
+            vec![5, 6]
+        );
+        assert_eq!(
+            breakdown
+                .direct_children
+                .iter()
+                .map(|entry| entry.generation)
+                .collect::<Vec<_>>(),
+            vec![5]
+        );
+    }
+
+    /// 节点上限：如实标注 `node_limit`，且三条不变量在截断后的子树上仍然成立。
+    #[test]
+    fn node_limit_truncates_and_keeps_invariants() {
+        let mut nodes = vec![node("root", None, 0, 1)];
+        for index in 0..10 {
+            nodes.push(node(
+                &format!("child-{index:02}"),
+                Some("root"),
+                1,
+                (index + 1) as u64,
+            ));
+        }
+        let breakdown = build_contribution_breakdown(&nodes, "root", 3, 32).expect("根必须存在");
+
+        assert!(breakdown.truncated);
+        assert_eq!(
+            breakdown.truncated_reason,
+            Some(ContributionTruncationReason::NodeLimit)
+        );
+        assert_eq!(breakdown.node_count, 3);
+        assert_eq!(generation_game_count(&breakdown), 3);
+        assert_eq!(breakdown.direct_children.len(), 3);
+        // 截掉的是排序后缀（child-00 / 01 / 02 留下），截断点确定。
+        assert_eq!(
+            breakdown
+                .direct_children
+                .iter()
+                .map(|entry| entry.game_id.as_str())
+                .collect::<Vec<_>>(),
+            vec!["child-00", "child-01", "child-02"]
+        );
+        assert_eq!(breakdown_play_counts(&breakdown), (1, 6, 7));
+        assert_eq!(
+            by_generation_total(&breakdown),
+            breakdown.inherited.play_count
+        );
+        assert_eq!(
+            direct_children_total(&breakdown),
+            breakdown.inherited.play_count
+        );
+    }
+
+    /// 深度上限：它自己就是截断原因；节点上限优先于深度上限。
+    #[test]
+    fn depth_limit_truncates_and_yields_to_node_limit() {
+        let mut nodes = vec![node("g0", None, 0, 1)];
+        for generation in 1..=5u32 {
+            nodes.push(node(
+                &format!("g{generation}"),
+                Some(&format!("g{}", generation - 1)),
+                generation,
+                generation as u64,
+            ));
+        }
+
+        let truncated = build_contribution_breakdown(&nodes, "g0", 500, 2).expect("根必须存在");
+        assert!(truncated.truncated);
+        assert_eq!(
+            truncated.truncated_reason,
+            Some(ContributionTruncationReason::DepthLimit)
+        );
+        assert_eq!(truncated.node_count, 2);
+        assert_eq!(
+            by_generation_total(&truncated),
+            truncated.inherited.play_count
+        );
+        assert_eq!(
+            direct_children_total(&truncated),
+            truncated.inherited.play_count
+        );
+
+        // 两种上限同时拦住时按节点上限报（资源上限更有指导性）。
+        let both = build_contribution_breakdown(&nodes, "g0", 1, 2).expect("根必须存在");
+        assert_eq!(
+            both.truncated_reason,
+            Some(ContributionTruncationReason::NodeLimit)
+        );
+        assert_eq!(both.node_count, 1);
+
+        // 不截断时原样返回 `None`，不发空串。
+        let full = build_contribution_breakdown(&nodes, "g0", 500, 32).expect("根必须存在");
+        assert!(!full.truncated);
+        assert_eq!(full.truncated_reason, None);
+        assert_eq!(full.node_count, 5);
+    }
+
+    /// 上限常量为**合同值**：技术方案 §3.11 与里程碑验收都引用 500 / 32，改动需同步契约与文档。
+    #[test]
+    fn contribution_limit_constants_are_pinned() {
+        assert_eq!(GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT, 500);
+        assert_eq!(GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT, 32);
+        assert_eq!(
+            ContributionTruncationReason::NodeLimit.as_str(),
+            "node_limit"
+        );
+        assert_eq!(
+            ContributionTruncationReason::DepthLimit.as_str(),
+            "depth_limit"
+        );
+    }
+
+    /// 递归定义的等价形式：`inherited == Σ over 参与计算的后代 own`。
+    ///
+    /// 这条恒等式是「按代际分解之和 == inherited」与「直接子代明细之和 == inherited」的公共原因，
+    /// 钉住它就能同时解释两个分解面为什么自洽。
+    #[test]
+    fn inherited_equals_sum_of_descendant_own() {
+        let nodes = [
+            node("root", None, 0, 10),
+            node("c1", Some("root"), 1, 1),
+            node("c2", Some("root"), 1, 2),
+            node("g1", Some("c1"), 2, 3),
+            node("g2", Some("g1"), 3, 4),
+            node("g3", Some("c2"), 2, 5),
+        ];
+        for limit in [0usize, 1, 3, 500] {
+            let breakdown =
+                build_contribution_breakdown(&nodes, "root", limit, 32).expect("根必须存在");
+            let descendant_own: u64 = breakdown
+                .by_generation
+                .iter()
+                .map(|entry| entry.own.play_count)
+                .sum();
+            assert_eq!(
+                breakdown.inherited.play_count, descendant_own,
+                "limit={limit} 时 inherited 必须等于参与计算的后代 own 之和"
+            );
+            assert_eq!(by_generation_total(&breakdown), descendant_own);
+            assert_eq!(direct_children_total(&breakdown), descendant_own);
+            assert_eq!(
+                breakdown.total.play_count,
+                breakdown.own.play_count + breakdown.inherited.play_count
+            );
+            assert_eq!(generation_game_count(&breakdown), breakdown.node_count);
+        }
+    }
+
+    /// 指标集合按结构体合并：改一个字段不会波及递归与归因的形状。
+    #[test]
+    fn totals_merge_is_the_single_extension_point() {
+        let mut left = ContributionTotals::from_play_count(2);
+        left += ContributionTotals::from_play_count(3);
+        assert_eq!(left.play_count, 5);
+        assert_eq!(
+            (ContributionTotals::from_play_count(u64::MAX)
+                + ContributionTotals::from_play_count(1))
+            .play_count,
+            u64::MAX
+        );
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/domain.rs b/server-rs/crates/module-game-distribution/src/domain.rs
index e66656687..de5807bbe 100644
--- a/server-rs/crates/module-game-distribution/src/domain.rs
+++ b/server-rs/crates/module-game-distribution/src/domain.rs
@@ -1,7 +1,11 @@
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 
-use crate::errors::{GameDistributionError, GameDistributionFieldError};
+use crate::errors::{
+    GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE,
+    GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE, GameDistributionError,
+    GameDistributionFieldError,
+};
 use shared_kernel::{build_prefixed_seed_id, normalize_required_string};
 
 pub const GAME_ID_PREFIX: &str = "game_";
@@ -39,15 +43,25 @@ pub fn generate_game_version_id(seed_micros: i64, version_number: u64) -> String
     )
 }
 
-/// 校验客户端提交的版本号（用户可见的正整数标签，不是不可变的 `version_id`）。
+/// 解析本次创建的版本号（用户可见的版本标签，不是不可变的 `version_id`）。
 ///
-/// 版本号必填且由客户端在一次发布意图内冻结；服务端不再自增、不与已有最大值比较。版本身份由
-/// `(game_id, project_key, version_number)` 三元组决定，见 [`game_distribution_version_key`]。
-pub fn resolve_version_number(requested: u64) -> Result<u64, GameDistributionFieldError> {
-    if requested == 0 {
-        return Err(GameDistributionFieldError::InvalidVersionNumber);
+/// 两条发布路径共用本函数：
+/// - `None`（旧两步路径的旧客户端兼容分支）：取该游戏已有最大版本号 +1；溢出时失败关闭，
+///   不回绕成 0，并向 api-server 透出冲突前缀。
+/// - `Some(requested)`（统一发布路径与旧路径的显式提交）：只要求正整数。同一个 `game_id` 的
+///   同一个版本号可以反复提交——每次提交都是一条新的版本记录（新的 `version_id`），旧公开实例
+///   不原地修改——所以**不与已有最大值比较**，允许重复标签，也允许回退到更小的标签。
+pub fn resolve_version_number(
+    max_existing: u64,
+    requested: Option<u64>,
+) -> Result<u64, GameDistributionFieldError> {
+    match requested {
+        Some(0) => Err(GameDistributionFieldError::InvalidVersionNumber),
+        Some(requested) => Ok(requested),
+        None => max_existing
+            .checked_add(1)
+            .ok_or(GameDistributionFieldError::VersionNumberExhausted),
     }
-    Ok(requested)
 }
 
 /// 版本的自然幂等键：`{game_id}:{project_key}:v{version_number}`。
@@ -231,6 +245,217 @@ pub enum GameDistributionAction {
     Purchase,
 }
 
+/// 作品级共创（Fork）授权档位：开放度只允许单向提升，不允许回退。
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum ForkAuthorization {
+    Forbidden,
+    NonCommercial,
+    Full,
+}
+
+pub const FORK_AUTHORIZATION_FORBIDDEN: &str = "forbidden";
+pub const FORK_AUTHORIZATION_NON_COMMERCIAL: &str = "nonCommercial";
+pub const FORK_AUTHORIZATION_FULL: &str = "full";
+
+impl ForkAuthorization {
+    pub fn parse(value: &str) -> Option<Self> {
+        match value.trim() {
+            FORK_AUTHORIZATION_FORBIDDEN => Some(Self::Forbidden),
+            FORK_AUTHORIZATION_NON_COMMERCIAL => Some(Self::NonCommercial),
+            FORK_AUTHORIZATION_FULL => Some(Self::Full),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Forbidden => FORK_AUTHORIZATION_FORBIDDEN,
+            Self::NonCommercial => FORK_AUTHORIZATION_NON_COMMERCIAL,
+            Self::Full => FORK_AUTHORIZATION_FULL,
+        }
+    }
+
+    /// 开放度序：数值越大越开放。
+    pub fn rank(self) -> u8 {
+        match self {
+            Self::Forbidden => 0,
+            Self::NonCommercial => 1,
+            Self::Full => 2,
+        }
+    }
+
+    /// 是否允许他人基于该作品发起改编。
+    pub fn allows_fork(self) -> bool {
+        !matches!(self, Self::Forbidden)
+    }
+
+    /// 作品行里的**原始存储值**是否允许他人共创（公开目录 `forkable` 过滤的判据）。
+    ///
+    /// 与 fork 门禁（`resolve_game_distribution_fork_declaration_tx` 的 `parse(...).unwrap_or(
+    /// Forbidden).allows_fork()`）是同一判据：**解析不出的取值按禁止解释**。若这里改用
+    /// 「原始字符串 `!= "forbidden"`」，一个未知档位的作品就会被列进共创页，点进去却必然回
+    /// 403 `FORK_NOT_AUTHORIZED`——目录不该给出一个点了必失败的入口。写库侧本来就失败关闭
+    /// （创建与提升都拒绝未知档位），所以这条收敛不会与任何既有行的行为产生差异。
+    pub fn stored_allows_fork(value: &str) -> bool {
+        Self::parse(value).is_some_and(Self::allows_fork)
+    }
+
+    /// 目标档位是否合法：只能提升，同级视为无变化，降级一律拒绝。
+    pub fn can_promote_to(self, target: Self) -> bool {
+        target.rank() > self.rank()
+    }
+}
+
+/// 改变作品共创授权档位（`PUT …/fork-authorization`）的裁决——**唯一判据来源**。
+///
+/// 写入事务只负责取数（血缘行是否存在、当前档位）与落库，规则本身写在这里，因此
+/// 「HTTP 挡住的」与「落库挡住的」永远是同一套判据，也才能在不起 `ReducerContext` 的宿主测试里
+/// 被钉死。返回新的档位（= `target`），或调用方应**原样透出**的失败文案——
+/// 文案有两种形态，都由 api-server 的字符串映射识别：以稳定码开头
+/// （`FORK_AUTHORIZATION_INHERITED:` / `FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED:`），
+/// 或 CAS 期望值不符的纯文案（含「不匹配」，映射成通用 409）。
+///
+/// 判定顺序即语义，三步都不写库：
+/// 1. **衍生作品是终态**：`has_lineage_row`（该作品存在血缘行 = 衍生作品）时档位由创建时**继承**
+///    父作品决定，之后不得再改，因此这里**先于 CAS 拒绝**——衍生作品的任何 PUT 都回
+///    `FORK_AUTHORIZATION_INHERITED`，连「传同值」这种幂等重试也一样。判定放在 CAS 之前是为了
+///    确定性：同一个衍生作品不会因为载荷不同（传同值走 CAS / 传新值走降级）而回不同的码。
+///    若放行，作者就能把继承来的 `nonCommercial` 再提成 `full`，得到一个**比祖先更宽**的子作品，
+///    把父作品在非商用授权下公开的工程内容变成可用商用。
+/// 2. **CAS**：期望值与当前值不符（调用方基于旧状态）→ 拒绝，刷新后重试即可。
+/// 3. **只升不降**：`target` 不严格高于 `current`（含同级）→ 降级码拒绝。
+///
+/// 母版（无血缘行）的语义**未变**：仍只升不降 + CAS。
+pub fn resolve_fork_authorization_promotion(
+    has_lineage_row: bool,
+    current: ForkAuthorization,
+    expected_fork_authorization: &str,
+    target: ForkAuthorization,
+) -> Result<ForkAuthorization, String> {
+    if has_lineage_row {
+        return Err(GameDistributionError::ForkAuthorizationInherited.to_string());
+    }
+    if current.as_str() != expected_fork_authorization.trim() {
+        return Err("共创授权期望值与当前状态不匹配".to_string());
+    }
+    if !current.can_promote_to(target) {
+        return Err(
+            GameDistributionError::ForkAuthorizationDowngradeNotAllowed {
+                current: current.as_str().to_string(),
+                requested: target.as_str().to_string(),
+            }
+            .to_string(),
+        );
+    }
+    Ok(target)
+}
+
+/// 改编代际：根作品为 0，直接改编根作品为 1，逐级递增。
+pub fn next_generation(parent_generation: u32) -> u32 {
+    parent_generation.saturating_add(1)
+}
+
+/// 某个作品行能否充当新的改编（Fork）来源。
+///
+/// 规则 =「未软删除」且「已公开」，两个条件缺一不可：
+/// - **已软删除的作品一律不能被新改编**（#565 的 `deleted_at`）。删除虽然会把可见性复位成
+///   `unpublished`，但那是删除的副作用；这里显式排除删除行，一是对外说明「来源已不可用」，
+///   二是避免将来改可见性语义时把已删作品重新变成可改编来源。
+/// - **未公开的作品**（审核中 / 未公开 / 已下架 / 已封禁）没有对外承诺，也不该成为改编来源。
+///
+/// 只看这两个布尔、不读行本身：调用方负责把行状态折叠成布尔，于是这条规则可以在不起
+/// `ReducerContext` 的前提下被单测钉死。
+pub fn can_serve_as_fork_source(is_deleted: bool, is_published: bool) -> bool {
+    !is_deleted && is_published
+}
+
+/// 某个直接子代是否计入父作品的「已被改编 N 次」。
+///
+/// 与来源可用性同样是「未软删除 + 已公开」，但动机不同，所以单独成函数而不是复用前者
+/// （两条规则将来可能各自演化，共用会让一处改动悄悄改掉另一处）：
+/// - **软删行必须排除**：删除只下线游戏行、保留血缘行；若把已删子作品也算进去，父作品的
+///   计数会虚报改编热度，并对外泄露「这里曾经有个作品」。
+/// - **未公开的子作品不算**：它还不是公开可知的衍生，算进去同样是虚报。
+///
+/// 尤其注意「已删但 `visibility` 恰好仍是 `published`」这个组合：删除与可见性复位之间
+/// 没有原子保证，读路径完全可能看到它，此时必须判 `false`。
+pub fn counts_as_public_derivative(is_deleted: bool, is_published: bool) -> bool {
+    !is_deleted && is_published
+}
+
+/// 血缘溯源卡对外可见的 `(标题, 作者名)`。
+///
+/// - `parent_available == false`（父作品已被软删除，或调用方已判定该行不可用）时**必须**
+///   返回 `(None, None)`：即使调用方把父行的标题与作者名都传进来，也一个都不外发。
+///   公开目录/详情早已下线被删作品，若还能从别人的溯源卡里读到它，删除就等于没删；
+///   因此这里**不做**任何「拿不到标题就回退用行数据」的降级。
+/// - `parent_available == true` 时按原值透传：标题原样返回；作者名保持三态——
+///   `None` 仍是 `None`，空串也仍是空串（不 trim、不把空串归一成 `None`，
+///   行的原值是什么就发什么，展示层自己决定空署名是否渲染）。
+pub fn fork_lineage_visible_identity(
+    parent_available: bool,
+    parent_title: &str,
+    parent_author_name: Option<&str>,
+) -> (Option<String>, Option<String>) {
+    if !parent_available {
+        return (None, None);
+    }
+    (
+        Some(parent_title.to_string()),
+        parent_author_name.map(str::to_string),
+    )
+}
+
+/// 「本次核心改动说明」的最小长度（**字符数**，不是字节数）。
+///
+/// 取 20 的理由：这一项要回答「这一版相对来源作品改了什么」，比作品标题（40）短、比角标（16）长——
+/// 一句话能说清的最小规模。下限不是防呆摆设：只写「改了」这类 2–3 个字的敷衍串等于没有说明，
+/// 而展示层（详情页 / 族谱溯源）要把它当作「每一代的差异」读，写不足就是缺失。
+pub const GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS: usize = 20;
+
+/// 「本次核心改动说明」的长度上限（**字符数**，不是字节数）。
+///
+/// 取 500 的理由：它是发布流程里的一个文本框，不是正文——作品详细介绍（2000）才是正文。
+/// 500 个字符足够写清「加了什么玩法、换了什么美术、修了什么」，同时保证详情页上一代的差异
+/// 不会把族谱节点挤出首屏。计数按 `chars()` 而不是字节：中文一个字 3 字节，按字节算会让中文
+/// 作者只能写三分之一的内容。
+pub const GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS: usize = 500;
+
+/// 衍生作品发布新版本时必填的「本次核心改动说明」校验。
+///
+/// 返回**违规对应的错误码**（`None` = 合法）。返回码而不是布尔，是为了让「必填」与「超限」这两条
+/// 语义不同的失败在 HTTP 面各有稳定码（`FORK_CHANGE_SUMMARY_REQUIRED` / `_INVALID`），而不是被
+/// 压成同一句文案让客户端只能猜。
+///
+/// 规则本身只写在这一处（唯一判据来源是写入事务 `create_game_distribution_version_tx`；api-server
+/// 不做 HTTP 层预校验），因此「HTTP 挡住的」与「落库挡住的」永远是同一套判据：
+/// - **母版（`is_derivative == false`）恒为 `None`**：0 代作品的「基于哪个作品创作」是空的，
+///   「本次改动」这一项对它没有意义。这是**忽略**而不是**可选**——母版即使传了说明也
+///   不校验、不落库（写侧把它写成 `NULL`），否则一个和血缘无关的字段会在母版上分叉出第二套语义。
+/// - 衍生作品缺失（`None` 或 trim 后为空）→ 必填码；trim 后字符数不在
+///   `MIN..=MAX` → 非法码。
+///
+/// 判定前统一 `trim`：一串空白与缺失同罪（调用方忘掉 trim 也不会把空白说明写进库），
+/// 计数也按 trim 后的字符数算，首尾空白不占额度。
+pub fn game_distribution_change_summary_violation(
+    value: Option<&str>,
+    is_derivative: bool,
+) -> Option<&'static str> {
+    if !is_derivative {
+        return None;
+    }
+    let trimmed = value.unwrap_or_default().trim();
+    if trimmed.is_empty() {
+        return Some(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE);
+    }
+    if !(GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS..=GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS)
+        .contains(&trimmed.chars().count())
+    {
+        return Some(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE);
+    }
+    None
+}
+
 pub(crate) fn normalize_id(value: impl AsRef<str>) -> Option<String> {
     normalize_required_string(value)
 }
@@ -241,19 +466,27 @@ mod tests {
 
     #[test]
     fn version_number_is_required_and_only_rejects_zero() {
-        assert_eq!(resolve_version_number(1).expect("首版 v1"), 1);
+        assert_eq!(resolve_version_number(0, Some(1)).expect("首版 v1"), 1);
         assert_eq!(
-            resolve_version_number(3).expect("同号重放 / 回退标签都合法"),
+            resolve_version_number(0, Some(3)).expect("同号重放 / 回退标签都合法"),
             3
         );
         assert_eq!(
-            resolve_version_number(u64::MAX).expect("极大标签合法"),
+            resolve_version_number(0, Some(u64::MAX)).expect("极大标签合法"),
             u64::MAX
         );
         assert_eq!(
-            resolve_version_number(0).expect_err("0 不是合法标签"),
+            resolve_version_number(0, Some(0)).expect_err("0 不是合法标签"),
             GameDistributionFieldError::InvalidVersionNumber
         );
+        assert_eq!(
+            resolve_version_number(2, None).expect("旧客户端缺省按最大值 +1"),
+            3
+        );
+        assert_eq!(
+            resolve_version_number(u64::MAX, None).expect_err("自增溢出应失败关闭"),
+            GameDistributionFieldError::VersionNumberExhausted
+        );
     }
 
     #[test]
@@ -302,3 +535,502 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod fork_soft_delete_tests {
+    use super::*;
+
+    /// 来源可用性：四种组合逐一钉死。
+    ///
+    /// 关键是「已软删除 + 可见性仍是 published」必须为 `false`——删除会复位可见性，但
+    /// 两个字段之间没有原子保证，读路径完全可能看到这个组合，它正是 rebase 时最容易退化成
+    /// 「只看 visibility」的地方。
+    #[test]
+    fn fork_source_requires_unremoved_and_published() {
+        let cases = [
+            (false, true, true, "未删 + 已公开"),
+            (true, true, false, "已软删除 + 可见性仍是 published"),
+            (false, false, false, "未删 + 未公开"),
+            (true, false, false, "已软删除 + 未公开"),
+        ];
+        for (is_deleted, is_published, expected, label) in cases {
+            assert_eq!(
+                can_serve_as_fork_source(is_deleted, is_published),
+                expected,
+                "{label}（is_deleted={is_deleted}, is_published={is_published}）"
+            );
+        }
+    }
+
+    /// 衍生计数纳入：同一条件、不同动机，四组组合同样逐一钉死。
+    #[test]
+    fn derivative_count_excludes_removed_and_unpublished_children() {
+        let cases = [
+            (false, true, true, "未删 + 已公开"),
+            (true, true, false, "已软删除 + 可见性仍是 published"),
+            (false, false, false, "未删 + 未公开"),
+            (true, false, false, "已软删除 + 未公开"),
+        ];
+        for (is_deleted, is_published, expected, label) in cases {
+            assert_eq!(
+                counts_as_public_derivative(is_deleted, is_published),
+                expected,
+                "{label}（is_deleted={is_deleted}, is_published={is_published}）"
+            );
+        }
+    }
+
+    /// 父作品可用：标题与作者名按原值透传。
+    #[test]
+    fn lineage_identity_passes_through_when_parent_available() {
+        assert_eq!(
+            fork_lineage_visible_identity(true, "原初之光", Some("原作者")),
+            (Some("原初之光".to_string()), Some("原作者".to_string()))
+        );
+        assert_eq!(
+            fork_lineage_visible_identity(true, "标题", None),
+            (Some("标题".to_string()), None)
+        );
+    }
+
+    /// 防泄露的关键断言：父作品不可用时，即使调用方把非空标题与作者名都传进来，
+    /// 也必须返回 `(None, None)`——不允许任何形式的回退。
+    #[test]
+    fn lineage_identity_never_leaks_removed_parent_identity() {
+        assert_eq!(
+            fork_lineage_visible_identity(false, "原初之光", Some("原作者")),
+            (None, None),
+            "父不可用时标题与作者名都不得外发"
+        );
+        assert_eq!(
+            fork_lineage_visible_identity(false, "原初之光", None),
+            (None, None)
+        );
+        assert_eq!(fork_lineage_visible_identity(false, "", None), (None, None));
+    }
+
+    /// 作者名三态语义（按实现断言）：`None` → `None`；空串 → 空串；只含空白的名字原样返回。
+    /// 即「行的原值是什么就发什么」，不 trim、不把空串归一成 `None`（展示层按 falsy 处理）。
+    #[test]
+    fn lineage_identity_keeps_author_name_tristate() {
+        assert_eq!(
+            fork_lineage_visible_identity(true, "标题", Some("")),
+            (Some("标题".to_string()), Some(String::new()))
+        );
+        assert_eq!(
+            fork_lineage_visible_identity(true, "标题", Some("  ")),
+            (Some("标题".to_string()), Some("  ".to_string()))
+        );
+    }
+}
+
+#[cfg(test)]
+mod fork_authorization_tests {
+    use super::*;
+    use crate::{GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE, GameDistributionError};
+
+    #[test]
+    fn parse_accepts_every_declared_ladder_value() {
+        for authorization in [
+            ForkAuthorization::Forbidden,
+            ForkAuthorization::NonCommercial,
+            ForkAuthorization::Full,
+        ] {
+            assert_eq!(
+                ForkAuthorization::parse(authorization.as_str()),
+                Some(authorization)
+            );
+        }
+    }
+
+    #[test]
+    fn parse_rejects_unknown_and_miscased_values() {
+        for value in ["", "allowed", "FULL", "non_commercial", "noncommercial"] {
+            assert_eq!(ForkAuthorization::parse(value), None, "value={value:?}");
+        }
+    }
+
+    /// 持久化行可能带着历史写入的空白；解析侧容忍首尾空白，避免把可识别的档位读成未知。
+    #[test]
+    fn parse_tolerates_surrounding_whitespace() {
+        assert_eq!(
+            ForkAuthorization::parse(" nonCommercial "),
+            Some(ForkAuthorization::NonCommercial)
+        );
+    }
+
+    #[test]
+    fn promotion_is_monotonic_and_never_downgrades() {
+        use ForkAuthorization::{Forbidden, Full, NonCommercial};
+        assert!(Forbidden.can_promote_to(NonCommercial));
+        assert!(Forbidden.can_promote_to(Full));
+        assert!(NonCommercial.can_promote_to(Full));
+
+        assert!(!Full.can_promote_to(Full));
+        assert!(!NonCommercial.can_promote_to(NonCommercial));
+        assert!(!Full.can_promote_to(NonCommercial));
+        assert!(!Full.can_promote_to(Forbidden));
+        assert!(!NonCommercial.can_promote_to(Forbidden));
+    }
+
+    /// **衍生作品的档位是终态**：存在血缘行时任何 PUT 都被拒（`FORK_AUTHORIZATION_INHERITED`），
+    /// 包括「传同值」这种幂等重试，也包括期望值已经过期的请求——因为判定先于 CAS，同一载荷
+    /// 不会因重试时机不同而回不同的码。
+    #[test]
+    fn derivative_put_is_rejected_even_with_the_same_or_stale_value() {
+        use ForkAuthorization::{Full, NonCommercial};
+
+        let cases = [
+            // （当前档位, 期望值, 目标档位, 标签）
+            (NonCommercial, "nonCommercial", NonCommercial, "传同值"),
+            (NonCommercial, "nonCommercial", Full, "想再提一级"),
+            (Full, "full", Full, "终态再传同值"),
+            (NonCommercial, "forbidden", Full, "期望值已过期"),
+            (Full, "forbidden", Full, "期望值与当前值都不符"),
+        ];
+        for (current, expected, target, label) in cases {
+            let error = resolve_fork_authorization_promotion(true, current, expected, target)
+                .expect_err("衍生作品的 PUT 必须被拒");
+            assert!(
+                error.starts_with(GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE),
+                "{label}：必须回稳定码前缀，got {error}"
+            );
+            assert!(
+                error.starts_with(&format!(
+                    "{GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE}:"
+                )),
+                "{label}：码后必须跟冒号（缺了会把整句当码，落到 FORK_ERROR），got {error}"
+            );
+            assert!(
+                error.contains("继承"),
+                "{label}：文案要讲清「由父作品继承」，got {error}"
+            );
+        }
+    }
+
+    /// 母版语义**未变**：仍只升不降（可跳级）、同级拒绝、CAS 不符回通用 409 文案（不带 `FORK_` 码）。
+    #[test]
+    fn master_put_still_promotes_with_unchanged_cas_semantics() {
+        use ForkAuthorization::{Forbidden, Full, NonCommercial};
+
+        for (current, expected, target) in [
+            (Forbidden, "forbidden", NonCommercial),
+            (Forbidden, "forbidden", Full),
+            (NonCommercial, "nonCommercial", Full),
+        ] {
+            assert_eq!(
+                resolve_fork_authorization_promotion(false, current, expected, target),
+                Ok(target),
+                "母版提升必须照常放行（current={current:?}, target={target:?}）"
+            );
+        }
+
+        for (current, expected, target, label) in [
+            (NonCommercial, "nonCommercial", NonCommercial, "同级"),
+            (Full, "full", NonCommercial, "降级"),
+            (Full, "full", Forbidden, "降到禁止共创"),
+        ] {
+            let error = resolve_fork_authorization_promotion(false, current, expected, target)
+                .expect_err("同级与降级都必须被拒");
+            assert!(
+                error.starts_with("FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED:"),
+                "{label}：must be the downgrade code, got {error}"
+            );
+        }
+
+        let error = resolve_fork_authorization_promotion(false, Full, "nonCommercial", Full)
+            .expect_err("CAS 不符必须被拒");
+        assert!(
+            error.contains("不匹配") && !error.contains("FORK_"),
+            "CAS 不符仍是纯文案（api-server 按「不匹配」子串落 409），got {error}"
+        );
+    }
+
+    #[test]
+    fn only_forbidden_blocks_forks() {
+        assert!(!ForkAuthorization::Forbidden.allows_fork());
+        assert!(ForkAuthorization::NonCommercial.allows_fork());
+        assert!(ForkAuthorization::Full.allows_fork());
+    }
+
+    /// 存储值判据（公开目录 `forkable` 过滤用）：三个合法档位按开放度作答，**未知取值按禁止**。
+    ///
+    /// 第二条断言是这条判据的全部价值：写库侧本来就失败关闭，因此库里的未知取值只可能来自更早的
+    /// 历史或未来新增档位；此时目录必须与 fork 门禁做出同一个判断，不把「点了必然 403」的作品
+    /// 列进共创页。
+    #[test]
+    fn stored_values_allow_fork_only_for_the_known_open_tiers() {
+        assert!(!ForkAuthorization::stored_allows_fork(
+            FORK_AUTHORIZATION_FORBIDDEN
+        ));
+        assert!(ForkAuthorization::stored_allows_fork(
+            FORK_AUTHORIZATION_NON_COMMERCIAL
+        ));
+        assert!(ForkAuthorization::stored_allows_fork(
+            FORK_AUTHORIZATION_FULL
+        ));
+        assert!(ForkAuthorization::stored_allows_fork(" full "));
+        for unknown in ["", " ", "allowed", "FULL", "non_commercial", "forbidden "] {
+            assert!(
+                !ForkAuthorization::stored_allows_fork(unknown),
+                "未知档位必须按禁止解释：{unknown:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn generation_starts_at_one_for_direct_derivatives() {
+        assert_eq!(next_generation(0), 1);
+        assert_eq!(next_generation(1), 2);
+        assert_eq!(next_generation(u32::MAX), u32::MAX);
+    }
+
+    /// HTTP 层按「错误码前缀」映射状态码，文案格式一旦变化就会静默退化成通用 4xx。
+    #[test]
+    fn fork_errors_are_prefixed_with_their_machine_code() {
+        let cases = [
+            (
+                GameDistributionError::ForkAuthorizationUnknown {
+                    value: "x".to_string(),
+                },
+                "FORK_AUTHORIZATION_UNKNOWN",
+            ),
+            (
+                GameDistributionError::ForkAuthorizationDowngradeNotAllowed {
+                    current: FORK_AUTHORIZATION_FULL.to_string(),
+                    requested: FORK_AUTHORIZATION_FORBIDDEN.to_string(),
+                },
+                "FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED",
+            ),
+            (
+                GameDistributionError::ForkAuthorizationInherited,
+                crate::GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE,
+            ),
+            (
+                GameDistributionError::ForkNotAuthorized,
+                "FORK_NOT_AUTHORIZED",
+            ),
+            (
+                GameDistributionError::ForkSourceNotFound,
+                "FORK_SOURCE_NOT_FOUND",
+            ),
+            (
+                GameDistributionError::ForkSourceNotAvailable,
+                "FORK_SOURCE_NOT_AVAILABLE",
+            ),
+            (
+                GameDistributionError::ForkSourceVersionMismatch,
+                "FORK_SOURCE_VERSION_MISMATCH",
+            ),
+            (
+                GameDistributionError::ForkDeclarationOnExistingGame,
+                "FORK_DECLARATION_ON_EXISTING_GAME",
+            ),
+            (
+                GameDistributionError::ForkChangeSummaryRequired,
+                crate::GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE,
+            ),
+            (
+                GameDistributionError::ForkChangeSummaryInvalid,
+                crate::GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE,
+            ),
+        ];
+        for (error, code) in cases {
+            assert!(
+                error.to_string().starts_with(code),
+                "expected {code} prefix, got {}",
+                error
+            );
+            // 前缀后面必须真的跟冒号：api-server 用 `split(':').next()` 取码，缺了冒号就会把整句
+            // 文案当成码，落到未登记分支变成 `FORK_ERROR`（且状态码退化成通用 409）。
+            assert!(
+                error.to_string().starts_with(&format!("{code}:")),
+                "expected {code} to be followed by ':', got {error}"
+            );
+        }
+    }
+
+    /// 共创主题同理：错误码同样靠前缀被 HTTP 层识别，文案格式一变就静默退化成通用 4xx。
+    ///
+    /// 这条测试**枚举全部主题码**——包括唯一不走领域变体的那条（游标解析只回裸字符串，`Display`
+    /// 的前缀测试天然覆盖不到它）。正因为当初漏了它，才有过「技术方案承诺 `THEME_INVALID_CURSOR`、
+    /// HTTP 面实际只回通用 `BAD_REQUEST`」这个真缺陷。
+    ///
+    /// 这里钉的是**领域侧**的半张表（本 crate 的码常量，`Display` 也复用同一批常量）；另一半
+    /// （`shared-contracts` 的同名常量 + 状态码）由 api-server 的
+    /// `theme_error_codes_are_reachable_from_module_messages` 钉；两半都对着同一组字符串，
+    /// 因此任何一侧改字都会红。
+    #[test]
+    fn theme_errors_are_prefixed_with_their_machine_code() {
+        let cases = [
+            (
+                GameDistributionError::ThemeNotFound.to_string(),
+                crate::GAME_DISTRIBUTION_THEME_NOT_FOUND_CODE,
+            ),
+            (
+                GameDistributionError::ThemeBadRequest {
+                    reason: "主题名不能为空".to_string(),
+                }
+                .to_string(),
+                crate::GAME_DISTRIBUTION_THEME_BAD_REQUEST_CODE,
+            ),
+            (
+                GameDistributionError::ThemeIdempotencyConflict.to_string(),
+                crate::GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT_CODE,
+            ),
+            (
+                GameDistributionError::ThemeMemberNotRoot {
+                    game_id: "game_child".to_string(),
+                }
+                .to_string(),
+                crate::GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT_CODE,
+            ),
+            (
+                GameDistributionError::ThemeMemberGameNotFound {
+                    game_id: "game_missing".to_string(),
+                }
+                .to_string(),
+                crate::GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND_CODE,
+            ),
+            (
+                crate::parse_game_distribution_theme_cursor("不是游标")
+                    .expect_err("非法游标必须报错"),
+                crate::GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE,
+            ),
+        ];
+        for (message, code) in &cases {
+            assert!(
+                message.starts_with(code),
+                "expected {code} prefix, got {message}"
+            );
+            // 前缀后面必须真的跟冒号：api-server 用 `split(':').next()` 取码，缺了冒号就会把整句
+            // 文案当成码，落到未登记分支变成 `THEME_ERROR`。
+            assert!(
+                message.starts_with(&format!("{code}:")),
+                "expected {code} to be followed by ':', got {message}"
+            );
+        }
+        // 覆盖完整性：本 crate 一共只有这 6 个主题码，将来新增的码必须一并进这张表，否则
+        // 新码的「HTTP 面是否可达」又会变成只有真栈才能发现的事。
+        for code in [
+            crate::GAME_DISTRIBUTION_THEME_NOT_FOUND_CODE,
+            crate::GAME_DISTRIBUTION_THEME_BAD_REQUEST_CODE,
+            crate::GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE,
+            crate::GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT_CODE,
+            crate::GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT_CODE,
+            crate::GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND_CODE,
+        ] {
+            assert!(
+                cases.iter().any(|(_, covered)| *covered == code),
+                "主题码 {code} 未被这条枚举测试覆盖"
+            );
+        }
+        // 空名原因要原样透出：400 只有一个状态码，区分「空名」与「超长」只有靠这句。
+        let empty_name = GameDistributionError::ThemeBadRequest {
+            reason: "主题名不能为空".to_string(),
+        };
+        assert!(empty_name.to_string().contains("主题名不能为空"));
+    }
+}
+
+/// 「本次核心改动说明」的规则：范围两端 + trim 口径 + 母版忽略，逐条钉死。
+///
+/// 这些用例只碰纯函数，不需要 `ReducerContext`——规则本身在事务外可验证，事务那边只留一条
+/// 「是否真的调用它、且只对衍生作品调用」的结构断言。
+#[cfg(test)]
+mod change_summary_tests {
+    use super::*;
+
+    fn violation(value: Option<&str>, is_derivative: bool) -> Option<&'static str> {
+        game_distribution_change_summary_violation(value, is_derivative)
+    }
+
+    /// 衍生作品：`None`、空串与「只有空白」都是「没写」，回必填码。
+    #[test]
+    fn derivative_without_a_summary_is_required() {
+        for value in [None, Some(""), Some("   "), Some("\n\t  \n")] {
+            assert_eq!(
+                violation(value, true),
+                Some(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE),
+                "value={value:?}"
+            );
+        }
+    }
+
+    /// 衍生作品：不足下限（19 个字符）回非法码——按**字符**计数，19 个汉字同样是 19。
+    #[test]
+    fn derivative_below_the_floor_is_invalid() {
+        let short_ascii = "a".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS - 1);
+        let short_cjk = "改".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS - 1);
+        let borderline = "改".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS);
+        assert_eq!(
+            violation(Some(&short_ascii), true),
+            Some(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE)
+        );
+        assert_eq!(
+            violation(Some(&short_cjk), true),
+            Some(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE),
+            "必须按字符计数：19 个汉字是 19 不是 57"
+        );
+        assert_eq!(violation(Some(&borderline), true), None, "下限本身合法");
+    }
+
+    /// 衍生作品：超过上限（501 个字符）回非法码；上限本身合法（含中文按字符算的对照）。
+    #[test]
+    fn derivative_above_the_ceiling_is_invalid() {
+        let over_ascii = "a".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS + 1);
+        let over_cjk = "改".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS + 1);
+        let at_ceiling = "改".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS);
+        assert_eq!(
+            violation(Some(&over_ascii), true),
+            Some(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE)
+        );
+        assert_eq!(
+            violation(Some(&over_cjk), true),
+            Some(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE),
+            "必须按字符计数：501 个汉字是 501 不是 1503（按字节算会误判成超限 3 倍）"
+        );
+        assert_eq!(violation(Some(&at_ceiling), true), None, "上限本身合法");
+    }
+
+    /// 区间内合法；首尾空白不占额度（trim 后计数），因此「刚好 20 个字 + 一堆空格」仍然合法。
+    #[test]
+    fn derivative_inside_the_range_passes_after_trimming() {
+        let text = "把跳台改成三段，并重画全部背景与角色立绘";
+        assert_eq!(
+            text.chars().count(),
+            GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS
+        );
+        assert_eq!(violation(Some(text), true), None);
+        let padded = format!(
+            "\n  {}  \t",
+            "改".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS)
+        );
+        assert_eq!(
+            violation(Some(&padded), true),
+            None,
+            "trim 后正好 500 个字符必须合法"
+        );
+    }
+
+    /// 母版（0 代）：无论传什么（缺失 / 超短 / 超长 / 正常）都恒为 `None`——
+    /// 「基于哪个作品创作」对母版不存在，说明这一项对它没有意义，因此是**忽略**而不是**可选**。
+    #[test]
+    fn master_ignores_the_summary_entirely() {
+        let overlong = "a".repeat(GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS + 1);
+        let cases = [
+            None,
+            Some(""),
+            Some("改了"),
+            Some(overlong.as_str()),
+            Some("把跳台改成三段，并重画全部背景"),
+        ];
+        for value in cases {
+            assert_eq!(
+                violation(value, false),
+                None,
+                "母版必须忽略该字段：value={value:?}"
+            );
+        }
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/errors.rs b/server-rs/crates/module-game-distribution/src/errors.rs
index c9c5ba563..e586072ae 100644
--- a/server-rs/crates/module-game-distribution/src/errors.rs
+++ b/server-rs/crates/module-game-distribution/src/errors.rs
@@ -1,6 +1,48 @@
 use std::{error::Error, fmt};
 
-use crate::{GameVersionStatus, GameVisibility, domain::MAX_GAME_PRICE_MUD_POINTS};
+use crate::{
+    GameVersionStatus, GameVisibility,
+    domain::{
+        GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS, GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS,
+        MAX_GAME_PRICE_MUD_POINTS,
+    },
+};
+
+/// 共创主题错误码的字面量。
+///
+/// 与 `shared-contracts` 里的同名常量是**同一组字符串的两个副本**：本 crate 不依赖
+/// `shared-contracts`（那边也不依赖本 crate），所以无法直接共用。两侧由 api-server 的一条测试
+/// 逐码比对（`theme_error_codes_are_reachable_from_module_messages`），任何一侧改字都会红。
+///
+/// 这些码必须出现在**每条**主题错误的文案开头（`"{CODE}: {中文说明}"`）：HTTP 层靠「文案含
+/// `THEME_` + 码前缀」映射稳定码，少一个前缀就静默退化成通用 `BAD_REQUEST`——游标解析就是
+/// 这样漏过一次（游标错误不是领域变体，只是裸字符串，所以不在下面的 `Display` 里）。
+pub const GAME_DISTRIBUTION_THEME_NOT_FOUND_CODE: &str = "THEME_NOT_FOUND";
+/// 后台请求参数非法（空名 / 超长 / 状态不在白名单）。
+pub const GAME_DISTRIBUTION_THEME_BAD_REQUEST_CODE: &str = "THEME_BAD_REQUEST";
+/// 主题列表游标格式非法。
+pub const GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE: &str = "THEME_INVALID_CURSOR";
+/// 同 `Idempotency-Key` 不同请求摘要。
+pub const GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT_CODE: &str = "THEME_IDEMPOTENCY_CONFLICT";
+/// 目标作品有血缘行（非根），不能作为主题成员。
+pub const GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT_CODE: &str = "THEME_MEMBER_NOT_ROOT";
+/// 作为成员的目标作品不存在。
+pub const GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND_CODE: &str = "THEME_MEMBER_GAME_NOT_FOUND";
+
+/// 共创（Fork）发布：衍生作品的版本缺少「本次核心改动说明」。
+///
+/// 与 `FORK_*` 同族，因此 api-server 的 `FORK_` 映射分支**先于**「不存在 / 状态 / 不匹配」这些
+/// 子串分支命中它；两个码都要逐条登记进映射表，否则会退化成默认的 `FORK_ERROR`（409）。
+pub const GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE: &str =
+    "FORK_CHANGE_SUMMARY_REQUIRED";
+/// 共创（Fork）发布：「本次核心改动说明」长度不在允许区间内。
+pub const GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE: &str = "FORK_CHANGE_SUMMARY_INVALID";
+/// 共创（Fork）授权：**衍生作品的档位是终态**——由创建时继承父作品决定，不能自行修改。
+///
+/// 只有衍生作品（存在血缘行）可达；母版仍走 `FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED`。
+/// 与 `FORK_*` 同族，因此同样必须先登记进 api-server 的 `FORK_` 映射表（409）。
+pub const GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE: &str =
+    "FORK_AUTHORIZATION_INHERITED";
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum GameDistributionFieldError {
@@ -14,6 +56,8 @@ pub enum GameDistributionFieldError {
     InvalidPackageBytes,
     MissingReviewReason,
     InvalidVersionNumber,
+    /// 旧客户端兼容分支请求「按已有最大值 +1」但版本号已到 `u64::MAX`：失败关闭，不回绕成 0。
+    VersionNumberExhausted,
     InvalidGamePrice,
     MissingWalletLedgerId,
 }
@@ -31,6 +75,7 @@ impl fmt::Display for GameDistributionFieldError {
             Self::InvalidPackageBytes => "packageBytes 必须大于 0",
             Self::MissingReviewReason => "拒绝审核必须提供理由",
             Self::InvalidVersionNumber => "版本号必须是大于 0 的整数",
+            Self::VersionNumberExhausted => "版本号已达上限，无法自动递增",
             // 上限只从常量取，避免改价格上限时漏改文案、前后端口径分叉。
             Self::InvalidGamePrice => {
                 return write!(
@@ -68,6 +113,65 @@ pub enum GameDistributionError {
     VersionNotPublished,
     VersionAlreadyPublished,
     ReviewActionNotAllowed,
+    /// 共创授权：请求了未知档位。
+    ForkAuthorizationUnknown {
+        value: String,
+    },
+    /// 共创授权：只允许提升开放度。
+    ForkAuthorizationDowngradeNotAllowed {
+        current: String,
+        requested: String,
+    },
+    /// 共创授权：衍生作品的档位是终态（创建时继承父作品），不能自行修改。
+    ///
+    /// 与「只升不降」是同一条策略的两面：母版只升不降，衍生作品连升都不允许。否则作者能把继承来的
+    /// `nonCommercial` 提成 `full`，得到一个比祖先更宽的子作品，把父作品在非商用授权下公开的
+    /// 工程内容变成可用商用。
+    ForkAuthorizationInherited,
+    /// 共创授权：来源作品未开放共创。
+    ForkNotAuthorized,
+    /// 共创授权：改编来源作品不存在。
+    ForkSourceNotFound,
+    /// 共创授权：改编来源作品当前不可改编。
+    ForkSourceNotAvailable,
+    /// 共创授权：改编来源版本不是该作品的当前公开版本。
+    ForkSourceVersionMismatch,
+    /// 共创授权：已存在的作品不能再声明改编来源。
+    ForkDeclarationOnExistingGame,
+    /// 共创主题：后台按 `theme_id` 找不到主题。
+    ///
+    /// 与公开侧的「主题不存在 / 未发布」文案**不是**同一条：公开侧刻意不带错误码，也不确认未发布
+    /// 主题的存在性（见 `spacetime-module` 的 `GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE`）。
+    ThemeNotFound,
+    /// 共创主题：请求参数非法（空名 / 超长 / 状态不在白名单）。
+    ///
+    /// 带 `reason` 而不是固定文案：空名与「名字超过 40 个字符」都要让运营一眼看懂改哪里，而 400
+    /// 这一个状态码不足以区分它们。
+    ThemeBadRequest {
+        reason: String,
+    },
+    /// 共创主题：同 `Idempotency-Key` 不同请求摘要。
+    ///
+    /// 与通用的「幂等键对应的请求摘要不一致」是同一条判定，只是换成主题自己的码：客户端可以按码
+    /// 分支，而不是从 409 的文案里猜这是哪一类冲突。
+    ThemeIdempotencyConflict,
+    /// 共创主题：目标作品有血缘行（不是根作品），不能作为成员。
+    ThemeMemberNotRoot {
+        game_id: String,
+    },
+    /// 共创主题：作为成员的目标作品不存在。
+    ThemeMemberGameNotFound {
+        game_id: String,
+    },
+    /// 共创（Fork）发布：衍生作品的新版本必须提供「本次核心改动说明」。
+    ///
+    /// 只在**衍生**作品上可达（0 代母版忽略该字段，见
+    /// `game_distribution_change_summary_violation`）；缺失与「trim 后为空」在这条码上合一。
+    ForkChangeSummaryRequired,
+    /// 共创（Fork）发布：「本次核心改动说明」长度不在允许区间内。
+    ///
+    /// 上限与下限都只从 `domain` 的常量取（文案插值它们），改区间不会漏改文案。
+    ForkChangeSummaryInvalid,
     /// 免费游戏不需要购买；客户端应直接进入游玩。
     FreeGameNotPurchasable,
     /// 作者本人无需购买：合同约定作者免购买即可游玩自己的付费作品，禁止产生扣费。
@@ -103,6 +207,80 @@ impl fmt::Display for GameDistributionError {
             Self::VersionNotPublished => formatter.write_str("游戏版本当前未公开"),
             Self::VersionAlreadyPublished => formatter.write_str("游戏版本已经公开"),
             Self::ReviewActionNotAllowed => formatter.write_str("当前版本不允许审核操作"),
+            // 共创相关错误的文案以错误码开头，供 HTTP 层按码映射状态码，避免子串碰撞。
+            Self::ForkAuthorizationUnknown { value } => write!(
+                formatter,
+                "FORK_AUTHORIZATION_UNKNOWN: 未知的共创授权档位 {value}"
+            ),
+            Self::ForkAuthorizationDowngradeNotAllowed { current, requested } => write!(
+                formatter,
+                "FORK_AUTHORIZATION_DOWNGRADE_NOT_ALLOWED: 共创授权只能提升，当前 {current}，请求 {requested}"
+            ),
+            Self::ForkAuthorizationInherited => write!(
+                formatter,
+                "{}: 衍生作品的共创授权由父作品继承，不能自行修改",
+                GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE
+            ),
+            Self::ForkNotAuthorized => {
+                formatter.write_str("FORK_NOT_AUTHORIZED: 该作品尚未开放共创授权")
+            }
+            Self::ForkSourceNotFound => {
+                formatter.write_str("FORK_SOURCE_NOT_FOUND: 改编来源作品不存在")
+            }
+            Self::ForkSourceNotAvailable => {
+                formatter.write_str("FORK_SOURCE_NOT_AVAILABLE: 改编来源作品当前不可改编")
+            }
+            Self::ForkSourceVersionMismatch => formatter
+                .write_str("FORK_SOURCE_VERSION_MISMATCH: 改编来源版本不是该作品的当前公开版本"),
+            Self::ForkDeclarationOnExistingGame => formatter
+                .write_str("FORK_DECLARATION_ON_EXISTING_GAME: 已存在的作品不能再声明改编来源"),
+            // 共创主题同理：文案以错误码开头，HTTP 层按码映射（不做子串猜测）；码串统一取上面的常量，
+            // 避免「常量改了、Display 没改」这类只有真栈才会发现的漂移。
+            Self::ThemeNotFound => write!(
+                formatter,
+                "{}: 主题不存在",
+                GAME_DISTRIBUTION_THEME_NOT_FOUND_CODE
+            ),
+            Self::ThemeBadRequest { reason } => {
+                write!(
+                    formatter,
+                    "{}: {reason}",
+                    GAME_DISTRIBUTION_THEME_BAD_REQUEST_CODE
+                )
+            }
+            Self::ThemeIdempotencyConflict => write!(
+                formatter,
+                "{}: 同一个 Idempotency-Key 对应了不同的请求",
+                GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT_CODE
+            ),
+            Self::ThemeMemberNotRoot { game_id } => write!(
+                formatter,
+                "{}: 作品 {game_id} 有血缘行（不是根作品），不能作为主题成员",
+                GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT_CODE
+            ),
+            Self::ThemeMemberGameNotFound { game_id } => {
+                write!(
+                    formatter,
+                    "{}: 作品 {game_id} 不存在",
+                    GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND_CODE
+                )
+            }
+            // 共创（Fork）发布：两类失败各有稳定码（必填 / 超限），不计入同一条码——客户端可以
+            // 只补一句说明重试，而不是把整份发布资料重填。码串取上面的常量，避免「常量改了、
+            // Display 没改」这种只有真栈才会发现的漂移。长度文案插值 `domain` 的上下限常量，
+            // 改区间时前后端口径不会分叉。
+            Self::ForkChangeSummaryRequired => write!(
+                formatter,
+                "{}: 衍生作品发布新版本必须填写本次核心改动说明",
+                GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE
+            ),
+            Self::ForkChangeSummaryInvalid => write!(
+                formatter,
+                "{}: 本次核心改动说明需为 {} 到 {} 个字符（按字符计，忽略首尾空白）",
+                GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE,
+                GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS,
+                GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS
+            ),
             Self::FreeGameNotPurchasable => formatter.write_str("免费游戏不需要购买"),
             Self::OwnerCannotPurchase => formatter.write_str("作者本人无需购买"),
             Self::PriceChanged => formatter.write_str("价格已变化，请刷新后重试"),
@@ -141,4 +319,38 @@ mod tests {
             format!("priceMudPoints 必须是 0 到 {MAX_GAME_PRICE_MUD_POINTS} 之间的整数")
         );
     }
+
+    /// 核心改动说明的两个码同样以常量前缀开头（api-server 按 `"{CODE}: "` 前缀映射 400），
+    /// 且超限文案插值 `domain` 的上下限常量——改区间不会漏改文案。
+    #[test]
+    fn change_summary_messages_start_with_their_codes_and_interpolate_the_range() {
+        let required = GameDistributionError::ForkChangeSummaryRequired.to_string();
+        assert!(required.starts_with(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE));
+        assert!(required.contains("核心改动说明"));
+
+        let invalid = GameDistributionError::ForkChangeSummaryInvalid.to_string();
+        assert!(invalid.starts_with(GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE));
+        assert!(invalid.contains(&GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS.to_string()));
+        assert!(invalid.contains(&GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS.to_string()));
+        assert_eq!(
+            GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS, 20,
+            "下限是契约的一部分（技术方案 §3.4），改它必须同步文档与前端文案"
+        );
+        assert_eq!(GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS, 500);
+    }
+
+    /// 「衍生作品授权终态」的文案同样以常量前缀 + 冒号开头：api-server 用 `split(':').next()`
+    /// 取码，缺了冒号会把整句当成码，落到未登记分支退化成 `FORK_ERROR`（通用 409）。
+    #[test]
+    fn inherited_authorization_message_starts_with_its_code() {
+        let message = GameDistributionError::ForkAuthorizationInherited.to_string();
+        assert!(
+            message.starts_with(&format!(
+                "{}: ",
+                GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE
+            )),
+            "got {message}"
+        );
+        assert!(message.contains("继承"), "got {message}");
+    }
 }
diff --git a/server-rs/crates/module-game-distribution/src/lib.rs b/server-rs/crates/module-game-distribution/src/lib.rs
index f6d265541..9efe2a00e 100644
--- a/server-rs/crates/module-game-distribution/src/lib.rs
+++ b/server-rs/crates/module-game-distribution/src/lib.rs
@@ -1,11 +1,17 @@
 mod application;
+mod catalog;
+mod collection;
 mod commands;
+mod contribution;
 mod domain;
 mod errors;
 mod events;
+mod lineage;
 mod package;
+mod project_bundle;
 mod release;
 mod reviews;
+mod theme;
 
 pub use reviews::{
     ReviewModerationValidationError, UserReviewValidationError, normalize_review_comment,
@@ -18,23 +24,86 @@ pub use application::{
     GameDistributionService, GameOperationResult, InMemoryGameDistributionStore,
     PublicationOperationResult, PurchaseOperationResult,
 };
+pub use catalog::{
+    GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR_CODE, GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_DEFAULT,
+    GAME_DISTRIBUTION_CATALOG_PAGE_LIMIT_MAX, GameDistributionCatalogPageItem,
+    encode_game_distribution_catalog_cursor, filter_public_game_distribution_catalog_by_forkable,
+    game_distribution_catalog_page_limit, page_public_game_distribution_catalog,
+    parse_game_distribution_catalog_cursor, sort_public_game_distribution_catalog,
+};
+pub use collection::{
+    GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_DEFAULT, GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_MAX,
+    GameDistributionCollectionPageItem, encode_game_distribution_collection_cursor,
+    game_distribution_collection_id, game_distribution_collection_page,
+    game_distribution_collection_page_limit, game_distribution_collection_visible,
+    parse_game_distribution_collection_cursor,
+};
 pub use commands::{
     CreateGameInput, CreateVersionInput, IdempotencyRequest, PurchaseGameInput, ReviewDecision,
 };
-pub use domain::{
-    GAME_PURCHASE_ID_PREFIX, GameDistributionAction, GamePurchaseDecision, GamePurchaseSnapshot,
-    GameSnapshot, GameVersionSnapshot, GameVersionStatus, GameVisibility,
-    MAX_GAME_PRICE_MUD_POINTS, compute_request_digest, derive_game_distribution_game_id,
-    game_distribution_version_key, game_purchase_id, generate_game_id, generate_game_version_id,
-    normalize_game_price_mud_points, resolve_game_purchase_decision, resolve_version_number,
+pub use contribution::{
+    ContributionBreakdown, ContributionChildBreakdown, ContributionGenerationBreakdown,
+    ContributionNode, ContributionTotals, ContributionTruncationReason,
+    GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT, GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT,
+    build_contribution_breakdown,
+};
+pub use domain::{
+    FORK_AUTHORIZATION_FORBIDDEN, FORK_AUTHORIZATION_FULL, FORK_AUTHORIZATION_NON_COMMERCIAL,
+    ForkAuthorization, GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS,
+    GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS, GAME_PURCHASE_ID_PREFIX, GameDistributionAction,
+    GamePurchaseDecision, GamePurchaseSnapshot, GameSnapshot, GameVersionSnapshot,
+    GameVersionStatus, GameVisibility, MAX_GAME_PRICE_MUD_POINTS, can_serve_as_fork_source,
+    compute_request_digest, counts_as_public_derivative, derive_game_distribution_game_id,
+    fork_lineage_visible_identity, game_distribution_change_summary_violation,
+    game_distribution_version_key, game_purchase_id, generate_game_id, generate_game_version_id,
+    next_generation, normalize_game_price_mud_points, resolve_fork_authorization_promotion,
+    resolve_game_purchase_decision, resolve_version_number,
+};
+pub use errors::{
+    GAME_DISTRIBUTION_FORK_AUTHORIZATION_INHERITED_CODE,
+    GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_INVALID_CODE,
+    GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE, GAME_DISTRIBUTION_THEME_BAD_REQUEST_CODE,
+    GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT_CODE, GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE,
+    GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND_CODE,
+    GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT_CODE, GAME_DISTRIBUTION_THEME_NOT_FOUND_CODE,
+    GameDistributionError, GameDistributionFieldError,
 };
-pub use errors::{GameDistributionError, GameDistributionFieldError};
 pub use events::GameDistributionEvent;
+pub use lineage::{
+    GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT, LineageGameFacts, LineageLink, LineageNodeList,
+    LineageResolvedLink, LineageTree, LineageTreeEntry, LineageTreeNode, PublicDerivativeIndex,
+    assemble_lineage_tree_entries, build_derived_node_list, build_lineage_tree,
+    lineage_anchor_readable, lineage_entry_from_game_facts, resolve_lineage_author_name,
+};
 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 project_bundle::{
+    MAX_PROJECT_BUNDLE_BYTES, MAX_PROJECT_COMPRESSION_RATIO, MAX_PROJECT_EXPANDED_BYTES,
+    MAX_PROJECT_FILE_BYTES, MAX_PROJECT_FILE_COUNT, ProjectBundleError, ProjectBundleFileManifest,
+    ProjectBundleManifest, validate_project_bundle_zip,
+};
 pub use release::{
     MAX_RELEASE_ASSET_BYTES, ReleaseAssetError, extract_release_asset,
     normalize_release_asset_path, release_asset_content_type,
 };
+pub use theme::{
+    GAME_DISTRIBUTION_THEME_ADMIN_STATUS_ALL, GAME_DISTRIBUTION_THEME_BADGE_MAX_CHARS,
+    GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_DELETED,
+    GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_MISSING, GAME_DISTRIBUTION_THEME_NAME_MAX_CHARS,
+    GAME_DISTRIBUTION_THEME_PAGE_LIMIT_DEFAULT, GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX,
+    GAME_DISTRIBUTION_THEME_STATUS_ARCHIVED, GAME_DISTRIBUTION_THEME_STATUS_DRAFT,
+    GAME_DISTRIBUTION_THEME_STATUS_PUBLISHED, GAME_DISTRIBUTION_THEME_STATUSES,
+    GAME_DISTRIBUTION_THEME_SUMMARY_MAX_CHARS, GameDistributionThemeMemberPageItem,
+    GameDistributionThemePageItem, encode_game_distribution_theme_cursor,
+    encode_game_distribution_theme_member_cursor,
+    game_distribution_theme_admin_status_filter_valid, game_distribution_theme_member_id,
+    game_distribution_theme_member_visibility, game_distribution_theme_member_visible,
+    game_distribution_theme_page_limit, game_distribution_theme_public_visible,
+    game_distribution_theme_root_acceptable, game_distribution_theme_roots_truncated,
+    game_distribution_theme_status_valid, game_distribution_theme_text_violation,
+    page_admin_theme_members, page_public_themes, page_theme_members,
+    parse_game_distribution_theme_cursor, parse_game_distribution_theme_member_cursor,
+    sort_public_themes, sort_theme_members,
+};
diff --git a/server-rs/crates/module-game-distribution/src/lineage.rs b/server-rs/crates/module-game-distribution/src/lineage.rs
new file mode 100644
index 000000000..4191e1bbd
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/lineage.rs
@@ -0,0 +1,965 @@
+//! 创作族谱（Lineage）树的纯构建规则：锚点可读性、可见性过滤、稳定排序、上限截断。
+//!
+//! 这里不碰 `ReducerContext`：调用方（`spacetime-module` 的事务函数）负责把「游戏行 + 血缘行」
+//! 折叠成 [`LineageTreeEntry`]，本模块只按纯函数规则产出对外节点。这样可以脱离 SpacetimeDB
+//! 直接单测可见性与截断，也避免读路径把「哪些节点能出现」的规则写成第二套。
+//!
+//! 三条不可越过的口径：
+//! - **锚点必须公开可读**：URL 里点名的作品若不存在、已软删除或未公开，一律按「不存在」处理
+//!   （api-server 映射 404）。不允许返回一个「标题降级为空的节点」——那等于对外确认
+//!   「这个 gameId 存在、它是第几代、它在血缘里的位置」，本身就是未公开作品的信息泄露。
+//! - **树里只出现公开且未删除的作品节点**：已软删除或未公开的作品既不是节点，也不外发标题/作者名。
+//! - **不补占位节点**：父/祖辈被排除时孩子照常出现并保留 `generation` 与 `parent_game_id`，
+//!   展示层遇到「父不在可见集合里」就按 M1 已确立的口径标注「原作品已不可用」，
+//!   不猜测、不回显父作品内容。
+
+use std::collections::{HashMap, HashSet, VecDeque};
+
+use crate::domain::{can_serve_as_fork_source, counts_as_public_derivative};
+
+/// 单次响应最多返回的树节点数；超出时如实标注 `truncated`，不静默丢弃。
+///
+/// 上限只拦「数量」，不改变排序：先按代际与创建时间稳定排序，再截前缀，
+/// 因此被截掉的总是最深的代际，而不是随机节点。
+pub const GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT: usize = 200;
+
+/// 锚点（URL 里点名的作品）是否可读：必须是未软删除且已公开的作品，否则一律按不存在处理。
+///
+/// 复用 `can_serve_as_fork_source`，与「能否作为新的改编来源」共用同一条「未删 + 已公开」口径，
+/// 不再写第二套判定；单测把四种组合钉死，防泄露回归。
+pub fn lineage_anchor_readable(is_deleted: bool, is_published: bool) -> bool {
+    can_serve_as_fork_source(is_deleted, is_published)
+}
+
+/// 树构建的输入行：调用方把游戏行与血缘行折叠成这些事实。
+///
+/// `is_published` 由调用方按表的可见性常量折叠，本模块不复制可见性字面量；
+/// `status` 原样回传给客户端。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LineageTreeEntry {
+    pub game_id: String,
+    pub title: String,
+    pub author_name: Option<String>,
+    pub generation: u32,
+    pub parent_game_id: Option<String>,
+    pub play_count: u64,
+    pub is_deleted: bool,
+    pub is_published: bool,
+    pub status: String,
+    pub created_at_micros: i64,
+    /// 该节点作品当前生效的封面对象键，与公开详情 / 公开目录同源（游戏行的 `cover_object_key`）；
+    /// 没有封面时为 `None`（对外发 `null`），不伪造空串或占位键。
+    pub cover_object_key: Option<String>,
+}
+
+/// 对外节点；`author_name` 为 `None` 表示作者信息不可得（账号与冻结资料都没有名字）。
+///
+/// 作者名的空值语义：调用方（`spacetime-module`）把空串与纯空白归一成 `None`——节点上没有
+/// 可渲染的名字就不占位。这与 M1 的 `fork_lineage_visible_identity` **刻意保留三态**
+/// （`Some("")` / `Some("  ")` 原样透传）不同，是有意为之：溯源卡由展示层按 falsy 判断是否
+/// 渲染「由 X 制作」，两种取值在两端渲染结果等价，但节点侧不该把空串当成一个名字发出去。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LineageTreeNode {
+    pub game_id: String,
+    pub title: String,
+    pub author_name: Option<String>,
+    pub generation: u32,
+    pub parent_game_id: Option<String>,
+    pub play_count: u64,
+    pub status: String,
+    /// 封面对象键（游戏行的 `cover_object_key`）；与公开目录 / 详情同源同口径，无封面为 `None`。
+    /// 只发对象键本身，**不带** `coverAssetId` 这类私有素材 id。
+    pub cover_object_key: Option<String>,
+}
+
+/// 族谱树：`root` 为根节点在可见集合中的投影，根不可读（已删/未公开）时为 `None`。
+///
+/// `nodes` 是整棵树（含根，若根可见）的稳定排序结果；`root` 只是取其中的根节点，
+/// 便于展示层直接标注「树顶」，不需要再按 ID 找一次。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LineageTree {
+    pub root: Option<LineageTreeNode>,
+    pub nodes: Vec<LineageTreeNode>,
+    pub truncated: bool,
+}
+
+/// 衍生作品列表：直接子代的稳定排序结果。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LineageNodeList {
+    pub nodes: Vec<LineageTreeNode>,
+    pub truncated: bool,
+}
+
+/// 构建以 `root_game_id` 为顶的整棵族谱树。
+///
+/// - `root_game_id`：该作品所属的母版，用于挑出 `root`；
+/// - `limit`：节点上限；`0` 视为「不要任何节点」而不回退到默认值，调用方负责传常量。
+pub fn build_lineage_tree(
+    entries: &[LineageTreeEntry],
+    root_game_id: &str,
+    limit: usize,
+) -> LineageTree {
+    let mut visible: Vec<&LineageTreeEntry> = entries
+        .iter()
+        .filter(|entry| can_serve_as_fork_source(entry.is_deleted, entry.is_published))
+        .collect();
+    stable_node_order(&mut visible);
+    let truncated = visible.len() > limit;
+    let nodes = visible
+        .into_iter()
+        .take(limit)
+        .map(lineage_tree_node)
+        .collect::<Vec<_>>();
+    let root = nodes
+        .iter()
+        .find(|node| node.game_id == root_game_id)
+        .cloned();
+    LineageTree {
+        root,
+        nodes,
+        truncated,
+    }
+}
+
+/// 构建「被改编」直接子代列表：只纳入对外可见的衍生作品，父作品自身不出现在列表里。
+///
+/// 用 `counts_as_public_derivative`（与公开详情 `forkCount` 同一条规则），
+/// 保证「被改编 N」的数字与列表条数一致。
+pub fn build_derived_node_list(entries: &[LineageTreeEntry], limit: usize) -> LineageNodeList {
+    let mut visible: Vec<&LineageTreeEntry> = entries
+        .iter()
+        .filter(|entry| counts_as_public_derivative(entry.is_deleted, entry.is_published))
+        .collect();
+    stable_node_order(&mut visible);
+    let truncated = visible.len() > limit;
+    let nodes = visible
+        .into_iter()
+        .take(limit)
+        .map(lineage_tree_node)
+        .collect::<Vec<_>>();
+    LineageNodeList { nodes, truncated }
+}
+
+/// 「公开可见后代数」的输入索引：血缘边（父 → 直接子代）+ 公开可见作品集合。
+///
+/// 事务侧**一次建索引、多次数子树**：目录一页最多 100 行，每行都要数一次子树，但数的时候
+/// 只在内存里走边、不再回表，也不新增表 / 列 / 索引、不维护物化计数（物化计数会和下架 /
+/// 封禁 / 删除状态产生第二份真相）。本类型不碰 `ReducerContext`，因此计数口径可以脱离
+/// SpacetimeDB 直接单测。
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct PublicDerivativeIndex {
+    /// `parent_game_id` → 直接子代 `game_id`（按输入顺序，不去重；计数时用 `visited` 去重）。
+    children: HashMap<String, Vec<String>>,
+    /// 通过 [`counts_as_public_derivative`] 的作品 ID（未软删除 + 已公开）。
+    visible: HashSet<String>,
+}
+
+impl PublicDerivativeIndex {
+    /// `edges`：血缘边 `(parent_game_id, game_id)`，只折叠行事实、不在这里过滤可见性；
+    /// `games`：`(game_id, is_deleted, is_published)`，可见性判定复用
+    /// [`counts_as_public_derivative`]（与公开详情 `forkCount` 同一条规则），调用方只负责把行状态
+    /// 折成布尔，不重写规则。
+    pub fn new(
+        edges: impl IntoIterator<Item = (String, String)>,
+        games: impl IntoIterator<Item = (String, bool, bool)>,
+    ) -> Self {
+        let mut children: HashMap<String, Vec<String>> = HashMap::new();
+        for (parent_game_id, game_id) in edges {
+            children.entry(parent_game_id).or_default().push(game_id);
+        }
+        let visible = games
+            .into_iter()
+            .filter(|(_, is_deleted, is_published)| {
+                counts_as_public_derivative(*is_deleted, *is_published)
+            })
+            .map(|(game_id, _, _)| game_id)
+            .collect();
+        Self { children, visible }
+    }
+
+    /// 公开可见的**全部后代**数（不含自己）——公开目录 / 公开详情 `coCreationCount` 的口径。
+    ///
+    /// 与 `forkCount`（只数**直接**子代、`build_derived_node_list` 的长度）刻意不同：
+    /// 这里是整棵子树的可见后代数。
+    ///
+    /// - **遍历**：从 `game_id` 沿血缘边 BFS；`visited` 起始就含自己，因此自引用与血缘环
+    ///   既不会死循环，也不会把自己数进去（同一作品最多被数一次）。
+    /// - **计数**：只有可见集合命中的后代才 `+1`；已软删除 / 未公开的后代不进任何一代的计数。
+    /// - **不在不可见处断链**：父作品已删 / 未公开时，它**可见的**后代仍算在祖先的后代数里
+    ///   （与族谱「父/祖辈被排除时孩子照常出现」同一条口径，不补占位节点）。
+    pub fn public_derivative_count(&self, game_id: &str) -> u64 {
+        let mut visited: HashSet<&str> = HashSet::new();
+        visited.insert(game_id);
+        let mut queue: VecDeque<&str> = VecDeque::new();
+        queue.push_back(game_id);
+        let mut count = 0_u64;
+        while let Some(current) = queue.pop_front() {
+            let Some(children) = self.children.get(current) else {
+                continue;
+            };
+            for child in children {
+                if !visited.insert(child.as_str()) {
+                    continue;
+                }
+                if self.visible.contains(child.as_str()) {
+                    count += 1;
+                }
+                queue.push_back(child.as_str());
+            }
+        }
+        count
+    }
+}
+
+/// 游戏行的事实：调用方从游戏表取出后折叠成这些字段，不携带任何 `ReducerContext` 依赖。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LineageGameFacts {
+    pub game_id: String,
+    pub title: String,
+    pub author_name: Option<String>,
+    pub play_count: u64,
+    pub is_deleted: bool,
+    pub is_published: bool,
+    pub status: String,
+    pub created_at_micros: i64,
+    /// 游戏行的封面对象键；与公开目录 / 详情用同一个字段，无封面为 `None`。
+    pub cover_object_key: Option<String>,
+}
+
+/// 血缘行的事实：谁改编自谁、属于哪个根、第几代。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LineageLink {
+    /// 子作品。
+    pub game_id: String,
+    pub parent_game_id: String,
+    pub root_game_id: String,
+    pub generation: u32,
+}
+
+/// 血缘行 + 它指向的游戏行事实；游戏行缺失（脏数据 / 历史遗留）时 `game` 为 `None`。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LineageResolvedLink {
+    pub link: LineageLink,
+    pub game: Option<LineageGameFacts>,
+}
+
+/// 把「根作品行 + 以该根为祖先的血缘行」装配成族谱树输入行。
+///
+/// 这一层是树形状正确性的根，规则全部收在这里并脱离 SpacetimeDB 可单测：
+/// - **家族归属**：只保留 `root_game_id` 命中的血缘行（调用方已按根索引取过一次，这里是显式
+///   不变量，避免将来换查询写法时把旁支混进树里）；
+/// - **根自身也在集合里**：根行以 0 代、无父进入；根行缺失时不占位（由展示层判「母版不可用」）；
+/// - **游戏行缺失就跳过**：不发只有 ID 的半残节点，也不 panic；
+/// - **重复行去重**：同一作品只保留第一次出现，根行优先于血缘行。
+pub fn assemble_lineage_tree_entries(
+    root_game_id: &str,
+    root: Option<LineageGameFacts>,
+    links: &[LineageResolvedLink],
+) -> Vec<LineageTreeEntry> {
+    let mut entries = Vec::new();
+    if let Some(root) = root {
+        entries.push(lineage_entry_from_game_facts(root, 0, None));
+    }
+    for resolved in links {
+        if resolved.link.root_game_id != root_game_id {
+            continue;
+        }
+        let Some(game) = resolved.game.clone() else {
+            continue;
+        };
+        entries.push(lineage_entry_from_game_facts(
+            game,
+            resolved.link.generation,
+            Some(resolved.link.parent_game_id.clone()),
+        ));
+    }
+    let mut seen = HashSet::new();
+    entries.retain(|entry| seen.insert(entry.game_id.clone()));
+    entries
+}
+
+/// 族谱节点的作者名：账号昵称优先（非空才用），否则退回发布时冻结的作者名；
+/// 两者都是空串或纯空白时返回 `None`——节点上没有可渲染的名字就不占位。
+///
+/// 注意与 M1 的 `fork_lineage_visible_identity` 的差异：那个函数刻意保留作者名三态
+/// （`Some("")` / `Some("  ")` 原样透传），因为溯源卡由展示层按 falsy 判断是否渲染
+/// 「由 X 制作」，两种取值渲染结果等价；节点侧则不该把空串当成一个名字发出去。
+pub fn resolve_lineage_author_name(
+    account_display_name: Option<&str>,
+    frozen_author_name: Option<&str>,
+) -> Option<String> {
+    if let Some(display_name) = account_display_name {
+        let trimmed = display_name.trim();
+        if !trimmed.is_empty() {
+            return Some(trimmed.to_string());
+        }
+    }
+    frozen_author_name
+        .map(str::trim)
+        .filter(|name| !name.is_empty())
+        .map(str::to_string)
+}
+
+/// 由行事实 + 血缘关系构造一条树输入行。
+///
+/// 公开给调用方复用：族谱树走 [`assemble_lineage_tree_entries`]，衍生列表则由调用方按
+/// `parent_game_id` 取直接子代后逐条调用本函数——两处的字段映射因此只有一份。
+pub fn lineage_entry_from_game_facts(
+    facts: LineageGameFacts,
+    generation: u32,
+    parent_game_id: Option<String>,
+) -> LineageTreeEntry {
+    LineageTreeEntry {
+        game_id: facts.game_id,
+        title: facts.title,
+        author_name: facts.author_name,
+        generation,
+        parent_game_id,
+        play_count: facts.play_count,
+        is_deleted: facts.is_deleted,
+        is_published: facts.is_published,
+        status: facts.status,
+        created_at_micros: facts.created_at_micros,
+        cover_object_key: facts.cover_object_key,
+    }
+}
+
+/// 稳定排序：代际升序 → 创建时间升序 → gameId 升序。
+///
+/// 最后一级是按 ID 的确定性兜底，避免同代同刻的作品在两次读之间换序（截断点会随之漂移）。
+fn stable_node_order(entries: &mut Vec<&LineageTreeEntry>) {
+    entries.sort_by(|left, right| {
+        left.generation
+            .cmp(&right.generation)
+            .then_with(|| left.created_at_micros.cmp(&right.created_at_micros))
+            .then_with(|| left.game_id.cmp(&right.game_id))
+    });
+    // 同一作品可能被调用方重复折叠进来（例如根行既在血缘索引外又被打点补进来），
+    // 排序后相同 ID 必然相邻；去重保证树上不出现重复节点，也不会把截断额度浪费在副本上。
+    entries.dedup_by(|left, right| left.game_id == right.game_id);
+}
+
+/// 折叠成对外节点；进入这里的前提是调用方已按可见性过滤过。
+fn lineage_tree_node(entry: &LineageTreeEntry) -> LineageTreeNode {
+    LineageTreeNode {
+        game_id: entry.game_id.clone(),
+        title: entry.title.clone(),
+        author_name: entry.author_name.clone(),
+        generation: entry.generation,
+        parent_game_id: entry.parent_game_id.clone(),
+        play_count: entry.play_count,
+        status: entry.status.clone(),
+        cover_object_key: entry.cover_object_key.clone(),
+    }
+}
+
+#[cfg(test)]
+mod lineage_tree_tests {
+    use super::*;
+
+    fn entry(
+        game_id: &str,
+        generation: u32,
+        created_at_micros: i64,
+        is_deleted: bool,
+        is_published: bool,
+    ) -> LineageTreeEntry {
+        LineageTreeEntry {
+            game_id: game_id.to_string(),
+            title: format!("作品 {game_id}"),
+            author_name: Some(format!("作者 {game_id}")),
+            generation,
+            parent_game_id: (generation > 0).then(|| format!("game_gen{}", generation - 1)),
+            play_count: generation as u64 * 10,
+            is_deleted,
+            is_published,
+            status: if is_published {
+                "published"
+            } else {
+                "unpublished"
+            }
+            .to_string(),
+            created_at_micros,
+            cover_object_key: None,
+        }
+    }
+
+    fn published(game_id: &str, generation: u32, created_at_micros: i64) -> LineageTreeEntry {
+        entry(game_id, generation, created_at_micros, false, true)
+    }
+
+    fn node_ids(tree: &LineageTree) -> Vec<&str> {
+        tree.nodes
+            .iter()
+            .map(|node| node.game_id.as_str())
+            .collect()
+    }
+
+    /// 锚点可读性：四种组合逐一钉死。「已软删除 + 可见性仍是 published」必须为 false——
+    /// 删除与可见性复位之间没有原子保证，读路径完全可能看到这个组合。
+    #[test]
+    fn anchor_requires_unremoved_and_published() {
+        let cases = [
+            (false, true, true, "未删 + 已公开"),
+            (true, true, false, "已软删除 + 可见性仍是 published"),
+            (false, false, false, "未删 + 未公开"),
+            (true, false, false, "已软删除 + 未公开"),
+        ];
+        for (is_deleted, is_published, expected, label) in cases {
+            assert_eq!(
+                lineage_anchor_readable(is_deleted, is_published),
+                expected,
+                "{label}（is_deleted={is_deleted}, is_published={is_published}）"
+            );
+        }
+    }
+
+    /// 软删除节点必须整体消失：既不是节点，也不把标题/作者名泄给任何人。
+    #[test]
+    fn soft_deleted_nodes_are_removed_without_leaking_identity() {
+        let entries = [
+            published("root", 0, 1),
+            entry("removed", 1, 2, true, true),
+            published("alive", 1, 3),
+        ];
+        let tree = build_lineage_tree(&entries, "root", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert_eq!(node_ids(&tree), vec!["root", "alive"]);
+        assert!(
+            tree.nodes.iter().all(|node| node.title != "作品 removed"
+                && node.author_name.as_deref() != Some("作者 removed")),
+            "被删作品的标题与作者名都不得出现在响应里"
+        );
+    }
+
+    /// 未公开的节点同样不出现，也不泄露身份；锚点自己未公开时整棵树不含它
+    /// （路由层已按 `lineage_anchor_readable` 判成 404，这里再钉住纯函数一侧）。
+    #[test]
+    fn unpublished_nodes_are_removed_including_the_anchor() {
+        let entries = [
+            published("root", 0, 1),
+            entry("hidden", 1, 2, false, false),
+            published("alive", 1, 3),
+        ];
+        let tree = build_lineage_tree(&entries, "root", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert_eq!(node_ids(&tree), vec!["root", "alive"]);
+
+        // 被点名的锚点未公开时也不得出现（没有「自身豁免」）。
+        let unpublished_anchor = [published("root", 0, 1), entry("anchor", 1, 2, false, false)];
+        let tree = build_lineage_tree(
+            &unpublished_anchor,
+            "root",
+            GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT,
+        );
+        assert_eq!(node_ids(&tree), vec!["root"]);
+        assert!(tree.nodes.iter().all(|node| node.game_id != "anchor"));
+    }
+
+    /// 树里不补占位节点：根已删/未公开时按 ID 与代际回退，孩子的父引用原样保留指向不可用的根。
+    #[test]
+    fn unavailable_root_falls_back_to_id_and_generation_tree() {
+        let entries = [
+            entry("root", 0, 1, true, true),
+            published("mid", 1, 2),
+            published("leaf", 2, 3),
+        ];
+        let tree = build_lineage_tree(&entries, "root", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert_eq!(node_ids(&tree), vec!["mid", "leaf"]);
+        assert!(tree.root.is_none(), "根不可用时 root 降级为空");
+        let mid = tree
+            .nodes
+            .iter()
+            .find(|node| node.game_id == "mid")
+            .expect("中间节点保留");
+        // 父引用原样保留指向不可用的根：展示层据此标注「原作品已不可用」，而不是断链。
+        assert_eq!(mid.parent_game_id.as_deref(), Some("game_gen0"));
+        assert_eq!(mid.generation, 1);
+        let leaf = tree
+            .nodes
+            .iter()
+            .find(|node| node.game_id == "leaf")
+            .expect("后代保留");
+        assert_eq!(leaf.generation, 2);
+    }
+
+    /// 根可见时 `root` 指回根节点，且节点集合含根（树顶就是根）。
+    #[test]
+    fn visible_root_is_exposed_as_tree_top() {
+        let entries = [published("root", 0, 5), published("child", 1, 6)];
+        let tree = build_lineage_tree(&entries, "root", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        let root = tree.root.expect("根应可见");
+        assert_eq!(root.game_id, "root");
+        assert_eq!(root.title, "作品 root");
+        assert_eq!(
+            tree.nodes.first().map(|node| node.game_id.as_str()),
+            Some("root")
+        );
+    }
+
+    /// 超出上限时如实标注，并只截掉最深代际（排序先于截断）。
+    #[test]
+    fn limit_truncates_deepest_generations_and_flags_it() {
+        let entries = [
+            published("g0", 0, 1),
+            published("g1", 1, 2),
+            published("g2", 2, 3),
+            published("g3", 3, 4),
+        ];
+        let tree = build_lineage_tree(&entries, "g0", 2);
+        assert!(tree.truncated);
+        assert_eq!(node_ids(&tree), vec!["g0", "g1"]);
+
+        let full = build_lineage_tree(&entries, "g0", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert!(!full.truncated);
+        assert_eq!(node_ids(&full).len(), 4);
+    }
+
+    /// 排序稳定：代际升序，同代按创建时间升序，同代同刻按 ID 升序。
+    #[test]
+    fn ordering_is_generation_then_creation_then_id() {
+        let entries = [
+            published("g1-late", 1, 50),
+            published("g0", 0, 40),
+            published("g1-b", 1, 10),
+            published("g1-a", 1, 10),
+        ];
+        let tree = build_lineage_tree(&entries, "g0", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert_eq!(
+            node_ids(&tree),
+            vec!["g0", "g1-a", "g1-b", "g1-late"],
+            "同代同刻必须按 ID 兜底，避免截断点漂移"
+        );
+    }
+
+    /// 重复折叠进来的同一作品只出现一次（例如调用方既按根补了根行、又重复打点）。
+    #[test]
+    fn duplicate_entries_collapse_to_one_node() {
+        let entries = [published("root", 0, 1), published("root", 0, 1)];
+        let tree = build_lineage_tree(&entries, "root", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert_eq!(node_ids(&tree), vec!["root"]);
+    }
+
+    /// 衍生列表只含对外可见的直接子代：软删除与未公开的直接子代都不在列表里。
+    ///
+    /// 调用方只会把「直接子代」折叠进来（父作品自身不在其中），所以这里验证的是两条可见性规则。
+    #[test]
+    fn derived_list_contains_only_visible_children() {
+        let entries = [
+            published("child-a", 3, 2),
+            entry("child-removed", 3, 3, true, true),
+            entry("child-hidden", 3, 4, false, false),
+        ];
+        let list = build_derived_node_list(&entries, GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        let ids = list
+            .nodes
+            .iter()
+            .map(|node| node.game_id.as_str())
+            .collect::<Vec<_>>();
+        assert_eq!(ids, vec!["child-a"]);
+        assert!(!list.truncated);
+    }
+
+    /// 衍生列表同样如实标注截断，并按创建时间稳定排序。
+    #[test]
+    fn derived_list_sorts_and_flags_truncation() {
+        let entries = [
+            published("late", 3, 30),
+            published("early", 3, 10),
+            published("mid", 3, 20),
+        ];
+        let list = build_derived_node_list(&entries, 2);
+        assert!(list.truncated);
+        let ids = list
+            .nodes
+            .iter()
+            .map(|node| node.game_id.as_str())
+            .collect::<Vec<_>>();
+        assert_eq!(ids, vec!["early", "mid"]);
+    }
+
+    /// 节点上限是**合同值**：一条断言同时钉住「常量本身」与「动作行为」。
+    ///
+    /// 只按常量符号构造输入不够——改常量时输入会一起变，测试仍绿。所以这里既断言
+    /// `200` 这个对外承诺值（技术方案 §3.4 与里程碑验收都写它），又用常量本身构造
+    /// 满量 / 超量输入，保证「改常量」和「改截断实现」都必须过这道门。
+    #[test]
+    fn node_limit_constant_is_pinned_and_governs_truncation() {
+        assert_eq!(
+            GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT, 200,
+            "节点上限是合同值（技术方案 §3.4 与里程碑验收都引用 200）；改动需同步契约与文档"
+        );
+
+        let mut entries = (0..GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT)
+            .map(|index| published(&format!("g{index}"), 0, index as i64))
+            .collect::<Vec<_>>();
+
+        // 恰好等于上限：不算截断。
+        let exact = build_lineage_tree(&entries, "g0", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert!(!exact.truncated);
+        assert_eq!(exact.nodes.len(), GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+
+        // 多一个：截断到常量值，并如实标注。
+        entries.push(published("overflow", 0, 10_000));
+        let overflowed = build_lineage_tree(&entries, "g0", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert!(overflowed.truncated);
+        assert_eq!(
+            overflowed.nodes.len(),
+            GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT,
+            "截断后节点数必须等于常量值"
+        );
+
+        // 衍生列表共用同一个上限常量，同样在超量时标注截断。
+        let derived_overflow =
+            build_derived_node_list(&entries, GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert!(derived_overflow.truncated);
+        assert_eq!(
+            derived_overflow.nodes.len(),
+            GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT
+        );
+    }
+
+    fn facts(game_id: &str, is_deleted: bool, is_published: bool) -> LineageGameFacts {
+        LineageGameFacts {
+            game_id: game_id.to_string(),
+            title: format!("作品 {game_id}"),
+            author_name: Some(format!("作者 {game_id}")),
+            play_count: 1,
+            is_deleted,
+            is_published,
+            status: if is_published {
+                "published"
+            } else {
+                "unpublished"
+            }
+            .to_string(),
+            created_at_micros: 10,
+            cover_object_key: None,
+        }
+    }
+
+    fn link(game_id: &str, parent: &str, root: &str, generation: u32) -> LineageResolvedLink {
+        LineageResolvedLink {
+            link: LineageLink {
+                game_id: game_id.to_string(),
+                parent_game_id: parent.to_string(),
+                root_game_id: root.to_string(),
+                generation,
+            },
+            game: Some(facts(game_id, false, true)),
+        }
+    }
+
+    fn assembled_ids(entries: &[LineageTreeEntry]) -> Vec<&str> {
+        entries.iter().map(|entry| entry.game_id.as_str()).collect()
+    }
+
+    /// 装配是树形状正确性的根：根行进集合（0 代、无父），同根的整族（各分支 + 深层后代）
+    /// 都进去，且后代保留自己的代际与父引用。
+    #[test]
+    fn assembly_keeps_root_and_whole_family_of_its_root() {
+        let entries = assemble_lineage_tree_entries(
+            "root",
+            Some(facts("root", false, true)),
+            &[
+                link("child-a", "root", "root", 1),
+                link("child-b", "root", "root", 1),
+                link("grandchild", "child-a", "root", 2),
+            ],
+        );
+        assert_eq!(
+            assembled_ids(&entries),
+            vec!["root", "child-a", "child-b", "grandchild"]
+        );
+        assert_eq!(entries[0].generation, 0, "根自身是 0 代");
+        assert_eq!(entries[0].parent_game_id, None, "根自身没有父");
+        let grandchild = entries
+            .iter()
+            .find(|entry| entry.game_id == "grandchild")
+            .expect("深层后代应进入集合");
+        assert_eq!(grandchild.generation, 2);
+        assert_eq!(grandchild.parent_game_id.as_deref(), Some("child-a"));
+    }
+
+    /// 不属于该根的血缘行一律排除，避免把旁支混进树里。
+    #[test]
+    fn assembly_excludes_links_from_other_roots() {
+        let entries = assemble_lineage_tree_entries(
+            "root",
+            Some(facts("root", false, true)),
+            &[
+                link("child-a", "root", "root", 1),
+                link("outsider", "other-root", "other-root", 1),
+            ],
+        );
+        assert_eq!(assembled_ids(&entries), vec!["root", "child-a"]);
+    }
+
+    /// 游戏行缺失（脏数据 / 历史遗留）时跳过该行：不 panic，也不产生只有 ID 的半残节点。
+    #[test]
+    fn assembly_skips_links_whose_game_row_is_missing() {
+        let mut broken = link("ghost", "root", "root", 1);
+        broken.game = None;
+        let entries = assemble_lineage_tree_entries(
+            "root",
+            Some(facts("root", false, true)),
+            &[broken, link("child-a", "root", "root", 1)],
+        );
+        assert_eq!(assembled_ids(&entries), vec!["root", "child-a"]);
+        assert!(entries.iter().all(|entry| entry.game_id != "ghost"));
+    }
+
+    /// 根行缺失（历史数据）时仍装配出后代：根不占位，由展示层按 `rootGameId` 判「母版不可用」。
+    #[test]
+    fn assembly_works_without_the_root_row() {
+        let entries =
+            assemble_lineage_tree_entries("root", None, &[link("child-a", "root", "root", 1)]);
+        assert_eq!(assembled_ids(&entries), vec!["child-a"]);
+    }
+
+    /// 重复行去重且保留第一次出现：同一作品既有根行又有血缘行时，根的身份（0 代、无父）优先。
+    #[test]
+    fn assembly_dedupes_keeping_the_first_occurrence() {
+        let entries = assemble_lineage_tree_entries(
+            "root",
+            Some(facts("root", false, true)),
+            &[
+                link("root", "someone", "root", 3),
+                link("root", "someone", "root", 3),
+            ],
+        );
+        assert_eq!(assembled_ids(&entries), vec!["root"]);
+        assert_eq!(entries[0].generation, 0, "根行优先，不被血缘行改写");
+        assert_eq!(entries[0].parent_game_id, None);
+    }
+
+    /// 作者名归一：账号昵称优先（并 trim）→ 退回冻结名 → 两者都空白则 `None`（节点不占位）。
+    #[test]
+    fn author_name_prefers_account_then_frozen_then_none() {
+        assert_eq!(
+            resolve_lineage_author_name(Some("账号昵称"), Some("冻结名")),
+            Some("账号昵称".to_string())
+        );
+        assert_eq!(
+            resolve_lineage_author_name(Some("  账号昵称  "), Some("冻结名")),
+            Some("账号昵称".to_string()),
+            "账号昵称去首尾空白后透传"
+        );
+        // 账号信息不可得（或昵称为空白）时退回发布时冻结的作者名。
+        assert_eq!(
+            resolve_lineage_author_name(None, Some("冻结名")),
+            Some("冻结名".to_string())
+        );
+        assert_eq!(
+            resolve_lineage_author_name(Some("   "), Some("冻结名")),
+            Some("冻结名".to_string())
+        );
+        // 两者都没有可渲染的名字 → 不占位。
+        assert_eq!(resolve_lineage_author_name(None, None), None);
+        assert_eq!(resolve_lineage_author_name(Some(""), Some("   ")), None);
+    }
+
+    /// 封面对象键与公开目录 / 详情同源（游戏行 `cover_object_key`），逐层原样透传到对外节点；
+    /// 无封面时为 `None`，不伪造空串或占位键。
+    #[test]
+    fn cover_object_key_is_passed_through_and_may_be_absent() {
+        // 带封面：行事实 → 树输入行 → 对外节点，三层都必须带上同一个键。
+        let mut covered = facts("with-cover", false, true);
+        covered.cover_object_key = Some("covers/with-cover.png".to_string());
+        let entries = assemble_lineage_tree_entries("with-cover", Some(covered), &[]);
+        assert_eq!(
+            entries[0].cover_object_key.as_deref(),
+            Some("covers/with-cover.png"),
+            "fact 上的封面对象键必须折进树输入行"
+        );
+        let tree = build_lineage_tree(&entries, "with-cover", GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert_eq!(
+            tree.nodes[0].cover_object_key.as_deref(),
+            Some("covers/with-cover.png"),
+            "树输入行的封面对象键必须折进对外节点"
+        );
+
+        // 有 / 无封面在同一个响应里都如实透传：`Some(key)` 原样，`None` 保持 `None`。
+        let mut plain = published("plain", 0, 1);
+        plain.cover_object_key = None;
+        let mut child = published("child-cover", 1, 2);
+        child.cover_object_key = Some("covers/child.png".to_string());
+        let tree = build_lineage_tree(
+            &[plain, child.clone()],
+            "plain",
+            GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT,
+        );
+        let plain_node = tree
+            .nodes
+            .iter()
+            .find(|node| node.game_id == "plain")
+            .expect("无封面节点应保留");
+        assert_eq!(
+            plain_node.cover_object_key, None,
+            "无封面节点必须发 null 语义"
+        );
+        let child_node = tree
+            .nodes
+            .iter()
+            .find(|node| node.game_id == "child-cover")
+            .expect("带封面节点应保留");
+        assert_eq!(
+            child_node.cover_object_key.as_deref(),
+            Some("covers/child.png")
+        );
+
+        // 衍生列表走同一份折叠函数，封面同样不得丢。
+        let list = build_derived_node_list(&[child], GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT);
+        assert_eq!(
+            list.nodes[0].cover_object_key.as_deref(),
+            Some("covers/child.png")
+        );
+    }
+}
+
+#[cfg(test)]
+mod public_derivative_count_tests {
+    use super::*;
+
+    /// `(game_id, is_deleted, is_published)`。
+    type GameFacts = (&'static str, bool, bool);
+
+    fn build_index(edges: &[(&str, &str)], games: &[GameFacts]) -> PublicDerivativeIndex {
+        PublicDerivativeIndex::new(
+            edges
+                .iter()
+                .map(|(parent, child)| (parent.to_string(), child.to_string())),
+            games.iter().map(|(game_id, is_deleted, is_published)| {
+                (game_id.to_string(), *is_deleted, *is_published)
+            }),
+        )
+    }
+
+    fn visible(game_id: &'static str) -> GameFacts {
+        (game_id, false, true)
+    }
+
+    /// 只用于 `forkCount` 一侧的对照：与 `lineage_tree_tests` 里同名 helper 同一形状（那个 helper
+    /// 是另一个测试模块私有的，这里不跨模块借用）。
+    fn published(game_id: &str, generation: u32, created_at_micros: i64) -> LineageTreeEntry {
+        LineageTreeEntry {
+            game_id: game_id.to_string(),
+            title: format!("作品 {game_id}"),
+            author_name: Some(format!("作者 {game_id}")),
+            generation,
+            parent_game_id: (generation > 0).then(|| format!("game_gen{}", generation - 1)),
+            play_count: generation as u64 * 10,
+            is_deleted: false,
+            is_published: true,
+            status: "published".to_string(),
+            created_at_micros,
+            cover_object_key: None,
+        }
+    }
+
+    /// 核心口径：根 + 3 个直接子代 + 其中 1 个再带 1 个孙代 ⇒ `forkCount == 3`、`coCreationCount == 4`。
+    ///
+    /// `forkCount` 一侧直接用同一批规则（`counts_as_public_derivative`）的衍生列表长度钉死：
+    /// 两个数字来自同一条可见性规则，只是深度不同（直接子代 vs 全部后代）。
+    #[test]
+    fn co_creation_counts_the_whole_subtree_while_fork_count_stays_direct() {
+        // `forkCount` 一侧：调用方按 `parent_game_id` 取**直接**子代后交给 `build_derived_node_list`
+        // （与模块里 `game_distribution_public_fork_count` 同一条可见性规则、同一层深度）。
+        let direct = build_derived_node_list(
+            &[
+                published("child-a", 1, 2),
+                published("child-b", 1, 3),
+                published("child-c", 1, 4),
+            ],
+            GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT,
+        );
+        assert_eq!(direct.nodes.len(), 3, "forkCount 口径 = 直接子代数");
+
+        let index = build_index(
+            &[
+                ("root", "child-a"),
+                ("root", "child-b"),
+                ("root", "child-c"),
+                ("child-a", "grandchild-a"),
+            ],
+            &[
+                visible("root"),
+                visible("child-a"),
+                visible("child-b"),
+                visible("child-c"),
+                visible("grandchild-a"),
+            ],
+        );
+        assert_eq!(
+            index.public_derivative_count("root"),
+            4,
+            "coCreationCount 口径 = 公开可见的全部后代（不含自己）"
+        );
+        assert_eq!(
+            index.public_derivative_count("child-a"),
+            1,
+            "孙代算进子代的子树"
+        );
+        assert_eq!(index.public_derivative_count("child-b"), 0);
+        assert_eq!(index.public_derivative_count("child-c"), 0);
+        assert_eq!(index.public_derivative_count("grandchild-a"), 0);
+    }
+
+    /// 无子代（或索引里根本没有这个作品）恒为 0：调用方据此发 `coCreationCount: 0`，而不是缺键。
+    #[test]
+    fn childless_games_count_zero() {
+        let index = build_index(&[], &[visible("lonely")]);
+        assert_eq!(index.public_derivative_count("lonely"), 0);
+        assert_eq!(
+            index.public_derivative_count("never-heard-of-it"),
+            0,
+            "未知作品按 0 处理，不 panic"
+        );
+    }
+
+    /// 不可见后代（软删 / 未公开）不进任何一代的计数；但**不在不可见处断链**——已删 / 未公开
+    /// 中间作品**可见的**后代仍算在祖先的后代数里（与族谱「父被排除时孩子照常出现」同一口径）。
+    #[test]
+    fn invisible_descendants_never_count_but_do_not_cut_the_subtree() {
+        let index = build_index(
+            &[
+                ("root", "deleted-child"),
+                ("root", "unpublished-child"),
+                ("deleted-child", "visible-grandchild"),
+                ("unpublished-child", "also-hidden"),
+            ],
+            &[
+                visible("root"),
+                ("deleted-child", true, true),
+                ("unpublished-child", false, false),
+                visible("visible-grandchild"),
+                ("also-hidden", true, true),
+            ],
+        );
+        // 1 = visible-grandchild；已删的直接子代自己、未公开的直接子代、以及它下面同样不可见的
+        // 后代都不计数。
+        assert_eq!(index.public_derivative_count("root"), 1);
+        // 中间作品自己的子树：它可见的后代照常算进它的后代数。
+        assert_eq!(index.public_derivative_count("deleted-child"), 1);
+        assert_eq!(index.public_derivative_count("unpublished-child"), 0);
+        // 「已软删除 + 可见性仍是 published」这类中间态同样不计数（读路径可能看到它）。
+        let stale = build_index(
+            &[("root", "stale")],
+            &[visible("root"), ("stale", true, true)],
+        );
+        assert_eq!(stale.public_derivative_count("root"), 0);
+    }
+
+    /// 自己永远不计数：自引用边与血缘环都不会把根算成自己的后代，也不会死循环；
+    /// 重复的血缘边只数一次。
+    #[test]
+    fn self_loops_and_cycles_never_count_the_root_twice() {
+        let self_loop = build_index(&[("root", "root")], &[visible("root")]);
+        assert_eq!(self_loop.public_derivative_count("root"), 0);
+
+        let cycle = build_index(
+            &[("root", "a"), ("a", "b"), ("b", "root"), ("root", "a")],
+            &[visible("root"), visible("a"), visible("b")],
+        );
+        assert_eq!(cycle.public_derivative_count("root"), 2, "环上只数 a、b");
+        assert_eq!(cycle.public_derivative_count("a"), 2, "环上只数 b、root");
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/package.rs b/server-rs/crates/module-game-distribution/src/package.rs
index 139ddc4b8..e3f0219b5 100644
--- a/server-rs/crates/module-game-distribution/src/package.rs
+++ b/server-rs/crates/module-game-distribution/src/package.rs
@@ -19,6 +19,11 @@ pub const MAX_PACKAGE_BYTES: u64 = 200 * 1024 * 1024;
 pub const MAX_EXPANDED_BYTES: u64 = 500 * 1024 * 1024;
 pub const MAX_FILE_BYTES: u64 = 64 * 1024 * 1024;
 pub const MAX_FILE_COUNT: usize = 10_000;
+/// 单条目压缩比上限：**声明解压大小 / 该条目自身的压缩字节** 的倍数。
+///
+/// 分母是该条目自己的压缩字节，不是整包体积：整包分母下，一个 10 MiB 的包单条可以声明
+/// 1 GiB 而不触发，这条检查几乎不生效。整包维度的主约束由 `MAX_PACKAGE_BYTES` /
+/// `MAX_FILE_BYTES` / `MAX_EXPANDED_BYTES` 承担。
 pub const MAX_COMPRESSION_RATIO: u64 = 100;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -74,7 +79,7 @@ pub fn validate_release_zip(bytes: &[u8]) -> Result<ReleasePackageManifest, Rele
     let mut expanded_bytes = 0_u64;
     let mut has_entry = false;
     for index in 0..archive.len() {
-        let mut file = archive
+        let file = archive
             .by_index(index)
             .map_err(|_| ReleasePackageError::InvalidArchive)?;
         if file.encrypted() {
@@ -110,12 +115,23 @@ pub fn validate_release_zip(bytes: &[u8]) -> Result<ReleasePackageManifest, Rele
         if expanded_bytes > MAX_EXPANDED_BYTES {
             return Err(ReleasePackageError::ExpandedPackageTooLarge);
         }
-        if declared_size > package_bytes.saturating_mul(MAX_COMPRESSION_RATIO) {
+        if declared_size > file.compressed_size().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)
+        // 读取层按**声明大小**封顶：`take(declared + 1)` 保证这条条目最多产出
+        // `declared + 1` 字节——读满声明值再多 1 字节即判「声明说谎（少报展开大小）」，
+        // 短读（实际不足声明值）同样失败。预分配收紧到单文件硬上限。
+        //
+        // 不变式：单条实际解压内存 ≤ 其声明大小 + 1（声明大小已被 `MAX_FILE_BYTES` 与
+        // `MAX_EXPANDED_BYTES` 夹住），因此整包实际内存被两道上限约束，不会出现
+        // 「声明 1 KiB、实际解压数 GiB」的内存放大。
+        let mut reader = file.take(declared_size.saturating_add(1));
+        let mut content = Vec::with_capacity(
+            usize::try_from(declared_size.min(MAX_FILE_BYTES)).unwrap_or(usize::MAX),
+        );
+        reader
+            .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);
@@ -297,4 +313,54 @@ mod tests {
         assert_eq!(manifest.package_bytes, bytes.len() as u64);
         assert_eq!(manifest.files.len(), 3);
     }
+
+    /// deflate 零内容条目，用于低成本构造规模类用例。
+    fn zeros_archive(path: &str, size: u64) -> Vec<u8> {
+        let mut output = Cursor::new(Vec::new());
+        let mut writer = ZipWriter::new(&mut output);
+        writer
+            .start_file(path, SimpleFileOptions::default())
+            .expect("zip entry");
+        let chunk = vec![0_u8; 1024 * 1024];
+        let mut remaining = size;
+        while remaining > 0 {
+            let take = usize::try_from(remaining.min(chunk.len() as u64)).unwrap_or(chunk.len());
+            writer.write_all(&chunk[..take]).expect("zip content");
+            remaining -= take as u64;
+        }
+        writer.finish().expect("finish zip");
+        output.into_inner()
+    }
+
+    /// 把单条目 zip 声明的解压大小改成 `declared_size`，但不动实际 deflate 数据：
+    /// 构造「声明说谎」的发行包（本地文件头与中央目录项一起改）。
+    fn declared_size_lie_archive(path: &str, actual_size: u64, declared_size: u32) -> Vec<u8> {
+        let mut bytes = zeros_archive(path, actual_size);
+        assert_eq!(&bytes[0..4], b"PK\x03\x04", "local file header");
+        // 本地文件头：… crc(14) + compressed(18) → 解压大小在偏移 22。
+        bytes[22..26].copy_from_slice(&declared_size.to_le_bytes());
+        let central = bytes
+            .windows(4)
+            .position(|window| window == b"PK\x01\x02")
+            .expect("central directory header");
+        // 中央目录项：… crc(16) + compressed(20) → 解压大小在偏移 24。
+        bytes[central + 24..central + 28].copy_from_slice(&declared_size.to_le_bytes());
+        bytes
+    }
+
+    /// P0-b（发行包路径的回归证据）：声明说谎必须在读取层失败关闭，不能先把 deflate
+    /// 流整段解进内存再比对长度。
+    #[test]
+    fn rejects_entries_whose_declared_size_is_a_lie() {
+        let under_report = declared_size_lie_archive("assets/liar.bin", 8 * 1024 * 1024, 1024);
+        assert_eq!(
+            validate_release_zip(&under_report),
+            Err(ReleasePackageError::ReadFailed)
+        );
+        let over_report = declared_size_lie_archive("assets/liar.bin", 4096, 1500);
+        assert_eq!(
+            validate_release_zip(&over_report),
+            Err(ReleasePackageError::ReadFailed)
+        );
+    }
 }
diff --git a/server-rs/crates/module-game-distribution/src/project_bundle.rs b/server-rs/crates/module-game-distribution/src/project_bundle.rs
new file mode 100644
index 000000000..decf5633d
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/project_bundle.rs
@@ -0,0 +1,1038 @@
+use std::{
+    collections::HashSet,
+    io::{Cursor, Read},
+};
+
+use sha2::{Digest, Sha256};
+
+use crate::package::normalize_archive_path;
+
+/// 工程源包（源码包）压缩体积上限。取值与发行包 `MAX_PACKAGE_BYTES` 逐字节一致：
+/// 两者共用同一条上传链路，反代的放行量（Nginx `client_max_body_size`、Pingora
+/// `MAX_API_BODY_BYTES`）就是按 200 MiB 校准的，比这更大的包根本到不了 `api-server`。
+/// 所以这里既不能比发行包更宽（否则要同步放开多处部署配置），也没有理由更严。
+pub const MAX_PROJECT_BUNDLE_BYTES: u64 = 200 * 1024 * 1024;
+/// 展开后总量上限，与发行包同口径（压缩包上限的 2.5 倍）：纯文本 / JSON 占比高的
+/// 源码包压缩比很高，包体小而展开量大，必须留出解压余量。
+pub const MAX_PROJECT_EXPANDED_BYTES: u64 = 500 * 1024 * 1024;
+/// 单文件上限与发行包一致；源码里没有需要突破 64 MiB 的单个文件。
+pub const MAX_PROJECT_FILE_BYTES: u64 = 64 * 1024 * 1024;
+/// 条目数上限与发行包一致；10 000 个文件对任何手写工程都绰绰有余。
+pub const MAX_PROJECT_FILE_COUNT: usize = 10_000;
+/// 单条目压缩比上限：**声明解压大小 / 该条目自身的压缩字节** 的倍数（与发行包同口径）。
+///
+/// 分母必须是该条目自己的压缩字节，不能用整包体积：整包分母下，一个 10 MiB 的包
+/// 单条可以声明 1 GiB 而不触发，这条检查几乎不生效。整包维度的主约束由
+/// `MAX_PROJECT_BUNDLE_BYTES` / `MAX_PROJECT_FILE_BYTES` / `MAX_PROJECT_EXPANDED_BYTES`
+/// 承担，本条只负责拦截同一体积内的异常压缩比。正常源码的压缩比远低于 100 倍。
+pub const MAX_PROJECT_COMPRESSION_RATIO: u64 = 100;
+
+/// 嵌套压缩包头部嗅探读取的字节数：条目改名（`deps.dat` / `deps.bin`）后靠 magic bytes
+/// 兜住，`nested_archive_format` 在这个窗口内判格式。
+const NESTED_ARCHIVE_SNIFF_BYTES: usize = 512;
+
+/// 内容嗅探的文本白名单扩展名（不含点、小写比较）：只对文本型条目做凭据特征扫描。
+///
+/// 刻意不做更宽的前缀启发（例如把 `sk-` 也当密钥）：误报会直接阻断作者发布，
+/// 而 `sk-` 同时也是无害字符串的常见前缀，收益与代价不成比例。宁可漏报未知命名，
+/// 也不让作者为一个正常文件反复试错。
+const SECRET_CONTENT_TEXT_EXTENSIONS: &[&str] = &[
+    "txt", "md", "json", "yml", "yaml", "toml", "ini", "cfg", "conf", "js", "ts", "tsx", "jsx",
+    "py", "rs", "go", "java", "sh", "ps1", "bat", "env",
+];
+/// 内容嗅探的条目大小上限：更大的条目大概率不是配置文件，扫描收益低、误报代价高。
+const SECRET_CONTENT_MAX_SNIFF_BYTES: u64 = 256 * 1024;
+/// 简单子串特征：命中任一即判定疑似凭据（GitHub / Slack token）。
+const SECRET_CONTENT_SIGNATURES: &[&str] = &["ghp_", "github_pat_", "xoxa-", "xoxb-", "xoxp-"];
+/// AWS Access Key ID 的固定前缀：后面必须紧跟 16 位大写字母 / 数字才算命中。
+const SECRET_AWS_ACCESS_KEY_PREFIX: &str = "AKIA";
+/// PEM 私钥块的行首标记：必须与 `PEM_PRIVATE_KEY_MARKER` 出现在同一行才判定。
+const PEM_PRIVATE_KEY_LINE_PREFIX: &str = "-----BEGIN ";
+/// PEM 私钥块的类型标记。
+const PEM_PRIVATE_KEY_MARKER: &str = "PRIVATE KEY-----";
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ProjectBundleFileManifest {
+    pub path: String,
+    pub size_bytes: u64,
+    pub sha256: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ProjectBundleManifest {
+    pub bundle_bytes: u64,
+    pub bundle_sha256: String,
+    pub files: Vec<ProjectBundleFileManifest>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ProjectBundleError {
+    EmptyBundle,
+    BundleTooLarge,
+    InvalidArchive,
+    TooManyFiles,
+    InvalidPath,
+    SymlinkNotAllowed,
+    EncryptedFileNotAllowed,
+    NestedArchiveNotAllowed,
+    DependencyDirectoryNotAllowed,
+    VersionControlDirectoryNotAllowed,
+    LocalStateDirectoryNotAllowed,
+    CredentialDirectoryNotAllowed,
+    BuildArtifactNotAllowed,
+    IdeDirectoryNotAllowed,
+    SensitiveFileNotAllowed,
+    SecretContentDetected,
+    FileTooLarge,
+    ExpandedBundleTooLarge,
+    CompressionRatioTooHigh,
+    ReadFailed,
+}
+
+/// 校验一个工程源包（zip）。规则与发行包不同：**不要求**根 `index.html`，也
+/// **不拒绝** `*.map` 之外的构建目录（只拦根级构建产物），因为这些是源码工程
+/// 的正常组成部分；反过来，源码包必须额外拦掉依赖目录、版本库元数据、AGC 本地
+/// 状态目录与凭据文件。非空且通过全部拒绝清单即返回 manifest。
+pub fn validate_project_bundle_zip(
+    bytes: &[u8],
+) -> Result<ProjectBundleManifest, ProjectBundleError> {
+    if bytes.is_empty() {
+        return Err(ProjectBundleError::EmptyBundle);
+    }
+    let bundle_bytes = u64::try_from(bytes.len()).unwrap_or(u64::MAX);
+    if bundle_bytes > MAX_PROJECT_BUNDLE_BYTES {
+        return Err(ProjectBundleError::BundleTooLarge);
+    }
+
+    let mut archive =
+        zip::ZipArchive::new(Cursor::new(bytes)).map_err(|_| ProjectBundleError::InvalidArchive)?;
+    if archive.len() == 0 {
+        // 只有 EOCD、没有任何条目的 zip 也是空包：源码工程至少得有一个文件。
+        return Err(ProjectBundleError::EmptyBundle);
+    }
+    if archive.len() > MAX_PROJECT_FILE_COUNT {
+        return Err(ProjectBundleError::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;
+    for index in 0..archive.len() {
+        let (path, declared_size, compressed_size, is_dir) = {
+            // `by_index` 对加密条目直接报「需要口令」，拿不到元数据；这里先用
+            // `by_index_raw` 只读头部判掉加密与符号链接，再决定是否解压取内容。
+            let file = archive
+                .by_index_raw(index)
+                .map_err(|_| ProjectBundleError::InvalidArchive)?;
+            if file.encrypted() {
+                return Err(ProjectBundleError::EncryptedFileNotAllowed);
+            }
+            if file.is_symlink() {
+                return Err(ProjectBundleError::SymlinkNotAllowed);
+            }
+            let enclosed = file
+                .enclosed_name()
+                .ok_or(ProjectBundleError::InvalidPath)?;
+            let path =
+                normalize_archive_path(&enclosed).map_err(|_| ProjectBundleError::InvalidPath)?;
+            (path, file.size(), file.compressed_size(), file.is_dir())
+        };
+        // 完全重复或大小写折叠后重复的条目：解包结果取决于解压器的遍历顺序，
+        // 在大小写不敏感的文件系统（Windows / macOS）上还会互相覆盖。
+        if !paths.insert(path.clone()) || !case_folded_paths.insert(path.to_ascii_lowercase()) {
+            return Err(ProjectBundleError::InvalidPath);
+        }
+        reject_forbidden_path(&path)?;
+        if is_dir {
+            continue;
+        }
+        if declared_size > MAX_PROJECT_FILE_BYTES {
+            return Err(ProjectBundleError::FileTooLarge);
+        }
+        expanded_bytes = expanded_bytes.saturating_add(declared_size);
+        if expanded_bytes > MAX_PROJECT_EXPANDED_BYTES {
+            return Err(ProjectBundleError::ExpandedBundleTooLarge);
+        }
+        if declared_size > compressed_size.saturating_mul(MAX_PROJECT_COMPRESSION_RATIO) {
+            return Err(ProjectBundleError::CompressionRatioTooHigh);
+        }
+
+        // 读取层按**声明大小**封顶：`take(declared + 1)` 保证这条条目最多产出
+        // `declared + 1` 字节——读满声明值再多 1 字节即判「声明说谎（少报展开大小）」，
+        // 短读（实际不足声明值）同样失败。预分配也收紧到单文件硬上限。
+        //
+        // 不变式：单条实际解压内存 ≤ 其声明大小 + 1（声明大小已被 `MAX_PROJECT_FILE_BYTES`
+        // 与 `MAX_PROJECT_EXPANDED_BYTES` 两道上限夹住），因此整包实际内存被两道上限约束，
+        // 不会出现「声明 1 KiB、实际解压数 GiB」的内存放大。
+        let mut reader = archive
+            .by_index(index)
+            .map_err(|_| ProjectBundleError::InvalidArchive)?
+            .take(declared_size.saturating_add(1));
+        let mut content = Vec::with_capacity(
+            usize::try_from(declared_size.min(MAX_PROJECT_FILE_BYTES)).unwrap_or(usize::MAX),
+        );
+        reader
+            .read_to_end(&mut content)
+            .map_err(|_| ProjectBundleError::ReadFailed)?;
+        if u64::try_from(content.len()).unwrap_or(u64::MAX) != declared_size {
+            return Err(ProjectBundleError::ReadFailed);
+        }
+        // 嵌套压缩包：扩展名并集已在上面的拒绝清单里拦过一轮，这里按**头部字节**兜住
+        // 改名（`deps.dat` / `deps.bin` 里装的是 zip / 7z / rar / gzip / tar 一样要拒）。
+        // 判的是**解压后**的内容（`by_index_raw` 返回的是压缩流，不能用来嗅探格式）。
+        if declared_size > 0 && nested_archive_format(&content).is_some() {
+            return Err(ProjectBundleError::NestedArchiveNotAllowed);
+        }
+        // 凭据内容嗅探：只扫「文本型且不大」的条目，命中已知凭据特征即拒。
+        if is_secret_content_candidate(&path, declared_size)
+            && secret_content_signature(&content).is_some()
+        {
+            return Err(ProjectBundleError::SecretContentDetected);
+        }
+        files.push(ProjectBundleFileManifest {
+            path,
+            size_bytes: declared_size,
+            sha256: hex::encode(Sha256::digest(&content)),
+        });
+    }
+
+    let bundle_digest = Sha256::digest(bytes);
+    Ok(ProjectBundleManifest {
+        bundle_bytes,
+        bundle_sha256: hex::encode(bundle_digest),
+        files,
+    })
+}
+
+/// 拒绝清单里与体积无关的部分：依赖 / 版本库 / 本地状态 / 构建产物 / IDE / 凭据。
+fn reject_forbidden_path(path: &str) -> Result<(), ProjectBundleError> {
+    let mut root = "";
+    let mut is_first = true;
+    let mut has_dependency_dir = false;
+    let mut has_version_control_dir = false;
+    let mut has_local_state_dir = false;
+    let mut has_credential_dir = false;
+    for part in path.split('/') {
+        if is_first {
+            root = part;
+            is_first = false;
+        }
+        has_dependency_dir |= part.eq_ignore_ascii_case("node_modules");
+        has_version_control_dir |=
+            part.eq_ignore_ascii_case(".git") || part.eq_ignore_ascii_case(".svn");
+        has_local_state_dir |= part.eq_ignore_ascii_case(".agent");
+        has_credential_dir |= part.eq_ignore_ascii_case(".aws")
+            || part.eq_ignore_ascii_case(".ssh")
+            || part.eq_ignore_ascii_case(".kube")
+            || part.eq_ignore_ascii_case(".docker")
+            || part.eq_ignore_ascii_case(".gnupg")
+            || part.eq_ignore_ascii_case(".terraform")
+            || part.eq_ignore_ascii_case(".secrets");
+    }
+
+    // 依赖目录出现在任意层级都拒绝：它是安装产物，体积大且可由 package.json 还原，
+    // 随包外发只会污染下一手工程，也拖垮上传与解包。
+    if has_dependency_dir {
+        return Err(ProjectBundleError::DependencyDirectoryNotAllowed);
+    }
+    // 版本库元数据（.git / .svn）带上会泄漏提交历史、分支名与远端地址。
+    if has_version_control_dir {
+        return Err(ProjectBundleError::VersionControlDirectoryNotAllowed);
+    }
+    // AGC 的本地状态目录（.agent）记录着本作品的改编来源与本地会话信息，随包外发
+    // 会把上一个作者的工作痕迹带给下一个使用者。
+    if has_local_state_dir {
+        return Err(ProjectBundleError::LocalStateDirectoryNotAllowed);
+    }
+    // 凭据目录（任意层级）：家庭目录下的 `.aws` / `.ssh` / `.kube` / `.docker` / `.gnupg`
+    // / `.terraform` / `.secrets` 装的是长期凭据、集群配置、注册表凭证、私钥环与
+    // Terraform 状态（可能含明文 secret），随包外发即不可撤销的泄漏。
+    if has_credential_dir {
+        return Err(ProjectBundleError::CredentialDirectoryNotAllowed);
+    }
+
+    // 构建产物与 IDE 只拦**根级**：根 dist / build / library / temp / local 是
+    // 构建输出（与模板包同规则），子目录里的 dist/ 是工程自己的目录布局，必须允许。
+    const ROOT_BUILD_DIRS: [&str; 5] = ["dist", "build", "library", "temp", "local"];
+    if ROOT_BUILD_DIRS
+        .iter()
+        .any(|name| root.eq_ignore_ascii_case(name))
+    {
+        return Err(ProjectBundleError::BuildArtifactNotAllowed);
+    }
+    const ROOT_IDE_DIRS: [&str; 2] = [".idea", ".vscode"];
+    if ROOT_IDE_DIRS
+        .iter()
+        .any(|name| root.eq_ignore_ascii_case(name))
+    {
+        return Err(ProjectBundleError::IdeDirectoryNotAllowed);
+    }
+
+    // 凭据与隐私按**文件名**判定（任意层级）：这些文件一旦外发就是不可撤销的泄漏。
+    // 大小写折叠后再比：包也会被大小写不敏感的文件系统解包，`.ENV` 与 `.env` 等价。
+    let file_name = path.rsplit('/').next().unwrap_or(path).to_ascii_lowercase();
+    if is_sensitive_file_name(&file_name) {
+        return Err(ProjectBundleError::SensitiveFileNotAllowed);
+    }
+    // 嵌套压缩包（扩展名并集）：解包阶段不会递归校验包里的包，等于绕过整份拒绝清单。
+    // `.tar.gz` 由 `.gz` 覆盖；改名成 `.dat` / `.bin` 之类的由头部字节嗅探兜住
+    // （见 `nested_archive_format`）。这里刻意用逐条 `ends_with("…")`：一致性门禁
+    // （`scripts/check-project-bundle-policy-parity.mjs`）就是按这个调用形状抓 token 的。
+    if file_name.ends_with(".zip")
+        || file_name.ends_with(".tar")
+        || file_name.ends_with(".gz")
+        || file_name.ends_with(".tgz")
+        || file_name.ends_with(".7z")
+        || file_name.ends_with(".rar")
+        || file_name.ends_with(".jar")
+        || file_name.ends_with(".whl")
+        || file_name.ends_with(".nupkg")
+    {
+        return Err(ProjectBundleError::NestedArchiveNotAllowed);
+    }
+    Ok(())
+}
+
+fn is_sensitive_file_name(name: &str) -> bool {
+    name.starts_with(".env") // .env / .env.local / .env.production …
+        || name.starts_with("credentials") // ~/.aws/credentials、credentials.json …
+        || name.starts_with("id_rsa")
+        || name.starts_with("id_ecdsa")
+        || name.starts_with("id_dsa")
+        || name.starts_with("id_ed25519")
+        || name.starts_with("terraform.tfstate") // terraform.tfstate / .tfstate.backup
+        || name.starts_with("service-account") // service-account.json …
+        || name.ends_with(".pem")
+        || name.ends_with(".key")
+        || name.ends_with(".p12")
+        || name.ends_with(".pfx")
+        || name.ends_with(".jks")
+        || name.ends_with(".keystore")
+        || name.ends_with(".ppk")
+        || name.ends_with(".p8")
+        || name.ends_with(".kdbx")
+        || name.ends_with(".der")
+        || name == ".htpasswd"
+        || name == ".pgpass"
+        || name == ".npmrc"
+        || name == ".netrc"
+        || name == ".git-credentials"
+        || name.ends_with(".map") // 源码映射会暴露原始源码与路径
+}
+
+/// 嵌套压缩包头部嗅探：从条目内容的头 512 字节判已知归档格式，返回格式名。
+///
+/// 只在按扩展名拦不住时才有意义（条目被改名成 `deps.dat` 之类），所以判的是**内容**
+/// 而不是文件名。`PK\x03\x04` 是 zip 的本地文件头；7z / rar 用各自 magic；
+/// gzip 是 `\x1f\x8b`；tar 在偏移 257 处写 `ustar`。
+fn nested_archive_format(content: &[u8]) -> Option<&'static str> {
+    let head = &content[..content.len().min(NESTED_ARCHIVE_SNIFF_BYTES)];
+    if head.starts_with(b"PK\x03\x04") {
+        return Some("zip");
+    }
+    if head.starts_with(b"7z\xBC\xAF\x27\x1C") {
+        return Some("7z");
+    }
+    if head.starts_with(b"Rar!\x1A\x07") {
+        return Some("rar");
+    }
+    if head.starts_with(b"\x1F\x8B") {
+        return Some("gzip");
+    }
+    if head.len() >= 262 && &head[257..262] == b"ustar" {
+        return Some("tar");
+    }
+    None
+}
+
+/// 是否值得做凭据内容嗅探：非空、声明大小 ≤ 256 KiB，且扩展名属于文本白名单
+/// （**无扩展名也算文本**——`credentials`、`config` 这类凭据文件常常没有扩展名）。
+fn is_secret_content_candidate(path: &str, declared_size: u64) -> bool {
+    if declared_size == 0 || declared_size > SECRET_CONTENT_MAX_SNIFF_BYTES {
+        return false;
+    }
+    let name = path.rsplit('/').next().unwrap_or(path);
+    let extension = match name.rfind('.') {
+        Some(index) if index > 0 && index + 1 < name.len() => &name[index + 1..],
+        _ => return true,
+    };
+    SECRET_CONTENT_TEXT_EXTENSIONS
+        .iter()
+        .any(|allowed| extension.eq_ignore_ascii_case(allowed))
+}
+
+/// 凭据内容嗅探：命中任一已知特征就返回该特征的说明。
+///
+/// 只做**低误报**的强特征；刻意不把 `sk-` 之类的前缀算进来（见 `SECRET_CONTENT_TEXT_EXTENSIONS`
+/// 上的口径说明）。返回说明串是为了让客户端能点名命中了哪条特征。
+fn secret_content_signature(content: &[u8]) -> Option<&'static str> {
+    if pem_private_key_detected(content) {
+        return Some("PEM 私钥块");
+    }
+    if aws_access_key_id_detected(content) {
+        return Some("AWS Access Key ID");
+    }
+    if SECRET_CONTENT_SIGNATURES
+        .iter()
+        .any(|signature| contains_bytes(content, signature.as_bytes()))
+    {
+        return Some("GitHub / Slack token");
+    }
+    None
+}
+
+/// PEM 私钥块：行首标记与私钥类型标记出现在**同一行**（证书块不会带 `PRIVATE KEY-----`）。
+fn pem_private_key_detected(content: &[u8]) -> bool {
+    content.split(|byte| *byte == b'\n').any(|line| {
+        contains_bytes(line, PEM_PRIVATE_KEY_LINE_PREFIX.as_bytes())
+            && contains_bytes(line, PEM_PRIVATE_KEY_MARKER.as_bytes())
+    })
+}
+
+/// AWS Access Key ID：`AKIA` 后紧跟 16 位大写字母或数字。
+fn aws_access_key_id_detected(content: &[u8]) -> bool {
+    let prefix = SECRET_AWS_ACCESS_KEY_PREFIX.as_bytes();
+    content
+        .windows(prefix.len())
+        .enumerate()
+        .any(|(index, window)| {
+            window == prefix
+                && content
+                    .get(index + prefix.len()..index + prefix.len() + 16)
+                    .is_some_and(|tail| {
+                        tail.iter()
+                            .all(|byte| byte.is_ascii_uppercase() || byte.is_ascii_digit())
+                    })
+        })
+}
+
+/// `haystack` 是否包含 `needle`（不引入正则依赖的等价实现）。
+fn contains_bytes(haystack: &[u8], needle: &[u8]) -> bool {
+    !needle.is_empty()
+        && haystack
+            .windows(needle.len())
+            .any(|window| window == needle)
+}
+
+#[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()
+    }
+
+    /// 用 deflate 逐块写入「声明体积很大、内容全为零」的文件：包体极小（零的压缩比
+    /// 极高），但中央目录里的解压后声明大小是真实的，用来低成本触达规模类检查。
+    fn zeros_archive(entries: &[(&str, u64)]) -> Vec<u8> {
+        let mut output = Cursor::new(Vec::new());
+        let mut writer = ZipWriter::new(&mut output);
+        let chunk = vec![0_u8; 1024 * 1024];
+        for (path, size) in entries {
+            writer
+                .start_file(*path, SimpleFileOptions::default())
+                .expect("zip entry");
+            let mut remaining = *size;
+            while remaining > 0 {
+                let take =
+                    usize::try_from(remaining.min(chunk.len() as u64)).unwrap_or(chunk.len());
+                writer.write_all(&chunk[..take]).expect("zip content");
+                remaining -= take as u64;
+            }
+        }
+        writer.finish().expect("finish zip");
+        output.into_inner()
+    }
+
+    /// 存储型（不压缩）大包：用于触达包体上限；预留容量避免 Vec 扩容时双倍占用。
+    fn stored_zeros_archive(path: &str, size: u64) -> Vec<u8> {
+        let mut output = Cursor::new(Vec::with_capacity(
+            usize::try_from(size).unwrap_or(0).saturating_add(4096),
+        ));
+        let mut writer = ZipWriter::new(&mut output);
+        writer
+            .start_file(
+                path,
+                SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored),
+            )
+            .expect("zip entry");
+        let chunk = vec![0_u8; 1024 * 1024];
+        let mut remaining = size;
+        while remaining > 0 {
+            let take = usize::try_from(remaining.min(chunk.len() as u64)).unwrap_or(chunk.len());
+            writer.write_all(&chunk[..take]).expect("zip content");
+            remaining -= take as u64;
+        }
+        writer.finish().expect("finish zip");
+        output.into_inner()
+    }
+
+    /// 手工给单条目 zip 打上「加密」标志位：zip crate 的写入端产不出加密条目
+    /// （需要 `aes-crypto` / ZipCrypto 特性），而校验器只看头部元数据、不解密，
+    /// 直接把通用位标记的 bit 0 置上即可覆盖这条拒绝分支。
+    fn encrypted_archive(path: &str, content: &[u8]) -> Vec<u8> {
+        let mut bytes = archive(&[(path, content)]);
+        assert_eq!(&bytes[0..4], b"PK\x03\x04", "local file header");
+        // 本地文件头：magic(4) + version needed(2) + general purpose flag(2)
+        bytes[6] |= 0b1;
+        // 中央目录项：magic(4) + version made by(2) + version needed(2) + flag(2)
+        let central = bytes
+            .windows(4)
+            .position(|window| window == b"PK\x01\x02")
+            .expect("central directory header");
+        bytes[central + 8] |= 0b1;
+        bytes
+    }
+
+    /// xorshift64：测试里不需要密码学强度，只要不可压缩（deflate 基本压不动）。
+    fn incompressible_bytes(len: usize) -> Vec<u8> {
+        let mut state = 0x9E37_79B9_7F4A_7C15_u64;
+        let mut output = Vec::with_capacity(len);
+        while output.len() < len {
+            state ^= state << 13;
+            state ^= state >> 7;
+            state ^= state << 17;
+            output.extend_from_slice(&state.to_le_bytes());
+        }
+        output.truncate(len);
+        output
+    }
+
+    #[test]
+    fn accepts_source_bundle_without_index_html() {
+        let bytes = archive(&[
+            ("package.json", br#"{"name":"demo"}"#),
+            ("vite.config.ts", b"export default {}"),
+            ("src/main.ts", b"console.log(1)"),
+            ("public/logo.png", b"\x89PNG\r\n\x1a\n"),
+        ]);
+        let manifest = validate_project_bundle_zip(&bytes).expect("valid source bundle");
+        // 源码包不要求根 index.html：上面这四个文件里故意没有它。
+        assert_eq!(manifest.bundle_bytes, bytes.len() as u64);
+        assert_eq!(manifest.bundle_sha256, hex::encode(Sha256::digest(&bytes)));
+        assert_eq!(
+            manifest
+                .files
+                .iter()
+                .map(|file| file.path.as_str())
+                .collect::<Vec<_>>(),
+            vec![
+                "package.json",
+                "vite.config.ts",
+                "src/main.ts",
+                "public/logo.png"
+            ]
+        );
+        assert!(manifest.files.iter().all(|file| file.path != "index.html"));
+        assert_eq!(manifest.files[0].size_bytes, 15);
+        assert_eq!(
+            manifest.files[0].sha256,
+            hex::encode(Sha256::digest(br#"{"name":"demo"}"#))
+        );
+    }
+
+    #[test]
+    fn rejects_empty_and_non_zip_input() {
+        assert_eq!(
+            validate_project_bundle_zip(&[]),
+            Err(ProjectBundleError::EmptyBundle)
+        );
+        assert_eq!(
+            validate_project_bundle_zip(b"definitely not a zip"),
+            Err(ProjectBundleError::InvalidArchive)
+        );
+        // 只有 EOCD、零条目的 zip 同样是空包。
+        assert_eq!(
+            validate_project_bundle_zip(&archive(&[])),
+            Err(ProjectBundleError::EmptyBundle)
+        );
+    }
+
+    /// 201 MiB 存储型单条目：包体一旦越过 200 MiB 就必须在解析条目前被拒。
+    #[test]
+    fn rejects_bundle_over_size_limit() {
+        let bytes = stored_zeros_archive("src/big.bin", 201 * 1024 * 1024);
+        assert!(bytes.len() as u64 > MAX_PROJECT_BUNDLE_BYTES);
+        assert_eq!(
+            validate_project_bundle_zip(&bytes),
+            Err(ProjectBundleError::BundleTooLarge)
+        );
+    }
+
+    #[test]
+    fn rejects_too_many_entries() {
+        let mut output = Cursor::new(Vec::new());
+        let mut writer = ZipWriter::new(&mut output);
+        for index in 0..MAX_PROJECT_FILE_COUNT + 1 {
+            writer
+                .start_file(
+                    format!("src/module_{index}.ts"),
+                    SimpleFileOptions::default(),
+                )
+                .expect("zip entry");
+            writer.write_all(b"export {};").expect("zip content");
+        }
+        writer.finish().expect("finish zip");
+        assert_eq!(
+            validate_project_bundle_zip(&output.into_inner()),
+            Err(ProjectBundleError::TooManyFiles)
+        );
+    }
+
+    #[test]
+    fn rejects_unsafe_and_duplicate_paths() {
+        for unsafe_path in [
+            "../escape.txt",
+            "/etc/passwd",
+            "src\\main.ts",
+            "src/*.ts",
+            "C:/evil.txt",
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[
+                    ("package.json", b"x"),
+                    (unsafe_path, b"x")
+                ])),
+                Err(ProjectBundleError::InvalidPath),
+                "path {unsafe_path:?} must be rejected"
+            );
+        }
+        // 逐字节同名的两条会被 zip crate 的中央目录索引合并（同名后写覆盖），校验器
+        // 根本看不到第二条；这里覆盖的是「归一化后同名」的重复：目录条目
+        // `src/main.ts/` 归一化后与文件 `src/main.ts` 完全相同。
+        let mut duplicate_output = Cursor::new(Vec::new());
+        {
+            let mut writer = ZipWriter::new(&mut duplicate_output);
+            writer
+                .start_file("src/main.ts", SimpleFileOptions::default())
+                .expect("zip entry");
+            writer.write_all(b"a").expect("zip content");
+            writer
+                .add_directory("src/main.ts/", SimpleFileOptions::default())
+                .expect("zip dir entry");
+            writer.finish().expect("finish zip");
+        }
+        assert_eq!(
+            validate_project_bundle_zip(&duplicate_output.into_inner()),
+            Err(ProjectBundleError::InvalidPath)
+        );
+        let case_folded_duplicate = archive(&[("src/main.ts", b"a"), ("SRC/Main.ts", b"b")]);
+        assert_eq!(
+            validate_project_bundle_zip(&case_folded_duplicate),
+            Err(ProjectBundleError::InvalidPath)
+        );
+    }
+
+    /// 符号链接条目必须整体拒绝：解包器不能跟随链接把内容写到包外。
+    #[test]
+    fn rejects_symlink_entries() {
+        let mut output = Cursor::new(Vec::new());
+        {
+            let mut writer = ZipWriter::new(&mut output);
+            writer
+                .start_file(
+                    "package.json",
+                    SimpleFileOptions::default().unix_permissions(0o644),
+                )
+                .expect("entry");
+            writer.write_all(b"{}").expect("content");
+            // 只能用 `add_symlink`：`unix_permissions` 会把 mode 掩成 `0o777`，
+            // 正常写入路径补的是 `S_IFREG`，造不出 `S_IFLNK` 条目。
+            writer
+                .add_symlink("escape", "/tmp", SimpleFileOptions::default())
+                .expect("symlink entry");
+            writer.finish().expect("finish zip");
+        }
+        assert_eq!(
+            validate_project_bundle_zip(&output.into_inner()),
+            Err(ProjectBundleError::SymlinkNotAllowed)
+        );
+    }
+
+    #[test]
+    fn rejects_encrypted_entries() {
+        let bytes = encrypted_archive("src/main.ts", b"console.log(1)");
+        assert_eq!(
+            validate_project_bundle_zip(&bytes),
+            Err(ProjectBundleError::EncryptedFileNotAllowed)
+        );
+    }
+
+    #[test]
+    fn rejects_nested_archives_by_extension_union_and_magic_bytes() {
+        // 扩展名并集：`.tar.gz` 由 `.gz` 覆盖。
+        for path in [
+            "artist/vendor.zip",
+            "artist/vendor.tar",
+            "artist/vendor.gz",
+            "artist/vendor.tgz",
+            "artist/vendor.7z",
+            "artist/vendor.rar",
+            "artist/vendor.jar",
+            "artist/vendor.whl",
+            "artist/vendor.nupkg",
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::NestedArchiveNotAllowed),
+                "path {path:?} must be rejected"
+            );
+        }
+
+        // 改名后靠头部字节命中：内层内容是真正的归档格式，扩展名却看不出来。
+        let inner_zip = archive(&[("inner.txt", b"x")]);
+        assert_eq!(
+            validate_project_bundle_zip(&archive(&[
+                ("package.json", b"{}"),
+                ("src/deps.dat", &inner_zip)
+            ])),
+            Err(ProjectBundleError::NestedArchiveNotAllowed)
+        );
+        let mut tar = vec![0_u8; 512];
+        tar[257..262].copy_from_slice(b"ustar");
+        for (name, content) in [
+            ("src/deps.bin", b"\x1F\x8B\x08\x00payload".as_slice()),
+            ("src/deps.bin", b"7z\xBC\xAF\x27\x1Cpayload".as_slice()),
+            ("src/deps.bin", b"Rar!\x1A\x07\x00payload".as_slice()),
+            ("src/deps.bin", tar.as_slice()),
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (name, content)])),
+                Err(ProjectBundleError::NestedArchiveNotAllowed),
+                "magic bytes for {name:?} must be rejected"
+            );
+        }
+
+        // 正常文件不误报：png 头、文本、空文件都要放行。
+        let ok = archive(&[
+            ("package.json", b"{}"),
+            ("src/main.ts", b"export {};"),
+            ("assets/logo.png", b"\x89PNG\r\n\x1a\nrest"),
+            ("assets/empty.bin", b""),
+        ]);
+        assert!(validate_project_bundle_zip(&ok).is_ok());
+    }
+
+    #[test]
+    fn rejects_dependency_and_vcs_and_local_state_directories() {
+        // 依赖目录：任意层级都拒绝。
+        for path in [
+            "node_modules/lodash/index.js",
+            "src/deep/node_modules/pkg/x.js",
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::DependencyDirectoryNotAllowed),
+                "path {path:?}"
+            );
+        }
+        // 版本库元数据：任意层级都拒绝。
+        for path in [".git/HEAD", "src/.svn/entries"] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::VersionControlDirectoryNotAllowed),
+                "path {path:?}"
+            );
+        }
+        // AGC 本地状态：任意层级都拒绝。
+        for path in [".agent/session.json", "src/deep/.agent/state.json"] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::LocalStateDirectoryNotAllowed),
+                "path {path:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_root_build_and_ide_directories_but_allows_nested_ones() {
+        for path in [
+            "dist/main.js",
+            "build/out.js",
+            "library/chunk.js",
+            "temp/scratch.ts",
+            "local/notes.md",
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::BuildArtifactNotAllowed),
+                "path {path:?}"
+            );
+        }
+        for path in [".idea/workspace.xml", ".vscode/settings.json"] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::IdeDirectoryNotAllowed),
+                "path {path:?}"
+            );
+        }
+        // 反例：子目录里的 dist/ / build/ 是工程自己的布局，必须放行；
+        // 根级但名字只是前缀（build.ts）的文件也不是构建目录。
+        let nested = archive(&[
+            ("package.json", b"{}"),
+            ("src/dist/main.js", b"x"),
+            ("packages/app/build/index.js", b"x"),
+            ("build.ts", b"export {}"),
+        ]);
+        let manifest = validate_project_bundle_zip(&nested).expect("nested dist allowed");
+        assert_eq!(manifest.files.len(), 4);
+    }
+
+    #[test]
+    fn rejects_sensitive_files_at_any_level() {
+        for path in [
+            ".env",
+            ".env.production",
+            "config/server.pem",
+            "certs/tls.key",
+            "certs/keystore.p12",
+            "certs/app.pfx",
+            ".npmrc",
+            ".netrc",
+            ".git-credentials",
+            "deploy/id_rsa",
+            "deploy/id_ed25519.pub",
+            "public/app.js.map",
+            // P0-a：更多 SSH / 云凭据文件名（不落在凭据目录里，走的是文件名判定）。
+            "deploy/id_ecdsa",
+            "deploy/id_dsa",
+            "deploy/credentials",
+            "deploy/credentials.json",
+            "ci/service-account.json",
+            "infra/terraform.tfstate",
+            "infra/terraform.tfstate.backup",
+            "certs/truststore.jks",
+            "certs/app.keystore",
+            "deploy/key.ppk",
+            "apple/AuthKey.p8",
+            "db/passwords.kdbx",
+            "certs/ca.der",
+            ".htpasswd",
+            ".pgpass",
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::SensitiveFileNotAllowed),
+                "path {path:?} must be rejected"
+            );
+        }
+    }
+
+    /// P0-a：凭据目录出现在任意层级都拒（家庭目录里那些装长期凭据的目录）。
+    #[test]
+    fn rejects_credential_directories_at_any_level() {
+        for path in [
+            ".aws/config",
+            ".ssh/known_hosts",
+            ".kube/config",
+            ".docker/config.json",
+            ".gnupg/pubring.kbx",
+            ".terraform/plugins.json",
+            ".secrets/vault.json",
+            // 任意层级 + 大小写折叠。
+            "game/nested/.AWS/config",
+            ".SSH/known_hosts",
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, b"x")])),
+                Err(ProjectBundleError::CredentialDirectoryNotAllowed),
+                "path {path:?} must be rejected"
+            );
+        }
+        // 反例：名字只是前缀的普通目录 / 文件必须放行。
+        let ok = archive(&[
+            ("package.json", b"{}"),
+            ("src/.sshrc", b"x"),
+            ("docker/Dockerfile", b"FROM scratch"),
+        ]);
+        assert!(validate_project_bundle_zip(&ok).is_ok());
+    }
+
+    /// P0-a：文本型小文件里的已知凭据特征必须拒；同时验证误报防线
+    /// （证书块、长度不足的 `AKIA`、二进制扩展名都不拦）。
+    #[test]
+    fn rejects_secret_content_only_in_small_text_files() {
+        let private_key = b"-----BEGIN RSA PRIVATE KEY-----\nMIIB\n";
+        let aws = b"aws_access_key_id = AKIAIOSFODNN7EXAMPLE\n";
+        let github = b"token: ghp_0123456789abcdefghijklmnopqrstuvwx\n";
+        let slack = b"SLACK_TOKEN=xoxb-123456789012-abcdefghijklmnop\n";
+        for (path, content) in [
+            ("deploy/seed.txt", private_key.as_slice()),
+            ("config/aws.json", aws.as_slice()),
+            ("ci/upload.yml", github.as_slice()),
+            ("src/notify.ts", slack.as_slice()),
+            // 无扩展名的凭据文件（`~/.aws/credentials` 之外的手工命名）也要扫。
+            ("deploy/production-secret", aws.as_slice()),
+        ] {
+            assert_eq!(
+                validate_project_bundle_zip(&archive(&[("package.json", b"{}"), (path, content)])),
+                Err(ProjectBundleError::SecretContentDetected),
+                "path {path:?} must be rejected"
+            );
+        }
+
+        // 误报防线：证书块不是私钥；`AKIA` 后不足 16 位；二进制扩展名不做内容扫描
+        // （宁可漏报也不阻断作者发布，见 `SECRET_CONTENT_TEXT_EXTENSIONS` 的口径）。
+        let ok = archive(&[
+            ("package.json", b"{}"),
+            ("docs/cert.txt", b"-----BEGIN CERTIFICATE-----\nMIIB\n"),
+            (
+                "src/notes.md",
+                b"AKIA-SHORT\nBEGIN without private key marker\n",
+            ),
+            ("assets/logo.png", aws.as_slice()),
+        ]);
+        assert!(validate_project_bundle_zip(&ok).is_ok());
+    }
+
+    /// 每条目 = 1 MiB 不可压缩压舱石 + 其余零内容：deflate 后压缩字节约 1 MiB，
+    /// 保证「声明大小 ≤ 该条目压缩字节 × 100」这条**按条目**判定时不会先触发
+    /// （压缩比分母改成单条目压缩字节后，纯零内容的条目会先撞压缩比）。
+    fn ballasted_zeros_archive(entries: &[(&str, u64)]) -> Vec<u8> {
+        let mut output = Cursor::new(Vec::new());
+        let mut writer = ZipWriter::new(&mut output);
+        let zeros = vec![0_u8; 1024 * 1024];
+        for (path, size) in entries {
+            writer
+                .start_file(*path, SimpleFileOptions::default())
+                .expect("zip entry");
+            let ballast = incompressible_bytes(1024 * 1024);
+            writer.write_all(&ballast).expect("zip content");
+            let mut remaining = size - ballast.len() as u64;
+            while remaining > 0 {
+                let take =
+                    usize::try_from(remaining.min(zeros.len() as u64)).unwrap_or(zeros.len());
+                writer.write_all(&zeros[..take]).expect("zip content");
+                remaining -= take as u64;
+            }
+        }
+        writer.finish().expect("finish zip");
+        output.into_inner()
+    }
+
+    /// 手工把单条目 zip 声明的解压大小改成 `declared_size`，但不动实际 deflate 数据：
+    /// 构造「声明说谎」的包（本地文件头与中央目录项一起改，模拟攻击者完全控制文件）。
+    fn declared_size_lie_archive(path: &str, actual_size: u64, declared_size: u32) -> Vec<u8> {
+        let mut bytes = zeros_archive(&[(path, actual_size)]);
+        assert_eq!(&bytes[0..4], b"PK\x03\x04", "local file header");
+        // 本地文件头：magic(4) + version(2) + flags(2) + method(2) + time(2) + date(2)
+        // + crc(4) + compressed(4) → 解压大小在偏移 22。
+        bytes[22..26].copy_from_slice(&declared_size.to_le_bytes());
+        let central = bytes
+            .windows(4)
+            .position(|window| window == b"PK\x01\x02")
+            .expect("central directory header");
+        // 中央目录项：crc(16) + compressed(20) → 解压大小在偏移 24。
+        bytes[central + 24..central + 28].copy_from_slice(&declared_size.to_le_bytes());
+        bytes
+    }
+
+    #[test]
+    fn rejects_oversized_single_file() {
+        // 65 MiB 零内容 deflate 后包体很小，但中央目录声明了真实解压大小。
+        let bytes = zeros_archive(&[("src/big.bin", 65 * 1024 * 1024)]);
+        assert_eq!(
+            validate_project_bundle_zip(&bytes),
+            Err(ProjectBundleError::FileTooLarge)
+        );
+    }
+
+    #[test]
+    fn rejects_excessive_expanded_size() {
+        // 每文件声明 63 MiB（未越单文件上限），累计第 8 个越过 500 MiB 展开上限。
+        // 每条目自带压舱石，保证不会先撞上「按条目压缩字节」判定的压缩比检查。
+        let bytes = ballasted_zeros_archive(&[
+            ("src/blob_0.ts", 63 * 1024 * 1024),
+            ("src/blob_1.ts", 63 * 1024 * 1024),
+            ("src/blob_2.ts", 63 * 1024 * 1024),
+            ("src/blob_3.ts", 63 * 1024 * 1024),
+            ("src/blob_4.ts", 63 * 1024 * 1024),
+            ("src/blob_5.ts", 63 * 1024 * 1024),
+            ("src/blob_6.ts", 63 * 1024 * 1024),
+            ("src/blob_7.ts", 63 * 1024 * 1024),
+        ]);
+        assert_eq!(
+            validate_project_bundle_zip(&bytes),
+            Err(ProjectBundleError::ExpandedBundleTooLarge)
+        );
+    }
+
+    #[test]
+    fn rejects_excessive_compression_ratio() {
+        // 分母是**该条目的压缩字节**：1 MiB 零内容 deflate 成 1 KB 上下，声明大小远超
+        // 自身压缩字节的 100 倍（整包分母下这条几乎不生效，见常量注释）。
+        let bytes = zeros_archive(&[("src/bomb.bin", 1024 * 1024)]);
+        assert_eq!(
+            validate_project_bundle_zip(&bytes),
+            Err(ProjectBundleError::CompressionRatioTooHigh)
+        );
+    }
+
+    /// P0-b：声明说谎（少报展开大小）必须在**读取这一层**失败关闭，而不是把 deflate
+    /// 流整段解进内存之后才比对长度——那正是服务端内存放大的来源。
+    #[test]
+    fn rejects_entries_whose_declared_size_is_a_lie() {
+        // 实际 8 MiB 的零内容 deflate 成几 KB，中央目录却声明 1 KiB：
+        // 旧写法会先把 8 MiB 解出来（Vec 反复扩容）再比对；新写法 `take(declare + 1)`
+        // 读到 1025 字节立刻判「多读 1 字节即溢出」。
+        let under_report = declared_size_lie_archive("src/liar.dat", 8 * 1024 * 1024, 1024);
+        assert_eq!(
+            validate_project_bundle_zip(&under_report),
+            Err(ProjectBundleError::ReadFailed)
+        );
+        // 反向（多报）：实际 4 KiB、声明 1500 字节，读取在声明值处截断后长度不符，同样失败。
+        let over_report = declared_size_lie_archive("src/liar.dat", 4096, 1500);
+        assert_eq!(
+            validate_project_bundle_zip(&over_report),
+            Err(ProjectBundleError::ReadFailed)
+        );
+    }
+
+    /// 数据区损坏（中央目录与声明大小都正常，只有 deflate 流本身是垃圾）时必须在
+    /// 解压阶段报 `ReadFailed`，而不是 panic 或静默产出错误清单。
+    #[test]
+    fn reports_read_failure_for_corrupt_entry_data() {
+        let mut bytes = archive(&[("package.json", b"{\"name\":\"demo\"}")]);
+        let name_len = usize::from(u16::from_le_bytes([bytes[26], bytes[27]]));
+        let extra_len = usize::from(u16::from_le_bytes([bytes[28], bytes[29]]));
+        let data_start = 30 + name_len + extra_len;
+        for byte in &mut bytes[data_start..data_start + 8] {
+            *byte = 0xFF;
+        }
+        assert_eq!(
+            validate_project_bundle_zip(&bytes),
+            Err(ProjectBundleError::ReadFailed)
+        );
+    }
+
+    /// 口径钉住：工程源包与发行包共用同一条上传链路，五项限值必须逐字节一致。
+    /// 反代放行量按 200 MiB 校准，任何一侧单独调整都会让合法包在到达服务前被拒。
+    #[test]
+    fn pins_limits_to_release_package_limits() {
+        assert_eq!(MAX_PROJECT_BUNDLE_BYTES, crate::package::MAX_PACKAGE_BYTES);
+        assert_eq!(
+            MAX_PROJECT_EXPANDED_BYTES,
+            crate::package::MAX_EXPANDED_BYTES
+        );
+        assert_eq!(MAX_PROJECT_FILE_BYTES, crate::package::MAX_FILE_BYTES);
+        assert_eq!(MAX_PROJECT_FILE_COUNT, crate::package::MAX_FILE_COUNT);
+        assert_eq!(
+            MAX_PROJECT_COMPRESSION_RATIO,
+            crate::package::MAX_COMPRESSION_RATIO
+        );
+    }
+}
diff --git a/server-rs/crates/module-game-distribution/src/theme.rs b/server-rs/crates/module-game-distribution/src/theme.rs
new file mode 100644
index 000000000..af2d825bb
--- /dev/null
+++ b/server-rs/crates/module-game-distribution/src/theme.rs
@@ -0,0 +1,1125 @@
+//! 共创主题的纯函数规则。
+//!
+//! 表与事务在 `spacetime-module::game_distribution`；这里只放能被不起 SpacetimeDB 的单测钉住的
+//! 规则：确定性成员主键、「主题 / 成员是否进入公开投影」的可见性判定、「成员只允许根」的约束，
+//! 以及公开主题列表与主题内成员的排序、游标编解码与切页。
+
+use crate::collection::game_distribution_collection_visible;
+
+/// 主题状态：`draft`（未发布）。
+pub const GAME_DISTRIBUTION_THEME_STATUS_DRAFT: &str = "draft";
+
+/// 主题状态：`published`（公开可见）。
+pub const GAME_DISTRIBUTION_THEME_STATUS_PUBLISHED: &str = "published";
+
+/// 主题状态：`archived`（已归档下架，行保留）。
+pub const GAME_DISTRIBUTION_THEME_STATUS_ARCHIVED: &str = "archived";
+
+/// 主题状态白名单：`draft` / `published` / `archived`。
+///
+/// 可见性判定、后台列表的 `status` 过滤白名单与 DTO 校验**共用这一份**（另加后台过滤里的
+/// `all`），因此新增一个状态只需要改这里一处；漏改会被「状态白名单」单测与 DTO parity 抓住。
+pub const GAME_DISTRIBUTION_THEME_STATUSES: [&str; 3] = [
+    GAME_DISTRIBUTION_THEME_STATUS_DRAFT,
+    GAME_DISTRIBUTION_THEME_STATUS_PUBLISHED,
+    GAME_DISTRIBUTION_THEME_STATUS_ARCHIVED,
+];
+
+/// 状态是否是白名单里的合法值。
+///
+/// 非法值由 api-server 映射 400（`THEME_BAD_REQUEST`），不落到 axum 默认的 422 纯文本。
+pub fn game_distribution_theme_status_valid(status: &str) -> bool {
+    GAME_DISTRIBUTION_THEME_STATUSES.contains(&status)
+}
+
+/// 后台列表 `status` 过滤里代表「全量」的取值。
+///
+/// 与 `GAME_DISTRIBUTION_THEME_STATUSES` 并列而不是塞进白名单：`all` 是**过滤视图**的取值，
+/// 不是主题行上的合法状态（没有任何一行的 `status` 会是 `all`）；混进去会让
+/// [`game_distribution_theme_status_valid`] 反过来接受一个落不进表的字符串。
+pub const GAME_DISTRIBUTION_THEME_ADMIN_STATUS_ALL: &str = "all";
+
+/// 后台列表 `status` 过滤值是否合法：`all` + 三个真实状态。
+///
+/// 单一实现，避免「api-server 放行、事务里当全量」这类两侧各写一遍白名单的漂移；非法值由
+/// api-server 映射 400（`THEME_BAD_REQUEST`）。
+pub fn game_distribution_theme_admin_status_filter_valid(status: &str) -> bool {
+    status == GAME_DISTRIBUTION_THEME_ADMIN_STATUS_ALL
+        || game_distribution_theme_status_valid(status)
+}
+
+/// 主题名长度上限（字符数，不是字节数）。
+///
+/// 设计文档（§3.10.8 / 里程碑 E）只写了「`name` 必填非空」，没有给上限。这里取 40：主题名与
+/// 作品标题（`title` 40）处在同一层级——都是卡片上一行标题——沿用同一量级可以让「一屏能放下
+/// 什么」在两条列表里一致；再长会被前端截断，运营写了也白写。
+pub const GAME_DISTRIBUTION_THEME_NAME_MAX_CHARS: usize = 40;
+
+/// 主题简介长度上限（字符数）。
+///
+/// 设计文档没写上限。取 200：主题简介是主题页头部的一段引导文案，比作品简介（120）略长
+/// （主题是运营叙事，需要多说一句「这一组作品为什么放在一起」），又远小于作品详细介绍
+/// （2000）——它不是正文，多出的字数只会把成员清单挤出首屏。
+pub const GAME_DISTRIBUTION_THEME_SUMMARY_MAX_CHARS: usize = 200;
+
+/// 主题角标长度上限（字符数）。
+///
+/// 设计文档没写上限。取 16：角标是卡片角上的短标签（「精选」「编辑推荐」「新春」），16 个字符
+/// 足够表达一个标签，同时短到不可能被当成第二段正文——真要写长文案的位置是 `summary`。
+pub const GAME_DISTRIBUTION_THEME_BADGE_MAX_CHARS: usize = 16;
+
+/// 后台主题文本字段的校验：合法返回 `None`，否则返回可直接拼进 `THEME_BAD_REQUEST:` 的原因。
+///
+/// 规则本身（长度上限、空名）只写在这里一处：**唯一的判据来源是写入事务**
+/// `ensure_game_distribution_theme_write_fields`（api-server 不做 HTTP 层预校验，违规一律由事务
+/// 回 `THEME_BAD_REQUEST:` 再映射 400），因此「HTTP 挡住的」与「落库挡住的」永远是同一套判据。
+/// 三个字段都先 `trim` 再判定：一串空格与空名同罪，调用方忘掉 trim 也不会把「只有空白的主题名」
+/// 写进库（长度也按 trim 后的字符数算，尾部空格不占额度）。
+pub fn game_distribution_theme_text_violation(
+    name: &str,
+    summary: &str,
+    badge: &str,
+) -> Option<&'static str> {
+    let name = name.trim();
+    let summary = summary.trim();
+    let badge = badge.trim();
+    let name_chars = name.chars().count();
+    if name_chars == 0 {
+        return Some("主题名不能为空");
+    }
+    if name_chars > GAME_DISTRIBUTION_THEME_NAME_MAX_CHARS {
+        return Some("主题名不能超过 40 个字符");
+    }
+    if summary.chars().count() > GAME_DISTRIBUTION_THEME_SUMMARY_MAX_CHARS {
+        return Some("主题简介不能超过 200 个字符");
+    }
+    if badge.chars().count() > GAME_DISTRIBUTION_THEME_BADGE_MAX_CHARS {
+        return Some("主题角标不能超过 16 个字符");
+    }
+    None
+}
+
+/// 主题是否应出现在公开投影（公开列表 / 公开详情 / 作品详情的 `themes`）里。
+///
+/// 等价于 `status == "published"`：`draft` 与 `archived` 一律不可见（后台仍可见全量）。与
+/// [`game_distribution_theme_status_valid`] 分开是刻意的——「值合法」与「对外可见」是两条不同
+/// 的规则，把两者混成一个函数会让「归档」这种合法但不可见的状态无从表达。
+pub fn game_distribution_theme_public_visible(status: &str) -> bool {
+    status == GAME_DISTRIBUTION_THEME_STATUS_PUBLISHED
+}
+
+/// 主题成员主键：`{theme_id}:{root_game_id}`。
+///
+/// 与 `game_distribution_collection_id`（收藏）同一写法：平台签发的两个标识用冒号拼成确定性 ID。
+/// `theme_id` 由本领域生成（`theme-*`）、`root_game_id` 也是（`game-*`），两者都不含 `:`，
+/// 因此组合是单射。
+///
+/// 用确定性主键而不是随机 ID，是为了让**去重由结构保证，而不是由流程保证**：同一 (主题, 根)
+/// 只可能有一行，这一点由主键约束本身成立。也正因为主键已经是那条约束，这张表**不需要**再建
+/// `(theme_id, root_game_id)` 唯一索引——两条具名索引只服务两个读取方向（按主题取成员、
+/// 按根反查所属主题）。
+pub fn game_distribution_theme_member_id(theme_id: &str, root_game_id: &str) -> String {
+    format!("{theme_id}:{root_game_id}")
+}
+
+/// 成员（根）是否应出现在公开投影里。
+///
+/// 只委托 [`game_distribution_collection_visible`]（收藏）的同一条口径：未软删除、可见性为
+/// `published`、且存在当前公开版本（`has_public_version` 由调用方按 `public_game_distribution_version`
+/// 命中给出）。**不新写第二个同义判定**：公开目录、收藏、主题成员三条路径共用一条规则，就不可能
+/// 出现「收藏列表看得见、主题页看不见」这类漂移。
+///
+/// 判定只在**投影时**发生，成员行本身不因此被删除：作品下架后该行只是不再出现在响应里，
+/// 作品重新公开后同一行会再次出现。
+pub fn game_distribution_theme_member_visible(
+    is_deleted: bool,
+    is_published: bool,
+    has_public_version: bool,
+) -> bool {
+    game_distribution_collection_visible(is_deleted, is_published, has_public_version)
+}
+
+/// 目标作品能否作为主题成员：**只有根作品**（没有血缘行，即第 0 代）。
+///
+/// 事实（该 `game_id` 是否存在血缘行）由调用方用血缘点查给出——`game_distribution_lineage()
+/// .game_id().find(&game_id)` 命中即有行 ⇒ 非根，一律拒绝（`409 THEME_MEMBER_NOT_ROOT`）。
+/// 纯函数只表达规则本身，不持有 `ReducerContext`。
+///
+/// 为什么不许任意代作品入主题：主题页要呈现的是**作品树**，而 `/games/{id}/lineage` 是**按根
+/// 聚合**的。若允许子作品也入主题，同一棵树会在主题页里出现多次（子作品自己一条、它的根又一条），
+/// 去重与「高亮当前节点」都会打架。要挂就挂它所属的根。
+pub fn game_distribution_theme_root_acceptable(has_lineage_row: bool) -> bool {
+    !has_lineage_row
+}
+
+/// 公开主题列表一页的默认条数。
+///
+/// 与 `/my-collections`（收录列表）取同一个数值：列表页是卡片网格，一屏放得下 20 张。
+pub const GAME_DISTRIBUTION_THEME_PAGE_LIMIT_DEFAULT: u32 = 20;
+
+/// 公开主题列表单次响应回传的条数上限。
+///
+/// 与 `/my-collections` 同一数值与同一处理方式：超界一律**截断**而不是报错，客户端拿到的是一个
+/// 完整页，而不是一个需要重试的错误。同时它也是主题详情成员清单的响应体积约束。
+pub const GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX: u32 = 50;
+
+/// 请求里的 `limit` → 实际页大小：`0` 取默认，超界截断到上限。
+///
+/// 抽成独立函数是为了让 api-server 记日志的「生效条数」与模块真正使用的页大小**同源**：
+/// 两处各自写一遍 `if == 0 ... min(...)` 迟早会漂移。
+pub fn game_distribution_theme_page_limit(limit: u32) -> usize {
+    let resolved = if limit == 0 {
+        GAME_DISTRIBUTION_THEME_PAGE_LIMIT_DEFAULT
+    } else {
+        limit.min(GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX)
+    };
+    resolved as usize
+}
+
+/// 主题公开列表里的一条：游标 / 排序所需的两个键 + 调用方自己的负载。
+///
+/// 泛型 `payload` 让「排序键」与「这一页要回传的东西」绑在同一个值上，纯函数切页时整条值一起
+/// 移动，因此不可能出现「按 A 排序、按 B 切页」的错位；模块侧把负载填成主题行，测试里填成
+/// 任意轻量值。
+#[derive(Clone, Debug, PartialEq)]
+pub struct GameDistributionThemePageItem<T> {
+    /// 主题主键 `theme-*`；主题表内唯一，因此可作全序兜底键。
+    pub theme_id: String,
+    /// 主题创建时间（Unix 微秒），主排序键。
+    pub created_at_micros: i64,
+    pub payload: T,
+}
+
+/// 主题列表游标编码：`{created_at_micros}:{theme_id}`。
+///
+/// 与后台列表、收藏列表同一套 `"{micros}:{id}"` 惯例。`theme_id` 由本领域签发（`theme-*`）、
+/// **不含冒号**，因此这里比收藏列表更简单；解析仍只切**第一个**冒号，格式对将来更长的 ID
+/// 也不会退化。
+pub fn encode_game_distribution_theme_cursor(created_at_micros: i64, theme_id: &str) -> String {
+    format!("{created_at_micros}:{theme_id}")
+}
+
+/// 主题列表游标解析；格式非法时返回带**稳定码**的 `Err`：`THEME_INVALID_CURSOR: …`。
+///
+/// 文案必须以码开头（`"{CODE}: {中文说明}"`）：api-server 的 `THEME_` 映射分支要求消息含 `THEME_`
+/// 且按冒号前的码查状态码表，少了前缀就静默退化成兜底的 400 + 通用 `BAD_REQUEST`，客户端只能去
+/// 匹配中文——这正是本项目出过一次的真缺陷（游标错误不是领域变体，只是裸字符串，`Display` 的
+/// 前缀测试覆盖不到它，所以另有一条测试专门枚举全部主题码）。
+///
+/// 仍然刻意避开的中文子串：只保留了**排在 `THEME_` 分支之前**的 `FORK_` 不能出现（否则会被
+/// `FORK_` 分支抢先映射）；「不存在」「状态」等子串不再有害——`THEME_` 分支先命中，码由前缀决定。
+pub fn parse_game_distribution_theme_cursor(value: &str) -> Result<(i64, String), String> {
+    let invalid = || {
+        format!(
+            "{}: 主题列表游标格式无效",
+            crate::GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE
+        )
+    };
+    let (micros, theme_id) = value.split_once(':').ok_or_else(invalid)?;
+    let micros = micros.parse::<i64>().map_err(|_| invalid())?;
+    if theme_id.is_empty() {
+        return Err(invalid());
+    }
+    Ok((micros, theme_id.to_string()))
+}
+
+/// 公开主题列表的稳定排序：`created_at` **倒序** + `theme_id` **升序**兜底。
+///
+/// 为什么这个比较器是**全序**：`created_at` 相同的两条必须还能分出先后，否则同一页边界上的项
+/// 会在翻页时重复或漏掉。`theme_id` 是主键、唯一，因此 `(created_at_micros, theme_id)` 唯一
+/// 决定顺序 —— 相同 `created_at` 不会被吞掉。
+///
+/// 作品详情的 `themes` 增量用**同一份**比较器，避免「列表一种顺序、详情另一种顺序」的第二套语义。
+pub fn sort_public_themes<T>(
+    mut items: Vec<GameDistributionThemePageItem<T>>,
+) -> Vec<GameDistributionThemePageItem<T>> {
+    items.sort_by(|left, right| {
+        right
+            .created_at_micros
+            .cmp(&left.created_at_micros)
+            .then_with(|| left.theme_id.cmp(&right.theme_id))
+    });
+    items
+}
+
+/// 公开主题列表分页：按上面的比较器排序、跳过游标之前的位置、取 `limit` 条，并返回下一页游标
+/// （没有下一页时为 `None`）。
+///
+/// 调用方必须**先**按可见性过滤、**再**把结果交给本函数：游标位置定义在已过滤的序列上。
+/// 反过来先把未过滤序列切页、再逐页过滤，会让被滤掉的行凭空占掉名额，并使下一页的游标指回
+/// 过滤前的序列——每翻一页都漏掉自己的若干条（与 `/my-collections` 同一条纪律）。
+pub fn page_public_themes<T>(
+    items: Vec<GameDistributionThemePageItem<T>>,
+    cursor: Option<(i64, String)>,
+    limit: u32,
+) -> (Vec<T>, Option<String>) {
+    let limit = game_distribution_theme_page_limit(limit);
+    let mut items = sort_public_themes(items);
+    if let Some((cursor_micros, cursor_id)) = cursor.as_ref() {
+        // 严格「在游标之后」：时间更早，或时间相同且 theme_id 更大（升序方向）。
+        items.retain(|item| {
+            item.created_at_micros < *cursor_micros
+                || (item.created_at_micros == *cursor_micros
+                    && item.theme_id.as_str() > cursor_id.as_str())
+        });
+    }
+    // 多取一条判断是否还有下一页；游标只指向这一页真正回传的最后一条。
+    let has_more = items.len() > limit;
+    items.truncate(limit);
+    let next_cursor = if has_more {
+        items.last().map(|item| {
+            encode_game_distribution_theme_cursor(item.created_at_micros, item.theme_id.as_str())
+        })
+    } else {
+        None
+    };
+    (
+        items.into_iter().map(|item| item.payload).collect(),
+        next_cursor,
+    )
+}
+
+/// 主题内成员的一条：排序所需两个键 + 调用方自己的负载（与主题列表同一写法）。
+#[derive(Clone, Debug, PartialEq)]
+pub struct GameDistributionThemeMemberPageItem<T> {
+    /// 成员主键 `{theme_id}:{root_game_id}`；同一主题内唯一，因此可作全序兜底键。
+    pub member_id: String,
+    /// 运营权重，主排序键；**允许重复**（重复由 `member_id` 兜底成全序）。
+    pub sort_order: i64,
+    pub payload: T,
+}
+
+/// 主题内成员的稳定排序：`sort_order` **升序** + `member_id` **升序**兜底。
+///
+/// 为什么需要兜底键：运营完全可能给多个成员填同一个 `sort_order`（「靠前的这几个先放一起」）。
+/// 若比较器在 `sort_order` 相同时不稳定，同一页边界上的成员会在翻页 / 渲染时重复或漏掉。
+/// `member_id` 是主键、在同一主题内唯一，因此 `(sort_order, member_id)` 唯一决定顺序。
+pub fn sort_theme_members<T>(
+    mut items: Vec<GameDistributionThemeMemberPageItem<T>>,
+) -> Vec<GameDistributionThemeMemberPageItem<T>> {
+    items.sort_by(|left, right| {
+        left.sort_order
+            .cmp(&right.sort_order)
+            .then_with(|| left.member_id.cmp(&right.member_id))
+    });
+    items
+}
+
+/// 主题详情成员清单：排序后取前 `limit` 条负载。
+///
+/// `limit` 由调用方显式给出（主题详情用 [`GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX`] 约束单次响应
+/// 体积），`0` 表示该次不回传成员。可见性过滤同样必须发生在**调用本函数之前**（游标/截断位置
+/// 定义在已过滤序列上，理由与主题列表一致）。
+pub fn page_theme_members<T>(
+    items: Vec<GameDistributionThemeMemberPageItem<T>>,
+    limit: usize,
+) -> Vec<T> {
+    let mut items = sort_theme_members(items);
+    items.truncate(limit);
+    items.into_iter().map(|item| item.payload).collect()
+}
+
+/// 主题详情的 `roots` 是否**被响应体积上限截断**了。
+///
+/// `visible_member_count` 是真实可见成员数（不截断，原样作为 `memberCount` 回报），
+/// `returned_root_count` 是这一份 `roots` 实际回传的条数：只有「回传的**少于**可见的」才是截断，
+/// 相等（常见情形：可见成员不足上限，全发）与更多都是 `false`。
+///
+/// 为什么必须把这个信号和 `memberCount` 分开：`page_theme_members` 会把成员截断到
+/// [`GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX`]，而 `memberCount` 刻意报**真实可见数**——两个数一旦
+/// 不等，客户端必须能分辨「这个主题就有这么多根」与「服务端只回了前 50 个」。不发明新约定：
+/// 族谱接口的 `truncated`（`GameDistributionLineageResponse.truncated`）就是同一个语义
+/// （「下面这份列表被上限截断了」），客户端按同一种方式分支。
+///
+/// 「更多」这一支写死成 `false` 是**防御性口径**：`returned > visible` 只可能来自调用方把两组
+/// 互不同源的数字拼在一起（例如清点在过滤前、取值在过滤后）。那种情况下并没有少发任何东西，
+/// 报「被截断」反而会诱导客户端去翻一个不存在的下一页，所以宁可报 `false`。
+pub fn game_distribution_theme_roots_truncated(
+    visible_member_count: usize,
+    returned_root_count: usize,
+) -> bool {
+    returned_root_count < visible_member_count
+}
+
+/// 后台成员行细粒度状态：成员行还在、但它指向的作品行**已被软删除**。
+pub const GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_DELETED: &str = "deleted";
+
+/// 后台成员行细粒度状态：成员行还在、但它指向的作品行**根本不存在**（历史脏行 / 被物理清理）。
+pub const GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_MISSING: &str = "missing";
+
+/// 后台成员行的细粒度可见性状态（**只给后台**，公开投影不发这个键）。
+///
+/// 与 [`game_distribution_theme_member_visible`] 的分工是刻意的、也必须写死：
+/// - [`game_distribution_theme_member_visible`] 回答「**此刻公开侧会不会出现它**」——未软删除 +
+///   `visibility == published` + 有当前公开版本。后台页面据此显示「当前不可见」标记。
+/// - 本函数回答「**为什么**不可见」，把那个布尔拆成可读的状态：软删除的行 → `deleted`，作品行
+///   不存在的历史行 → `missing`，否则原样透传作品行的 `visibility`（`unpublished` / `published`
+///   / `suspended`）。
+///
+/// 两个口径**不是**同一件事，也不许互相推导：`visibility == "published"` 但作品没有当前公开版本时
+/// `visible == false`，这是**刻意**的（运营要能一眼看出「作品已公开、但没有公开版本」这种异常，
+/// 而不是只看到一个说不清原因的「不可见」）。
+///
+/// 判定顺序：**作品行不存在优先于软删除**——没有行就无从谈起 `deleted_at`，把那种历史行报成
+/// `deleted` 会误导运营去「恢复一个不存在的作品」。
+pub fn game_distribution_theme_member_visibility(
+    game_row_present: bool,
+    is_deleted: bool,
+    game_visibility: &str,
+) -> String {
+    if !game_row_present {
+        return GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_MISSING.to_string();
+    }
+    if is_deleted {
+        return GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_DELETED.to_string();
+    }
+    game_visibility.to_string()
+}
+
+/// 后台成员列表游标编码：`{sort_order}:{member_id}`（`member_id` = `{theme_id}:{root_game_id}`）。
+///
+/// 与主题列表 / 收藏列表同一套 `"{i64}:{rest}"` 惯例：第一段是**排序键**（这里为运营权重
+/// `sort_order`），第二段是这个序列里的唯一兜底键（成员主键，本身自带冒号）。解析仍只切**第一个**
+/// 冒号，因此 `member_id` 里的冒号不会把格式搞坏（与收藏列表同一条纪律）。
+///
+/// 与主题列表游标第一段是 `created_at_micros` 不同：这条列表按运营权重排序，游标锚点因此是权重
+/// 而不是时间——两者都只是「i64 + 唯一键」，格式上同构。
+pub fn encode_game_distribution_theme_member_cursor(sort_order: i64, member_id: &str) -> String {
+    format!("{sort_order}:{member_id}")
+}
+
+/// 后台成员列表游标解析；**只委托** [`parse_game_distribution_theme_cursor`]，不重写解析。
+///
+/// 两个游标都是 `"{i64}:{rest}"`，唯一键的差异（`theme_id` vs `member_id`）不改变解析规则，
+/// 因此这里刻意不去复制一份「切第一个冒号 + 校验 i64 + 非空」的实现：复制出来的第二份迟早会与
+/// 第一份漂移（那正是本项目出过一次的 `THEME_INVALID_CURSOR` 不可达缺陷）。委托意味着两侧共用
+/// 同一个失败文案，而该文案以稳定码 `THEME_INVALID_CURSOR` 开头、且不含会被 api-server 抢先命中的
+/// `FORK_` 子串——非法游标因此在 HTTP 面上仍然是**可达的 400 + 稳定码**。
+pub fn parse_game_distribution_theme_member_cursor(value: &str) -> Result<(i64, String), String> {
+    parse_game_distribution_theme_cursor(value)
+}
+
+/// 后台成员列表切页：排序 → 跳过游标之前的位置 → 取 `limit` 条，并返回下一页游标
+/// （没有下一页时为 `None`）。
+///
+/// 与公开侧**共用同一份比较器** [`sort_theme_members`]（`sort_order` 升序 + `member_id` 升序兜底，
+/// 全序），只是在它之上多了游标与切页——后台与公开对「成员之间谁在前」不该有两套语义。
+///
+/// 与公开投影的关键差异：调用方**不**做可见性过滤（后台要看全部成员行，含草稿 / 归档主题、
+/// 含当前不可见的成员）。因此这里的顺序纪律与 `/my-collections` 相反半边：不是「先过滤再切页」，
+/// 而是「**行集合本身就是全集**，直接排序切页」——后台没有「被滤掉的行占掉名额」的问题，因为
+/// 一行都不会被滤掉。`limit` 归一化复用 [`game_distribution_theme_page_limit`]（缺省 20 / 上限 50 /
+/// `0` 取默认 / 超界截断），与其它列表同一套数值。
+pub fn page_admin_theme_members<T>(
+    items: Vec<GameDistributionThemeMemberPageItem<T>>,
+    cursor: Option<(i64, String)>,
+    limit: u32,
+) -> (Vec<T>, Option<String>) {
+    let limit = game_distribution_theme_page_limit(limit);
+    let mut items = sort_theme_members(items);
+    if let Some((cursor_sort_order, cursor_member_id)) = cursor.as_ref() {
+        // 严格「在游标之后」：权重更大，或权重相同且 member_id 更大（升序方向）。
+        items.retain(|item| {
+            item.sort_order > *cursor_sort_order
+                || (item.sort_order == *cursor_sort_order
+                    && item.member_id.as_str() > cursor_member_id.as_str())
+        });
+    }
+    // 多取一条判断是否还有下一页；游标只指向这一页真正回传的最后一条。
+    let has_more = items.len() > limit;
+    items.truncate(limit);
+    let next_cursor = if has_more {
+        items.last().map(|item| {
+            encode_game_distribution_theme_member_cursor(item.sort_order, item.member_id.as_str())
+        })
+    } else {
+        None
+    };
+    (
+        items.into_iter().map(|item| item.payload).collect(),
+        next_cursor,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn member_id_is_deterministic_and_pair_specific() {
+        assert_eq!(
+            game_distribution_theme_member_id("theme_a", "game_a"),
+            "theme_a:game_a"
+        );
+        // 同一对组合永远得到同一个键（重复 upsert 只留一行、成员幂等删除都依赖这一点）。
+        assert_eq!(
+            game_distribution_theme_member_id("theme_a", "game_a"),
+            game_distribution_theme_member_id("theme_a", "game_a")
+        );
+        // 主键派生必须对「主题」「根」两个维度都敏感：漏掉任一维度，不同主题 / 不同根的成员就会
+        // 共用同一行而互相覆盖（这是结构防重的前提）。
+        assert_ne!(
+            game_distribution_theme_member_id("theme_a", "game_a"),
+            game_distribution_theme_member_id("theme_b", "game_a")
+        );
+        assert_ne!(
+            game_distribution_theme_member_id("theme_a", "game_a"),
+            game_distribution_theme_member_id("theme_a", "game_b")
+        );
+    }
+
+    /// 状态白名单与公开可见性是**两条**不同的规则：`archived` 合法但不可见。
+    #[test]
+    fn status_whitelist_and_public_visibility_are_separate_rules() {
+        for status in GAME_DISTRIBUTION_THEME_STATUSES {
+            assert!(game_distribution_theme_status_valid(status), "{status}");
+        }
+        for status in ["", "PUBLISHED", "deleted", "hidden", " all"] {
+            assert!(!game_distribution_theme_status_valid(status), "{status}");
+        }
+
+        // 只有 published 公开可见；draft 与 archived 都不可见，但它们的值仍然合法。
+        assert!(game_distribution_theme_public_visible(
+            GAME_DISTRIBUTION_THEME_STATUS_PUBLISHED
+        ));
+        assert!(!game_distribution_theme_public_visible(
+            GAME_DISTRIBUTION_THEME_STATUS_DRAFT
+        ));
+        assert!(!game_distribution_theme_public_visible(
+            GAME_DISTRIBUTION_THEME_STATUS_ARCHIVED
+        ));
+        assert!(game_distribution_theme_status_valid(
+            GAME_DISTRIBUTION_THEME_STATUS_ARCHIVED
+        ));
+        // 非法值当然也不可见（不是「非 published 一律可见」的口子）。
+        assert!(!game_distribution_theme_public_visible("published "));
+    }
+
+    /// 成员可见性四组合 + 「未删已公开但无当前公开版本」必须 false；并与收藏口径**逐格相等**。
+    ///
+    /// 最后一组断言是这条「委托而不是复制」的守门人：将来若只改收藏判定而忘了成员，或反之，
+    /// 这个测试会红。
+    #[test]
+    fn member_visibility_matches_the_collection_ruling_cell_by_cell() {
+        assert!(game_distribution_theme_member_visible(false, true, true));
+        assert!(!game_distribution_theme_member_visible(false, false, true));
+        assert!(!game_distribution_theme_member_visible(true, true, true));
+        assert!(!game_distribution_theme_member_visible(false, true, false));
+
+        for is_deleted in [false, true] {
+            for is_published in [false, true] {
+                for has_public_version in [false, true] {
+                    assert_eq!(
+                        game_distribution_theme_member_visible(
+                            is_deleted,
+                            is_published,
+                            has_public_version
+                        ),
+                        game_distribution_collection_visible(
+                            is_deleted,
+                            is_published,
+                            has_public_version
+                        ),
+                        "成员与收藏必须共用同一条公开可读口径（deleted={is_deleted}, published={is_published}, version={has_public_version}）"
+                    );
+                }
+            }
+        }
+    }
+
+    /// 「成员下架 → 投影跳过 → 重新公开 → 自动回来」：行不变，只有判定翻转。
+    #[test]
+    fn member_row_survives_unpublish_and_returns_after_republish() {
+        assert!(game_distribution_theme_member_visible(false, true, true));
+        assert!(!game_distribution_theme_member_visible(false, false, true));
+        assert!(game_distribution_theme_member_visible(false, true, true));
+    }
+
+    /// 成员只允许根：`has_lineage_row == true`（非根）⇒ 拒绝；无血缘行 ⇒ 接受。
+    #[test]
+    fn only_root_games_are_acceptable_members() {
+        assert!(game_distribution_theme_root_acceptable(false));
+        assert!(!game_distribution_theme_root_acceptable(true));
+    }
+
+    /// 后台过滤白名单 = `all` + 三个真实状态；`all` 自己**不是**能落进主题行的状态。
+    #[test]
+    fn admin_status_filter_accepts_all_plus_real_statuses_only() {
+        assert!(game_distribution_theme_admin_status_filter_valid(
+            GAME_DISTRIBUTION_THEME_ADMIN_STATUS_ALL
+        ));
+        for status in GAME_DISTRIBUTION_THEME_STATUSES {
+            assert!(
+                game_distribution_theme_admin_status_filter_valid(status),
+                "{status}"
+            );
+        }
+        for status in ["", "ALL", "deleted", "published ", " archived"] {
+            assert!(
+                !game_distribution_theme_admin_status_filter_valid(status),
+                "{status}"
+            );
+        }
+        // 两条白名单刻意分开：`all` 只服务过滤视图，混进状态白名单会让它被当成可落库的值。
+        assert!(!game_distribution_theme_status_valid(
+            GAME_DISTRIBUTION_THEME_ADMIN_STATUS_ALL
+        ));
+    }
+
+    /// 后台主题文本校验：空名 / 超长各有明确原因；边界取「刚好合法」，且按**字符**而不是字节计数。
+    #[test]
+    fn theme_text_validation_pins_limits_at_the_boundary() {
+        assert_eq!(
+            game_distribution_theme_text_violation("", "", ""),
+            Some("主题名不能为空")
+        );
+        assert_eq!(
+            game_distribution_theme_text_violation("   ", "", ""),
+            Some("主题名不能为空"),
+            "调用方传 trim 后的值：一串空格与空名同罪"
+        );
+
+        // 40 个中文字符 = 120 字节：按字节计数的实现会在这里红。
+        let max_name = "主".repeat(GAME_DISTRIBUTION_THEME_NAME_MAX_CHARS);
+        assert_eq!(
+            game_distribution_theme_text_violation(&max_name, "", ""),
+            None
+        );
+        let too_long_name = "主".repeat(GAME_DISTRIBUTION_THEME_NAME_MAX_CHARS + 1);
+        assert_eq!(
+            game_distribution_theme_text_violation(&too_long_name, "", ""),
+            Some("主题名不能超过 40 个字符")
+        );
+
+        let max_summary = "简".repeat(GAME_DISTRIBUTION_THEME_SUMMARY_MAX_CHARS);
+        assert_eq!(
+            game_distribution_theme_text_violation("主题", &max_summary, ""),
+            None
+        );
+        assert_eq!(
+            game_distribution_theme_text_violation("主题", &format!("{max_summary}简"), ""),
+            Some("主题简介不能超过 200 个字符")
+        );
+
+        let max_badge = "标".repeat(GAME_DISTRIBUTION_THEME_BADGE_MAX_CHARS);
+        assert_eq!(
+            game_distribution_theme_text_violation("主题", "", &max_badge),
+            None
+        );
+        assert_eq!(
+            game_distribution_theme_text_violation("主题", "", &format!("{max_badge}标")),
+            Some("主题角标不能超过 16 个字符")
+        );
+
+        // 三个上限各自独立：简介/角标超长不会因为名字合法而被放过。
+        assert_eq!(
+            game_distribution_theme_text_violation("主题", &max_summary, &format!("{max_badge}标")),
+            Some("主题角标不能超过 16 个字符")
+        );
+
+        // 长度按 trim 后的字符数算：40 个字 + 首尾空格仍然合法（空格不占额度）。
+        assert_eq!(
+            game_distribution_theme_text_violation(&format!("  {max_name}  "), "", ""),
+            None
+        );
+    }
+
+    /// `limit` 语义：`0` 取默认 20（不是「返回 0 条」），超界截断到 50（不是报错）。
+    #[test]
+    fn page_limit_defaults_zero_and_truncates_overflow() {
+        assert_eq!(game_distribution_theme_page_limit(0), 20);
+        assert_eq!(game_distribution_theme_page_limit(1), 1);
+        assert_eq!(game_distribution_theme_page_limit(50), 50);
+        assert_eq!(
+            game_distribution_theme_page_limit(51),
+            50,
+            "超界截断而不是报错"
+        );
+        assert_eq!(game_distribution_theme_page_limit(u32::MAX), 50);
+    }
+
+    /// 游标编解码：往返双射、解析只切第一个冒号、负数微秒可逆，各种非法输入一律 `Err`。
+    #[test]
+    fn cursor_round_trips_and_rejects_malformed_values() {
+        let cursor = encode_game_distribution_theme_cursor(1_700_000_000_000_000, "theme_a");
+        assert_eq!(cursor, "1700000000000000:theme_a");
+        assert_eq!(
+            parse_game_distribution_theme_cursor(&cursor).unwrap(),
+            (1_700_000_000_000_000, "theme_a".to_string())
+        );
+        // 负数微秒（仅编码假设，仍必须可逆）。
+        assert_eq!(
+            parse_game_distribution_theme_cursor("-5:theme_a").unwrap(),
+            (-5, "theme_a".to_string())
+        );
+        // 解析只切第一个冒号：micros 之后的整段（含更多冒号）都是 theme_id。
+        assert_eq!(
+            parse_game_distribution_theme_cursor("9:theme:a").unwrap(),
+            (9, "theme:a".to_string())
+        );
+
+        for malformed in [
+            "",
+            "not-a-cursor",
+            "100",
+            "abc:theme_a",
+            "100:",
+            " :theme_a",
+        ] {
+            assert!(
+                parse_game_distribution_theme_cursor(malformed).is_err(),
+                "非法游标必须报错：{malformed:?}"
+            );
+        }
+    }
+
+    /// 非法游标文案必须以**稳定码**开头，且不含会被 api-server 抢先映射的子串。
+    ///
+    /// 只有排在 `THEME_` 分支**之前**的分支才会抢：`map_spacetime_error` 里 `FORK_` 在前、
+    /// `THEME_` 紧随其后，`owner 不匹配` / `已被删除` / 409 的「状态」子串都在 `THEME_` **之后**，
+    /// 因此不再需要回避它们（这里保留断言，是为了让「顺序一变就红」这件事仍然可见）。
+    #[test]
+    fn invalid_cursor_message_stays_in_the_bad_request_bucket() {
+        let message =
+            parse_game_distribution_theme_cursor("不是游标").expect_err("非法游标必须报错");
+        assert!(
+            message.starts_with(crate::GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE),
+            "游标错误必须以稳定码开头，否则 HTTP 面只能回通用 BAD_REQUEST：{message}"
+        );
+        assert!(message.contains("格式无效"), "{message}");
+        for forbidden in [
+            "不存在",
+            "已被删除",
+            "状态",
+            "不匹配",
+            "幂等",
+            "已存在",
+            "FORK_",
+        ] {
+            assert!(
+                !message.contains(forbidden),
+                "游标错误文案不得含「{forbidden}」：{message}"
+            );
+        }
+    }
+
+    fn item(theme_id: &str, created_at_micros: i64) -> GameDistributionThemePageItem<String> {
+        GameDistributionThemePageItem {
+            theme_id: theme_id.to_string(),
+            created_at_micros,
+            payload: theme_id.to_string(),
+        }
+    }
+
+    /// 不足一页：全部回传，且**没有**下一页游标（不能给一个指向空页的游标，否则客户端会多翻一次死页）。
+    #[test]
+    fn page_returns_everything_without_cursor_when_under_limit() {
+        let (page, next) =
+            page_public_themes(vec![item("theme_a", 300), item("theme_b", 200)], None, 20);
+        assert_eq!(page, vec!["theme_a", "theme_b"]);
+        assert_eq!(next, None);
+    }
+
+    /// 恰好一页：`has_more` 依赖「多取一条」，因此 `len == limit` 时不能再给游标。
+    #[test]
+    fn page_at_exact_limit_has_no_cursor() {
+        let (page, next) =
+            page_public_themes(vec![item("theme_a", 300), item("theme_b", 200)], None, 2);
+        assert_eq!(page.len(), 2);
+        assert_eq!(next, None);
+    }
+
+    /// 连续翻页直到消耗完：每页**不重复**上一页的项，也**不跳过**任何项；最后一页游标为 `None`。
+    #[test]
+    fn paging_walks_the_whole_sequence_without_gaps_or_duplicates() {
+        let entries = vec![
+            item("theme_a", 500),
+            item("theme_b", 400),
+            item("theme_c", 300),
+            item("theme_d", 200),
+            item("theme_e", 100),
+        ];
+        let mut seen: Vec<String> = Vec::new();
+        let mut cursor = None;
+        let mut pages = 0;
+        loop {
+            let (page, next) = page_public_themes(entries.clone(), cursor, 2);
+            assert!(!page.is_empty(), "非末页不得为空");
+            if next.is_some() {
+                assert_eq!(page.len(), 2, "还有下一页时必须填满 limit 条");
+            }
+            seen.extend(page);
+            pages += 1;
+            match next {
+                Some(value) => cursor = Some(parse_game_distribution_theme_cursor(&value).unwrap()),
+                None => break,
+            }
+        }
+        assert_eq!(pages, 3);
+        assert_eq!(
+            seen,
+            vec!["theme_a", "theme_b", "theme_c", "theme_d", "theme_e"],
+            "翻页顺序必须严格是「创建时间倒序」且不重不漏"
+        );
+    }
+
+    /// 同一 `created_at` 多条：`theme_id` 升序兜底保证全序，翻页边界不重不漏。
+    ///
+    /// 这是唯一能钉住「排序是全序」的场景：若比较器在 `created_at` 相同时不稳定，三条同刻主题里
+    /// 的某一条就会被下一页重复返回或被整段跳过。
+    #[test]
+    fn page_tiebreaks_equal_created_at_by_theme_id_ascending() {
+        let entries = vec![
+            item("theme_c", 100),
+            item("theme_a", 100),
+            item("theme_d", 99),
+            item("theme_b", 100),
+        ];
+        let (first, next) = page_public_themes(entries.clone(), None, 2);
+        assert_eq!(first, vec!["theme_a", "theme_b"]);
+        let cursor = next.expect("还有同刻与更早的项");
+        assert_eq!(cursor, "100:theme_b");
+        let (second, last) = page_public_themes(
+            entries,
+            Some(parse_game_distribution_theme_cursor(&cursor).unwrap()),
+            2,
+        );
+        assert_eq!(second, vec!["theme_c", "theme_d"]);
+        assert_eq!(last, None, "第二页就是最后一页");
+    }
+
+    /// **先过滤、再排序切页**：被滤掉的行不得凭空占掉名额，也不得出现在任何一页里。
+    ///
+    /// 这里用「可见性过滤在调用方、发生在切页之前」的结构模拟模块侧的真实顺序：把不可见的行
+    /// 混在同一批输入里，先 `retain`，再交给 `page_public_themes`；若顺序反过来（先切页再过滤），
+    /// 第一页就会因为不可见行占位而只回传 1 条，翻页也会漏项。
+    #[test]
+    fn visibility_filter_must_happen_before_paging() {
+        // theme_b / theme_d 是「不可见」的主题（draft / archived），它们不该占页名额。
+        let raw = vec![
+            item("theme_a", 500),
+            item("theme_b", 400),
+            item("theme_c", 300),
+            item("theme_d", 200),
+            item("theme_e", 100),
+        ];
+        let visible = raw
+            .into_iter()
+            .filter(|entry| entry.theme_id != "theme_b" && entry.theme_id != "theme_d")
+            .collect::<Vec<_>>();
+
+        let mut seen: Vec<String> = Vec::new();
+        let mut cursor = None;
+        loop {
+            let (page, next) = page_public_themes(visible.clone(), cursor, 1);
+            if next.is_some() {
+                assert_eq!(page.len(), 1, "过滤后仍有余量时必须填满 limit 条");
+            }
+            seen.extend(page);
+            match next {
+                Some(value) => cursor = Some(parse_game_distribution_theme_cursor(&value).unwrap()),
+                None => break,
+            }
+        }
+        assert_eq!(seen, vec!["theme_a", "theme_c", "theme_e"]);
+        assert!(
+            !seen.iter().any(|id| id == "theme_b" || id == "theme_d"),
+            "不可见主题不得出现在任何一页"
+        );
+    }
+
+    fn member(member_id: &str, sort_order: i64) -> GameDistributionThemeMemberPageItem<String> {
+        GameDistributionThemeMemberPageItem {
+            member_id: member_id.to_string(),
+            sort_order,
+            payload: member_id.to_string(),
+        }
+    }
+
+    /// 成员排序：`sort_order` 升序；同 `sort_order` 按 `member_id` 升序兜底（输入顺序无关）。
+    #[test]
+    fn member_sort_orders_by_rank_then_member_id() {
+        let sorted = sort_theme_members(vec![
+            member("theme_a:game_c", 10),
+            member("theme_a:game_a", 5),
+            member("theme_a:game_d", 10),
+            member("theme_a:game_b", 5),
+        ])
+        .into_iter()
+        .map(|entry| entry.payload)
+        .collect::<Vec<_>>();
+        assert_eq!(
+            sorted,
+            vec![
+                "theme_a:game_a",
+                "theme_a:game_b",
+                "theme_a:game_c",
+                "theme_a:game_d",
+            ]
+        );
+    }
+
+    /// 成员排序是全序：同一 `sort_order` 下无论输入怎么打乱，输出都相同（稳定且不重不漏）。
+    #[test]
+    fn member_sort_is_a_total_order_for_duplicate_ranks() {
+        let expected = vec![
+            "theme_a:game_a",
+            "theme_a:game_b",
+            "theme_a:game_c",
+            "theme_a:game_d",
+        ];
+        for rotation in 0..4 {
+            let mut items = vec![
+                member("theme_a:game_b", 7),
+                member("theme_a:game_d", 7),
+                member("theme_a:game_a", 7),
+                member("theme_a:game_c", 7),
+            ];
+            items.rotate_left(rotation);
+            let sorted = sort_theme_members(items)
+                .into_iter()
+                .map(|entry| entry.payload)
+                .collect::<Vec<_>>();
+            assert_eq!(sorted, expected, "rotation={rotation}");
+        }
+    }
+
+    /// 成员清单截断：保留排序后的前缀，不改变顺序；`limit` 大于总数时原样回传。
+    #[test]
+    fn member_page_truncates_after_sorting() {
+        let items = vec![
+            member("theme_a:game_c", 30),
+            member("theme_a:game_a", 10),
+            member("theme_a:game_b", 20),
+        ];
+        assert_eq!(
+            page_theme_members(items.clone(), 2),
+            vec!["theme_a:game_a", "theme_a:game_b"],
+            "截断必须发生在排序之后，不能按输入顺序取前两条"
+        );
+        assert_eq!(
+            page_theme_members(items.clone(), 3),
+            vec!["theme_a:game_a", "theme_a:game_b", "theme_a:game_c"]
+        );
+        assert_eq!(
+            page_theme_members(items.clone(), usize::MAX).len(),
+            3,
+            "上限大于总数时原样回传"
+        );
+        assert!(
+            page_theme_members(items, 0).is_empty(),
+            "limit=0 不回传成员"
+        );
+    }
+
+    /// `rootsTruncated` 三态：全发（含空）/ 被上限截断 / 防御性「回传多于可见」。
+    ///
+    /// 第一组是「相等」，最常见（可见成员不足上限，整份回传）；第二组是唯一必须报 `true` 的情形；
+    /// 第三组钉住防御性口径——两组数字不同源时不得凭空报「还有更多」。
+    #[test]
+    fn roots_truncated_is_true_only_when_the_returned_list_was_cut() {
+        assert!(!game_distribution_theme_roots_truncated(0, 0), "空主题");
+        assert!(
+            !game_distribution_theme_roots_truncated(3, 3),
+            "不足上限：全发"
+        );
+        assert!(
+            !game_distribution_theme_roots_truncated(
+                GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX as usize,
+                GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX as usize,
+            ),
+            "恰好等于上限：一份都没少，不算截断"
+        );
+
+        assert!(
+            game_distribution_theme_roots_truncated(51, 50),
+            "可见 51 条只回 50 条：必须给出「还有更多」的信号"
+        );
+        assert!(game_distribution_theme_roots_truncated(120, 50));
+        assert!(game_distribution_theme_roots_truncated(1, 0));
+
+        assert!(
+            !game_distribution_theme_roots_truncated(50, 51),
+            "回传多于可见只可能是两组数字不同源：没有少发东西，不得报截断"
+        );
+    }
+
+    /// 后台成员行的细粒度状态：`missing` 优先于 `deleted`，其余原样透传作品的 `visibility`；
+    /// 并与 `visible` 的组合口径一并钉住——「已公开但没有当前公开版本」必须 `visible = false`
+    /// 而 `visibility = "published"`（刻意的两个独立字段，不许互相推导）。
+    #[test]
+    fn admin_member_visibility_classifies_missing_deleted_and_passthrough() {
+        assert_eq!(
+            game_distribution_theme_member_visibility(false, false, "published"),
+            GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_MISSING,
+            "作品行不存在 → missing"
+        );
+        assert_eq!(
+            game_distribution_theme_member_visibility(false, true, "published"),
+            GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_MISSING,
+            "没有行就无从谈起 deleted_at：missing 必须优先于 deleted"
+        );
+        assert_eq!(
+            game_distribution_theme_member_visibility(true, true, "published"),
+            GAME_DISTRIBUTION_THEME_MEMBER_VISIBILITY_DELETED
+        );
+        for visibility in ["unpublished", "published", "suspended"] {
+            assert_eq!(
+                game_distribution_theme_member_visibility(true, false, visibility),
+                visibility,
+                "未删且行存在时原样透传作品的 visibility"
+            );
+        }
+
+        // 三类「当前不可见」各一条（未公开 / 已下架 / 已公开但无当前公开版本），逐一断言
+        // `visible == false`，同时 `visibility` 仍是原样透传的那个值：两个字段不许互相推导。
+        for (visibility, is_published, has_public_version) in [
+            ("unpublished", false, true),
+            ("suspended", false, true),
+            ("published", true, false),
+        ] {
+            assert_eq!(
+                game_distribution_theme_member_visibility(true, false, visibility),
+                visibility
+            );
+            assert!(
+                !game_distribution_theme_member_visible(false, is_published, has_public_version),
+                "{visibility}（published={is_published}, has_version={has_public_version}）此刻必须不可见"
+            );
+        }
+
+        assert!(
+            !game_distribution_theme_member_visible(false, false, false),
+            "missing 行（没有作品行）不可能可见"
+        );
+        assert!(
+            !game_distribution_theme_member_visible(true, true, true),
+            "软删除行不可能可见"
+        );
+    }
+
+    /// 后台成员游标：与主题列表**共用同一份解析实现**（因此共用同一个可达的稳定码），
+    /// 只切第一个冒号（`member_id` 自带冒号），非法输入仍一律 `Err`。
+    #[test]
+    fn admin_member_cursor_delegates_to_the_theme_cursor_parser() {
+        let cursor = encode_game_distribution_theme_member_cursor(3, "theme_a:game_b");
+        assert_eq!(cursor, "3:theme_a:game_b");
+        assert_eq!(
+            parse_game_distribution_theme_member_cursor(&cursor).unwrap(),
+            (3, "theme_a:game_b".to_string())
+        );
+        // 解析只切第一个冒号：第二段仍是完整的 `{theme_id}:{root_game_id}`。
+        assert_eq!(
+            parse_game_distribution_theme_member_cursor("0:theme_a:game_b").unwrap(),
+            (0, "theme_a:game_b".to_string())
+        );
+        assert_eq!(
+            parse_game_distribution_theme_member_cursor("-7:theme_a:game_b").unwrap(),
+            (-7, "theme_a:game_b".to_string())
+        );
+        let error =
+            parse_game_distribution_theme_member_cursor("不是游标").expect_err("非法游标必须报错");
+        assert!(
+            error.starts_with(crate::GAME_DISTRIBUTION_THEME_INVALID_CURSOR_CODE),
+            "委托解析器意味着两处共用同一个可达的稳定码：{error}"
+        );
+        for malformed in ["", "3", "abc:x", "3:", " :x"] {
+            assert!(
+                parse_game_distribution_theme_member_cursor(malformed).is_err(),
+                "非法游标必须报错：{malformed:?}"
+            );
+        }
+    }
+
+    /// 后台成员分页：复用同一份全序比较器，翻页不重不漏（同权重靠 `member_id` 兜底），
+    /// 末页 `None`，`limit` 归一化与超界截断与其它列表同口径。
+    #[test]
+    fn admin_member_page_walks_every_row_without_gaps() {
+        let rows = vec![
+            member("theme_a:game_c", 2),
+            member("theme_a:game_a", 1),
+            member("theme_a:game_b", 1),
+            member("theme_a:game_d", 9),
+            member("theme_a:game_e", 0),
+        ];
+        let mut seen: Vec<String> = Vec::new();
+        let mut cursor = None;
+        let mut pages = 0;
+        loop {
+            let (page, next) = page_admin_theme_members(rows.clone(), cursor, 2);
+            assert!(!page.is_empty(), "非末页不得为空");
+            if next.is_some() {
+                assert_eq!(page.len(), 2, "还有下一页时必须填满 limit 条");
+            }
+            seen.extend(page);
+            pages += 1;
+            match next {
+                Some(value) => {
+                    cursor = Some(parse_game_distribution_theme_member_cursor(&value).unwrap())
+                }
+                None => break,
+            }
+        }
+        assert_eq!(pages, 3);
+        assert_eq!(
+            seen,
+            vec![
+                "theme_a:game_e",
+                "theme_a:game_a",
+                "theme_a:game_b",
+                "theme_a:game_c",
+                "theme_a:game_d",
+            ],
+            "权重升序 + member_id 升序兜底：全序翻页不重不漏"
+        );
+
+        let (all, next) = page_admin_theme_members(rows.clone(), None, 0);
+        assert_eq!(all.len(), 5, "limit=0 取默认 20：装着五行");
+        assert_eq!(next, None, "末页必须没有游标");
+        let (capped, next) = page_admin_theme_members(rows, None, u32::MAX);
+        assert_eq!(capped.len(), 5, "超界截断到上限 50，仍装得下");
+        assert_eq!(next, None);
+    }
+
+    /// 游标锚在「这一页真正回传的最后一条」上：下一页从它**之后**开始（不重复它）。
+    #[test]
+    fn admin_member_page_cursor_points_at_the_last_returned_row() {
+        let rows = vec![
+            member("theme_a:game_a", 1),
+            member("theme_a:game_b", 3),
+            member("theme_a:game_c", 5),
+        ];
+        let (first, next) = page_admin_theme_members(rows.clone(), None, 1);
+        assert_eq!(first, vec!["theme_a:game_a"]);
+        let cursor = next.expect("还有两行");
+        assert_eq!(cursor, "1:theme_a:game_a");
+        let (second, next) = page_admin_theme_members(
+            rows,
+            Some(parse_game_distribution_theme_member_cursor(&cursor).unwrap()),
+            1,
+        );
+        assert_eq!(second, vec!["theme_a:game_b"]);
+        assert_eq!(next.as_deref(), Some("3:theme_a:game_b"));
+    }
+
+    /// 后台成员切页必须复用**同一份**成员比较器（`sort_theme_members`）与页大小归一化函数，
+    /// 不在切页里另长一套排序 / 另一套 `limit` 语义。
+    #[test]
+    fn admin_member_page_reuses_the_shared_member_comparator_and_limit() {
+        let source = include_str!("theme.rs");
+        let start = source
+            .find("pub fn page_admin_theme_members<T>(")
+            .expect("后台成员切页必须存在");
+        let tail = &source[start..];
+        let body = &tail[..tail.find("\n}\n").expect("函数必须有结尾")];
+        assert!(
+            body.contains("sort_theme_members(items)"),
+            "排序必须复用公开侧同一份比较器（sort_order 升序 + member_id 升序兜底）"
+        );
+        assert!(!body.contains("sort_by"), "不得在切页里自写第二套比较器");
+        assert!(
+            body.contains("game_distribution_theme_page_limit(limit)"),
+            "页大小归一化必须复用同一函数（缺省 20 / 上限 50 / 0 取默认 / 超界截断）"
+        );
+    }
+}
diff --git a/server-rs/crates/module-runtime/src/agc_analytics.rs b/server-rs/crates/module-runtime/src/agc_analytics.rs
index c0c2ed4a4..388c3e1ea 100644
--- a/server-rs/crates/module-runtime/src/agc_analytics.rs
+++ b/server-rs/crates/module-runtime/src/agc_analytics.rs
@@ -386,6 +386,45 @@ mod tests {
         raw["file_path"] = json!("secret");
         assert!(serde_json::from_value::<Event>(raw).is_err());
     }
+
+    /// `creation_source` 的取值集合必须与客户端埋点合同一一对应：客户端新增「从平台作品开始创作」
+    /// （`platform_game`）后，服务端不认得就会把整条事件判成 `invalid_properties` 丢掉。这里把
+    /// 全部受支持取值逐个跑通，并钉住未知取值仍然失败关闭（不得静默接受或静默丢弃）。
+    #[test]
+    fn agc_accepts_every_creation_source_and_rejects_unknown() {
+        for creation_source in [
+            "home_game",
+            "home_design",
+            "template",
+            "selected_directory",
+            "platform_game",
+        ] {
+            let mut e = event(
+                "project_create_success",
+                json!({ "creation_source": creation_source }),
+            );
+            // `project_create_success` 要求 source=editor 且 project_id 非空（见 `EventRules::validate`）。
+            e.project_id = Some("project-a".into());
+            assert_eq!(
+                validate_agc_analytics_batch(&batch(e)),
+                Ok(()),
+                "{creation_source}"
+            );
+        }
+        for unknown in ["remix", "platform", "PLATFORM_GAME", ""] {
+            let mut e = event(
+                "project_create_success",
+                json!({ "creation_source": unknown }),
+            );
+            e.project_id = Some("project-a".into());
+            assert_eq!(
+                validate_agc_analytics_batch(&batch(e)),
+                Err("invalid_properties"),
+                "{unknown}"
+            );
+        }
+    }
+
     #[test]
     fn agc_requires_explicit_nullable_fields_and_no_optional_nulls() {
         let mut raw =
diff --git a/server-rs/crates/pingora-gateway/src/main.rs b/server-rs/crates/pingora-gateway/src/main.rs
index 1f7e2ed13..2d6c77f18 100644
--- a/server-rs/crates/pingora-gateway/src/main.rs
+++ b/server-rs/crates/pingora-gateway/src/main.rs
@@ -68,10 +68,14 @@ const MAIN_SPA_PATHS: &[&str] = &[
     "/design-system",
     "/editor/canvas",
     "/games",
+    "/games/compare",
     "/games/detail",
+    "/games/lineage",
     "/games/mine",
     "/games/play",
     "/games/publish",
+    "/games/theme",
+    "/games/themes",
     "/creators",
     "/creators/connections",
     "/pay",
diff --git a/server-rs/crates/shared-contracts/src/agc_analytics.rs b/server-rs/crates/shared-contracts/src/agc_analytics.rs
index bb26bdebd..6aa8171e3 100644
--- a/server-rs/crates/shared-contracts/src/agc_analytics.rs
+++ b/server-rs/crates/shared-contracts/src/agc_analytics.rs
@@ -55,7 +55,9 @@ values!(CreationSource {
     HomeGame,
     HomeDesign,
     Template,
-    SelectedDirectory
+    SelectedDirectory,
+    // 从平台作品开始创作（改编 Fork）：取件自平台已授权公开作品的发行成品包。
+    PlatformGame
 });
 values!(OpenSource {
     Create,
diff --git a/server-rs/crates/shared-contracts/src/game_distribution.rs b/server-rs/crates/shared-contracts/src/game_distribution.rs
index 8da3e67d0..d44617d59 100644
--- a/server-rs/crates/shared-contracts/src/game_distribution.rs
+++ b/server-rs/crates/shared-contracts/src/game_distribution.rs
@@ -14,6 +14,51 @@ pub const GAME_DISTRIBUTION_CATEGORIES: [&str; 7] =
 /// 客户端要么放行服务端必拒的包（白等一次上传），要么拦掉服务端能收的包。
 pub const GAME_DISTRIBUTION_MAX_PACKAGE_BYTES: u64 = 200 * 1024 * 1024;
 
+/// 版本号无法分配时的统一错误前缀（只在自动递增溢出时使用）。
+///
+/// 旧的「必须严格大于当前最大版本号」限制已经取消：同一 gameId 的同一个版本号可以反复提交，
+/// 每次生成新的 versionId，也允许回退到更小的标签。显式版本号只要求 `>= 1`，`0` 这类非法值
+/// 走普通 400；只有旧客户端缺省时按最大版本号自动递增、撞上 `u64::MAX` 才会带上此前缀，
+/// api-server 据此映射成 HTTP 409。
+pub const GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT: &str = "VERSION_NUMBER_CONFLICT";
+
+/// 收藏（收录）被拒的统一文案：作品存在，但当前**不可收藏**（未公开 / 已软删除 / 没有当前公开版本）。
+///
+/// 两处共用同一个常量，避免只改一边就让 HTTP 语义漂移：
+/// - `spacetime-module` 的 `ensure_game_distribution_collectable` 返回它；
+/// - `api-server` 的 `map_spacetime_error` 靠其中的 `状态` 子串命中 **409** 分支。
+///
+/// 文案刻意**不含**「不存在」与「已被删除」：那两个子串会先命中 404 分支，等于用错误码对外
+/// 确认未公开作品的存在性（与软删除作品按「不存在」处理同一口径）。
+pub const GAME_DISTRIBUTION_COLLECTION_STATE_CONFLICT: &str =
+    "作品状态不允许收藏（未公开或已软删除）";
+
+/// 共创主题相关错误的稳定前缀码（`模块前缀_原因`，与 `FORK_*` 同族写法）。
+///
+/// 领域侧（`spacetime-module`）与 api-server 的集中映射**共用这些常量**：新增一种主题错误只需
+/// 在这里加一个码并在映射表里加一行，不会出现「事务里写了一个没人认识的字符串」这种静默漂移。
+/// 公开侧刻意**不带**这些码：主题不存在 / 未发布一律只回「主题不存在」文案（不确认未发布主题的
+/// 存在性），因此公开的 404 与这里的 `THEME_NOT_FOUND` 是两条不同的路径。
+pub const GAME_DISTRIBUTION_THEME_NOT_FOUND: &str = "THEME_NOT_FOUND";
+/// 后台请求参数非法：空 `name` / 非法 `status`（含列表过滤值）。
+pub const GAME_DISTRIBUTION_THEME_BAD_REQUEST: &str = "THEME_BAD_REQUEST";
+/// 主题列表游标格式非法。
+pub const GAME_DISTRIBUTION_THEME_INVALID_CURSOR: &str = "THEME_INVALID_CURSOR";
+/// 同 `Idempotency-Key` 不同请求摘要。
+pub const GAME_DISTRIBUTION_THEME_IDEMPOTENCY_CONFLICT: &str = "THEME_IDEMPOTENCY_CONFLICT";
+/// 目标作品有血缘行（非根），不能作为主题成员。
+pub const GAME_DISTRIBUTION_THEME_MEMBER_NOT_ROOT: &str = "THEME_MEMBER_NOT_ROOT";
+/// 目标作品不存在。
+pub const GAME_DISTRIBUTION_THEME_MEMBER_GAME_NOT_FOUND: &str = "THEME_MEMBER_GAME_NOT_FOUND";
+
+/// 公开游戏目录（游戏广场）游标格式非法的稳定码。
+///
+/// 与 `THEME_INVALID_CURSOR` 同族但**不同前缀**：目录是作品列表、主题是运营归组，两组码各归各的
+/// 映射分支，混用会让「非法目录游标」被当成主题错误去查主题表。api-server 的 `CATALOG_` 分支
+/// 排在「不存在 / 状态」等子串分支之前，因此模块产出的文案也**不得**含 `FORK_` / `THEME_`
+/// （那两个 `contains` 分支更早命中），这一点由两侧的单测同时钉住。
+pub const GAME_DISTRIBUTION_CATALOG_INVALID_CURSOR: &str = "CATALOG_INVALID_CURSOR";
+
 /// 游戏分发发布媒体在对象存储里的内部前缀。
 ///
 /// 写入端（api-server）与只读授权端（spacetime-module）共用这一段常量：objectKey 形如
@@ -144,6 +189,12 @@ pub struct GameDistributionVersionSummary {
     pub sha256: String,
     pub published_at: String,
     pub controls: Vec<String>,
+    /// 本版相对改编来源作品的核心改动说明（衍生作品必有；母版为 `None`）。
+    ///
+    /// 版本级字段：同一作品的不同代版本各有各的说明，详情页与族谱溯源据此展示「每一代的差异」。
+    /// 公开投影与作者侧读到的是同一列，它不含任何私有字段（不含对象键 / 素材 id）。
+    #[serde(default)]
+    pub change_summary: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
@@ -178,6 +229,38 @@ pub struct GameDistributionGameSummary {
     /// 公开列表/详情保证返回；作者侧及旧响应可省略。
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub rating_summary: Option<GameDistributionRatingSummary>,
+    /// 作品级共创授权档位；缺省按「禁止共创」解释。
+    #[serde(default)]
+    pub fork_authorization: GameDistributionForkAuthorization,
+    /// 直接改编该作品的已公开作品数。
+    #[serde(default)]
+    pub fork_count: u64,
+    /// 该作品子树里**公开可见的全部后代**数（不含自己）——网页端「共创次数」。
+    ///
+    /// 与 `fork_count`（只看**直接**子代）刻意不同：本字段数整棵子树的可见后代。口径 = 未软删除
+    /// + 已公开，与 `fork_count` 共用同一批可见性规则，只是深度不同。**公开投影**
+    /// （公开目录 / 公开详情 / 我的收藏 / 主题成员）恒发；作者侧同形响应可省略（旧响应也缺省），
+    /// 读取方按 `0` 兜底。
+    #[serde(default)]
+    pub co_creation_count: u64,
+    /// 该作品的改编来源；母版为空。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lineage: Option<GameDistributionLineage>,
+    /// 当前登录用户是否已收藏（收录）该作品。
+    ///
+    /// **只有公开详情在登录时下发**：匿名请求（含携带无效 token 按匿名处理）不发这个键，
+    /// 也不发 `false`——`false` 会把「未登录」说成「没收藏」，客户端无法区分，就会渲染出
+    /// 错误的收藏按钮态。公开目录不填。值来自 `is_game_distribution_collected_and_return`
+    /// 的真实投影，不是客户端本地状态。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collected: Option<bool>,
+    /// 该作品所属的**公开**共创主题：先取作品的根、再按根反查成员行（跨主题多归属，因此是数组）。
+    ///
+    /// **只有公开详情下发**（匿名与登录都发；没有所属主题时发空数组，展示层不渲染空容器）；
+    /// 公开列表与作者侧不发该键。第 N 代作品同样能看到主题——反查用的是**根**，不是作品自身。
+    /// 排序与公开主题列表共用同一份比较器（创建时间倒序 + `theme_id` 升序兜底）。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub themes: Option<Vec<GameDistributionThemeReference>>,
     /// 买断制价格（泥点）；`0` 表示免费。旧响应可省略，按免费处理。
     #[serde(default)]
     pub price_mud_points: u64,
@@ -186,6 +269,232 @@ pub struct GameDistributionGameSummary {
     pub purchased: bool,
 }
 
+/// 作品级共创（Fork）授权档位：只允许单向提升开放度。
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum GameDistributionForkAuthorization {
+    /// 仅可游玩，不可复刻改编。
+    #[default]
+    Forbidden,
+    /// 可二次开发，禁止盈利。
+    NonCommercial,
+    /// 可改编、可商用、可发布新版本。
+    Full,
+}
+
+/// 公开的改编血缘摘要：只含作品级信息，不含对象键与素材键。
+///
+/// `root_title` / `parent_title` 为 `None` 表示对应作品已被软删除，标题不再对外输出；
+/// `parent_author_name` 同理（父作品被删时不回传作者名）。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionLineage {
+    /// 代际；直接改编母版为 1。
+    pub generation: u32,
+    pub root_game_id: String,
+    pub root_title: Option<String>,
+    pub parent_game_id: String,
+    pub parent_title: Option<String>,
+    #[serde(default)]
+    pub parent_author_name: Option<String>,
+}
+
+/// 创建游戏时可选携带的改编声明；只在全新作品上生效。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionForkDeclaration {
+    pub parent_game_id: String,
+    pub parent_version_id: String,
+}
+
+/// 修改作品共创授权：**只有母版**能提升（只升不降），`expected` 用于并发校验。
+///
+/// 衍生作品（存在血缘行）的档位由创建时继承父作品决定、是终态，任何 `PUT` 都返回 409
+/// `FORK_AUTHORIZATION_INHERITED`（含传同值的幂等重试）。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionSetForkAuthorizationRequest {
+    pub expected_fork_authorization: GameDistributionForkAuthorization,
+    pub fork_authorization: GameDistributionForkAuthorization,
+}
+
+/// 族谱树上对外可见的单个作品节点。
+///
+/// 只带作品级公开信息：不含**素材键 / 内部 id**（例如 `coverAssetId`）；封面对象键
+/// `cover_object_key` 是公开投影的一部分，与公开目录 / 详情同源同口径（都来自游戏行的
+/// `cover_object_key`），无封面时为空。
+/// 只有公开且未软删除的作品会成为节点（锚点可读性由接口在读出前判定，不可读即 404），
+/// 因此标题必然存在；`author_name` 为 `None` 表示作者信息不可得。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionLineageNode {
+    pub game_id: String,
+    pub title: String,
+    #[serde(default)]
+    pub author_name: Option<String>,
+    /// 代际；母版为 0。
+    pub generation: u32,
+    /// 父作品 ID；母版为空。父作品不可用时仍回传 ID，展示层据此降级为「原作品不可用」。
+    #[serde(default)]
+    pub parent_game_id: Option<String>,
+    pub play_count: u64,
+    /// 可见性。当前**只有已公开作品会成为节点**（未公开节点被过滤、未公开锚点直接 404），
+    /// 所以线上取值实际恒为 `published`；保留该字段是为了将来允许非公开节点进入树时
+    /// 不必再改契约，届时展示层按此渲染状态。
+    pub status: GameDistributionVisibility,
+    /// 该节点作品当前生效的封面对象键（与公开目录 / 详情同源，都来自游戏行
+    /// `cover_object_key`）；无封面时为 `null`。只发对象键，**不带** `coverAssetId` 等私有 id。
+    #[serde(default)]
+    pub cover_object_key: Option<String>,
+}
+
+/// 族谱读接口的响应：以根作品为顶的整棵树。
+///
+/// `nodes` 按代际升序、同代按创建时间升序稳定排序，含根（若根可见）；超过节点上限时
+/// 截断尾部并置 `truncated`，不静默丢弃。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionLineageResponse {
+    /// 请求作品所属的根作品 ID；根已删/未公开时仍回传，展示层据此标注树顶不可用。
+    pub root_game_id: String,
+    /// 根节点在可见集合中的投影；根已软删除或未公开时为空。
+    #[serde(default)]
+    pub root: Option<GameDistributionLineageNode>,
+    pub nodes: Vec<GameDistributionLineageNode>,
+    pub truncated: bool,
+}
+
+/// 直接衍生作品（「被改编」）列表的响应；只含对外可见的直接子代。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionDerivedResponse {
+    /// 被改编的父作品 ID。
+    pub game_id: String,
+    pub nodes: Vec<GameDistributionLineageNode>,
+    pub truncated: bool,
+}
+
+/// 归集的指标集合（当前只有游玩数）。
+///
+/// 单独成结构体而不是把字段摊进响应里：将来加点赞 / 收藏 / 收入只需加字段，
+/// 递归定义（`inherited(W) = Σ 直接子代 total`、`total = own + inherited`）与投影形状都不动。
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionContributionTotals {
+    pub play_count: u64,
+}
+
+/// 按代际分解的一条：**只含后代**（不含根自身），`generation` 为绝对代际（与族谱一致）。
+///
+/// 语义：这一条是祖先 `inherited` 里**由这一代自己产生**的那一份，`total` 即该代贡献；
+/// `inherited` 恒为 `0`——该代从更深代际继承到的量已计入更深代际那一条，重复计入会让
+/// 「各代之和」大于祖先的 `inherited`（同一个后代会在多层分解里被重复计数）。
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionContributionGeneration {
+    pub generation: u32,
+    /// 这一代计入分解的后代节点数。
+    pub game_count: u64,
+    pub own: GameDistributionContributionTotals,
+    pub inherited: GameDistributionContributionTotals,
+    pub total: GameDistributionContributionTotals,
+}
+
+/// 直接子代明细的一条：`total` 是该直接子代**含自己整棵子树**的值。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionContributionChild {
+    pub game_id: String,
+    pub generation: u32,
+    pub own: GameDistributionContributionTotals,
+    pub inherited: GameDistributionContributionTotals,
+    pub total: GameDistributionContributionTotals,
+}
+
+/// 作者视角的贡献归集与归因响应（`GET /api/game-distribution/games/{gameId}/contribution`）。
+///
+/// 不变量（在**截断后的子树**上依然成立）：
+/// - `inherited == Σ byGeneration.total == Σ directChildren.total`；
+/// - `total == own + inherited`；
+/// - `nodeCount == Σ byGeneration.gameCount`（= 参与计算的**后代**节点数，不含根）。
+///
+/// `truncated` 为真时 `truncatedReason` 取 `node_limit` / `depth_limit`，未截断为 `null`
+/// （与族谱接口 `truncated` 同约定：超限如实标注，不静默给半个数）。
+/// **本期只做计算**：响应里没有资金 / 分成 / 结算字段。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionContributionResponse {
+    pub game_id: String,
+    pub own: GameDistributionContributionTotals,
+    pub inherited: GameDistributionContributionTotals,
+    pub total: GameDistributionContributionTotals,
+    pub by_generation: Vec<GameDistributionContributionGeneration>,
+    pub direct_children: Vec<GameDistributionContributionChild>,
+    /// 参与计算的后代节点数（不含根）。
+    pub node_count: u64,
+    pub truncated: bool,
+    #[serde(default)]
+    pub truncated_reason: Option<String>,
+}
+
+/// Fork 取件内容的形态。M2a 只有已构建的发行成品包；M2b 引入工程源包后，同一版本同时存在
+/// 两者时优先 `project`。
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum GameDistributionForkSourceKind {
+    /// 已构建的发行成品包（静态可玩产物）。
+    Package,
+    /// 可编辑的工程源包（M2b 引入）。
+    Project,
+}
+
+/// Fork 取件元数据：客户端据此校验取到的内容并决定建项形态。
+///
+/// 只含版本身份与摘要，**不含 OSS 对象键**——下载走同源受鉴权路径 `download_path`，
+/// 对象键只留在服务端。`sha256` / `bytes` 取自版本行已存的发行包摘要，不重新计算。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionForkSource {
+    pub game_id: String,
+    pub version_id: String,
+    pub source: GameDistributionForkSourceKind,
+    pub sha256: String,
+    pub bytes: u64,
+    /// 同源相对路径（如 `/api/game-distribution/games/game_1/fork-source/package`）；
+    /// 客户端按当前 origin 解析后带 Bearer 请求，不接受绝对 URL。
+    pub download_path: String,
+}
+
+/// Fork 取件元数据接口（`GET /api/game-distribution/games/{gameId}/fork-source`）的响应体。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionForkSourceResponse {
+    pub fork_source: GameDistributionForkSource,
+}
+
+/// 收藏（收录）写入 / 取消后的权威投影值。
+///
+/// `collected` 是**调用后**的收藏事实（服务端真实投影，不是前端本地状态），PUT 与 DELETE
+/// 共用一个形状，客户端不需要按「动词」推断结果。
+///
+/// `replayed` 只在带幂等键的「收藏」上有意义：`PUT` 命中同键收据时回 `true`（本次没有产生
+/// 新事实）。`DELETE` 按确定性主键删除、天然幂等，因此**不下发**该键（`None`）。
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionCollectionState {
+    pub collected: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub replayed: Option<bool>,
+}
+
+/// 公开游戏目录（`GET /api/game-distribution/games`）的响应体。
+///
+/// 只含公开可玩的作品（`published` + 未软删除 + 有当前公开版本），逐条是公开投影。**真游标
+/// 分页**：`limit` 缺省 **48**（保持既有首屏语义）、上限 **100**，超界**截断**而非报错；`cursor`
+/// 形如 `"{created_at_micros}:{game_id}"`（与主题 / 收藏列表同一套 `"{micros}:{id}"` 惯例，解析
+/// 只切第一个冒号）；**格式非法 → 400 `CATALOG_INVALID_CURSOR`**（不吞成 200 空页）。排序
+/// `created_at` 倒序 + `game_id` 升序兜底（全序，翻页不重不漏），`next_cursor` 为真实值、
+/// **末页为 `null`**。
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GameDistributionListResponse {
@@ -194,6 +503,144 @@ pub struct GameDistributionListResponse {
     pub next_cursor: Option<String>,
 }
 
+/// 「我的收藏（收录）」列表接口（`GET /api/game-distribution/my-collections`）的响应体。
+///
+/// 形状与公开目录 `GameDistributionListResponse` 一致（同一份公开投影），但**分页语义不同**：
+/// 默认一页 20 条、上限 50 条（公开目录另有自己的口径），排序按「收藏时间倒序 + collection_id
+/// 升序兜底」。`next_cursor` 是真实游标（`"{created_at_micros}:{collection_id}"`），
+/// 最后一页为 `null`；游标格式非法时服务端返回 400。
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionMyCollectionsResponse {
+    pub games: Vec<GameDistributionGameSummary>,
+    #[serde(default)]
+    pub next_cursor: Option<String>,
+}
+
+/// 共创主题的三态处置：`draft`（未发布）/ `published`（公开可见）/ `archived`（归档下架）。
+///
+/// 后台写接口的入参用这个枚举而不是裸字符串：非法取值在反序列化阶段即被拒绝（api-server 映射
+/// 400），不会带着一个「未定义状态」进入事务。模块侧的数据列仍是字符串，配套白名单是
+/// `module_game_distribution::GAME_DISTRIBUTION_THEME_STATUSES`。
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum GameDistributionThemeStatus {
+    /// 已创建但未对外发布：公开侧任何投影都看不到。
+    #[default]
+    Draft,
+    /// 已发布：公开列表、公开详情与作品详情的 `themes` 都会出现。
+    Published,
+    /// 已归档下架：不再公开，但主题行与成员行都保留。
+    Archived,
+}
+
+/// 作品详情「所属主题」增量的单个条目：只够渲染一个跳转入口。
+///
+/// 不含简介与成员数——详情页只需要「这条作品属于哪些主题」和一个能点进去的名字与角标，
+/// 完整信息在主题页（`GameDistributionThemeDetail`）取。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionThemeReference {
+    pub theme_id: String,
+    pub name: String,
+    pub badge: String,
+}
+
+/// 公开主题列表的单条：主题名、简介、角标与**当前公开可见成员数**。
+///
+/// `member_count` 是**真实可见成员数**（同一份成员可见性判定，不含草稿 / 已下架成员），
+/// 不是成员行总数：若回报「全部成员行数」，运营就能通过计数变化探测存在草稿 / 被下架成员。
+/// 也正因为它是真实数，它与详情 `roots` 的长度**在可见成员超过响应体积上限时不再相等**——
+/// 「下面这份 roots 被上限截断」是详情响应上独立的 `roots_truncated` 信号，不要用这个字段反推。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionThemeSummary {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+}
+
+/// 公开主题列表接口（`GET /api/game-distribution/themes`）的响应体。
+///
+/// 只含 `status == published` 的主题。分页沿用既有游标惯例：默认 20 条、上限 50 条、超界截断；
+/// `next_cursor` 是真实游标（`"{created_at_micros}:{theme_id}"`），最后一页为 `null`；游标格式
+/// 非法时服务端返回 400。排序为创建时间倒序 + `theme_id` 升序兜底（全序，翻页不重不漏）。
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionThemeListResponse {
+    pub themes: Vec<GameDistributionThemeSummary>,
+    #[serde(default)]
+    pub next_cursor: Option<String>,
+}
+
+/// 公开主题详情接口（`GET /api/game-distribution/themes/{theme_id}`）的响应体。
+///
+/// 顶层扁平形状与 `GET /games/{gameId}` 同形，不引入第二套包装。`roots` 逐条是**公开目录同一份**
+/// 作品投影（`GameDistributionGameSummary`），排序为 `sort_order` 升序 + `member_id` 升序兜底。
+/// 主题不存在或未发布时接口返回 404（不返回空壳）；已发布但可见成员为空时返回 200 + 空 `roots`。
+///
+/// 两个成员数相关的字段口径**刻意不同，不要互相推导**：
+/// - `member_count` 是**真实可见成员数**（不截断），回答「这个主题有多少棵作品树」；
+/// - `roots_truncated` 才是「**下面这份 `roots` 被响应体积上限截断**」的信号，回答「你看到的是
+///   不是全部」。它与族谱响应上的 `truncated` 是同一个约定（列表被上限截断时置 `true`），
+///   客户端按同一种方式分支；`roots.len()` 与 `member_count` 不等时就必须看这个字段。
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionThemeDetail {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+    pub roots: Vec<GameDistributionGameSummary>,
+    pub roots_truncated: bool,
+}
+
+/// 后台创建主题（`POST /admin/api/game-distribution/themes`）的请求体。
+///
+/// `name` 必填且非空（空名由 api-server 映射 400）；其余字段省略时按「空文本 / 排序 0 /
+/// `draft`」落库——与表列默认一致，因此「省略」与「显式传默认」是同一个请求，幂等摘要也相同。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionCreateThemeRequest {
+    pub name: String,
+    #[serde(default)]
+    pub summary: String,
+    #[serde(default)]
+    pub badge: String,
+    #[serde(default)]
+    pub sort_order: i64,
+    #[serde(default)]
+    pub status: GameDistributionThemeStatus,
+}
+
+/// 后台更新主题（`PUT /admin/api/game-distribution/themes/{theme_id}`）的请求体。
+///
+/// **整体覆盖**这几个字段（不是部分更新）：字段都必填，避免「省略 = 保留旧值」与「省略 = 清空」
+/// 两种解释在客户端之间漂移。`updated_at` 每次生效即刷新。
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionUpdateThemeRequest {
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: GameDistributionThemeStatus,
+}
+
+/// 后台增 / 改成员（`PUT /admin/api/game-distribution/themes/{theme_id}/members/{root_game_id}`）的请求体。
+///
+/// 成员身份完全由路径给出（`theme_id` + `root_game_id`），body 只承载运营权重；重复调用由确定性
+/// 主键保证幂等（同主题同根只有一行，`created_at` 首次写入后不再变）。
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionUpsertThemeMemberRequest {
+    #[serde(default)]
+    pub sort_order: i64,
+}
+
 /// 统一发布与资料编辑共用的游戏展示资料（不含身份字段）。
 ///
 /// 首次发布用它 bootstrap 作品行，同时冻结进版本资料快照；作者编辑资料时复用同一套校验。
@@ -242,6 +689,134 @@ pub struct GameMetadata {
         ts(type = "'landscape' | 'portrait' | 'responsive'")
     )]
     pub orientation: GameDistributionOrientation,
+    /// 上架时选择的共创授权档位；缺省按「禁止共创」解释（与表列默认一致，旧客户端不受影响）。
+    ///
+    /// **只对母版（0 代作品）生效**：带 `fork` 声明时，新作品的档位在创建时**继承父作品当时的
+    /// 档位**，本字段一律被忽略且不报错（旧客户端会惯常带默认值），服务端也不接受「收窄」。
+    /// 继承来的档位是**终态**：衍生作品之后再调 `PUT …/fork-authorization` 一律被拒（409
+    /// `FORK_AUTHORIZATION_INHERITED`），母版才走「只升不降」。父作品为 `forbidden` 时根本建立
+    /// 不了血缘，所以衍生作品不会继承到 `forbidden`。
+    /// 字段形状刻意保持不变（非 `Option` + `#[serde(default)]`）：改了会让幂等摘要漂移。
+    ///
+    /// 写成非 `Option` + `#[serde(default)]` 而不是 `Option<..>`：省略与显式传 `forbidden`
+    /// 得到同一个值，因此 `create_game` 的幂等摘要（对整个请求体取摘要）也相同——省略与显式
+    /// 传默认不会变成两个不同的请求；未知取值由反序列化直接拒绝（api-server 映射 400），
+    /// 不会静默落成 `forbidden`。
+    #[cfg_attr(
+        feature = "ts-bindings",
+        ts(type = "'forbidden' | 'nonCommercial' | 'full'")
+    )]
+    #[serde(default)]
+    pub fork_authorization: GameDistributionForkAuthorization,
+    /// 改编来源声明；只在全新作品上生效，复用既有身份时会被拒绝。
+    ///
+    /// TS 侧标成可选：渲染层**不**提交该键，改编声明由原生发布链路从项目内
+    /// `.agent/fork-source.json` 读取后并入；显式 `null` 与省略在服务端等价。
+    #[cfg_attr(
+        feature = "ts-bindings",
+        ts(optional, type = "{ parentGameId: string, parentVersionId: string }")
+    )]
+    #[serde(default)]
+    pub fork: Option<GameDistributionForkDeclaration>,
+}
+
+#[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>,
+    /// 沿用线上封面时给出既有对象键；同时携带 `cover` 二进制 part 时以 part 为准。
+    #[serde(default)]
+    pub cover_object_key: Option<String>,
+    /// 与最终截图顺序一一对应：`Some(objectKey)` 沿用线上，`None` 取按顺序出现的 `screenshot` 二进制 part。
+    #[serde(default)]
+    pub screenshots: Vec<Option<String>>,
+    pub device_support: GameDistributionDeviceSupport,
+    pub input_modes: Vec<GameDistributionInputMode>,
+    pub orientation: GameDistributionOrientation,
+    /// 上架时选择的共创授权档位；缺省按「禁止共创」解释（与表列默认一致，旧客户端不受影响）。
+    ///
+    /// **只对母版（0 代作品）生效**：带 `fork` 声明时，新作品的档位在创建时**继承父作品当时的
+    /// 档位**，本字段一律被忽略且不报错（旧客户端会惯常带默认值），服务端也不接受「收窄」。
+    /// 继承来的档位是**终态**：衍生作品之后再调 `PUT …/fork-authorization` 一律被拒（409
+    /// `FORK_AUTHORIZATION_INHERITED`），母版才走「只升不降」。父作品为 `forbidden` 时根本建立
+    /// 不了血缘，所以衍生作品不会继承到 `forbidden`。
+    /// 字段形状刻意保持不变（非 `Option` + `#[serde(default)]`）：改了会让幂等摘要漂移。
+    ///
+    /// 写成非 `Option` + `#[serde(default)]` 而不是 `Option<..>`：省略与显式传 `forbidden`
+    /// 得到同一个值，因此 `create_game` 的幂等摘要（对整个请求体取摘要）也相同——省略与显式
+    /// 传默认不会变成两个不同的请求；未知取值由反序列化直接拒绝（api-server 映射 400），
+    /// 不会静默落成 `forbidden`。
+    #[serde(default)]
+    pub fork_authorization: GameDistributionForkAuthorization,
+    /// 改编来源声明；只在全新作品上生效，复用既有身份时会被拒绝。
+    #[serde(default)]
+    pub fork: Option<GameDistributionForkDeclaration>,
+}
+
+/// 旧两步发布路径的创建请求与新统一资料形状的桥接：字段集完全一致，只多一个属于外层身份的
+/// `local_project_id`（由 api-server 单独校验），因此可以按值克隆出等价的 `GameMetadata`
+/// 复用同一套资料校验阈值，避免两套判据漂移。
+impl From<&GameDistributionCreateGameRequest> for GameMetadata {
+    fn from(payload: &GameDistributionCreateGameRequest) -> Self {
+        Self {
+            title: payload.title.clone(),
+            summary: payload.summary.clone(),
+            description: payload.description.clone(),
+            category: payload.category.clone(),
+            tags: payload.tags.clone(),
+            cover_object_key: payload.cover_object_key.clone(),
+            screenshots: payload.screenshots.clone(),
+            device_support: payload.device_support.clone(),
+            input_modes: payload.input_modes.clone(),
+            orientation: payload.orientation.clone(),
+            fork_authorization: payload.fork_authorization.clone(),
+            fork: payload.fork.clone(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GameDistributionCreateVersionRequest {
+    #[serde(default)]
+    pub local_project_id: Option<String>,
+    /// 用户可见的正整数版本标签（AGC 发布面板由工程内部版本序数派生后原样提交）。
+    ///
+    /// 传入时只要求 `>= 1`：同一 gameId 的同一个版本号可以反复提交，每次提交生成新的
+    /// versionId，允许重复标签与回退到更小的版本号，不与已有最大值比较。缺省时保留旧客户端
+    /// 兼容行为：服务端按该游戏已有最大版本号 +1（此时溢出才会返回 409）。
+    /// 缺省时序列化省略该字段，保证旧客户端请求的幂等摘要与升级前一致。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version_number: Option<u64>,
+    /// 作者提交的买断制价格（泥点）；`0` 表示免费，缺省按免费处理。
+    /// 价格随版本冻结，审核通过时与资料一起生效到游戏行。
+    #[serde(default)]
+    pub price_mud_points: u64,
+    pub package_sha256: String,
+    pub package_bytes: u64,
+    pub package_file_count: u32,
+    pub package_entry_path: String,
+    pub game_metadata: GameDistributionCreateGameRequest,
+    /// 「本次核心改动说明」：衍生作品发布新版本时**必填**（按字符计、trim 后 20–500 个字符），
+    /// 0 代母版**忽略**该字段（不校验、不落库）。
+    ///
+    /// 派生作品判定取**血缘行**（该作品有父即衍生），不接受客户端自称；缺失 / 超长一律失败关闭，
+    /// 错误码 `FORK_CHANGE_SUMMARY_REQUIRED` / `FORK_CHANGE_SUMMARY_INVALID`（均 400）。
+    ///
+    /// 写成 `#[serde(default, skip_serializing_if = "Option::is_none")]`：与 `version_number` 同一
+    /// 纪律——api-server 的幂等摘要对整个请求体取摘要，**未携带该字段的旧客户端请求必须逐字节
+    /// 与升级前一致**，否则升级后同 `Idempotency-Key` 的重放会被误判成「同键不同请求」而 409。
+    /// 反过来，真的换了说明又复用同一个键，就该按冲突拒绝（说明是这次请求的一部分）。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub change_summary: Option<String>,
 }
 
 /// 作者编辑游戏级展示资料的请求体。
@@ -289,6 +864,12 @@ pub struct GameDistributionPrivateVersion {
     pub review_reason: Option<String>,
     #[serde(default)]
     pub entry_url: Option<String>,
+    /// 工程源包字节数；`0` 表示该版本未上传工程源包（作者上架时选择不给源码）。
+    #[serde(default)]
+    pub project_bundle_bytes: u64,
+    /// 工程源包整包 SHA-256；未上传为 `None`。**对象键不下发**，只在服务端使用。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project_bundle_sha256: Option<String>,
     pub created_at: String,
     pub updated_at: String,
 }
@@ -384,6 +965,94 @@ mod tests {
         assert!(serialized.get("projectKey").is_none());
     }
 
+    #[test]
+    fn create_version_request_change_summary_is_optional_and_never_serialized_as_null() {
+        let request = |extra: serde_json::Value| {
+            let mut payload = serde_json::json!({
+                "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",
+                },
+            });
+            if let serde_json::Value::Object(fields) = &mut payload {
+                for (key, value) in extra.as_object().expect("extra 必须是对象") {
+                    fields.insert(key.clone(), value.clone());
+                }
+            }
+            payload
+        };
+
+        // 旧客户端不带该字段：解析成 `None`，且序列化时**省略该键**——api-server 对请求体取幂等
+        // 摘要，多出一个 `"changeSummary":null` 会让升级后的重放被误判成不同请求（409）。
+        let legacy: GameDistributionCreateVersionRequest =
+            serde_json::from_value(request(serde_json::json!({}))).expect("旧请求应可解析");
+        assert_eq!(legacy.change_summary, None);
+        let serialized = serde_json::to_value(&legacy).expect("应可序列化");
+        assert!(
+            serialized.get("changeSummary").is_none(),
+            "缺省字段必须整个省略而不是发 null：{serialized}"
+        );
+
+        let with_summary: GameDistributionCreateVersionRequest = serde_json::from_value(request(
+            serde_json::json!({ "changeSummary": "把跳台改成三段，并重画全部背景" }),
+        ))
+        .expect("带说明的请求应可解析");
+        assert_eq!(
+            with_summary.change_summary.as_deref(),
+            Some("把跳台改成三段，并重画全部背景")
+        );
+        let serialized = serde_json::to_value(&with_summary).expect("应可序列化");
+        assert_eq!(
+            serialized["changeSummary"],
+            serde_json::json!("把跳台改成三段，并重画全部背景")
+        );
+    }
+
+    #[test]
+    fn version_summary_change_summary_tolerates_missing_and_null() {
+        // 公开版本负载在母版上发 `null`；旧响应则可能整个缺键——两种都必须能解析。
+        for payload in [
+            serde_json::json!({
+                "id": "version_1",
+                "version": "1",
+                "entryUrl": null,
+                "sha256": "c".repeat(64),
+                "publishedAt": "2026-10-06T00:00:00Z",
+                "controls": [],
+            }),
+            serde_json::json!({
+                "id": "version_1",
+                "version": "1",
+                "entryUrl": null,
+                "sha256": "c".repeat(64),
+                "publishedAt": "2026-10-06T00:00:00Z",
+                "controls": [],
+                "changeSummary": null,
+            }),
+            serde_json::json!({
+                "id": "version_1",
+                "version": "1",
+                "entryUrl": null,
+                "sha256": "c".repeat(64),
+                "publishedAt": "2026-10-06T00:00:00Z",
+                "controls": [],
+                "changeSummary": "把跳台改成三段，并重画全部背景",
+            }),
+        ] {
+            let summary: GameDistributionVersionSummary =
+                serde_json::from_value(payload).expect("版本摘要应可解析");
+            assert_eq!(summary.id, "version_1");
+        }
+    }
+
     #[test]
     fn update_game_metadata_request_round_trips_publication_revision() {
         let payload: GameDistributionUpdateGameMetadataRequest =
diff --git a/server-rs/crates/shared-contracts/src/game_distribution_publish.rs b/server-rs/crates/shared-contracts/src/game_distribution_publish.rs
index 5fcedc3b8..44d9f09d2 100644
--- a/server-rs/crates/shared-contracts/src/game_distribution_publish.rs
+++ b/server-rs/crates/shared-contracts/src/game_distribution_publish.rs
@@ -36,6 +36,12 @@ pub struct NewGameVersionRequest {
     pub package_entry_path: String,
     /// 作品展示资料：首次发布用于 bootstrap 游戏行，同时冻结进版本资料快照。
     pub game_metadata: GameMetadata,
+    /// 「本次核心改动说明」：衍生作品发布新版本时由服务端事务校验；母版忽略。
+    ///
+    /// 与旧两步请求同口径：api-server 原样透传、事务统一判定；未携带该字段的旧客户端请求
+    /// 序列化结果保持逐字节不变（`skip_serializing_if`）。
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub change_summary: Option<String>,
 }
 
 /// 统一发布响应：作者侧游戏投影 + 私有版本投影 + 是否幂等重放。
diff --git a/server-rs/crates/spacetime-client/src/active.rs b/server-rs/crates/spacetime-client/src/active.rs
index 24b179da3..da130208c 100644
--- a/server-rs/crates/spacetime-client/src/active.rs
+++ b/server-rs/crates/spacetime-client/src/active.rs
@@ -23,17 +23,23 @@ mod error_reports;
 pub mod external_api_key;
 pub mod game_distribution;
 pub use game_distribution::{
-    GameDistributionAdminGameListRecordInput, GameDistributionAdminUserReviewListRecordInput,
-    GameDistributionApproveRecordInput, GameDistributionCancelVersionRecordInput,
-    GameDistributionConfirmPackageRecordInput, GameDistributionDeleteGameRecordInput,
+    GameDistributionAdminGameListRecordInput, GameDistributionAdminThemeListRecordInput,
+    GameDistributionAdminThemeMemberListRecordInput,
+    GameDistributionAdminUserReviewListRecordInput, GameDistributionApproveRecordInput,
+    GameDistributionCancelVersionRecordInput, GameDistributionCollectGameRecordInput,
+    GameDistributionConfirmPackageRecordInput, GameDistributionConfirmProjectBundleRecordInput,
+    GameDistributionCreateGameRecordInput, GameDistributionCreateThemeRecordInput,
+    GameDistributionCreateVersionRecordInput, GameDistributionDeleteGameRecordInput,
     GameDistributionFailUploadRecordInput, GameDistributionGetGameRecordInput,
     GameDistributionOwnerGameListRecordInput, GameDistributionPlayCountIncrementRecordInput,
     GameDistributionPublicGameListRecordInput, GameDistributionPublishVersionRecordInput,
     GameDistributionPurchaseRecordInput, GameDistributionRejectRecordInput,
     GameDistributionRestoreRecordInput, GameDistributionReviewGameListRecordInput,
-    GameDistributionReviewModerationRecordInput, GameDistributionSubmitReviewRecordInput,
-    GameDistributionSuspendRecordInput, GameDistributionUnpublishRecordInput,
-    GameDistributionUpdateMetadataRecordInput,
+    GameDistributionReviewModerationRecordInput, GameDistributionSetForkAuthorizationRecordInput,
+    GameDistributionSubmitReviewRecordInput, GameDistributionSuspendRecordInput,
+    GameDistributionThemeMemberRemoveRecordInput, GameDistributionThemeMemberUpsertRecordInput,
+    GameDistributionUncollectGameRecordInput, GameDistributionUnpublishRecordInput,
+    GameDistributionUpdateMetadataRecordInput, GameDistributionUpdateThemeRecordInput,
 };
 #[path = "active/external_generation.rs"]
 pub mod external_generation;
diff --git a/server-rs/crates/spacetime-client/src/active/mapper.rs b/server-rs/crates/spacetime-client/src/active/mapper.rs
index 75e54e3be..641f1c8f6 100644
--- a/server-rs/crates/spacetime-client/src/active/mapper.rs
+++ b/server-rs/crates/spacetime-client/src/active/mapper.rs
@@ -96,13 +96,22 @@ pub use self::external_generation::{
     ExternalGenerationQueueStatsRecord,
 };
 pub use self::game_distribution::{
-    GameDistributionAdminGameRecord, GameDistributionAdminUserReviewDetailRecord,
-    GameDistributionAdminUserReviewListRecord, GameDistributionAdminUserReviewRecord,
-    GameDistributionAdminVersionRecord, GameDistributionGameRecord,
-    GameDistributionOwnerGameRecord, GameDistributionPublicGameRecord,
-    GameDistributionPurchaseRecord, GameDistributionRatingSummaryRecord,
-    GameDistributionReviewGameListRecord, GameDistributionReviewGameRecord,
-    GameDistributionReviewModerationOperationRecord, GameDistributionReviewModerationRecord,
+    GameDistributionAdminGameRecord, GameDistributionAdminThemeMemberListRecord,
+    GameDistributionAdminThemeMemberRecord, GameDistributionAdminThemeMemberRowRecord,
+    GameDistributionAdminThemeMutationRecord, GameDistributionAdminThemeRecord,
+    GameDistributionAdminUserReviewDetailRecord, GameDistributionAdminUserReviewListRecord,
+    GameDistributionAdminUserReviewRecord, GameDistributionAdminVersionRecord,
+    GameDistributionCollectionMutationRecord, GameDistributionContributionChildRecord,
+    GameDistributionContributionGenerationRecord, GameDistributionContributionRecord,
+    GameDistributionContributionTotalsRecord, GameDistributionDerivedGamesRecord,
+    GameDistributionForkSourceRecord, GameDistributionGameRecord,
+    GameDistributionLineageNodeRecord, GameDistributionLineageRecord,
+    GameDistributionLineageTreeRecord, GameDistributionOwnerGameRecord,
+    GameDistributionPublicGameRecord, GameDistributionPurchaseRecord,
+    GameDistributionRatingSummaryRecord, GameDistributionReviewGameListRecord,
+    GameDistributionReviewGameRecord, GameDistributionReviewModerationOperationRecord,
+    GameDistributionReviewModerationRecord, GameDistributionThemeDetailRecord,
+    GameDistributionThemeReferenceRecord, GameDistributionThemeSummaryRecord,
     GameDistributionUserReviewListRecord, GameDistributionUserReviewRecord,
     GameDistributionUserReviewSaveRecord, GameDistributionVersionRecord,
 };
@@ -169,11 +178,20 @@ pub(crate) use self::external_generation::{
 };
 pub(crate) use self::game_distribution::{
     ensure_admin_user_review_result, ensure_user_review_result, map_admin_user_review,
-    map_game_distribution_admin_game_list_result, map_game_distribution_game_result,
+    map_game_distribution_admin_game_list_result, map_game_distribution_admin_theme_list_result,
+    map_game_distribution_admin_theme_member_list_result,
+    map_game_distribution_admin_theme_member_remove_result,
+    map_game_distribution_admin_theme_member_upsert_result,
+    map_game_distribution_admin_theme_mutation_result,
+    map_game_distribution_collection_list_result, map_game_distribution_collection_mutation_result,
+    map_game_distribution_collection_state_result, map_game_distribution_contribution_result,
+    map_game_distribution_derived_games_result, map_game_distribution_fork_source_result,
+    map_game_distribution_game_result, map_game_distribution_lineage_result,
     map_game_distribution_owner_game_list_result, map_game_distribution_public_game_list_result,
     map_game_distribution_public_game_result, map_game_distribution_purchase_result,
-    map_game_distribution_review_list_result, map_game_distribution_version_result,
-    map_review_moderation_operation, map_user_review,
+    map_game_distribution_review_list_result, map_game_distribution_theme_detail_result,
+    map_game_distribution_theme_list_result, map_game_distribution_theme_refs_result,
+    map_game_distribution_version_result, map_review_moderation_operation, map_user_review,
 };
 pub(crate) use self::payment::{
     map_payment_api_key_list_result, map_payment_api_key_result, map_payment_app_list_result,
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
index 48f4bc736..6cf7e12ea 100644
--- a/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs
+++ b/server-rs/crates/spacetime-client/src/active/mapper/game_distribution.rs
@@ -180,6 +180,8 @@ pub struct GameDistributionGameRecord {
     pub cover_object_key: Option<String>,
     pub project_key: Option<String>,
     pub screenshots_json: Option<String>,
+    /// 作品级共创授权档位：`forbidden` / `nonCommercial` / `full`。
+    pub fork_authorization: String,
     /// 买断制价格（泥点）；`0` 表示免费。
     pub price_mud_points: u64,
 }
@@ -213,6 +215,16 @@ pub struct GameDistributionVersionRecord {
     pub updated_at: String,
     /// 创建版本时冻结的资料快照；历史版本可能为空，读取方必须容忍。
     pub metadata_json: Option<String>,
+    /// 工程源包对象键；未上传为 `None`（只在服务端使用，不下发给客户端）。
+    pub project_bundle_object_key: Option<String>,
+    /// 工程源包字节数；`0` 表示未上传。
+    pub project_bundle_bytes: u64,
+    /// 工程源包整包 SHA-256；未上传为 `None`。
+    pub project_bundle_sha256: Option<String>,
+    /// 本版的核心改动说明（衍生作品必有，母版为 `None`）。
+    ///
+    /// 不含私有字段，可直接进入公开投影（`changeSummary`）；展示层按它渲染「每一代的差异」。
+    pub change_summary: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
@@ -244,6 +256,14 @@ pub struct GameDistributionAdminGameRecord {
     pub publication_revision: u64,
     pub created_at: String,
     pub updated_at: String,
+    /// 作品级共创授权档位。
+    pub fork_authorization: String,
+    /// 改编代际；母版为 0。
+    pub lineage_generation: u32,
+    /// 改编来源作品；母版为 None。
+    pub forked_from_game_id: Option<String>,
+    /// 直接改编该作品的已公开作品数。
+    pub derived_count: u64,
     pub versions: Vec<GameDistributionAdminVersionRecord>,
     /// 软删除时间；为空表示未删除。
     pub deleted_at: Option<String>,
@@ -253,6 +273,22 @@ pub struct GameDistributionAdminGameRecord {
 pub struct GameDistributionOwnerGameRecord {
     pub game: GameDistributionGameRecord,
     pub versions: Vec<GameDistributionVersionRecord>,
+    /// 直接改编该作品的已公开作品数（作者页「被改编 N」入口）。
+    pub fork_count: u64,
+}
+
+/// 公开的改编血缘摘要；母版为 `None`。
+///
+/// `root_title` / `parent_title` 为 `None` 表示对应作品已被软删除，标题不再对外输出；
+/// `parent_author_name` 同理。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionLineageRecord {
+    pub generation: u32,
+    pub root_game_id: String,
+    pub root_title: Option<String>,
+    pub parent_game_id: String,
+    pub parent_title: Option<String>,
+    pub parent_author_name: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
@@ -260,6 +296,225 @@ pub struct GameDistributionPublicGameRecord {
     pub game: GameDistributionGameRecord,
     pub current_version: Option<GameDistributionVersionRecord>,
     pub rating_summary: GameDistributionRatingSummaryRecord,
+    /// 直接改编该作品的已公开作品数。
+    pub fork_count: u64,
+    /// 该作品子树里公开可见的全部后代数（不含自己）；口径与 `fork_count` 只差深度。
+    pub co_creation_count: u64,
+    /// 该作品的改编来源；母版为 None。
+    pub lineage: Option<GameDistributionLineageRecord>,
+}
+
+/// 族谱 / 衍生列表的单个对外节点。
+///
+/// 已软删除或未公开的作品不会成为节点（`module_game_distribution::lineage` 的纯函数负责过滤），
+/// 所以标题必然存在；`author_name` 为 `None` 表示作者信息不可得。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionLineageNodeRecord {
+    pub game_id: String,
+    pub title: String,
+    pub author_name: Option<String>,
+    pub generation: u32,
+    pub parent_game_id: Option<String>,
+    pub play_count: u64,
+    pub status: String,
+    /// 封面对象键（游戏行 `cover_object_key`）；与公开目录 / 详情同源，无封面为 `None`。
+    pub cover_object_key: Option<String>,
+}
+
+/// 以某作品根为顶的整棵族谱树。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionLineageTreeRecord {
+    pub root_game_id: String,
+    pub root: Option<GameDistributionLineageNodeRecord>,
+    pub nodes: Vec<GameDistributionLineageNodeRecord>,
+    pub truncated: bool,
+}
+
+/// 某作品的直接衍生作品（「被改编」）列表。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionDerivedGamesRecord {
+    pub game_id: String,
+    pub nodes: Vec<GameDistributionLineageNodeRecord>,
+    pub truncated: bool,
+}
+
+/// 贡献归集 / 归因的指标集合（当前只有游玩数）。
+///
+/// 单独成结构体：将来加点赞 / 收藏 / 收入只需加字段，递归与归因形状都不动。
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionContributionTotalsRecord {
+    pub play_count: u64,
+}
+
+/// 按代际分解的一条（**只含后代**，`generation` 为绝对代际）。
+///
+/// `total` 是这一代对祖先 `inherited` 的贡献（即该代节点自身的量），`inherited` 恒为 0：
+/// 更深代际的量归它们自己那一条，重复计入会让各代之和大于祖先的 `inherited`。
+#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionContributionGenerationRecord {
+    pub generation: u32,
+    pub game_count: u64,
+    pub own: GameDistributionContributionTotalsRecord,
+    pub inherited: GameDistributionContributionTotalsRecord,
+    pub total: GameDistributionContributionTotalsRecord,
+}
+
+/// 直接子代明细的一条：`total` 含该子代整棵子树。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionContributionChildRecord {
+    pub game_id: String,
+    pub generation: u32,
+    pub own: GameDistributionContributionTotalsRecord,
+    pub inherited: GameDistributionContributionTotalsRecord,
+    pub total: GameDistributionContributionTotalsRecord,
+}
+
+/// 作者视角的贡献归集与归因结果。
+///
+/// 不变量：`inherited == Σ by_generation.total == Σ direct_children.total`、
+/// `total == own + inherited`、`node_count == Σ by_generation.game_count`（截断后同样成立）。
+/// **本期只做计算**：没有任何资金 / 分成字段。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionContributionRecord {
+    pub game_id: String,
+    pub own: GameDistributionContributionTotalsRecord,
+    pub inherited: GameDistributionContributionTotalsRecord,
+    pub total: GameDistributionContributionTotalsRecord,
+    pub by_generation: Vec<GameDistributionContributionGenerationRecord>,
+    pub direct_children: Vec<GameDistributionContributionChildRecord>,
+    pub node_count: u64,
+    pub truncated: bool,
+    /// `node_limit` / `depth_limit`；未截断为 `None`。
+    pub truncated_reason: Option<String>,
+}
+
+/// Fork 取件信息（受鉴权内容下发通道的元数据）。
+///
+/// `found == false` 表示游戏行不存在（api-server → 404）；`available == false` 表示行存在但
+/// 不可作为改编来源（已软删除 / 未公开 / 没有当前公开版本 → 409）。**不含对象键**：
+/// 只带版本身份与摘要，下载路径由 api-server 拼同源相对路径。
+///
+/// `project_bundle_*` 是 M2b 的可选第二份资产：`project_bundle_bytes > 0 &&
+/// project_bundle_sha256.is_some()` 才算「有工程源包」，api-server 据此在 `project` 与
+/// `package` 之间选资产；字节数与摘要成对写入，缺一即按没有工程包处理。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionForkSourceRecord {
+    pub found: bool,
+    pub available: bool,
+    pub fork_authorization: String,
+    pub version_id: Option<String>,
+    pub package_sha256: Option<String>,
+    pub package_bytes: Option<u64>,
+    /// 工程源包整包 SHA-256；未上传为 `None`。
+    pub project_bundle_sha256: Option<String>,
+    /// 工程源包字节数；`0` 表示未上传。
+    pub project_bundle_bytes: u64,
+}
+
+/// 收藏（收录）写入 / 取消后的权威投影值。
+///
+/// `collected` 是**调用后**的收藏事实（不是前端本地状态）；`replayed` 只在带幂等键的「收藏」
+/// 上有意义（取消按确定性主键删除，天然幂等，恒为 `false`）。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionCollectionMutationRecord {
+    pub collected: bool,
+    pub replayed: bool,
+}
+
+/// 公开共创主题的对外投影：列表条目与详情头部**共用同一个形状**。
+///
+/// `member_count` 是**当前公开可见成员数**（与详情 `roots` 长度同一个数），不是成员行总数。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionThemeSummaryRecord {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+}
+
+/// 作品详情 `themes` 增量的单个条目：只够渲染一个跳转入口（不含简介与成员数）。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionThemeReferenceRecord {
+    pub theme_id: String,
+    pub name: String,
+    pub badge: String,
+}
+
+/// 公开共创主题详情：主题头 + 可见成员根（逐条公开目录同一份公开投影）。
+///
+/// 主题不存在 / 未发布时模块侧 `ok == false`，这里折成 `Procedure` 错误，由 api-server 的既有
+/// 映射落 404（不返回空壳）；已发布但可见成员为空是**正常**结果（空 `roots`）。
+///
+/// `member_count` 是**真实可见成员数**（与列表 `GameDistributionThemeSummaryRecord::member_count`
+/// 同口径、不截断），`roots_truncated` 才是「这份 `roots` 被响应体积上限截断」的信号——两者是
+/// 独立字段，不要用 `member_count == roots.len()` 反推（可见成员 > 50 时该等式故意不成立）。
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionThemeDetailRecord {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+    pub roots: Vec<GameDistributionPublicGameRecord>,
+    pub roots_truncated: bool,
+}
+
+/// 后台主题行记录：公开投影看不到的列（运营排序、状态、时间戳）与**成员行总数**都在这里。
+///
+/// `member_count` 与公开记录的 `member_count` 语义**刻意不同**：这里是成员行总数（含当前对外
+/// 不可见的成员），公开侧是当前可见成员数。后台没有「不该被探测」的顾虑，运营恰恰需要知道
+/// 自己挂了几行；公开侧报总数则会泄露「存在草稿 / 被下架成员」。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionAdminThemeRecord {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub member_count: u64,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+/// 后台创建 / 更新主题后的权威投影：`replayed` 为 true 表示命中同键幂等收据（本次没有写库）。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionAdminThemeMutationRecord {
+    pub theme: GameDistributionAdminThemeRecord,
+    pub replayed: bool,
+}
+
+/// 后台主题成员行记录（PUT 落成的那一行）。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionAdminThemeMemberRecord {
+    pub theme_id: String,
+    pub root_game_id: String,
+    pub sort_order: i64,
+    pub created_at: String,
+}
+
+/// 后台主题成员**读**行记录（含当前对外不可见的行）：运营核对名单用。
+///
+/// `title` 取游戏行标题，游戏行不存在时为 `None`（api-server 发 `null`）。`visible` 与 `visibility`
+/// 是两个独立口径：前者是「此刻公开投影会不会出现它」，后者是「为什么」——`visibility` 为
+/// `published` 而没有当前公开版本时 `visible = false` 是刻意的。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionAdminThemeMemberRowRecord {
+    pub root_game_id: String,
+    pub title: Option<String>,
+    pub sort_order: i64,
+    pub created_at: String,
+    pub visible: bool,
+    pub visibility: String,
+}
+
+/// 后台主题成员列表记录：**行总数**（不受分页影响）+ 这一页 + 下一页游标（末页 `None`）。
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct GameDistributionAdminThemeMemberListRecord {
+    pub total_members: u64,
+    pub members: Vec<GameDistributionAdminThemeMemberRowRecord>,
+    pub next_cursor: Option<String>,
 }
 
 fn map_game(
@@ -289,6 +544,7 @@ fn map_game(
         project_key: value.project_key,
         cover_object_key: value.cover_object_key,
         screenshots_json: value.screenshots_json,
+        fork_authorization: value.fork_authorization,
         price_mud_points: value.price_mud_points,
     }
 }
@@ -312,6 +568,11 @@ fn map_version(
         created_at: shared_kernel::format_timestamp_micros(value.created_at_micros),
         updated_at: shared_kernel::format_timestamp_micros(value.updated_at_micros),
         metadata_json: value.metadata_json,
+        project_bundle_object_key: value.project_bundle_object_key,
+        project_bundle_bytes: value.project_bundle_bytes,
+        // 生成绑定把 `project_bundle_sha256` 折成 `project_bundle_sha_256`（同 `package_sha_256`）。
+        project_bundle_sha256: value.project_bundle_sha_256,
+        change_summary: value.change_summary,
     }
 }
 
@@ -353,6 +614,10 @@ fn map_admin_game(
         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),
+        fork_authorization: value.fork_authorization,
+        lineage_generation: value.lineage_generation,
+        forked_from_game_id: value.forked_from_game_id,
+        derived_count: value.derived_count,
         versions: value.versions.into_iter().map(map_admin_version).collect(),
         deleted_at: value
             .deleted_at_micros
@@ -360,6 +625,377 @@ fn map_admin_game(
     }
 }
 
+fn map_lineage(
+    value: Option<crate::module_bindings::GameDistributionLineageSnapshot>,
+) -> Option<GameDistributionLineageRecord> {
+    value.map(|value| GameDistributionLineageRecord {
+        generation: value.generation,
+        root_game_id: value.root_game_id,
+        root_title: value.root_title,
+        parent_game_id: value.parent_game_id,
+        parent_title: value.parent_title,
+        parent_author_name: value.parent_author_name,
+    })
+}
+
+fn map_lineage_node(
+    value: crate::module_bindings::GameDistributionLineageNodeSnapshot,
+) -> GameDistributionLineageNodeRecord {
+    GameDistributionLineageNodeRecord {
+        game_id: value.game_id,
+        title: value.title,
+        author_name: value.author_name,
+        generation: value.generation,
+        parent_game_id: value.parent_game_id,
+        play_count: value.play_count,
+        status: value.status,
+        cover_object_key: value.cover_object_key,
+    }
+}
+
+/// 族谱树：`found == false` 表示锚点不可公开读取（不存在 / 未公开 / 已软删除），
+/// 折成 `None` 由 api-server 映射成 404。
+pub(crate) fn map_game_distribution_lineage_result(
+    result: crate::module_bindings::GameDistributionLineageResult,
+) -> Result<Option<GameDistributionLineageTreeRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    if !result.found {
+        return Ok(None);
+    }
+    Ok(Some(GameDistributionLineageTreeRecord {
+        root_game_id: result.root_game_id,
+        root: result.root.map(map_lineage_node),
+        nodes: result.nodes.into_iter().map(map_lineage_node).collect(),
+        truncated: result.truncated,
+    }))
+}
+
+/// 直接衍生作品列表：`found == false` 的语义与族谱一致。
+pub(crate) fn map_game_distribution_derived_games_result(
+    result: crate::module_bindings::GameDistributionDerivedGamesResult,
+) -> Result<Option<GameDistributionDerivedGamesRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    if !result.found {
+        return Ok(None);
+    }
+    Ok(Some(GameDistributionDerivedGamesRecord {
+        game_id: result.game_id,
+        nodes: result.nodes.into_iter().map(map_lineage_node).collect(),
+        truncated: result.truncated,
+    }))
+}
+
+fn map_contribution_totals(
+    value: crate::module_bindings::GameDistributionContributionTotalsSnapshot,
+) -> GameDistributionContributionTotalsRecord {
+    GameDistributionContributionTotalsRecord {
+        play_count: value.play_count,
+    }
+}
+
+/// 贡献归集：`ok == false` 是服务端失败（含 `游戏 owner 不匹配` → api-server 403）；
+/// `found == false` 表示作品不存在 / 已软删除，折成 `None` 由 api-server 映射 404。
+pub(crate) fn map_game_distribution_contribution_result(
+    result: crate::module_bindings::GameDistributionContributionResult,
+) -> Result<Option<GameDistributionContributionRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    if !result.found {
+        return Ok(None);
+    }
+    let Some(contribution) = result.contribution else {
+        // `found == true` 却没有负载是不可能状态：不折成 404（那会把契约破裂说成「作品不存在」）。
+        return Err(SpacetimeClientError::procedure_failed(Some(
+            "贡献归集缺失：found 为真但没有结果负载".to_string(),
+        )));
+    };
+    Ok(Some(GameDistributionContributionRecord {
+        game_id: contribution.game_id,
+        own: map_contribution_totals(contribution.own),
+        inherited: map_contribution_totals(contribution.inherited),
+        total: map_contribution_totals(contribution.total),
+        by_generation: contribution
+            .by_generation
+            .into_iter()
+            .map(|entry| GameDistributionContributionGenerationRecord {
+                generation: entry.generation,
+                game_count: entry.game_count,
+                own: map_contribution_totals(entry.own),
+                inherited: map_contribution_totals(entry.inherited),
+                total: map_contribution_totals(entry.total),
+            })
+            .collect(),
+        direct_children: contribution
+            .direct_children
+            .into_iter()
+            .map(|entry| GameDistributionContributionChildRecord {
+                game_id: entry.game_id,
+                generation: entry.generation,
+                own: map_contribution_totals(entry.own),
+                inherited: map_contribution_totals(entry.inherited),
+                total: map_contribution_totals(entry.total),
+            })
+            .collect(),
+        node_count: contribution.node_count,
+        truncated: contribution.truncated,
+        truncated_reason: contribution.truncated_reason,
+    }))
+}
+
+/// Fork 取件信息：`ok == false` 是服务端失败（走既有错误映射）；`found` / `available` 原样透传，
+/// HTTP 语义（404 / 409 / 403）由 api-server 决定。
+pub(crate) fn map_game_distribution_fork_source_result(
+    result: crate::module_bindings::GameDistributionForkSourceResult,
+) -> Result<GameDistributionForkSourceRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(GameDistributionForkSourceRecord {
+        found: result.found,
+        available: result.available,
+        fork_authorization: result.fork_authorization,
+        version_id: result.version_id,
+        // SpacetimeDB 生成绑定把 `package_sha256` 折成 `package_sha_256`（与版本快照同约定）。
+        package_sha256: result.package_sha_256,
+        package_bytes: result.package_bytes,
+        // 同约定：`project_bundle_sha256` → `project_bundle_sha_256`。
+        project_bundle_sha256: result.project_bundle_sha_256,
+        project_bundle_bytes: result.project_bundle_bytes,
+    })
+}
+
+/// 收藏 / 取消收藏结果：`ok == false` 是服务端失败（走既有错误映射，含 404 / 409）。
+pub(crate) fn map_game_distribution_collection_mutation_result(
+    result: crate::module_bindings::GameDistributionCollectionMutationResult,
+) -> Result<GameDistributionCollectionMutationRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(GameDistributionCollectionMutationRecord {
+        collected: result.collected,
+        replayed: result.replayed,
+    })
+}
+
+/// 公开详情的收藏态：只回传布尔，`ok == false` 走既有错误映射。
+pub(crate) fn map_game_distribution_collection_state_result(
+    result: crate::module_bindings::GameDistributionCollectionStateResult,
+) -> Result<bool, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result.collected)
+}
+
+/// 「我的收藏（收录）」列表：逐条用公开目录同一份公开投影映射，形状因此与公开目录一致。
+///
+/// 同时透传真实的下页游标（`None` = 最后一页），让 api-server 能原样发出 `nextCursor`。
+pub(crate) fn map_game_distribution_collection_list_result(
+    result: crate::module_bindings::GameDistributionCollectionListResult,
+) -> Result<(Vec<GameDistributionPublicGameRecord>, Option<String>), SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok((
+        result.games.into_iter().map(map_public_game).collect(),
+        result.next_cursor,
+    ))
+}
+
+fn map_public_game(
+    value: crate::module_bindings::GameDistributionPublicGameSnapshot,
+) -> GameDistributionPublicGameRecord {
+    GameDistributionPublicGameRecord {
+        game: map_game(value.game),
+        current_version: value.current_version.map(map_version),
+        rating_summary: GameDistributionRatingSummaryRecord {
+            average_score: value.average_score,
+            rating_count: value.rating_count,
+        },
+        fork_count: value.fork_count,
+        co_creation_count: value.co_creation_count,
+        lineage: map_lineage(value.lineage),
+    }
+}
+
+/// 公开主题的对外投影（列表条目与详情头部共用同一个形状）。
+fn map_theme(
+    value: crate::module_bindings::GameDistributionThemeSnapshot,
+) -> GameDistributionThemeSummaryRecord {
+    GameDistributionThemeSummaryRecord {
+        theme_id: value.theme_id,
+        name: value.name,
+        summary: value.summary,
+        badge: value.badge,
+        member_count: value.member_count,
+    }
+}
+
+/// 作品详情 `themes` 增量的单个条目。
+fn map_theme_reference(
+    value: crate::module_bindings::GameDistributionThemeReferenceSnapshot,
+) -> GameDistributionThemeReferenceRecord {
+    GameDistributionThemeReferenceRecord {
+        theme_id: value.theme_id,
+        name: value.name,
+        badge: value.badge,
+    }
+}
+
+/// 公开主题列表：`ok == false` 是服务端失败（游标非法等，走既有错误映射 → 400）。
+///
+/// 同时透传真实的下页游标（`None` = 最后一页），让 api-server 能原样发出 `nextCursor`。
+pub(crate) fn map_game_distribution_theme_list_result(
+    result: crate::module_bindings::GameDistributionThemeListResult,
+) -> Result<(Vec<GameDistributionThemeSummaryRecord>, Option<String>), SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok((
+        result.themes.into_iter().map(map_theme).collect(),
+        result.next_cursor,
+    ))
+}
+
+/// 公开主题详情：`ok == false` 表示主题不存在 / 未发布，折成 `Procedure` 错误由 api-server 映射
+/// 404（这里**不**构造空壳主题，否则「不存在」会被渲染成一个空白的正常主题页）。
+pub(crate) fn map_game_distribution_theme_detail_result(
+    result: crate::module_bindings::GameDistributionThemeDetailResult,
+) -> Result<GameDistributionThemeDetailRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(GameDistributionThemeDetailRecord {
+        theme_id: result.theme_id,
+        name: result.name,
+        summary: result.summary,
+        badge: result.badge,
+        member_count: result.member_count,
+        roots: result.roots.into_iter().map(map_public_game).collect(),
+        roots_truncated: result.roots_truncated,
+    })
+}
+
+/// 作品详情 `themes` 增量：没有所属主题时是空数组（不是错误，也不是 `None`）。
+pub(crate) fn map_game_distribution_theme_refs_result(
+    result: crate::module_bindings::GameDistributionThemeRefsResult,
+) -> Result<Vec<GameDistributionThemeReferenceRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result.themes.into_iter().map(map_theme_reference).collect())
+}
+
+/// 后台主题行（列表条目与写接口返回值共用同一个形状）。
+fn map_admin_theme(
+    value: crate::module_bindings::GameDistributionAdminThemeSnapshot,
+) -> GameDistributionAdminThemeRecord {
+    GameDistributionAdminThemeRecord {
+        theme_id: value.theme_id,
+        name: value.name,
+        summary: value.summary,
+        badge: value.badge,
+        sort_order: value.sort_order,
+        status: value.status,
+        member_count: value.member_count,
+        created_at: shared_kernel::format_timestamp_micros(value.created_at_micros),
+        updated_at: shared_kernel::format_timestamp_micros(value.updated_at_micros),
+    }
+}
+
+/// 后台创建 / 更新主题：`ok == false` 走既有错误映射（400 / 404 / 409）。
+///
+/// `ok == true` 却缺主题行属于服务端契约违背：**不能**降级成「成功但没有内容」——那会让 handler
+/// 把一个空壳当正常主题渲染；这里直接折成错误，让问题在第一次调用就暴露。
+pub(crate) fn map_game_distribution_admin_theme_mutation_result(
+    result: crate::module_bindings::GameDistributionAdminThemeMutationResult,
+) -> Result<GameDistributionAdminThemeMutationRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    let theme = result.theme.ok_or_else(|| {
+        SpacetimeClientError::procedure_failed(Some("主题写接口未回传主题行".to_string()))
+    })?;
+    Ok(GameDistributionAdminThemeMutationRecord {
+        theme: map_admin_theme(theme),
+        replayed: result.replayed,
+    })
+}
+
+/// 后台增 / 改成员：`ok == false` 走既有错误映射；成功时必须有成员行（PUT 的语义就是「落成一行」）。
+pub(crate) fn map_game_distribution_admin_theme_member_upsert_result(
+    result: crate::module_bindings::GameDistributionAdminThemeMemberMutationResult,
+) -> Result<GameDistributionAdminThemeMemberRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    let member = result.member.ok_or_else(|| {
+        SpacetimeClientError::procedure_failed(Some("主题成员写接口未回传成员行".to_string()))
+    })?;
+    Ok(GameDistributionAdminThemeMemberRecord {
+        theme_id: member.theme_id,
+        root_game_id: member.root_game_id,
+        sort_order: member.sort_order,
+        created_at: shared_kernel::format_timestamp_micros(member.created_at_micros),
+    })
+}
+
+/// 后台移除成员：成功时**没有**成员行（行已经不在库里），因此这里只关心 `ok`。
+///
+/// 刻意不回传「之前存不存在」：成员不存在也算成功，重复 DELETE 的响应因此逐字节相同。
+pub(crate) fn map_game_distribution_admin_theme_member_remove_result(
+    result: crate::module_bindings::GameDistributionAdminThemeMemberMutationResult,
+) -> Result<(), SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(())
+}
+
+/// 后台主题成员**列表**：`ok == false` 走既有错误映射（主题不存在 → 404 `THEME_NOT_FOUND`、
+/// 非法游标 → 400 `THEME_INVALID_CURSOR`）。
+///
+/// 成功时空列表是**正常结果**（主题存在但一个成员都没挂），因此这里不把空 `members` 当契约违背；
+/// 行总数与下一页游标原样透传（api-server 据此发 `totalMembers` 与 `nextCursor`，末页 `null`）。
+pub(crate) fn map_game_distribution_admin_theme_member_list_result(
+    result: crate::module_bindings::GameDistributionAdminThemeMemberListResult,
+) -> Result<GameDistributionAdminThemeMemberListRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(GameDistributionAdminThemeMemberListRecord {
+        total_members: result.total_members,
+        members: result
+            .members
+            .into_iter()
+            .map(|row| GameDistributionAdminThemeMemberRowRecord {
+                root_game_id: row.root_game_id,
+                title: row.title,
+                sort_order: row.sort_order,
+                created_at: shared_kernel::format_timestamp_micros(row.created_at_micros),
+                visible: row.visible,
+                visibility: row.visibility,
+            })
+            .collect(),
+        next_cursor: result.next_cursor,
+    })
+}
+
+/// 后台主题列表：含 `draft` / `archived`（可见性过滤只发生在公开路径上）。
+pub(crate) fn map_game_distribution_admin_theme_list_result(
+    result: crate::module_bindings::GameDistributionAdminThemeListResult,
+) -> Result<Vec<GameDistributionAdminThemeRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    Ok(result.themes.into_iter().map(map_admin_theme).collect())
+}
+
 pub(crate) fn map_game_distribution_admin_game_list_result(
     result: crate::module_bindings::GameDistributionAdminGameListResult,
 ) -> Result<(Vec<GameDistributionAdminGameRecord>, Option<String>), SpacetimeClientError> {
@@ -404,28 +1040,24 @@ pub(crate) fn map_game_distribution_owner_game_list_result(
         .map(|value| GameDistributionOwnerGameRecord {
             game: map_game(value.game),
             versions: value.versions.into_iter().map(map_version).collect(),
+            fork_count: value.fork_count,
         })
         .collect())
 }
 
+/// 公开游戏目录：`ok == false` 是服务端失败（游标非法等，走既有错误映射 → 400）。
+///
+/// 同时透传真实的下页游标（`None` = 最后一页），让 api-server 能原样发出 `nextCursor`。
 pub(crate) fn map_game_distribution_public_game_list_result(
     result: crate::module_bindings::GameDistributionGameListProcedureResult,
-) -> Result<Vec<GameDistributionPublicGameRecord>, SpacetimeClientError> {
+) -> Result<(Vec<GameDistributionPublicGameRecord>, Option<String>), 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),
-            rating_summary: GameDistributionRatingSummaryRecord {
-                average_score: value.average_score,
-                rating_count: value.rating_count,
-            },
-        })
-        .collect())
+    Ok((
+        result.games.into_iter().map(map_public_game).collect(),
+        result.next_cursor,
+    ))
 }
 
 pub(crate) fn map_game_distribution_version_result(
@@ -443,14 +1075,7 @@ pub(crate) fn map_game_distribution_public_game_result(
     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),
-        rating_summary: GameDistributionRatingSummaryRecord {
-            average_score: value.average_score,
-            rating_count: value.rating_count,
-        },
-    }))
+    Ok(result.game.map(map_public_game))
 }
 
 pub(crate) fn map_game_distribution_review_list_result(
@@ -462,6 +1087,433 @@ pub(crate) fn map_game_distribution_review_list_result(
     Ok(result.versions.into_iter().map(map_version).collect())
 }
 
+#[cfg(test)]
+mod lineage_result_tests {
+    use super::*;
+
+    fn lineage_result(found: bool) -> crate::module_bindings::GameDistributionLineageResult {
+        crate::module_bindings::GameDistributionLineageResult {
+            ok: true,
+            found,
+            root_game_id: "game-root".to_string(),
+            root: None,
+            nodes: Vec::new(),
+            truncated: false,
+            error_message: None,
+        }
+    }
+
+    fn derived_result(found: bool) -> crate::module_bindings::GameDistributionDerivedGamesResult {
+        crate::module_bindings::GameDistributionDerivedGamesResult {
+            ok: true,
+            found,
+            game_id: "game-root".to_string(),
+            nodes: Vec::new(),
+            truncated: true,
+            error_message: None,
+        }
+    }
+
+    /// 锚点不可读（`found = false`）必须折成 `None` 交给 api-server 映射 404，
+    /// 而不是返回一棵空树——空树会被误读成「这部作品存在但没有衍生」。
+    #[test]
+    fn unreadable_anchor_maps_to_none_for_lineage() {
+        assert!(
+            map_game_distribution_lineage_result(lineage_result(false))
+                .expect("found=false 不是错误")
+                .is_none()
+        );
+        let tree = map_game_distribution_lineage_result(lineage_result(true))
+            .expect("可读锚点")
+            .expect("可读锚点应有树");
+        assert_eq!(tree.root_game_id, "game-root");
+        assert!(!tree.truncated);
+    }
+
+    #[test]
+    fn unreadable_anchor_maps_to_none_for_derived() {
+        assert!(
+            map_game_distribution_derived_games_result(derived_result(false))
+                .expect("found=false 不是错误")
+                .is_none()
+        );
+        let derived = map_game_distribution_derived_games_result(derived_result(true))
+            .expect("可读锚点")
+            .expect("可读锚点应有列表");
+        assert_eq!(derived.game_id, "game-root");
+        assert!(derived.truncated);
+    }
+}
+
+/// 主题相关结果的映射：失败必须折成 `Procedure` 错误（api-server 才能映射 404 / 400），
+/// **不能**折成空壳主题或空列表——空壳会把「主题不存在」渲染成「主题存在但没有内容」，
+/// 而这正是公开详情那条 404 纪律要避免的。`ok = true` + 空 `roots` 则是正常结果（空态）。
+#[cfg(test)]
+mod theme_result_tests {
+    use super::*;
+
+    fn detail_result(ok: bool) -> crate::module_bindings::GameDistributionThemeDetailResult {
+        crate::module_bindings::GameDistributionThemeDetailResult {
+            ok,
+            theme_id: if ok { "theme_a" } else { "" }.to_string(),
+            name: if ok { "主题 theme_a" } else { "" }.to_string(),
+            summary: if ok { "运营简介" } else { "" }.to_string(),
+            badge: if ok { "精选" } else { "" }.to_string(),
+            member_count: if ok { 1 } else { 0 },
+            roots: Vec::new(),
+            roots_truncated: false,
+            error_message: (!ok).then(|| "主题不存在".to_string()),
+        }
+    }
+
+    #[test]
+    fn theme_not_found_maps_to_procedure_error_instead_of_an_empty_theme() {
+        let error = map_game_distribution_theme_detail_result(detail_result(false))
+            .expect_err("ok = false 必须是错误");
+        assert_eq!(error.to_string(), "主题不存在");
+        let detail = map_game_distribution_theme_detail_result(detail_result(true))
+            .expect("已发布主题（哪怕可见成员为空）是正常结果");
+        assert_eq!(detail.theme_id, "theme_a");
+        assert_eq!(detail.member_count, 1);
+        assert!(detail.roots.is_empty(), "空成员不是错误");
+        assert!(!detail.roots_truncated, "未截断必须是 false（不靠缺省值）");
+    }
+
+    /// `member_count` 与 `roots_truncated` 是两个独立口径：映射层不得拿 `roots.len()` 去覆盖任何一个。
+    #[test]
+    fn theme_detail_truncation_flag_survives_mapping_with_a_full_member_count() {
+        let mut result = detail_result(true);
+        result.member_count = 120;
+        result.roots_truncated = true;
+        let detail =
+            map_game_distribution_theme_detail_result(result).expect("已发布主题是正常结果");
+        assert_eq!(
+            detail.member_count, 120,
+            "memberCount 是真实可见成员数，不能被回传条数截回去"
+        );
+        assert!(
+            detail.roots_truncated,
+            "「这份 roots 被截断」必须原样透传到 api-server（否则客户端只能靠两个数猜）"
+        );
+        assert_ne!(
+            detail.member_count,
+            detail.roots.len() as u64,
+            "截断时两个数故意不相等——正是本字段存在的理由"
+        );
+    }
+
+    #[test]
+    fn theme_list_keeps_the_real_cursor_and_refs_map_to_an_empty_array() {
+        let (themes, next_cursor) = map_game_distribution_theme_list_result(
+            crate::module_bindings::GameDistributionThemeListResult {
+                ok: true,
+                themes: vec![crate::module_bindings::GameDistributionThemeSnapshot {
+                    theme_id: "theme_a".to_string(),
+                    name: "主题 theme_a".to_string(),
+                    summary: "运营简介".to_string(),
+                    badge: "精选".to_string(),
+                    member_count: 3,
+                }],
+                next_cursor: Some("100:theme_a".to_string()),
+                error_message: None,
+            },
+        )
+        .expect("列表结果");
+        assert_eq!(themes.len(), 1);
+        assert_eq!(themes[0].member_count, 3);
+        assert_eq!(next_cursor.as_deref(), Some("100:theme_a"));
+
+        let refs = map_game_distribution_theme_refs_result(
+            crate::module_bindings::GameDistributionThemeRefsResult {
+                ok: true,
+                themes: Vec::new(),
+                error_message: None,
+            },
+        )
+        .expect("增量结果");
+        assert!(refs.is_empty(), "没有所属主题是空数组，不是错误");
+
+        let list_error = map_game_distribution_theme_list_result(
+            crate::module_bindings::GameDistributionThemeListResult {
+                ok: false,
+                themes: Vec::new(),
+                next_cursor: None,
+                error_message: Some("主题列表游标格式无效".to_string()),
+            },
+        )
+        .expect_err("非法游标必须是错误（api-server 才能映射 400）");
+        assert_eq!(list_error.to_string(), "主题列表游标格式无效");
+    }
+}
+
+/// 公开游戏目录结果的映射：失败必须折成 `Procedure` 错误（api-server 才能按码映射 400），
+/// 成功必须透传**真实游标**（`None` = 最后一页）。
+///
+/// 修正前这条映射只回 `Vec<GameDistributionPublicGameRecord>`：游标在 facade 这一层就被丢掉，
+/// api-server 只能把 `nextCursor` 写死成 `null`，于是客户端永远翻不到第二页。
+#[cfg(test)]
+mod catalog_result_tests {
+    use super::*;
+
+    #[test]
+    fn catalog_list_keeps_the_real_cursor_and_folds_failures_into_procedure_errors() {
+        let (games, next_cursor) = map_game_distribution_public_game_list_result(
+            crate::module_bindings::GameDistributionGameListProcedureResult {
+                ok: true,
+                games: Vec::new(),
+                next_cursor: Some("1700000000000000:game_a".to_string()),
+                error_message: None,
+            },
+        )
+        .expect("列表结果");
+        assert!(games.is_empty());
+        assert_eq!(next_cursor.as_deref(), Some("1700000000000000:game_a"));
+
+        let (_, last_page) = map_game_distribution_public_game_list_result(
+            crate::module_bindings::GameDistributionGameListProcedureResult {
+                ok: true,
+                games: Vec::new(),
+                next_cursor: None,
+                error_message: None,
+            },
+        )
+        .expect("末页结果");
+        assert_eq!(last_page, None, "末页没有下一页游标");
+
+        let error = map_game_distribution_public_game_list_result(
+            crate::module_bindings::GameDistributionGameListProcedureResult {
+                ok: false,
+                games: Vec::new(),
+                next_cursor: None,
+                error_message: Some("CATALOG_INVALID_CURSOR: 目录游标格式无效".to_string()),
+            },
+        )
+        .expect_err("非法游标必须是错误（api-server 才能映射 400 + 稳定码）");
+        assert_eq!(
+            error.to_string(),
+            "CATALOG_INVALID_CURSOR: 目录游标格式无效"
+        );
+    }
+}
+
+/// 后台主题写接口结果的映射。
+///
+/// 三条纪律：① `ok = false` 必须折成 `Procedure` 错误（api-server 才能按码映射 400 / 404 / 409）；
+/// ② `ok = true` 却没有载荷是**契约违背**，直接失败，不能降级成「成功但没内容」；
+/// ③ 时间戳在这里由微秒折成 `seconds.microsZ` 文本（与后台作品行同一口径）。
+#[cfg(test)]
+mod admin_theme_result_tests {
+    use super::*;
+
+    const CREATED_MICROS: i64 = 1_700_000_000_123_456;
+    const UPDATED_MICROS: i64 = 1_700_000_100_654_321;
+
+    fn admin_theme_snapshot() -> crate::module_bindings::GameDistributionAdminThemeSnapshot {
+        crate::module_bindings::GameDistributionAdminThemeSnapshot {
+            theme_id: "theme_a".to_string(),
+            name: "共创主题".to_string(),
+            summary: "运营简介".to_string(),
+            badge: "精选".to_string(),
+            sort_order: 7,
+            status: "draft".to_string(),
+            member_count: 3,
+            created_at_micros: CREATED_MICROS,
+            updated_at_micros: UPDATED_MICROS,
+        }
+    }
+
+    fn mutation_result(
+        ok: bool,
+        theme: Option<crate::module_bindings::GameDistributionAdminThemeSnapshot>,
+    ) -> crate::module_bindings::GameDistributionAdminThemeMutationResult {
+        crate::module_bindings::GameDistributionAdminThemeMutationResult {
+            ok,
+            replayed: false,
+            theme,
+            error_message: (!ok).then(|| "THEME_NOT_FOUND: 主题不存在".to_string()),
+        }
+    }
+
+    fn member_result(
+        ok: bool,
+        member: Option<crate::module_bindings::GameDistributionAdminThemeMemberSnapshot>,
+    ) -> crate::module_bindings::GameDistributionAdminThemeMemberMutationResult {
+        crate::module_bindings::GameDistributionAdminThemeMemberMutationResult {
+            ok,
+            member,
+            error_message: (!ok).then(|| "THEME_MEMBER_NOT_ROOT: 不是根作品".to_string()),
+        }
+    }
+
+    #[test]
+    fn admin_theme_mutation_keeps_row_status_and_iso_timestamps() {
+        let mut result = mutation_result(true, Some(admin_theme_snapshot()));
+        result.replayed = true;
+        let record = map_game_distribution_admin_theme_mutation_result(result).expect("成功写结果");
+        assert!(record.replayed, "重放必须原样透传");
+        assert_eq!(record.theme.theme_id, "theme_a");
+        // 后台行**必须**保留 draft / archived（公开投影那条路径才过滤可见性）。
+        assert_eq!(record.theme.status, "draft");
+        assert_eq!(record.theme.sort_order, 7);
+        assert_eq!(record.theme.member_count, 3);
+        assert_eq!(record.theme.created_at, "1700000000.123456Z");
+        assert_eq!(record.theme.updated_at, "1700000100.654321Z");
+
+        let error = map_game_distribution_admin_theme_mutation_result(mutation_result(false, None))
+            .expect_err("失败必须是错误");
+        assert_eq!(error.to_string(), "THEME_NOT_FOUND: 主题不存在");
+
+        // `ok = true` 却没有行是契约违背：不能降级成「成功但没有内容」。
+        let missing =
+            map_game_distribution_admin_theme_mutation_result(mutation_result(true, None))
+                .expect_err("缺载荷必须失败关闭");
+        assert!(missing.to_string().contains("未回传主题行"));
+    }
+
+    #[test]
+    fn admin_theme_member_mutation_separates_upsert_from_idempotent_remove() {
+        let member = crate::module_bindings::GameDistributionAdminThemeMemberSnapshot {
+            theme_id: "theme_a".to_string(),
+            root_game_id: "game_root".to_string(),
+            sort_order: 2,
+            created_at_micros: CREATED_MICROS,
+        };
+        let record = map_game_distribution_admin_theme_member_upsert_result(member_result(
+            true,
+            Some(member),
+        ))
+        .expect("PUT 成功");
+        assert_eq!(record.root_game_id, "game_root");
+        assert_eq!(record.sort_order, 2);
+        assert_eq!(record.created_at, "1700000000.123456Z");
+
+        let upsert_error =
+            map_game_distribution_admin_theme_member_upsert_result(member_result(false, None))
+                .expect_err("非根作品必须是错误");
+        assert_eq!(
+            upsert_error.to_string(),
+            "THEME_MEMBER_NOT_ROOT: 不是根作品"
+        );
+        let upsert_missing =
+            map_game_distribution_admin_theme_member_upsert_result(member_result(true, None))
+                .expect_err("PUT 成功却没有成员行是契约违背");
+        assert!(upsert_missing.to_string().contains("未回传成员行"));
+
+        // DELETE 成功时**本来就没有**成员行（行已经不在库里）：这不是契约违背。
+        map_game_distribution_admin_theme_member_remove_result(member_result(true, None))
+            .expect("成员不存在也算成功（幂等删除）");
+        let remove_error =
+            map_game_distribution_admin_theme_member_remove_result(member_result(false, None))
+                .expect_err("主题不存在仍必须是错误");
+        assert_eq!(
+            remove_error.to_string(),
+            "THEME_MEMBER_NOT_ROOT: 不是根作品"
+        );
+    }
+
+    #[test]
+    fn admin_theme_list_maps_drafts_and_fails_closed() {
+        let themes = map_game_distribution_admin_theme_list_result(
+            crate::module_bindings::GameDistributionAdminThemeListResult {
+                ok: true,
+                themes: vec![admin_theme_snapshot()],
+                error_message: None,
+            },
+        )
+        .expect("列表结果");
+        assert_eq!(themes.len(), 1);
+        assert_eq!(themes[0].status, "draft");
+
+        let error = map_game_distribution_admin_theme_list_result(
+            crate::module_bindings::GameDistributionAdminThemeListResult {
+                ok: false,
+                themes: Vec::new(),
+                error_message: Some("THEME_BAD_REQUEST: 未知的主题状态过滤值 hidden".to_string()),
+            },
+        )
+        .expect_err("非法过滤值必须是错误（api-server 才能映射 400）");
+        assert!(error.to_string().contains("THEME_BAD_REQUEST"));
+    }
+
+    /// 后台成员列表：行总数与末页游标原样透传、`visible` / `visibility` 不许互相推导、
+    /// **空成员是正常结果**（主题存在但一个都没挂），失败折成可映射的 `Procedure` 错误。
+    #[test]
+    fn admin_theme_member_list_keeps_totals_and_visibility_columns_apart() {
+        let result = map_game_distribution_admin_theme_member_list_result(
+            crate::module_bindings::GameDistributionAdminThemeMemberListResult {
+                ok: true,
+                theme_id: "theme_a".to_string(),
+                total_members: 2,
+                members: vec![
+                    crate::module_bindings::GameDistributionAdminThemeMemberRowSnapshot {
+                        root_game_id: "game_root".to_string(),
+                        title: Some("作品标题".to_string()),
+                        sort_order: 3,
+                        created_at_micros: CREATED_MICROS,
+                        visible: false,
+                        // 「已公开但没有当前公开版本」：visible=false 而 visibility=published，刻意。
+                        visibility: "published".to_string(),
+                    },
+                    crate::module_bindings::GameDistributionAdminThemeMemberRowSnapshot {
+                        root_game_id: "game_gone".to_string(),
+                        title: None,
+                        sort_order: 9,
+                        created_at_micros: UPDATED_MICROS,
+                        visible: false,
+                        visibility: "missing".to_string(),
+                    },
+                ],
+                next_cursor: Some("3:theme_a:game_root".to_string()),
+                error_message: None,
+            },
+        )
+        .expect("成功读结果");
+        assert_eq!(result.total_members, 2, "行总数原样透传（不受分页影响）");
+        assert_eq!(result.members.len(), 2);
+        assert_eq!(result.members[0].created_at, "1700000000.123456Z");
+        assert!(!result.members[0].visible);
+        assert_eq!(
+            result.members[0].visibility, "published",
+            "visible 与 visibility 是两个独立字段，映射层不许互相推导"
+        );
+        assert_eq!(result.members[1].title, None, "作品行缺失时 title 是 null");
+        assert_eq!(result.members[1].visibility, "missing");
+        assert_eq!(
+            result.next_cursor.as_deref(),
+            Some("3:theme_a:game_root"),
+            "下一页游标原样透传（api-server 据此发 nextCursor）"
+        );
+
+        // 主题存在但一个成员都没挂：空数组 + total 0 是正常结果，不是契约违背。
+        let empty = map_game_distribution_admin_theme_member_list_result(
+            crate::module_bindings::GameDistributionAdminThemeMemberListResult {
+                ok: true,
+                theme_id: "theme_b".to_string(),
+                total_members: 0,
+                members: Vec::new(),
+                next_cursor: None,
+                error_message: None,
+            },
+        )
+        .expect("空名单也成功");
+        assert!(empty.members.is_empty());
+        assert_eq!(empty.next_cursor, None, "末页游标是 None");
+
+        let error = map_game_distribution_admin_theme_member_list_result(
+            crate::module_bindings::GameDistributionAdminThemeMemberListResult {
+                ok: false,
+                theme_id: String::new(),
+                total_members: 0,
+                members: Vec::new(),
+                next_cursor: None,
+                error_message: Some("THEME_NOT_FOUND: 主题不存在".to_string()),
+            },
+        )
+        .expect_err("主题不存在必须是错误（api-server 才能映射 404）");
+        assert_eq!(error.to_string(), "THEME_NOT_FOUND: 主题不存在");
+    }
+}
+
 /// 解析购买/回读统一结果：`(购买记录, 钱包余额, replayed)`。
 pub(crate) fn map_game_distribution_purchase_result(
     result: crate::module_bindings::GameDistributionPurchaseResult,
diff --git a/server-rs/crates/spacetime-client/src/game_distribution.rs b/server-rs/crates/spacetime-client/src/game_distribution.rs
index 82d0da10d..6b6e10023 100644
--- a/server-rs/crates/spacetime-client/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-client/src/game_distribution.rs
@@ -33,6 +33,17 @@ pub struct GameDistributionPublicGameListRecordInput {
     pub category: Option<String>,
     pub limit: u32,
     pub author_id: Option<String>,
+    /// 上一页返回的目录游标（`"{created_at_micros}:{game_id}"`）；`None` = 第一页。
+    ///
+    /// 解析在模块侧事务里，非法格式由服务端回稳定码 `CATALOG_INVALID_CURSOR`（api-server 映射
+    /// 400）；facade 不预校验，避免「客户端挡住的」与「服务端挡住的」变成两套判据。
+    pub cursor: Option<String>,
+    /// 只返回可被共创的作品（AGC「共创」页的过滤）；`false` = 不过滤 = 既有目录行为。
+    ///
+    /// 过滤在事务内、切页之前完成，因此翻开第二页时也仍然只含可共创作品，且末页游标与实际
+    /// 条数一致。取值口径（真值 `1` / `true` 大小写不敏感、非法取值宽容降级成「不过滤」）
+    /// 由 HTTP 面定；facade 只透传已有结论，不在这里重新解释字符串。
+    pub forkable: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -99,6 +110,81 @@ pub struct GameDistributionPublishVersionRecordInput {
     pub idempotency_key: String,
     pub request_digest: String,
     pub now_micros: i64,
+    /// 衍生作品的「本次核心改动说明」；母版传了也会被忽略（落 NULL）。
+    pub change_summary: 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 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,
+    /// 上架时选择的共创授权档位（`forbidden` / `nonCommercial` / `full`）。
+    /// 只对母版生效：带血缘声明时，事务在创建时继承父作品当时的档位并忽略本值（见
+    /// `spacetime-module` 的 `resolve_game_distribution_creation_fork_authorization`）。
+    pub fork_authorization: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+    /// 同一作者的本地项目标识；重复发布会复用既有 game_id。
+    pub local_project_id: Option<String>,
+    /// 改编来源作品；仅全新作品允许携带。
+    pub forked_from_game_id: Option<String>,
+    /// 建立血缘时来源作品的公开版本。
+    pub forked_from_version_id: Option<String>,
+    /// 创建时即持久化的封面 OSS objectKey（发布媒体直传）。
+    pub cover_object_key: Option<String>,
+    /// 创建时即持久化的截图 OSS objectKey JSON 数组。
+    pub screenshots_json: Option<String>,
+}
+
+/// 修改作品共创授权档位；**只有母版**可用（只升不降），衍生作品的档位由创建时继承父作品决定。
+/// 两者都带上期望的当前档位做 CAS。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionSetForkAuthorizationRecordInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub fork_authorization: String,
+    pub expected_fork_authorization: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionCreateVersionRecordInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_id: String,
+    /// 用户可见的正整数版本标签；`None` 时由服务端按已有最大版本号自动 +1（旧客户端兼容）。
+    /// 传入时只要求 `>= 1`：同一 gameId 的同一标签可以反复提交，每次生成新的 version_id。
+    pub version_number: Option<u64>,
+    /// api-server 校验并解析素材后生成的资料快照 JSON。
+    pub metadata_json: 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,
+    /// 本版相对改编来源的核心改动说明；衍生作品必填、母版忽略。
+    ///
+    /// api-server **原样透传**（未 trim、未校验）：规则只在事务里判定一次，
+    /// 避免 HTTP 层与落库层各写一套阈值。
+    pub change_summary: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -116,6 +202,19 @@ pub struct GameDistributionConfirmPackageRecordInput {
     pub updated_at_micros: i64,
 }
 
+/// 作者确认某版本已上传的工程源包（可选资产）；对象键由 api-server 派生后传入。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionConfirmProjectBundleRecordInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub project_bundle_object_key: String,
+    pub project_bundle_bytes: u64,
+    pub project_bundle_sha256: 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,
@@ -234,6 +333,16 @@ pub struct GameDistributionDeleteGameRecordInput {
     pub now_micros: i64,
 }
 
+/// 收藏（收录）公开作品；`user_id` 来自 api-server 的认证主体，调用方不能指定他人。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionCollectGameRecordInput {
+    pub game_id: String,
+    pub user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
 /// 买断制购买；`expected_price_mud_points` 与服务端当前价格 CAS。
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct GameDistributionPurchaseRecordInput {
@@ -245,6 +354,79 @@ pub struct GameDistributionPurchaseRecordInput {
     pub now_micros: i64,
 }
 
+/// 取消收藏（收录）。按确定性主键删除，天然幂等，因此不带幂等键。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionUncollectGameRecordInput {
+    pub game_id: String,
+    pub user_id: String,
+}
+
+/// 后台创建共创主题。`theme_id` 由 api-server 生成（`theme-` + 随机后缀）：请求体里没有这个字段，
+/// 因此外部调用方无法指定主题 ID，而幂等收据仍能记住「首次创建的是哪一行」。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionCreateThemeRecordInput {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub admin_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+/// 后台整体覆盖主题字段（改名 / 简介 / 角标 / 排序 / 状态）。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionUpdateThemeRecordInput {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub admin_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+/// 后台增 / 改主题成员；成员身份由 `(theme_id, root_game_id)` 决定，因此不需要幂等键。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionThemeMemberUpsertRecordInput {
+    pub theme_id: String,
+    pub root_game_id: String,
+    pub sort_order: i64,
+    pub now_micros: i64,
+}
+
+/// 后台移除主题成员；按确定性主键删除，成员不存在也算成功，因此不需要幂等键。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionThemeMemberRemoveRecordInput {
+    pub theme_id: String,
+    pub root_game_id: String,
+}
+
+/// 后台主题列表：`status` 为 `all` / `draft` / `published` / `archived`（缺省 = 全量），无游标。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionAdminThemeListRecordInput {
+    pub status: Option<String>,
+    pub limit: u32,
+}
+
+/// 后台主题成员列表：`theme_id` 必填；`limit` 与其它列表同口径（缺省 20 / 上限 50 / `0` 取默认 /
+/// 超界截断）；`cursor` 形如 `"{sortOrder}:{memberId}"`。
+///
+/// **不套公开可见性过滤、也不要求主题已发布**：返回该主题的全部成员行（含当前不可见的），
+/// `draft` / `archived` 主题照常可读——后台运营要在发布前核对名单。
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GameDistributionAdminThemeMemberListRecordInput {
+    pub theme_id: String,
+    pub limit: u32,
+    pub cursor: Option<String>,
+}
+
 impl SpacetimeClient {
     pub async fn list_admin_game_distribution_user_reviews(
         &self,
@@ -524,15 +706,21 @@ impl SpacetimeClient {
         .await
     }
 
+    /// 公开游戏目录（游标分页）；只含公开可玩的作品。
+    ///
+    /// 返回 `(games, next_cursor)`：`next_cursor` 为 `None` 表示这一页就是最后一页。
+    /// 游标格式非法由模块侧报错，api-server 透传成 400（不吞掉、也不自己造一种 200 的空页）。
     pub async fn list_game_distribution_games(
         &self,
         input: GameDistributionPublicGameListRecordInput,
-    ) -> Result<Vec<GameDistributionPublicGameRecord>, SpacetimeClientError> {
+    ) -> Result<(Vec<GameDistributionPublicGameRecord>, Option<String>), SpacetimeClientError> {
         let input = crate::module_bindings::GameDistributionPublicGameListInput {
             search: input.search,
             category: input.category,
             limit: input.limit,
             author_id: input.author_id,
+            cursor: input.cursor,
+            forkable: input.forkable,
         };
         self.call_after_connect("list_game_distribution_games", move |connection, sender| {
             connection
@@ -615,6 +803,486 @@ impl SpacetimeClient {
         .await
     }
 
+    /// 读取以该作品根为顶的创作族谱树；锚点不可公开读取时返回 `None`，由 api-server 映射 404。
+    pub async fn get_game_distribution_lineage(
+        &self,
+        game_id: String,
+    ) -> Result<Option<GameDistributionLineageTreeRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionLineageInput { game_id };
+        self.call_after_connect(
+            "get_game_distribution_lineage",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .get_game_distribution_lineage_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_lineage_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 读取作者自己作品的贡献归集与归因（递归：子代所有的都算父代的）。
+    ///
+    /// `found == false`（作品不存在 / 已软删除）折成 `None`，由 api-server 映射 404；
+    /// 非作者由 procedure 报 `游戏 owner 不匹配`（api-server → 403）。本期只做计算。
+    pub async fn get_game_distribution_contribution(
+        &self,
+        game_id: String,
+        owner_user_id: String,
+    ) -> Result<Option<GameDistributionContributionRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionContributionInput {
+            game_id,
+            owner_user_id,
+        };
+        self.call_after_connect(
+            "get_game_distribution_contribution",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .get_game_distribution_contribution_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_contribution_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 读取某作品的直接衍生作品（「被改编」列表）；锚点不可公开读取时返回 `None`。
+    pub async fn list_game_distribution_derived_games(
+        &self,
+        game_id: String,
+    ) -> Result<Option<GameDistributionDerivedGamesRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionDerivedGamesInput { game_id };
+        self.call_after_connect(
+            "list_game_distribution_derived_games",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_game_distribution_derived_games_and_return_then(
+                        input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_derived_games_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    /// 读取某作品的 Fork 取件信息（受鉴权内容下发通道的元数据）。
+    ///
+    /// `found` / `available` 原样回传给 api-server，由它映射 404 / 409 / 403；这里不做 HTTP 语义。
+    pub async fn get_game_distribution_fork_source(
+        &self,
+        game_id: String,
+    ) -> Result<GameDistributionForkSourceRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionForkSourceInput { game_id };
+        self.call_after_connect(
+            "get_game_distribution_fork_source",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .get_game_distribution_fork_source_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_fork_source_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 收藏（收录）某公开作品；命中同键幂等收据时回 `replayed = true`。
+    pub async fn set_game_distribution_collection(
+        &self,
+        input: GameDistributionCollectGameRecordInput,
+    ) -> Result<GameDistributionCollectionMutationRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionCollectGameInput {
+            game_id: input.game_id,
+            user_id: input.user_id,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "set_game_distribution_collection",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .set_game_distribution_collection_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_collection_mutation_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 取消收藏（收录）；按确定性主键删除，重复调用结果相同。
+    pub async fn unset_game_distribution_collection(
+        &self,
+        input: GameDistributionUncollectGameRecordInput,
+    ) -> Result<GameDistributionCollectionMutationRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionUncollectGameInput {
+            game_id: input.game_id,
+            user_id: input.user_id,
+        };
+        self.call_after_connect(
+            "unset_game_distribution_collection",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .unset_game_distribution_collection_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_collection_mutation_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 「我的收藏（收录）」列表（分页）；只返回当前公开可读的作品，形状与公开目录一致。
+    ///
+    /// 返回 `(games, next_cursor)`：`next_cursor` 为 `None` 表示这一页就是最后一页。
+    pub async fn list_game_distribution_collections(
+        &self,
+        user_id: String,
+        limit: u32,
+        cursor: Option<String>,
+    ) -> Result<(Vec<GameDistributionPublicGameRecord>, Option<String>), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionCollectionListInput {
+            user_id,
+            limit,
+            cursor,
+        };
+        self.call_after_connect(
+            "list_game_distribution_collections",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_game_distribution_collections_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_collection_list_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 某用户是否已收藏某作品；公开详情用它计算 `collected`。
+    pub async fn is_game_distribution_collected(
+        &self,
+        game_id: String,
+        user_id: String,
+    ) -> Result<bool, SpacetimeClientError> {
+        let input =
+            crate::module_bindings::GameDistributionCollectionStateInput { game_id, user_id };
+        self.call_after_connect(
+            "is_game_distribution_collected",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .is_game_distribution_collected_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_collection_state_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 公开共创主题列表（游标分页）；只含 `published` 主题。
+    ///
+    /// 返回 `(themes, next_cursor)`：`next_cursor` 为 `None` 表示这一页就是最后一页。
+    /// 游标格式非法由模块侧报错，api-server 透传成 400（不吞掉、也不自己造一种 200 的空页）。
+    pub async fn list_game_distribution_themes(
+        &self,
+        limit: u32,
+        cursor: Option<String>,
+    ) -> Result<(Vec<GameDistributionThemeSummaryRecord>, Option<String>), SpacetimeClientError>
+    {
+        let input = crate::module_bindings::GameDistributionThemeListInput { limit, cursor };
+        self.call_after_connect(
+            "list_game_distribution_themes",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_game_distribution_themes_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_theme_list_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 公开共创主题详情：主题头 + 可见成员根（逐条公开目录同一份公开投影）。
+    ///
+    /// 主题不存在 / 未发布时模块侧 `ok == false`，这里折成 `Procedure` 错误，由 api-server 的
+    /// 既有映射落 404（不返回空壳主题）；已发布但可见成员为空是正常结果（空 `roots`）。
+    pub async fn get_game_distribution_theme_detail(
+        &self,
+        theme_id: String,
+    ) -> Result<GameDistributionThemeDetailRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionThemeDetailInput { theme_id };
+        self.call_after_connect(
+            "get_game_distribution_theme_detail",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .get_game_distribution_theme_detail_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_theme_detail_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 某作品所属的公开共创主题（作品详情 `themes` 增量）。
+    ///
+    /// 入参是**作品** ID（任意代）：根解析在事务内用血缘行完成，因此第 N 代作品也能拿到它所属根
+    /// 的主题。没有所属主题时是空数组，不是错误。
+    pub async fn list_game_distribution_theme_refs_for_root(
+        &self,
+        game_id: String,
+    ) -> Result<Vec<GameDistributionThemeReferenceRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionThemeRefsInput { game_id };
+        self.call_after_connect(
+            "list_game_distribution_theme_refs_for_root",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_game_distribution_theme_refs_for_root_and_return_then(
+                        input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_theme_refs_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    /// 后台创建共创主题（`POST /admin/api/game-distribution/themes`）。
+    ///
+    /// `theme_id` 由 api-server 生成后传入（请求体里没有这个字段）；命中同键幂等收据时
+    /// `replayed = true`，且回的是**库里首次创建的那一行**。
+    pub async fn create_game_distribution_theme(
+        &self,
+        input: GameDistributionCreateThemeRecordInput,
+    ) -> Result<GameDistributionAdminThemeMutationRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionCreateThemeInput {
+            theme_id: input.theme_id,
+            name: input.name,
+            summary: input.summary,
+            badge: input.badge,
+            sort_order: input.sort_order,
+            status: input.status,
+            admin_user_id: input.admin_user_id,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "create_game_distribution_theme",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .create_game_distribution_theme_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_admin_theme_mutation_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 后台整体覆盖主题字段（`PUT /admin/api/game-distribution/themes/{theme_id}`）。
+    ///
+    /// `theme_id` 不存在由事务回带码错误（api-server 映射 404）；命中幂等收据的重放不写库。
+    pub async fn update_game_distribution_theme(
+        &self,
+        input: GameDistributionUpdateThemeRecordInput,
+    ) -> Result<GameDistributionAdminThemeMutationRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionUpdateThemeInput {
+            theme_id: input.theme_id,
+            name: input.name,
+            summary: input.summary,
+            badge: input.badge,
+            sort_order: input.sort_order,
+            status: input.status,
+            admin_user_id: input.admin_user_id,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "update_game_distribution_theme",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .update_game_distribution_theme_and_return_then(input, move |_, result| {
+                        let mapped = result
+                            .map_err(SpacetimeClientError::from_sdk_error)
+                            .and_then(map_game_distribution_admin_theme_mutation_result);
+                        send_once(&sender, mapped);
+                    });
+            },
+        )
+        .await
+    }
+
+    /// 后台增 / 改主题成员（`PUT …/members/{root_game_id}`）；幂等由确定性主键保证。
+    pub async fn upsert_game_distribution_theme_member(
+        &self,
+        input: GameDistributionThemeMemberUpsertRecordInput,
+    ) -> Result<GameDistributionAdminThemeMemberRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionThemeMemberUpsertInput {
+            theme_id: input.theme_id,
+            root_game_id: input.root_game_id,
+            sort_order: input.sort_order,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "upsert_game_distribution_theme_member",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .upsert_game_distribution_theme_member_and_return_then(
+                        input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_admin_theme_member_upsert_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    /// 后台移除主题成员（`DELETE …/members/{root_game_id}`）；成员不存在也算成功（幂等）。
+    pub async fn remove_game_distribution_theme_member(
+        &self,
+        input: GameDistributionThemeMemberRemoveRecordInput,
+    ) -> Result<(), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionThemeMemberRemoveInput {
+            theme_id: input.theme_id,
+            root_game_id: input.root_game_id,
+        };
+        self.call_after_connect(
+            "remove_game_distribution_theme_member",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .remove_game_distribution_theme_member_and_return_then(
+                        input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_admin_theme_member_remove_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    /// 后台主题列表：含 `draft` / `archived`，无游标（一次取全，超界截断到上限）。
+    pub async fn list_admin_game_distribution_themes(
+        &self,
+        input: GameDistributionAdminThemeListRecordInput,
+    ) -> Result<Vec<GameDistributionAdminThemeRecord>, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionAdminThemeListInput {
+            status: input.status,
+            limit: input.limit,
+        };
+        self.call_after_connect(
+            "list_admin_game_distribution_themes",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_admin_game_distribution_themes_and_return_then(
+                        input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_admin_theme_list_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
+    /// 后台主题成员列表：返回该主题的**全部成员行**（含当前对外不可见的行），带每行可见性、行总数
+    /// 与下一页游标。
+    ///
+    /// 与公开投影的差别正是本接口存在的理由：**不套公开可见性过滤**、**也不要求主题已发布**——
+    /// 草稿 / 归档主题的成员名单在公开投影里根本读不到，运营却必须在发布前核对。
+    ///
+    /// 主题不存在由事务回带码错误（api-server 映射 404 `THEME_NOT_FOUND`）；非法游标同样由事务回
+    /// 稳定码错误（400 `THEME_INVALID_CURSOR`），这里不吞成「200 + 空页」。
+    pub async fn list_admin_game_distribution_theme_members(
+        &self,
+        input: GameDistributionAdminThemeMemberListRecordInput,
+    ) -> Result<GameDistributionAdminThemeMemberListRecord, SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionAdminThemeMemberListInput {
+            theme_id: input.theme_id,
+            limit: input.limit,
+            cursor: input.cursor,
+        };
+        self.call_after_connect(
+            "list_admin_game_distribution_theme_members",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .list_admin_game_distribution_theme_members_and_return_then(
+                        input,
+                        move |_, result| {
+                            let mapped = result
+                                .map_err(SpacetimeClientError::from_sdk_error)
+                                .and_then(map_game_distribution_admin_theme_member_list_result);
+                            send_once(&sender, mapped);
+                        },
+                    );
+            },
+        )
+        .await
+    }
+
     /// 按 OSS objectKey 判定公开媒体是否可匿名读取；只回公开授权布尔。
     pub async fn get_game_distribution_media_read_access(
         &self,
@@ -729,6 +1397,7 @@ impl SpacetimeClient {
             idempotency_key: input.idempotency_key,
             request_digest: input.request_digest,
             now_micros: input.now_micros,
+            change_summary: input.change_summary,
         };
         self.call_after_connect(
             "publish_game_distribution_version",
@@ -758,6 +1427,134 @@ impl SpacetimeClient {
         .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,
+            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,
+            fork_authorization: input.fork_authorization,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+            local_project_id: input.local_project_id,
+            forked_from_game_id: input.forked_from_game_id,
+            forked_from_version_id: input.forked_from_version_id,
+            cover_object_key: input.cover_object_key,
+            screenshots_json: input.screenshots_json,
+        };
+        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 set_game_distribution_fork_authorization(
+        &self,
+        input: GameDistributionSetForkAuthorizationRecordInput,
+    ) -> Result<(GameDistributionGameRecord, bool), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionSetForkAuthorizationInput {
+            game_id: input.game_id,
+            owner_user_id: input.owner_user_id,
+            fork_authorization: input.fork_authorization,
+            expected_fork_authorization: input.expected_fork_authorization,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            now_micros: input.now_micros,
+        };
+        self.call_after_connect(
+            "set_game_distribution_fork_authorization",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .set_game_distribution_fork_authorization_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,
+            version_number: input.version_number,
+            metadata_json: input.metadata_json,
+            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,
+            change_summary: input.change_summary,
+        };
+        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,
@@ -845,6 +1642,49 @@ impl SpacetimeClient {
         .await
     }
 
+    /// 确认某版本已上传的工程源包（可选资产）。
+    ///
+    /// 与 `confirm_game_distribution_package` 分开：工程源包不驱动版本状态机，摘要与字节数随请求
+    /// 带上（没有创建版本时预登记的包摘要可比），阶段门由事务按「尚未公开」判定。
+    pub async fn confirm_game_distribution_project_bundle(
+        &self,
+        input: GameDistributionConfirmProjectBundleRecordInput,
+    ) -> Result<(GameDistributionVersionRecord, bool), SpacetimeClientError> {
+        let input = crate::module_bindings::GameDistributionConfirmProjectBundleInput {
+            version_id: input.version_id,
+            owner_user_id: input.owner_user_id,
+            project_bundle_object_key: input.project_bundle_object_key,
+            project_bundle_bytes: input.project_bundle_bytes,
+            // 生成绑定把 `project_bundle_sha256` 折成 `project_bundle_sha_256`。
+            project_bundle_sha_256: input.project_bundle_sha256,
+            idempotency_key: input.idempotency_key,
+            request_digest: input.request_digest,
+            updated_at_micros: input.updated_at_micros,
+        };
+        self.call_after_connect(
+            "confirm_game_distribution_project_bundle",
+            move |connection, sender| {
+                connection
+                    .procedures()
+                    .confirm_game_distribution_project_bundle_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 fail_game_distribution_upload(
         &self,
         input: GameDistributionFailUploadRecordInput,
diff --git a/server-rs/crates/spacetime-client/src/module_bindings.rs b/server-rs/crates/spacetime-client/src/module_bindings.rs
index b7698ac4c..176edc086 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings.rs
@@ -161,6 +161,7 @@ pub mod complete_profile_recharge_order_expiration_schedule_and_return_procedure
 pub mod confirm_asset_object_and_return_procedure;
 pub mod confirm_asset_object_reducer;
 pub mod confirm_game_distribution_package_and_return_procedure;
+pub mod confirm_game_distribution_project_bundle_and_return_procedure;
 pub mod consume_profile_wallet_points_and_return_procedure;
 pub mod create_admin_account_and_return_procedure;
 pub mod create_ai_task_and_return_procedure;
@@ -172,6 +173,9 @@ pub mod create_editor_project_and_return_procedure;
 pub mod create_editor_project_resource_and_return_procedure;
 pub mod create_error_report_and_return_procedure;
 pub mod create_external_api_key_and_return_procedure;
+pub mod create_game_distribution_game_and_return_procedure;
+pub mod create_game_distribution_theme_and_return_procedure;
+pub mod create_game_distribution_version_and_return_procedure;
 pub mod create_payment_api_key_and_return_procedure;
 pub mod create_payment_app_and_return_procedure;
 pub mod create_payment_order_and_return_procedure;
@@ -422,6 +426,15 @@ pub mod follow_creator_and_return_procedure;
 pub mod game_distribution_admin_game_list_input_type;
 pub mod game_distribution_admin_game_list_result_type;
 pub mod game_distribution_admin_game_snapshot_type;
+pub mod game_distribution_admin_theme_list_input_type;
+pub mod game_distribution_admin_theme_list_result_type;
+pub mod game_distribution_admin_theme_member_list_input_type;
+pub mod game_distribution_admin_theme_member_list_result_type;
+pub mod game_distribution_admin_theme_member_mutation_result_type;
+pub mod game_distribution_admin_theme_member_row_snapshot_type;
+pub mod game_distribution_admin_theme_member_snapshot_type;
+pub mod game_distribution_admin_theme_mutation_result_type;
+pub mod game_distribution_admin_theme_snapshot_type;
 pub mod game_distribution_admin_user_review_input_type;
 pub mod game_distribution_admin_user_review_list_input_type;
 pub mod game_distribution_admin_user_review_result_type;
@@ -429,9 +442,31 @@ pub mod game_distribution_admin_user_review_snapshot_type;
 pub mod game_distribution_admin_version_snapshot_type;
 pub mod game_distribution_approve_input_type;
 pub mod game_distribution_cancel_version_input_type;
+pub mod game_distribution_collect_game_input_type;
+pub mod game_distribution_collection_list_input_type;
+pub mod game_distribution_collection_list_result_type;
+pub mod game_distribution_collection_mutation_result_type;
+pub mod game_distribution_collection_state_input_type;
+pub mod game_distribution_collection_state_result_type;
+pub mod game_distribution_collection_table;
+pub mod game_distribution_collection_type;
 pub mod game_distribution_confirm_package_input_type;
+pub mod game_distribution_confirm_project_bundle_input_type;
+pub mod game_distribution_contribution_child_snapshot_type;
+pub mod game_distribution_contribution_generation_snapshot_type;
+pub mod game_distribution_contribution_input_type;
+pub mod game_distribution_contribution_result_type;
+pub mod game_distribution_contribution_snapshot_type;
+pub mod game_distribution_contribution_totals_snapshot_type;
+pub mod game_distribution_create_game_input_type;
+pub mod game_distribution_create_theme_input_type;
+pub mod game_distribution_create_version_input_type;
 pub mod game_distribution_delete_game_input_type;
+pub mod game_distribution_derived_games_input_type;
+pub mod game_distribution_derived_games_result_type;
 pub mod game_distribution_fail_upload_input_type;
+pub mod game_distribution_fork_source_input_type;
+pub mod game_distribution_fork_source_result_type;
 pub mod game_distribution_game_list_procedure_result_type;
 pub mod game_distribution_game_procedure_result_type;
 pub mod game_distribution_game_snapshot_type;
@@ -440,6 +475,12 @@ pub mod game_distribution_game_type;
 pub mod game_distribution_get_game_input_type;
 pub mod game_distribution_idempotency_receipt_table;
 pub mod game_distribution_idempotency_receipt_type;
+pub mod game_distribution_lineage_input_type;
+pub mod game_distribution_lineage_node_snapshot_type;
+pub mod game_distribution_lineage_result_type;
+pub mod game_distribution_lineage_snapshot_type;
+pub mod game_distribution_lineage_table;
+pub mod game_distribution_lineage_type;
 pub mod game_distribution_media_read_access_procedure_result_type;
 pub mod game_distribution_my_review_input_type;
 pub mod game_distribution_owner_game_list_input_type;
@@ -470,10 +511,27 @@ pub mod game_distribution_review_moderation_log_type;
 pub mod game_distribution_review_moderation_operation_snapshot_type;
 pub mod game_distribution_review_table;
 pub mod game_distribution_review_type;
+pub mod game_distribution_set_fork_authorization_input_type;
 pub mod game_distribution_submit_review_input_type;
 pub mod game_distribution_suspend_input_type;
+pub mod game_distribution_theme_detail_input_type;
+pub mod game_distribution_theme_detail_result_type;
+pub mod game_distribution_theme_list_input_type;
+pub mod game_distribution_theme_list_result_type;
+pub mod game_distribution_theme_member_remove_input_type;
+pub mod game_distribution_theme_member_table;
+pub mod game_distribution_theme_member_type;
+pub mod game_distribution_theme_member_upsert_input_type;
+pub mod game_distribution_theme_reference_snapshot_type;
+pub mod game_distribution_theme_refs_input_type;
+pub mod game_distribution_theme_refs_result_type;
+pub mod game_distribution_theme_snapshot_type;
+pub mod game_distribution_theme_table;
+pub mod game_distribution_theme_type;
+pub mod game_distribution_uncollect_game_input_type;
 pub mod game_distribution_unpublish_input_type;
 pub mod game_distribution_update_metadata_input_type;
+pub mod game_distribution_update_theme_input_type;
 pub mod game_distribution_user_review_input_type;
 pub mod game_distribution_user_review_list_input_type;
 pub mod game_distribution_user_review_result_type;
@@ -504,10 +562,14 @@ pub mod get_external_generation_job_result_and_return_procedure;
 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_contribution_and_return_procedure;
+pub mod get_game_distribution_fork_source_and_return_procedure;
 pub mod get_game_distribution_game_and_return_procedure;
+pub mod get_game_distribution_lineage_and_return_procedure;
 pub mod get_game_distribution_media_read_access_and_return_procedure;
 pub mod get_game_distribution_my_review_and_return_procedure;
 pub mod get_game_distribution_purchase_and_return_procedure;
+pub mod get_game_distribution_theme_detail_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;
@@ -533,8 +595,11 @@ pub mod import_database_migration_incremental_from_chunks_procedure;
 pub mod import_database_migration_incremental_from_file_procedure;
 pub mod increment_game_distribution_game_play_counts_and_return_procedure;
 pub mod initialize_editor_generation_pricing_config_if_missing_and_return_procedure;
+pub mod is_game_distribution_collected_and_return_procedure;
 pub mod list_admin_accounts_and_return_procedure;
 pub mod list_admin_game_distribution_games_and_return_procedure;
+pub mod list_admin_game_distribution_theme_members_and_return_procedure;
+pub mod list_admin_game_distribution_themes_and_return_procedure;
 pub mod list_admin_game_distribution_user_reviews_and_return_procedure;
 pub mod list_agc_tracking_events_procedure;
 pub mod list_asset_history_and_return_procedure;
@@ -545,9 +610,13 @@ pub mod list_error_reports_and_return_procedure;
 pub mod list_external_api_keys_and_return_procedure;
 pub mod list_external_generation_job_summaries_and_return_procedure;
 pub mod list_external_generation_jobs_and_return_procedure;
+pub mod list_game_distribution_collections_and_return_procedure;
+pub mod list_game_distribution_derived_games_and_return_procedure;
 pub mod list_game_distribution_games_and_return_procedure;
 pub mod list_game_distribution_review_games_and_return_procedure;
 pub mod list_game_distribution_reviews_and_return_procedure;
+pub mod list_game_distribution_theme_refs_for_root_and_return_procedure;
+pub mod list_game_distribution_themes_and_return_procedure;
 pub mod list_game_distribution_user_reviews_and_return_procedure;
 pub mod list_owner_game_distribution_games_and_return_procedure;
 pub mod list_payment_api_keys_and_return_procedure;
@@ -700,6 +769,7 @@ pub mod refund_profile_wallet_points_and_return_procedure;
 pub mod reject_game_distribution_version_and_return_procedure;
 pub mod release_profile_recharge_refund_hold_and_return_procedure;
 pub mod remove_creator_follower_and_return_procedure;
+pub mod remove_game_distribution_theme_member_and_return_procedure;
 pub mod rename_editor_project_and_return_procedure;
 pub mod renew_external_generation_job_lease_and_return_procedure;
 pub mod repair_editor_asset_media_and_return_procedure;
@@ -882,6 +952,8 @@ pub mod save_editor_project_layout_v_2_and_return_procedure;
 pub mod save_game_distribution_my_review_and_return_procedure;
 pub mod seed_analytics_date_dimensions_reducer;
 pub mod set_editor_showcase_asset_like_for_viewer_and_return_procedure;
+pub mod set_game_distribution_collection_and_return_procedure;
+pub mod set_game_distribution_fork_authorization_and_return_procedure;
 pub mod set_payment_order_provider_code_and_return_procedure;
 pub mod settle_llm_router_quota_and_return_procedure;
 pub mod start_ai_task_reducer;
@@ -898,6 +970,7 @@ pub mod tracking_event_table;
 pub mod tracking_event_type;
 pub mod unfollow_creator_and_return_procedure;
 pub mod unpublish_game_distribution_game_and_return_procedure;
+pub mod unset_game_distribution_collection_and_return_procedure;
 pub mod update_admin_account_and_return_procedure;
 pub mod update_editor_asset_and_return_procedure;
 pub mod update_editor_asset_folder_and_return_procedure;
@@ -906,11 +979,13 @@ pub mod update_editor_showcase_asset_display_and_return_procedure;
 pub mod update_error_report_and_return_procedure;
 pub mod update_external_generation_job_phase_and_return_procedure;
 pub mod update_game_distribution_game_metadata_and_return_procedure;
+pub mod update_game_distribution_theme_and_return_procedure;
 pub mod update_payment_app_and_return_procedure;
 pub mod upload_agc_analytics_batch_procedure;
 pub mod upsert_editor_generation_pricing_config_and_return_procedure;
 pub mod upsert_editor_showcase_campaign_config_and_return_procedure;
 pub mod upsert_feature_gate_config_procedure;
+pub mod upsert_game_distribution_theme_member_and_return_procedure;
 pub mod upsert_llm_router_account_and_return_procedure;
 pub mod upsert_runtime_setting_and_return_procedure;
 pub mod user_account_table;
@@ -1076,6 +1151,7 @@ pub use complete_profile_recharge_order_expiration_schedule_and_return_procedure
 pub use confirm_asset_object_and_return_procedure::confirm_asset_object_and_return;
 pub use confirm_asset_object_reducer::confirm_asset_object;
 pub use confirm_game_distribution_package_and_return_procedure::confirm_game_distribution_package_and_return;
+pub use confirm_game_distribution_project_bundle_and_return_procedure::confirm_game_distribution_project_bundle_and_return;
 pub use consume_profile_wallet_points_and_return_procedure::consume_profile_wallet_points_and_return;
 pub use create_admin_account_and_return_procedure::create_admin_account_and_return;
 pub use create_ai_task_and_return_procedure::create_ai_task_and_return;
@@ -1087,6 +1163,9 @@ pub use create_editor_project_and_return_procedure::create_editor_project_and_re
 pub use create_editor_project_resource_and_return_procedure::create_editor_project_resource_and_return;
 pub use create_error_report_and_return_procedure::create_error_report_and_return;
 pub use create_external_api_key_and_return_procedure::create_external_api_key_and_return;
+pub use create_game_distribution_game_and_return_procedure::create_game_distribution_game_and_return;
+pub use create_game_distribution_theme_and_return_procedure::create_game_distribution_theme_and_return;
+pub use create_game_distribution_version_and_return_procedure::create_game_distribution_version_and_return;
 pub use create_payment_api_key_and_return_procedure::create_payment_api_key_and_return;
 pub use create_payment_app_and_return_procedure::create_payment_app_and_return;
 pub use create_payment_order_and_return_procedure::create_payment_order_and_return;
@@ -1337,6 +1416,15 @@ pub use follow_creator_and_return_procedure::follow_creator_and_return;
 pub use game_distribution_admin_game_list_input_type::GameDistributionAdminGameListInput;
 pub use game_distribution_admin_game_list_result_type::GameDistributionAdminGameListResult;
 pub use game_distribution_admin_game_snapshot_type::GameDistributionAdminGameSnapshot;
+pub use game_distribution_admin_theme_list_input_type::GameDistributionAdminThemeListInput;
+pub use game_distribution_admin_theme_list_result_type::GameDistributionAdminThemeListResult;
+pub use game_distribution_admin_theme_member_list_input_type::GameDistributionAdminThemeMemberListInput;
+pub use game_distribution_admin_theme_member_list_result_type::GameDistributionAdminThemeMemberListResult;
+pub use game_distribution_admin_theme_member_mutation_result_type::GameDistributionAdminThemeMemberMutationResult;
+pub use game_distribution_admin_theme_member_row_snapshot_type::GameDistributionAdminThemeMemberRowSnapshot;
+pub use game_distribution_admin_theme_member_snapshot_type::GameDistributionAdminThemeMemberSnapshot;
+pub use game_distribution_admin_theme_mutation_result_type::GameDistributionAdminThemeMutationResult;
+pub use game_distribution_admin_theme_snapshot_type::GameDistributionAdminThemeSnapshot;
 pub use game_distribution_admin_user_review_input_type::GameDistributionAdminUserReviewInput;
 pub use game_distribution_admin_user_review_list_input_type::GameDistributionAdminUserReviewListInput;
 pub use game_distribution_admin_user_review_result_type::GameDistributionAdminUserReviewResult;
@@ -1344,9 +1432,31 @@ pub use game_distribution_admin_user_review_snapshot_type::GameDistributionAdmin
 pub use game_distribution_admin_version_snapshot_type::GameDistributionAdminVersionSnapshot;
 pub use game_distribution_approve_input_type::GameDistributionApproveInput;
 pub use game_distribution_cancel_version_input_type::GameDistributionCancelVersionInput;
+pub use game_distribution_collect_game_input_type::GameDistributionCollectGameInput;
+pub use game_distribution_collection_list_input_type::GameDistributionCollectionListInput;
+pub use game_distribution_collection_list_result_type::GameDistributionCollectionListResult;
+pub use game_distribution_collection_mutation_result_type::GameDistributionCollectionMutationResult;
+pub use game_distribution_collection_state_input_type::GameDistributionCollectionStateInput;
+pub use game_distribution_collection_state_result_type::GameDistributionCollectionStateResult;
+pub use game_distribution_collection_table::*;
+pub use game_distribution_collection_type::GameDistributionCollection;
 pub use game_distribution_confirm_package_input_type::GameDistributionConfirmPackageInput;
+pub use game_distribution_confirm_project_bundle_input_type::GameDistributionConfirmProjectBundleInput;
+pub use game_distribution_contribution_child_snapshot_type::GameDistributionContributionChildSnapshot;
+pub use game_distribution_contribution_generation_snapshot_type::GameDistributionContributionGenerationSnapshot;
+pub use game_distribution_contribution_input_type::GameDistributionContributionInput;
+pub use game_distribution_contribution_result_type::GameDistributionContributionResult;
+pub use game_distribution_contribution_snapshot_type::GameDistributionContributionSnapshot;
+pub use game_distribution_contribution_totals_snapshot_type::GameDistributionContributionTotalsSnapshot;
+pub use game_distribution_create_game_input_type::GameDistributionCreateGameInput;
+pub use game_distribution_create_theme_input_type::GameDistributionCreateThemeInput;
+pub use game_distribution_create_version_input_type::GameDistributionCreateVersionInput;
 pub use game_distribution_delete_game_input_type::GameDistributionDeleteGameInput;
+pub use game_distribution_derived_games_input_type::GameDistributionDerivedGamesInput;
+pub use game_distribution_derived_games_result_type::GameDistributionDerivedGamesResult;
 pub use game_distribution_fail_upload_input_type::GameDistributionFailUploadInput;
+pub use game_distribution_fork_source_input_type::GameDistributionForkSourceInput;
+pub use game_distribution_fork_source_result_type::GameDistributionForkSourceResult;
 pub use game_distribution_game_list_procedure_result_type::GameDistributionGameListProcedureResult;
 pub use game_distribution_game_procedure_result_type::GameDistributionGameProcedureResult;
 pub use game_distribution_game_snapshot_type::GameDistributionGameSnapshot;
@@ -1355,6 +1465,12 @@ pub use game_distribution_game_type::GameDistributionGame;
 pub use game_distribution_get_game_input_type::GameDistributionGetGameInput;
 pub use game_distribution_idempotency_receipt_table::*;
 pub use game_distribution_idempotency_receipt_type::GameDistributionIdempotencyReceipt;
+pub use game_distribution_lineage_input_type::GameDistributionLineageInput;
+pub use game_distribution_lineage_node_snapshot_type::GameDistributionLineageNodeSnapshot;
+pub use game_distribution_lineage_result_type::GameDistributionLineageResult;
+pub use game_distribution_lineage_snapshot_type::GameDistributionLineageSnapshot;
+pub use game_distribution_lineage_table::*;
+pub use game_distribution_lineage_type::GameDistributionLineage;
 pub use game_distribution_media_read_access_procedure_result_type::GameDistributionMediaReadAccessProcedureResult;
 pub use game_distribution_my_review_input_type::GameDistributionMyReviewInput;
 pub use game_distribution_owner_game_list_input_type::GameDistributionOwnerGameListInput;
@@ -1385,10 +1501,27 @@ pub use game_distribution_review_moderation_log_type::GameDistributionReviewMode
 pub use game_distribution_review_moderation_operation_snapshot_type::GameDistributionReviewModerationOperationSnapshot;
 pub use game_distribution_review_table::*;
 pub use game_distribution_review_type::GameDistributionReview;
+pub use game_distribution_set_fork_authorization_input_type::GameDistributionSetForkAuthorizationInput;
 pub use game_distribution_submit_review_input_type::GameDistributionSubmitReviewInput;
 pub use game_distribution_suspend_input_type::GameDistributionSuspendInput;
+pub use game_distribution_theme_detail_input_type::GameDistributionThemeDetailInput;
+pub use game_distribution_theme_detail_result_type::GameDistributionThemeDetailResult;
+pub use game_distribution_theme_list_input_type::GameDistributionThemeListInput;
+pub use game_distribution_theme_list_result_type::GameDistributionThemeListResult;
+pub use game_distribution_theme_member_remove_input_type::GameDistributionThemeMemberRemoveInput;
+pub use game_distribution_theme_member_table::*;
+pub use game_distribution_theme_member_type::GameDistributionThemeMember;
+pub use game_distribution_theme_member_upsert_input_type::GameDistributionThemeMemberUpsertInput;
+pub use game_distribution_theme_reference_snapshot_type::GameDistributionThemeReferenceSnapshot;
+pub use game_distribution_theme_refs_input_type::GameDistributionThemeRefsInput;
+pub use game_distribution_theme_refs_result_type::GameDistributionThemeRefsResult;
+pub use game_distribution_theme_snapshot_type::GameDistributionThemeSnapshot;
+pub use game_distribution_theme_table::*;
+pub use game_distribution_theme_type::GameDistributionTheme;
+pub use game_distribution_uncollect_game_input_type::GameDistributionUncollectGameInput;
 pub use game_distribution_unpublish_input_type::GameDistributionUnpublishInput;
 pub use game_distribution_update_metadata_input_type::GameDistributionUpdateMetadataInput;
+pub use game_distribution_update_theme_input_type::GameDistributionUpdateThemeInput;
 pub use game_distribution_user_review_input_type::GameDistributionUserReviewInput;
 pub use game_distribution_user_review_list_input_type::GameDistributionUserReviewListInput;
 pub use game_distribution_user_review_result_type::GameDistributionUserReviewResult;
@@ -1419,10 +1552,14 @@ pub use get_external_generation_job_result_and_return_procedure::get_external_ge
 pub use get_external_generation_job_summary_and_return_procedure::get_external_generation_job_summary_and_return;
 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_contribution_and_return_procedure::get_game_distribution_contribution_and_return;
+pub use get_game_distribution_fork_source_and_return_procedure::get_game_distribution_fork_source_and_return;
 pub use get_game_distribution_game_and_return_procedure::get_game_distribution_game_and_return;
+pub use get_game_distribution_lineage_and_return_procedure::get_game_distribution_lineage_and_return;
 pub use get_game_distribution_media_read_access_and_return_procedure::get_game_distribution_media_read_access_and_return;
 pub use get_game_distribution_my_review_and_return_procedure::get_game_distribution_my_review_and_return;
 pub use get_game_distribution_purchase_and_return_procedure::get_game_distribution_purchase_and_return;
+pub use get_game_distribution_theme_detail_and_return_procedure::get_game_distribution_theme_detail_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;
@@ -1448,8 +1585,11 @@ pub use import_database_migration_incremental_from_chunks_procedure::import_data
 pub use import_database_migration_incremental_from_file_procedure::import_database_migration_incremental_from_file;
 pub use increment_game_distribution_game_play_counts_and_return_procedure::increment_game_distribution_game_play_counts_and_return;
 pub use initialize_editor_generation_pricing_config_if_missing_and_return_procedure::initialize_editor_generation_pricing_config_if_missing_and_return;
+pub use is_game_distribution_collected_and_return_procedure::is_game_distribution_collected_and_return;
 pub use list_admin_accounts_and_return_procedure::list_admin_accounts_and_return;
 pub use list_admin_game_distribution_games_and_return_procedure::list_admin_game_distribution_games_and_return;
+pub use list_admin_game_distribution_theme_members_and_return_procedure::list_admin_game_distribution_theme_members_and_return;
+pub use list_admin_game_distribution_themes_and_return_procedure::list_admin_game_distribution_themes_and_return;
 pub use list_admin_game_distribution_user_reviews_and_return_procedure::list_admin_game_distribution_user_reviews_and_return;
 pub use list_agc_tracking_events_procedure::list_agc_tracking_events;
 pub use list_asset_history_and_return_procedure::list_asset_history_and_return;
@@ -1460,9 +1600,13 @@ pub use list_error_reports_and_return_procedure::list_error_reports_and_return;
 pub use list_external_api_keys_and_return_procedure::list_external_api_keys_and_return;
 pub use list_external_generation_job_summaries_and_return_procedure::list_external_generation_job_summaries_and_return;
 pub use list_external_generation_jobs_and_return_procedure::list_external_generation_jobs_and_return;
+pub use list_game_distribution_collections_and_return_procedure::list_game_distribution_collections_and_return;
+pub use list_game_distribution_derived_games_and_return_procedure::list_game_distribution_derived_games_and_return;
 pub use list_game_distribution_games_and_return_procedure::list_game_distribution_games_and_return;
 pub use list_game_distribution_review_games_and_return_procedure::list_game_distribution_review_games_and_return;
 pub use list_game_distribution_reviews_and_return_procedure::list_game_distribution_reviews_and_return;
+pub use list_game_distribution_theme_refs_for_root_and_return_procedure::list_game_distribution_theme_refs_for_root_and_return;
+pub use list_game_distribution_themes_and_return_procedure::list_game_distribution_themes_and_return;
 pub use list_game_distribution_user_reviews_and_return_procedure::list_game_distribution_user_reviews_and_return;
 pub use list_owner_game_distribution_games_and_return_procedure::list_owner_game_distribution_games_and_return;
 pub use list_payment_api_keys_and_return_procedure::list_payment_api_keys_and_return;
@@ -1615,6 +1759,7 @@ pub use refund_profile_wallet_points_and_return_procedure::refund_profile_wallet
 pub use reject_game_distribution_version_and_return_procedure::reject_game_distribution_version_and_return;
 pub use release_profile_recharge_refund_hold_and_return_procedure::release_profile_recharge_refund_hold_and_return;
 pub use remove_creator_follower_and_return_procedure::remove_creator_follower_and_return;
+pub use remove_game_distribution_theme_member_and_return_procedure::remove_game_distribution_theme_member_and_return;
 pub use rename_editor_project_and_return_procedure::rename_editor_project_and_return;
 pub use renew_external_generation_job_lease_and_return_procedure::renew_external_generation_job_lease_and_return;
 pub use repair_editor_asset_media_and_return_procedure::repair_editor_asset_media_and_return;
@@ -1797,6 +1942,8 @@ pub use save_editor_project_layout_v_2_and_return_procedure::save_editor_project
 pub use save_game_distribution_my_review_and_return_procedure::save_game_distribution_my_review_and_return;
 pub use seed_analytics_date_dimensions_reducer::seed_analytics_date_dimensions;
 pub use set_editor_showcase_asset_like_for_viewer_and_return_procedure::set_editor_showcase_asset_like_for_viewer_and_return;
+pub use set_game_distribution_collection_and_return_procedure::set_game_distribution_collection_and_return;
+pub use set_game_distribution_fork_authorization_and_return_procedure::set_game_distribution_fork_authorization_and_return;
 pub use set_payment_order_provider_code_and_return_procedure::set_payment_order_provider_code_and_return;
 pub use settle_llm_router_quota_and_return_procedure::settle_llm_router_quota_and_return;
 pub use start_ai_task_reducer::start_ai_task;
@@ -1813,6 +1960,7 @@ pub use tracking_event_table::*;
 pub use tracking_event_type::TrackingEvent;
 pub use unfollow_creator_and_return_procedure::unfollow_creator_and_return;
 pub use unpublish_game_distribution_game_and_return_procedure::unpublish_game_distribution_game_and_return;
+pub use unset_game_distribution_collection_and_return_procedure::unset_game_distribution_collection_and_return;
 pub use update_admin_account_and_return_procedure::update_admin_account_and_return;
 pub use update_editor_asset_and_return_procedure::update_editor_asset_and_return;
 pub use update_editor_asset_folder_and_return_procedure::update_editor_asset_folder_and_return;
@@ -1821,11 +1969,13 @@ pub use update_editor_showcase_asset_display_and_return_procedure::update_editor
 pub use update_error_report_and_return_procedure::update_error_report_and_return;
 pub use update_external_generation_job_phase_and_return_procedure::update_external_generation_job_phase_and_return;
 pub use update_game_distribution_game_metadata_and_return_procedure::update_game_distribution_game_metadata_and_return;
+pub use update_game_distribution_theme_and_return_procedure::update_game_distribution_theme_and_return;
 pub use update_payment_app_and_return_procedure::update_payment_app_and_return;
 pub use upload_agc_analytics_batch_procedure::upload_agc_analytics_batch;
 pub use upsert_editor_generation_pricing_config_and_return_procedure::upsert_editor_generation_pricing_config_and_return;
 pub use upsert_editor_showcase_campaign_config_and_return_procedure::upsert_editor_showcase_campaign_config_and_return;
 pub use upsert_feature_gate_config_procedure::upsert_feature_gate_config;
+pub use upsert_game_distribution_theme_member_and_return_procedure::upsert_game_distribution_theme_member_and_return;
 pub use upsert_llm_router_account_and_return_procedure::upsert_llm_router_account_and_return;
 pub use upsert_runtime_setting_and_return_procedure::upsert_runtime_setting_and_return;
 pub use user_account_table::*;
@@ -1988,12 +2138,16 @@ pub struct DbUpdate {
     external_generation_job_event: __sdk::TableUpdate<ExternalGenerationJobEvent>,
     external_generation_job_summary: __sdk::TableUpdate<ExternalGenerationJobSummary>,
     feature_gate_config: __sdk::TableUpdate<FeatureGateConfig>,
+    game_distribution_collection: __sdk::TableUpdate<GameDistributionCollection>,
     game_distribution_game: __sdk::TableUpdate<GameDistributionGame>,
     game_distribution_idempotency_receipt: __sdk::TableUpdate<GameDistributionIdempotencyReceipt>,
+    game_distribution_lineage: __sdk::TableUpdate<GameDistributionLineage>,
     game_distribution_purchase: __sdk::TableUpdate<GameDistributionPurchase>,
     game_distribution_review: __sdk::TableUpdate<GameDistributionReview>,
     game_distribution_review_moderation_log:
         __sdk::TableUpdate<GameDistributionReviewModerationLog>,
+    game_distribution_theme: __sdk::TableUpdate<GameDistributionTheme>,
+    game_distribution_theme_member: __sdk::TableUpdate<GameDistributionThemeMember>,
     game_distribution_version: __sdk::TableUpdate<GameDistributionVersion>,
     llm_router_account: __sdk::TableUpdate<LlmRouterAccount>,
     llm_router_billing_checkpoint: __sdk::TableUpdate<LlmRouterBillingCheckpoint>,
@@ -2205,6 +2359,9 @@ impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate {
                 "feature_gate_config" => db_update
                     .feature_gate_config
                     .append(feature_gate_config_table::parse_table_update(table_update)?),
+                "game_distribution_collection" => db_update.game_distribution_collection.append(
+                    game_distribution_collection_table::parse_table_update(table_update)?,
+                ),
                 "game_distribution_game" => db_update.game_distribution_game.append(
                     game_distribution_game_table::parse_table_update(table_update)?,
                 ),
@@ -2215,6 +2372,9 @@ impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate {
                         )?,
                     )
                 }
+                "game_distribution_lineage" => db_update.game_distribution_lineage.append(
+                    game_distribution_lineage_table::parse_table_update(table_update)?,
+                ),
                 "game_distribution_purchase" => db_update.game_distribution_purchase.append(
                     game_distribution_purchase_table::parse_table_update(table_update)?,
                 ),
@@ -2228,6 +2388,14 @@ impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate {
                         )?,
                     )
                 }
+                "game_distribution_theme" => db_update.game_distribution_theme.append(
+                    game_distribution_theme_table::parse_table_update(table_update)?,
+                ),
+                "game_distribution_theme_member" => {
+                    db_update.game_distribution_theme_member.append(
+                        game_distribution_theme_member_table::parse_table_update(table_update)?,
+                    )
+                }
                 "game_distribution_version" => db_update.game_distribution_version.append(
                     game_distribution_version_table::parse_table_update(table_update)?,
                 ),
@@ -2627,6 +2795,12 @@ impl __sdk::DbUpdate for DbUpdate {
                 &self.feature_gate_config,
             )
             .with_updates_by_pk(|row| &row.gate_key);
+        diff.game_distribution_collection = cache
+            .apply_diff_to_table::<GameDistributionCollection>(
+                "game_distribution_collection",
+                &self.game_distribution_collection,
+            )
+            .with_updates_by_pk(|row| &row.collection_id);
         diff.game_distribution_game = cache
             .apply_diff_to_table::<GameDistributionGame>(
                 "game_distribution_game",
@@ -2639,6 +2813,12 @@ impl __sdk::DbUpdate for DbUpdate {
                 &self.game_distribution_idempotency_receipt,
             )
             .with_updates_by_pk(|row| &row.receipt_id);
+        diff.game_distribution_lineage = cache
+            .apply_diff_to_table::<GameDistributionLineage>(
+                "game_distribution_lineage",
+                &self.game_distribution_lineage,
+            )
+            .with_updates_by_pk(|row| &row.game_id);
         diff.game_distribution_purchase = cache
             .apply_diff_to_table::<GameDistributionPurchase>(
                 "game_distribution_purchase",
@@ -2657,6 +2837,18 @@ impl __sdk::DbUpdate for DbUpdate {
                 &self.game_distribution_review_moderation_log,
             )
             .with_updates_by_pk(|row| &row.operation_id);
+        diff.game_distribution_theme = cache
+            .apply_diff_to_table::<GameDistributionTheme>(
+                "game_distribution_theme",
+                &self.game_distribution_theme,
+            )
+            .with_updates_by_pk(|row| &row.theme_id);
+        diff.game_distribution_theme_member = cache
+            .apply_diff_to_table::<GameDistributionThemeMember>(
+                "game_distribution_theme_member",
+                &self.game_distribution_theme_member,
+            )
+            .with_updates_by_pk(|row| &row.member_id);
         diff.game_distribution_version = cache
             .apply_diff_to_table::<GameDistributionVersion>(
                 "game_distribution_version",
@@ -3036,12 +3228,18 @@ impl __sdk::DbUpdate for DbUpdate {
                 "feature_gate_config" => db_update
                     .feature_gate_config
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "game_distribution_collection" => db_update
+                    .game_distribution_collection
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
                 "game_distribution_game" => db_update
                     .game_distribution_game
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
                 "game_distribution_idempotency_receipt" => db_update
                     .game_distribution_idempotency_receipt
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "game_distribution_lineage" => db_update
+                    .game_distribution_lineage
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
                 "game_distribution_purchase" => db_update
                     .game_distribution_purchase
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
@@ -3051,6 +3249,12 @@ impl __sdk::DbUpdate for DbUpdate {
                 "game_distribution_review_moderation_log" => db_update
                     .game_distribution_review_moderation_log
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "game_distribution_theme" => db_update
+                    .game_distribution_theme
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "game_distribution_theme_member" => db_update
+                    .game_distribution_theme_member
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
                 "game_distribution_version" => db_update
                     .game_distribution_version
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
@@ -3331,12 +3535,18 @@ impl __sdk::DbUpdate for DbUpdate {
                 "feature_gate_config" => db_update
                     .feature_gate_config
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "game_distribution_collection" => db_update
+                    .game_distribution_collection
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
                 "game_distribution_game" => db_update
                     .game_distribution_game
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
                 "game_distribution_idempotency_receipt" => db_update
                     .game_distribution_idempotency_receipt
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "game_distribution_lineage" => db_update
+                    .game_distribution_lineage
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
                 "game_distribution_purchase" => db_update
                     .game_distribution_purchase
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
@@ -3346,6 +3556,12 @@ impl __sdk::DbUpdate for DbUpdate {
                 "game_distribution_review_moderation_log" => db_update
                     .game_distribution_review_moderation_log
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "game_distribution_theme" => db_update
+                    .game_distribution_theme
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "game_distribution_theme_member" => db_update
+                    .game_distribution_theme_member
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
                 "game_distribution_version" => db_update
                     .game_distribution_version
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
@@ -3544,13 +3760,17 @@ pub struct AppliedDiff<'r> {
     external_generation_job_event: __sdk::TableAppliedDiff<'r, ExternalGenerationJobEvent>,
     external_generation_job_summary: __sdk::TableAppliedDiff<'r, ExternalGenerationJobSummary>,
     feature_gate_config: __sdk::TableAppliedDiff<'r, FeatureGateConfig>,
+    game_distribution_collection: __sdk::TableAppliedDiff<'r, GameDistributionCollection>,
     game_distribution_game: __sdk::TableAppliedDiff<'r, GameDistributionGame>,
     game_distribution_idempotency_receipt:
         __sdk::TableAppliedDiff<'r, GameDistributionIdempotencyReceipt>,
+    game_distribution_lineage: __sdk::TableAppliedDiff<'r, GameDistributionLineage>,
     game_distribution_purchase: __sdk::TableAppliedDiff<'r, GameDistributionPurchase>,
     game_distribution_review: __sdk::TableAppliedDiff<'r, GameDistributionReview>,
     game_distribution_review_moderation_log:
         __sdk::TableAppliedDiff<'r, GameDistributionReviewModerationLog>,
+    game_distribution_theme: __sdk::TableAppliedDiff<'r, GameDistributionTheme>,
+    game_distribution_theme_member: __sdk::TableAppliedDiff<'r, GameDistributionThemeMember>,
     game_distribution_version: __sdk::TableAppliedDiff<'r, GameDistributionVersion>,
     llm_router_account: __sdk::TableAppliedDiff<'r, LlmRouterAccount>,
     llm_router_billing_checkpoint: __sdk::TableAppliedDiff<'r, LlmRouterBillingCheckpoint>,
@@ -3822,6 +4042,11 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
             &self.feature_gate_config,
             event,
         );
+        callbacks.invoke_table_row_callbacks::<GameDistributionCollection>(
+            "game_distribution_collection",
+            &self.game_distribution_collection,
+            event,
+        );
         callbacks.invoke_table_row_callbacks::<GameDistributionGame>(
             "game_distribution_game",
             &self.game_distribution_game,
@@ -3832,6 +4057,11 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
             &self.game_distribution_idempotency_receipt,
             event,
         );
+        callbacks.invoke_table_row_callbacks::<GameDistributionLineage>(
+            "game_distribution_lineage",
+            &self.game_distribution_lineage,
+            event,
+        );
         callbacks.invoke_table_row_callbacks::<GameDistributionPurchase>(
             "game_distribution_purchase",
             &self.game_distribution_purchase,
@@ -3847,6 +4077,16 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
             &self.game_distribution_review_moderation_log,
             event,
         );
+        callbacks.invoke_table_row_callbacks::<GameDistributionTheme>(
+            "game_distribution_theme",
+            &self.game_distribution_theme,
+            event,
+        );
+        callbacks.invoke_table_row_callbacks::<GameDistributionThemeMember>(
+            "game_distribution_theme_member",
+            &self.game_distribution_theme_member,
+            event,
+        );
         callbacks.invoke_table_row_callbacks::<GameDistributionVersion>(
             "game_distribution_version",
             &self.game_distribution_version,
@@ -4772,11 +5012,15 @@ impl __sdk::SpacetimeModule for RemoteModule {
         external_generation_job_event_table::register_table(client_cache);
         external_generation_job_summary_table::register_table(client_cache);
         feature_gate_config_table::register_table(client_cache);
+        game_distribution_collection_table::register_table(client_cache);
         game_distribution_game_table::register_table(client_cache);
         game_distribution_idempotency_receipt_table::register_table(client_cache);
+        game_distribution_lineage_table::register_table(client_cache);
         game_distribution_purchase_table::register_table(client_cache);
         game_distribution_review_table::register_table(client_cache);
         game_distribution_review_moderation_log_table::register_table(client_cache);
+        game_distribution_theme_table::register_table(client_cache);
+        game_distribution_theme_member_table::register_table(client_cache);
         game_distribution_version_table::register_table(client_cache);
         llm_router_account_table::register_table(client_cache);
         llm_router_billing_checkpoint_table::register_table(client_cache);
@@ -4868,11 +5112,15 @@ impl __sdk::SpacetimeModule for RemoteModule {
         "external_generation_job_event",
         "external_generation_job_summary",
         "feature_gate_config",
+        "game_distribution_collection",
         "game_distribution_game",
         "game_distribution_idempotency_receipt",
+        "game_distribution_lineage",
         "game_distribution_purchase",
         "game_distribution_review",
         "game_distribution_review_moderation_log",
+        "game_distribution_theme",
+        "game_distribution_theme_member",
         "game_distribution_version",
         "llm_router_account",
         "llm_router_billing_checkpoint",
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/admin_list_profile_membership_plans_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/admin_list_profile_membership_plans_procedure.rs
index 6f1dc3cd1..112b270d5 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/admin_list_profile_membership_plans_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/admin_list_profile_membership_plans_procedure.rs
@@ -34,10 +34,10 @@ pub trait admin_list_profile_membership_plans {
         input: RuntimeProfileMembershipPlanAdminListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipPlanAdminListProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipPlanAdminListProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl admin_list_profile_membership_plans for super::RemoteProcedures {
         input: RuntimeProfileMembershipPlanAdminListInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipPlanAdminListProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipPlanAdminListProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp.invoke_procedure_with_callback::<_, RuntimeProfileMembershipPlanAdminListProcedureResult>(
             "admin_list_profile_membership_plans",
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/admin_upsert_profile_membership_plan_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/admin_upsert_profile_membership_plan_procedure.rs
index 3ff1b58f7..0dd5c1a4a 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/admin_upsert_profile_membership_plan_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/admin_upsert_profile_membership_plan_procedure.rs
@@ -34,10 +34,10 @@ pub trait admin_upsert_profile_membership_plan {
         input: RuntimeProfileMembershipPlanAdminUpsertInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipPlanAdminProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipPlanAdminProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl admin_upsert_profile_membership_plan for super::RemoteProcedures {
         input: RuntimeProfileMembershipPlanAdminUpsertInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipPlanAdminProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipPlanAdminProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, RuntimeProfileMembershipPlanAdminProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_project_bundle_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_project_bundle_and_return_procedure.rs
new file mode 100644
index 000000000..0c1ce5bbd
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/confirm_game_distribution_project_bundle_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_project_bundle_input_type::GameDistributionConfirmProjectBundleInput;
+use super::game_distribution_procedure_result_type::GameDistributionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ConfirmGameDistributionProjectBundleAndReturnArgs {
+    pub input: GameDistributionConfirmProjectBundleInput,
+}
+
+impl __sdk::InModule for ConfirmGameDistributionProjectBundleAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `confirm_game_distribution_project_bundle_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait confirm_game_distribution_project_bundle_and_return {
+    fn confirm_game_distribution_project_bundle_and_return(
+        &self,
+        input: GameDistributionConfirmProjectBundleInput,
+    ) {
+        self.confirm_game_distribution_project_bundle_and_return_then(input, |_, _| {});
+    }
+
+    fn confirm_game_distribution_project_bundle_and_return_then(
+        &self,
+        input: GameDistributionConfirmProjectBundleInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl confirm_game_distribution_project_bundle_and_return for super::RemoteProcedures {
+    fn confirm_game_distribution_project_bundle_and_return_then(
+        &self,
+        input: GameDistributionConfirmProjectBundleInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "confirm_game_distribution_project_bundle_and_return",
+                ConfirmGameDistributionProjectBundleAndReturnArgs { 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..46ab463fe
--- /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_theme_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_theme_and_return_procedure.rs
new file mode 100644
index 000000000..2b8753a3e
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/create_game_distribution_theme_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_admin_theme_mutation_result_type::GameDistributionAdminThemeMutationResult;
+use super::game_distribution_create_theme_input_type::GameDistributionCreateThemeInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct CreateGameDistributionThemeAndReturnArgs {
+    pub input: GameDistributionCreateThemeInput,
+}
+
+impl __sdk::InModule for CreateGameDistributionThemeAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `create_game_distribution_theme_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait create_game_distribution_theme_and_return {
+    fn create_game_distribution_theme_and_return(&self, input: GameDistributionCreateThemeInput) {
+        self.create_game_distribution_theme_and_return_then(input, |_, _| {});
+    }
+
+    fn create_game_distribution_theme_and_return_then(
+        &self,
+        input: GameDistributionCreateThemeInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl create_game_distribution_theme_and_return for super::RemoteProcedures {
+    fn create_game_distribution_theme_and_return_then(
+        &self,
+        input: GameDistributionCreateThemeInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionAdminThemeMutationResult>(
+                "create_game_distribution_theme_and_return",
+                CreateGameDistributionThemeAndReturnArgs { 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..5a9005c87
--- /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/follow_creator_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/follow_creator_and_return_procedure.rs
index 58a53fda3..184a6da23 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/follow_creator_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/follow_creator_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait follow_creator_and_return {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl follow_creator_and_return for super::RemoteProcedures {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, CreatorRelationshipResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs
index 71e653c96..28508f471 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_game_snapshot_type.rs
@@ -21,6 +21,10 @@ pub struct GameDistributionAdminGameSnapshot {
     pub publication_revision: u64,
     pub created_at_micros: i64,
     pub updated_at_micros: i64,
+    pub fork_authorization: String,
+    pub lineage_generation: u32,
+    pub forked_from_game_id: Option<String>,
+    pub derived_count: u64,
     pub versions: Vec<GameDistributionAdminVersionSnapshot>,
     pub deleted_at_micros: Option<i64>,
 }
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_list_input_type.rs
new file mode 100644
index 000000000..993ef137f
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_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 GameDistributionAdminThemeListInput {
+    pub status: Option<String>,
+    pub limit: u32,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeListInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_list_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_list_result_type.rs
new file mode 100644
index 000000000..9f1b2073d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_list_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_admin_theme_snapshot_type::GameDistributionAdminThemeSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionAdminThemeListResult {
+    pub ok: bool,
+    pub themes: Vec<GameDistributionAdminThemeSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeListResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_list_input_type.rs
new file mode 100644
index 000000000..8d088a259
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_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 GameDistributionAdminThemeMemberListInput {
+    pub theme_id: String,
+    pub limit: u32,
+    pub cursor: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeMemberListInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_list_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_list_result_type.rs
new file mode 100644
index 000000000..4015e4d5e
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_list_result_type.rs
@@ -0,0 +1,22 @@
+// 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_admin_theme_member_row_snapshot_type::GameDistributionAdminThemeMemberRowSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionAdminThemeMemberListResult {
+    pub ok: bool,
+    pub theme_id: String,
+    pub total_members: u64,
+    pub members: Vec<GameDistributionAdminThemeMemberRowSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeMemberListResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_mutation_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_mutation_result_type.rs
new file mode 100644
index 000000000..c0027afb8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_mutation_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_admin_theme_member_snapshot_type::GameDistributionAdminThemeMemberSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionAdminThemeMemberMutationResult {
+    pub ok: bool,
+    pub member: Option<GameDistributionAdminThemeMemberSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeMemberMutationResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_row_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_row_snapshot_type.rs
new file mode 100644
index 000000000..ebe0ac380
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_row_snapshot_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 GameDistributionAdminThemeMemberRowSnapshot {
+    pub root_game_id: String,
+    pub title: Option<String>,
+    pub sort_order: i64,
+    pub created_at_micros: i64,
+    pub visible: bool,
+    pub visibility: String,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeMemberRowSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_snapshot_type.rs
new file mode 100644
index 000000000..7b4f7e5b0
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_member_snapshot_type.rs
@@ -0,0 +1,18 @@
+// 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 GameDistributionAdminThemeMemberSnapshot {
+    pub theme_id: String,
+    pub root_game_id: String,
+    pub sort_order: i64,
+    pub created_at_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeMemberSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_mutation_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_mutation_result_type.rs
new file mode 100644
index 000000000..a16ff0899
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_mutation_result_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};
+
+use super::game_distribution_admin_theme_snapshot_type::GameDistributionAdminThemeSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionAdminThemeMutationResult {
+    pub ok: bool,
+    pub replayed: bool,
+    pub theme: Option<GameDistributionAdminThemeSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeMutationResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_snapshot_type.rs
new file mode 100644
index 000000000..45f40d33d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_admin_theme_snapshot_type.rs
@@ -0,0 +1,23 @@
+// 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 GameDistributionAdminThemeSnapshot {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub member_count: u64,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionAdminThemeSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collect_game_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collect_game_input_type.rs
new file mode 100644
index 000000000..d4be5592a
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collect_game_input_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};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionCollectGameInput {
+    pub game_id: String,
+    pub user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionCollectGameInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_list_input_type.rs
new file mode 100644
index 000000000..629172423
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_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 GameDistributionCollectionListInput {
+    pub user_id: String,
+    pub limit: u32,
+    pub cursor: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionCollectionListInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_list_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_list_result_type.rs
new file mode 100644
index 000000000..4411b43fe
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_list_result_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};
+
+use super::game_distribution_public_game_snapshot_type::GameDistributionPublicGameSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionCollectionListResult {
+    pub ok: bool,
+    pub games: Vec<GameDistributionPublicGameSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionCollectionListResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_mutation_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_mutation_result_type.rs
new file mode 100644
index 000000000..45c0553d6
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_mutation_result_type.rs
@@ -0,0 +1,18 @@
+// 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 GameDistributionCollectionMutationResult {
+    pub ok: bool,
+    pub collected: bool,
+    pub replayed: bool,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionCollectionMutationResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_state_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_state_input_type.rs
new file mode 100644
index 000000000..779e9bc31
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_state_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 GameDistributionCollectionStateInput {
+    pub game_id: String,
+    pub user_id: String,
+}
+
+impl __sdk::InModule for GameDistributionCollectionStateInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_state_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_state_result_type.rs
new file mode 100644
index 000000000..6c30e2f91
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_state_result_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 GameDistributionCollectionStateResult {
+    pub ok: bool,
+    pub collected: bool,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionCollectionStateResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_table.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_table.rs
new file mode 100644
index 000000000..c7416eebf
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_table.rs
@@ -0,0 +1,235 @@
+// 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_collection_type::GameDistributionCollection;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_distribution_collection`.
+///
+/// Obtain a handle from the [`GameDistributionCollectionTableAccess::game_distribution_collection`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_distribution_collection()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_collection().on_insert(...)`.
+pub struct GameDistributionCollectionTableHandle<'ctx> {
+    imp: __sdk::TableHandle<GameDistributionCollection>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_distribution_collection`.
+pub struct GameDistributionCollectionTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameDistributionCollectionTableAccessor {
+    type Row = GameDistributionCollection;
+    type Handle<'db> = GameDistributionCollectionTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_distribution_collection()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_distribution_collection`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameDistributionCollectionTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameDistributionCollectionTableHandle`], which mediates access to the table `game_distribution_collection`.
+    fn game_distribution_collection(&self) -> GameDistributionCollectionTableHandle<'_>;
+}
+
+impl GameDistributionCollectionTableAccess for super::RemoteTables {
+    fn game_distribution_collection(&self) -> GameDistributionCollectionTableHandle<'_> {
+        GameDistributionCollectionTableHandle {
+            imp: self
+                .imp
+                .get_table::<GameDistributionCollection>("game_distribution_collection"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameDistributionCollectionInsertCallbackId(__sdk::CallbackId);
+pub struct GameDistributionCollectionDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameDistributionCollectionTableHandle<'ctx> {
+    type Row = GameDistributionCollection;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionCollection> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameDistributionCollectionTableHandle<'ctx> {
+    type Row = GameDistributionCollection;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionCollection> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameDistributionCollectionInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionCollectionInsertCallbackId {
+        GameDistributionCollectionInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionCollectionInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameDistributionCollectionDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionCollectionDeleteCallbackId {
+        GameDistributionCollectionDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionCollectionDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameDistributionCollectionTableHandle<'ctx> {
+    type InsertCallbackId = GameDistributionCollectionInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionCollectionInsertCallbackId {
+        GameDistributionCollectionInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionCollectionInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameDistributionCollectionTableHandle<'ctx> {
+    type DeleteCallbackId = GameDistributionCollectionDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionCollectionDeleteCallbackId {
+        GameDistributionCollectionDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionCollectionDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameDistributionCollectionUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameDistributionCollectionTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionCollectionUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionCollectionUpdateCallbackId {
+        GameDistributionCollectionUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionCollectionUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameDistributionCollectionTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionCollectionUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionCollectionUpdateCallbackId {
+        GameDistributionCollectionUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionCollectionUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `collection_id` unique index on the table `game_distribution_collection`,
+/// which allows point queries on the field of the same name
+/// via the [`GameDistributionCollectionCollectionIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_collection().collection_id().find(...)`.
+pub struct GameDistributionCollectionCollectionIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<GameDistributionCollection, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameDistributionCollectionTableHandle<'ctx> {
+    /// Get a handle on the `collection_id` unique index on the table `game_distribution_collection`.
+    pub fn collection_id(&self) -> GameDistributionCollectionCollectionIdUnique<'ctx> {
+        GameDistributionCollectionCollectionIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("collection_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameDistributionCollectionCollectionIdUnique<'ctx> {
+    /// Find the subscribed row whose `collection_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<GameDistributionCollection> {
+        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::<GameDistributionCollection>("game_distribution_collection");
+    _table.add_unique_constraint::<String>("collection_id", |row| &row.collection_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<GameDistributionCollection>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<GameDistributionCollection>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `GameDistributionCollection`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_distribution_collectionQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `GameDistributionCollection`.
+    fn game_distribution_collection(
+        &self,
+    ) -> __sdk::__query_builder::Table<GameDistributionCollection>;
+}
+
+impl game_distribution_collectionQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_distribution_collection(
+        &self,
+    ) -> __sdk::__query_builder::Table<GameDistributionCollection> {
+        __sdk::__query_builder::Table::new("game_distribution_collection")
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_type.rs
new file mode 100644
index 000000000..f94dd5035
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_collection_type.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};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionCollection {
+    pub collection_id: String,
+    pub user_id: String,
+    pub game_id: String,
+    pub created_at: __sdk::Timestamp,
+}
+
+impl __sdk::InModule for GameDistributionCollection {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `GameDistributionCollection`.
+///
+/// Provides typed access to columns for query building.
+pub struct GameDistributionCollectionCols {
+    pub collection_id: __sdk::__query_builder::Col<GameDistributionCollection, String>,
+    pub user_id: __sdk::__query_builder::Col<GameDistributionCollection, String>,
+    pub game_id: __sdk::__query_builder::Col<GameDistributionCollection, String>,
+    pub created_at: __sdk::__query_builder::Col<GameDistributionCollection, __sdk::Timestamp>,
+}
+
+impl __sdk::__query_builder::HasCols for GameDistributionCollection {
+    type Cols = GameDistributionCollectionCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        GameDistributionCollectionCols {
+            collection_id: __sdk::__query_builder::Col::new(table_name, "collection_id"),
+            user_id: __sdk::__query_builder::Col::new(table_name, "user_id"),
+            game_id: __sdk::__query_builder::Col::new(table_name, "game_id"),
+            created_at: __sdk::__query_builder::Col::new(table_name, "created_at"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `GameDistributionCollection`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct GameDistributionCollectionIxCols {
+    pub collection_id: __sdk::__query_builder::IxCol<GameDistributionCollection, String>,
+    pub game_id: __sdk::__query_builder::IxCol<GameDistributionCollection, String>,
+    pub user_id: __sdk::__query_builder::IxCol<GameDistributionCollection, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for GameDistributionCollection {
+    type IxCols = GameDistributionCollectionIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        GameDistributionCollectionIxCols {
+            collection_id: __sdk::__query_builder::IxCol::new(table_name, "collection_id"),
+            game_id: __sdk::__query_builder::IxCol::new(table_name, "game_id"),
+            user_id: __sdk::__query_builder::IxCol::new(table_name, "user_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for GameDistributionCollection {}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_confirm_project_bundle_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_confirm_project_bundle_input_type.rs
new file mode 100644
index 000000000..4b3a8d378
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_confirm_project_bundle_input_type.rs
@@ -0,0 +1,22 @@
+// 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 GameDistributionConfirmProjectBundleInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub project_bundle_object_key: String,
+    pub project_bundle_bytes: u64,
+    pub project_bundle_sha_256: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub updated_at_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionConfirmProjectBundleInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_child_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_child_snapshot_type.rs
new file mode 100644
index 000000000..b04775847
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_child_snapshot_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};
+
+use super::game_distribution_contribution_totals_snapshot_type::GameDistributionContributionTotalsSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionContributionChildSnapshot {
+    pub game_id: String,
+    pub generation: u32,
+    pub own: GameDistributionContributionTotalsSnapshot,
+    pub inherited: GameDistributionContributionTotalsSnapshot,
+    pub total: GameDistributionContributionTotalsSnapshot,
+}
+
+impl __sdk::InModule for GameDistributionContributionChildSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_generation_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_generation_snapshot_type.rs
new file mode 100644
index 000000000..41fcaf2c8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_generation_snapshot_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};
+
+use super::game_distribution_contribution_totals_snapshot_type::GameDistributionContributionTotalsSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionContributionGenerationSnapshot {
+    pub generation: u32,
+    pub game_count: u64,
+    pub own: GameDistributionContributionTotalsSnapshot,
+    pub inherited: GameDistributionContributionTotalsSnapshot,
+    pub total: GameDistributionContributionTotalsSnapshot,
+}
+
+impl __sdk::InModule for GameDistributionContributionGenerationSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_input_type.rs
new file mode 100644
index 000000000..ffd7f84cc
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_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 GameDistributionContributionInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+}
+
+impl __sdk::InModule for GameDistributionContributionInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_result_type.rs
new file mode 100644
index 000000000..73e257ffc
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_result_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};
+
+use super::game_distribution_contribution_snapshot_type::GameDistributionContributionSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionContributionResult {
+    pub ok: bool,
+    pub found: bool,
+    pub contribution: Option<GameDistributionContributionSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionContributionResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_snapshot_type.rs
new file mode 100644
index 000000000..9bfd5266d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_snapshot_type.rs
@@ -0,0 +1,27 @@
+// 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_contribution_child_snapshot_type::GameDistributionContributionChildSnapshot;
+use super::game_distribution_contribution_generation_snapshot_type::GameDistributionContributionGenerationSnapshot;
+use super::game_distribution_contribution_totals_snapshot_type::GameDistributionContributionTotalsSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionContributionSnapshot {
+    pub game_id: String,
+    pub own: GameDistributionContributionTotalsSnapshot,
+    pub inherited: GameDistributionContributionTotalsSnapshot,
+    pub total: GameDistributionContributionTotalsSnapshot,
+    pub by_generation: Vec<GameDistributionContributionGenerationSnapshot>,
+    pub direct_children: Vec<GameDistributionContributionChildSnapshot>,
+    pub node_count: u64,
+    pub truncated: bool,
+    pub truncated_reason: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionContributionSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_totals_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_totals_snapshot_type.rs
new file mode 100644
index 000000000..7fe83e108
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_contribution_totals_snapshot_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 GameDistributionContributionTotalsSnapshot {
+    pub play_count: u64,
+}
+
+impl __sdk::InModule for GameDistributionContributionTotalsSnapshot {
+    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..81751db0c
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_game_input_type.rs
@@ -0,0 +1,37 @@
+// 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 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 fork_authorization: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+    pub local_project_id: Option<String>,
+    pub forked_from_game_id: Option<String>,
+    pub forked_from_version_id: Option<String>,
+    pub cover_object_key: Option<String>,
+    pub screenshots_json: 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_theme_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_theme_input_type.rs
new file mode 100644
index 000000000..311276a95
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_theme_input_type.rs
@@ -0,0 +1,24 @@
+// 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 GameDistributionCreateThemeInput {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub admin_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionCreateThemeInput {
+    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..651d2546d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_create_version_input_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 GameDistributionCreateVersionInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_id: String,
+    pub version_number: Option<u64>,
+    pub metadata_json: 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,
+    pub change_summary: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionCreateVersionInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_derived_games_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_derived_games_input_type.rs
new file mode 100644
index 000000000..ceb822408
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_derived_games_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 GameDistributionDerivedGamesInput {
+    pub game_id: String,
+}
+
+impl __sdk::InModule for GameDistributionDerivedGamesInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_derived_games_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_derived_games_result_type.rs
new file mode 100644
index 000000000..fcd9c98fa
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_derived_games_result_type.rs
@@ -0,0 +1,22 @@
+// 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_lineage_node_snapshot_type::GameDistributionLineageNodeSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionDerivedGamesResult {
+    pub ok: bool,
+    pub found: bool,
+    pub game_id: String,
+    pub nodes: Vec<GameDistributionLineageNodeSnapshot>,
+    pub truncated: bool,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionDerivedGamesResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fork_source_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fork_source_input_type.rs
new file mode 100644
index 000000000..5575203b6
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fork_source_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 GameDistributionForkSourceInput {
+    pub game_id: String,
+}
+
+impl __sdk::InModule for GameDistributionForkSourceInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fork_source_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fork_source_result_type.rs
new file mode 100644
index 000000000..d65126e5b
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_fork_source_result_type.rs
@@ -0,0 +1,24 @@
+// 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 GameDistributionForkSourceResult {
+    pub ok: bool,
+    pub found: bool,
+    pub available: bool,
+    pub fork_authorization: String,
+    pub version_id: Option<String>,
+    pub package_sha_256: Option<String>,
+    pub package_bytes: Option<u64>,
+    pub project_bundle_sha_256: Option<String>,
+    pub project_bundle_bytes: u64,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionForkSourceResult {
+    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
index fb6d59a54..953cc14ff 100644
--- 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
@@ -11,6 +11,7 @@ use super::game_distribution_public_game_snapshot_type::GameDistributionPublicGa
 pub struct GameDistributionGameListProcedureResult {
     pub ok: bool,
     pub games: Vec<GameDistributionPublicGameSnapshot>,
+    pub next_cursor: Option<String>,
     pub error_message: Option<String>,
 }
 
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
index 7e2e8168f..06ab180dc 100644
--- 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
@@ -31,6 +31,7 @@ pub struct GameDistributionGameSnapshot {
     pub cover_object_key: Option<String>,
     pub screenshots_json: Option<String>,
     pub price_mud_points: u64,
+    pub fork_authorization: String,
 }
 
 impl __sdk::InModule for GameDistributionGameSnapshot {
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
index 16c5163b5..e533c09a5 100644
--- 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
@@ -33,6 +33,7 @@ pub struct GameDistributionGame {
     pub screenshots_json: Option<String>,
     pub deleted_at: Option<__sdk::Timestamp>,
     pub price_mud_points: u64,
+    pub fork_authorization: String,
 }
 
 impl __sdk::InModule for GameDistributionGame {
@@ -69,6 +70,7 @@ pub struct GameDistributionGameCols {
     pub screenshots_json: __sdk::__query_builder::Col<GameDistributionGame, Option<String>>,
     pub deleted_at: __sdk::__query_builder::Col<GameDistributionGame, Option<__sdk::Timestamp>>,
     pub price_mud_points: __sdk::__query_builder::Col<GameDistributionGame, u64>,
+    pub fork_authorization: __sdk::__query_builder::Col<GameDistributionGame, String>,
 }
 
 impl __sdk::__query_builder::HasCols for GameDistributionGame {
@@ -113,6 +115,7 @@ impl __sdk::__query_builder::HasCols for GameDistributionGame {
             screenshots_json: __sdk::__query_builder::Col::new(table_name, "screenshots_json"),
             deleted_at: __sdk::__query_builder::Col::new(table_name, "deleted_at"),
             price_mud_points: __sdk::__query_builder::Col::new(table_name, "price_mud_points"),
+            fork_authorization: __sdk::__query_builder::Col::new(table_name, "fork_authorization"),
         }
     }
 }
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_input_type.rs
new file mode 100644
index 000000000..53263e05c
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_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 GameDistributionLineageInput {
+    pub game_id: String,
+}
+
+impl __sdk::InModule for GameDistributionLineageInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_node_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_node_snapshot_type.rs
new file mode 100644
index 000000000..33d97dd2d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_node_snapshot_type.rs
@@ -0,0 +1,22 @@
+// 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 GameDistributionLineageNodeSnapshot {
+    pub game_id: String,
+    pub title: String,
+    pub author_name: Option<String>,
+    pub generation: u32,
+    pub parent_game_id: Option<String>,
+    pub play_count: u64,
+    pub status: String,
+    pub cover_object_key: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionLineageNodeSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_result_type.rs
new file mode 100644
index 000000000..b83513525
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_result_type.rs
@@ -0,0 +1,23 @@
+// 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_lineage_node_snapshot_type::GameDistributionLineageNodeSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionLineageResult {
+    pub ok: bool,
+    pub found: bool,
+    pub root_game_id: String,
+    pub root: Option<GameDistributionLineageNodeSnapshot>,
+    pub nodes: Vec<GameDistributionLineageNodeSnapshot>,
+    pub truncated: bool,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionLineageResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_snapshot_type.rs
new file mode 100644
index 000000000..d2c4b2cb9
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_snapshot_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 GameDistributionLineageSnapshot {
+    pub generation: u32,
+    pub root_game_id: String,
+    pub root_title: Option<String>,
+    pub parent_game_id: String,
+    pub parent_title: Option<String>,
+    pub parent_author_name: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionLineageSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_table.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_table.rs
new file mode 100644
index 000000000..1a8dc339c
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_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_lineage_type::GameDistributionLineage;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_distribution_lineage`.
+///
+/// Obtain a handle from the [`GameDistributionLineageTableAccess::game_distribution_lineage`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_distribution_lineage()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_lineage().on_insert(...)`.
+pub struct GameDistributionLineageTableHandle<'ctx> {
+    imp: __sdk::TableHandle<GameDistributionLineage>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_distribution_lineage`.
+pub struct GameDistributionLineageTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameDistributionLineageTableAccessor {
+    type Row = GameDistributionLineage;
+    type Handle<'db> = GameDistributionLineageTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_distribution_lineage()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_distribution_lineage`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameDistributionLineageTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameDistributionLineageTableHandle`], which mediates access to the table `game_distribution_lineage`.
+    fn game_distribution_lineage(&self) -> GameDistributionLineageTableHandle<'_>;
+}
+
+impl GameDistributionLineageTableAccess for super::RemoteTables {
+    fn game_distribution_lineage(&self) -> GameDistributionLineageTableHandle<'_> {
+        GameDistributionLineageTableHandle {
+            imp: self
+                .imp
+                .get_table::<GameDistributionLineage>("game_distribution_lineage"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameDistributionLineageInsertCallbackId(__sdk::CallbackId);
+pub struct GameDistributionLineageDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameDistributionLineageTableHandle<'ctx> {
+    type Row = GameDistributionLineage;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionLineage> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameDistributionLineageTableHandle<'ctx> {
+    type Row = GameDistributionLineage;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionLineage> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameDistributionLineageInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionLineageInsertCallbackId {
+        GameDistributionLineageInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionLineageInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameDistributionLineageDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionLineageDeleteCallbackId {
+        GameDistributionLineageDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionLineageDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameDistributionLineageTableHandle<'ctx> {
+    type InsertCallbackId = GameDistributionLineageInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionLineageInsertCallbackId {
+        GameDistributionLineageInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionLineageInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameDistributionLineageTableHandle<'ctx> {
+    type DeleteCallbackId = GameDistributionLineageDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionLineageDeleteCallbackId {
+        GameDistributionLineageDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionLineageDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameDistributionLineageUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameDistributionLineageTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionLineageUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionLineageUpdateCallbackId {
+        GameDistributionLineageUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionLineageUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameDistributionLineageTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionLineageUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionLineageUpdateCallbackId {
+        GameDistributionLineageUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionLineageUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `game_id` unique index on the table `game_distribution_lineage`,
+/// which allows point queries on the field of the same name
+/// via the [`GameDistributionLineageGameIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_lineage().game_id().find(...)`.
+pub struct GameDistributionLineageGameIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<GameDistributionLineage, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameDistributionLineageTableHandle<'ctx> {
+    /// Get a handle on the `game_id` unique index on the table `game_distribution_lineage`.
+    pub fn game_id(&self) -> GameDistributionLineageGameIdUnique<'ctx> {
+        GameDistributionLineageGameIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("game_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameDistributionLineageGameIdUnique<'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<GameDistributionLineage> {
+        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::<GameDistributionLineage>("game_distribution_lineage");
+    _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<GameDistributionLineage>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<GameDistributionLineage>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `GameDistributionLineage`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_distribution_lineageQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `GameDistributionLineage`.
+    fn game_distribution_lineage(&self) -> __sdk::__query_builder::Table<GameDistributionLineage>;
+}
+
+impl game_distribution_lineageQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_distribution_lineage(&self) -> __sdk::__query_builder::Table<GameDistributionLineage> {
+        __sdk::__query_builder::Table::new("game_distribution_lineage")
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_type.rs
new file mode 100644
index 000000000..b41ae6b6d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_lineage_type.rs
@@ -0,0 +1,73 @@
+// 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 GameDistributionLineage {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub parent_game_id: String,
+    pub parent_version_id: String,
+    pub root_game_id: String,
+    pub generation: u32,
+    pub created_at: __sdk::Timestamp,
+}
+
+impl __sdk::InModule for GameDistributionLineage {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `GameDistributionLineage`.
+///
+/// Provides typed access to columns for query building.
+pub struct GameDistributionLineageCols {
+    pub game_id: __sdk::__query_builder::Col<GameDistributionLineage, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<GameDistributionLineage, String>,
+    pub parent_game_id: __sdk::__query_builder::Col<GameDistributionLineage, String>,
+    pub parent_version_id: __sdk::__query_builder::Col<GameDistributionLineage, String>,
+    pub root_game_id: __sdk::__query_builder::Col<GameDistributionLineage, String>,
+    pub generation: __sdk::__query_builder::Col<GameDistributionLineage, u32>,
+    pub created_at: __sdk::__query_builder::Col<GameDistributionLineage, __sdk::Timestamp>,
+}
+
+impl __sdk::__query_builder::HasCols for GameDistributionLineage {
+    type Cols = GameDistributionLineageCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        GameDistributionLineageCols {
+            game_id: __sdk::__query_builder::Col::new(table_name, "game_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            parent_game_id: __sdk::__query_builder::Col::new(table_name, "parent_game_id"),
+            parent_version_id: __sdk::__query_builder::Col::new(table_name, "parent_version_id"),
+            root_game_id: __sdk::__query_builder::Col::new(table_name, "root_game_id"),
+            generation: __sdk::__query_builder::Col::new(table_name, "generation"),
+            created_at: __sdk::__query_builder::Col::new(table_name, "created_at"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `GameDistributionLineage`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct GameDistributionLineageIxCols {
+    pub game_id: __sdk::__query_builder::IxCol<GameDistributionLineage, String>,
+    pub owner_user_id: __sdk::__query_builder::IxCol<GameDistributionLineage, String>,
+    pub parent_game_id: __sdk::__query_builder::IxCol<GameDistributionLineage, String>,
+    pub root_game_id: __sdk::__query_builder::IxCol<GameDistributionLineage, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for GameDistributionLineage {
+    type IxCols = GameDistributionLineageIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        GameDistributionLineageIxCols {
+            game_id: __sdk::__query_builder::IxCol::new(table_name, "game_id"),
+            owner_user_id: __sdk::__query_builder::IxCol::new(table_name, "owner_user_id"),
+            parent_game_id: __sdk::__query_builder::IxCol::new(table_name, "parent_game_id"),
+            root_game_id: __sdk::__query_builder::IxCol::new(table_name, "root_game_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for GameDistributionLineage {}
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
index 67a5946db..9e5e217a3 100644
--- 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
@@ -12,6 +12,7 @@ use super::game_distribution_version_snapshot_type::GameDistributionVersionSnaps
 pub struct GameDistributionOwnerGameSnapshot {
     pub game: GameDistributionGameSnapshot,
     pub versions: Vec<GameDistributionVersionSnapshot>,
+    pub fork_count: u64,
 }
 
 impl __sdk::InModule for GameDistributionOwnerGameSnapshot {
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
index c7b8add29..567db490b 100644
--- 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
@@ -11,6 +11,8 @@ pub struct GameDistributionPublicGameListInput {
     pub category: Option<String>,
     pub limit: u32,
     pub author_id: Option<String>,
+    pub cursor: Option<String>,
+    pub forkable: bool,
 }
 
 impl __sdk::InModule for GameDistributionPublicGameListInput {
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
index b9cd4b0aa..85a59a615 100644
--- 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
@@ -5,6 +5,7 @@
 use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
 
 use super::game_distribution_game_snapshot_type::GameDistributionGameSnapshot;
+use super::game_distribution_lineage_snapshot_type::GameDistributionLineageSnapshot;
 use super::game_distribution_version_snapshot_type::GameDistributionVersionSnapshot;
 
 #[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
@@ -14,6 +15,9 @@ pub struct GameDistributionPublicGameSnapshot {
     pub current_version: Option<GameDistributionVersionSnapshot>,
     pub average_score: Option<f64>,
     pub rating_count: u64,
+    pub fork_count: u64,
+    pub co_creation_count: u64,
+    pub lineage: Option<GameDistributionLineageSnapshot>,
 }
 
 impl __sdk::InModule for GameDistributionPublicGameSnapshot {
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_publish_version_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_publish_version_input_type.rs
index 28a7a41e7..492cc729c 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_publish_version_input_type.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_publish_version_input_type.rs
@@ -34,6 +34,7 @@ pub struct GameDistributionPublishVersionInput {
     pub idempotency_key: String,
     pub request_digest: String,
     pub now_micros: i64,
+    pub change_summary: Option<String>,
 }
 
 impl __sdk::InModule for GameDistributionPublishVersionInput {
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_set_fork_authorization_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_set_fork_authorization_input_type.rs
new file mode 100644
index 000000000..3776a1550
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_set_fork_authorization_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 GameDistributionSetForkAuthorizationInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub fork_authorization: String,
+    pub expected_fork_authorization: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionSetForkAuthorizationInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_detail_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_detail_input_type.rs
new file mode 100644
index 000000000..a09c598ea
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_detail_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 GameDistributionThemeDetailInput {
+    pub theme_id: String,
+}
+
+impl __sdk::InModule for GameDistributionThemeDetailInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_detail_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_detail_result_type.rs
new file mode 100644
index 000000000..7d013eaaa
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_detail_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_public_game_snapshot_type::GameDistributionPublicGameSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionThemeDetailResult {
+    pub ok: bool,
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+    pub roots: Vec<GameDistributionPublicGameSnapshot>,
+    pub roots_truncated: bool,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionThemeDetailResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_list_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_list_input_type.rs
new file mode 100644
index 000000000..d0dc8e2c0
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_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 GameDistributionThemeListInput {
+    pub limit: u32,
+    pub cursor: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionThemeListInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_list_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_list_result_type.rs
new file mode 100644
index 000000000..4a3b48b1e
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_list_result_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};
+
+use super::game_distribution_theme_snapshot_type::GameDistributionThemeSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionThemeListResult {
+    pub ok: bool,
+    pub themes: Vec<GameDistributionThemeSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionThemeListResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_remove_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_remove_input_type.rs
new file mode 100644
index 000000000..7b73fda80
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_remove_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 GameDistributionThemeMemberRemoveInput {
+    pub theme_id: String,
+    pub root_game_id: String,
+}
+
+impl __sdk::InModule for GameDistributionThemeMemberRemoveInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_table.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_table.rs
new file mode 100644
index 000000000..d0f8809b9
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_table.rs
@@ -0,0 +1,238 @@
+// 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_theme_member_type::GameDistributionThemeMember;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_distribution_theme_member`.
+///
+/// Obtain a handle from the [`GameDistributionThemeMemberTableAccess::game_distribution_theme_member`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_distribution_theme_member()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_theme_member().on_insert(...)`.
+pub struct GameDistributionThemeMemberTableHandle<'ctx> {
+    imp: __sdk::TableHandle<GameDistributionThemeMember>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_distribution_theme_member`.
+pub struct GameDistributionThemeMemberTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameDistributionThemeMemberTableAccessor {
+    type Row = GameDistributionThemeMember;
+    type Handle<'db> = GameDistributionThemeMemberTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_distribution_theme_member()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_distribution_theme_member`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameDistributionThemeMemberTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameDistributionThemeMemberTableHandle`], which mediates access to the table `game_distribution_theme_member`.
+    fn game_distribution_theme_member(&self) -> GameDistributionThemeMemberTableHandle<'_>;
+}
+
+impl GameDistributionThemeMemberTableAccess for super::RemoteTables {
+    fn game_distribution_theme_member(&self) -> GameDistributionThemeMemberTableHandle<'_> {
+        GameDistributionThemeMemberTableHandle {
+            imp: self
+                .imp
+                .get_table::<GameDistributionThemeMember>("game_distribution_theme_member"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameDistributionThemeMemberInsertCallbackId(__sdk::CallbackId);
+pub struct GameDistributionThemeMemberDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameDistributionThemeMemberTableHandle<'ctx> {
+    type Row = GameDistributionThemeMember;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionThemeMember> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameDistributionThemeMemberTableHandle<'ctx> {
+    type Row = GameDistributionThemeMember;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionThemeMember> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameDistributionThemeMemberInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeMemberInsertCallbackId {
+        GameDistributionThemeMemberInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionThemeMemberInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameDistributionThemeMemberDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeMemberDeleteCallbackId {
+        GameDistributionThemeMemberDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionThemeMemberDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameDistributionThemeMemberTableHandle<'ctx> {
+    type InsertCallbackId = GameDistributionThemeMemberInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeMemberInsertCallbackId {
+        GameDistributionThemeMemberInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionThemeMemberInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameDistributionThemeMemberTableHandle<'ctx> {
+    type DeleteCallbackId = GameDistributionThemeMemberDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeMemberDeleteCallbackId {
+        GameDistributionThemeMemberDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionThemeMemberDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameDistributionThemeMemberUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameDistributionThemeMemberTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionThemeMemberUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeMemberUpdateCallbackId {
+        GameDistributionThemeMemberUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionThemeMemberUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameDistributionThemeMemberTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionThemeMemberUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeMemberUpdateCallbackId {
+        GameDistributionThemeMemberUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionThemeMemberUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `member_id` unique index on the table `game_distribution_theme_member`,
+/// which allows point queries on the field of the same name
+/// via the [`GameDistributionThemeMemberMemberIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_theme_member().member_id().find(...)`.
+pub struct GameDistributionThemeMemberMemberIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<GameDistributionThemeMember, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameDistributionThemeMemberTableHandle<'ctx> {
+    /// Get a handle on the `member_id` unique index on the table `game_distribution_theme_member`.
+    pub fn member_id(&self) -> GameDistributionThemeMemberMemberIdUnique<'ctx> {
+        GameDistributionThemeMemberMemberIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("member_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameDistributionThemeMemberMemberIdUnique<'ctx> {
+    /// Find the subscribed row whose `member_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<GameDistributionThemeMember> {
+        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::<GameDistributionThemeMember>("game_distribution_theme_member");
+    _table.add_unique_constraint::<String>("member_id", |row| &row.member_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<GameDistributionThemeMember>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse(
+            "TableUpdate<GameDistributionThemeMember>",
+            "TableUpdate",
+        )
+        .with_cause(e)
+        .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `GameDistributionThemeMember`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_distribution_theme_memberQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `GameDistributionThemeMember`.
+    fn game_distribution_theme_member(
+        &self,
+    ) -> __sdk::__query_builder::Table<GameDistributionThemeMember>;
+}
+
+impl game_distribution_theme_memberQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_distribution_theme_member(
+        &self,
+    ) -> __sdk::__query_builder::Table<GameDistributionThemeMember> {
+        __sdk::__query_builder::Table::new("game_distribution_theme_member")
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_type.rs
new file mode 100644
index 000000000..677d2984d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_type.rs
@@ -0,0 +1,65 @@
+// 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 GameDistributionThemeMember {
+    pub member_id: String,
+    pub theme_id: String,
+    pub root_game_id: String,
+    pub sort_order: i64,
+    pub created_at: __sdk::Timestamp,
+}
+
+impl __sdk::InModule for GameDistributionThemeMember {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `GameDistributionThemeMember`.
+///
+/// Provides typed access to columns for query building.
+pub struct GameDistributionThemeMemberCols {
+    pub member_id: __sdk::__query_builder::Col<GameDistributionThemeMember, String>,
+    pub theme_id: __sdk::__query_builder::Col<GameDistributionThemeMember, String>,
+    pub root_game_id: __sdk::__query_builder::Col<GameDistributionThemeMember, String>,
+    pub sort_order: __sdk::__query_builder::Col<GameDistributionThemeMember, i64>,
+    pub created_at: __sdk::__query_builder::Col<GameDistributionThemeMember, __sdk::Timestamp>,
+}
+
+impl __sdk::__query_builder::HasCols for GameDistributionThemeMember {
+    type Cols = GameDistributionThemeMemberCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        GameDistributionThemeMemberCols {
+            member_id: __sdk::__query_builder::Col::new(table_name, "member_id"),
+            theme_id: __sdk::__query_builder::Col::new(table_name, "theme_id"),
+            root_game_id: __sdk::__query_builder::Col::new(table_name, "root_game_id"),
+            sort_order: __sdk::__query_builder::Col::new(table_name, "sort_order"),
+            created_at: __sdk::__query_builder::Col::new(table_name, "created_at"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `GameDistributionThemeMember`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct GameDistributionThemeMemberIxCols {
+    pub member_id: __sdk::__query_builder::IxCol<GameDistributionThemeMember, String>,
+    pub root_game_id: __sdk::__query_builder::IxCol<GameDistributionThemeMember, String>,
+    pub theme_id: __sdk::__query_builder::IxCol<GameDistributionThemeMember, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for GameDistributionThemeMember {
+    type IxCols = GameDistributionThemeMemberIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        GameDistributionThemeMemberIxCols {
+            member_id: __sdk::__query_builder::IxCol::new(table_name, "member_id"),
+            root_game_id: __sdk::__query_builder::IxCol::new(table_name, "root_game_id"),
+            theme_id: __sdk::__query_builder::IxCol::new(table_name, "theme_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for GameDistributionThemeMember {}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_upsert_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_upsert_input_type.rs
new file mode 100644
index 000000000..1a01182fa
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_member_upsert_input_type.rs
@@ -0,0 +1,18 @@
+// 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 GameDistributionThemeMemberUpsertInput {
+    pub theme_id: String,
+    pub root_game_id: String,
+    pub sort_order: i64,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionThemeMemberUpsertInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_reference_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_reference_snapshot_type.rs
new file mode 100644
index 000000000..50ced40db
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_reference_snapshot_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 GameDistributionThemeReferenceSnapshot {
+    pub theme_id: String,
+    pub name: String,
+    pub badge: String,
+}
+
+impl __sdk::InModule for GameDistributionThemeReferenceSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_refs_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_refs_input_type.rs
new file mode 100644
index 000000000..6bbab4389
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_refs_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 GameDistributionThemeRefsInput {
+    pub game_id: String,
+}
+
+impl __sdk::InModule for GameDistributionThemeRefsInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_refs_result_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_refs_result_type.rs
new file mode 100644
index 000000000..d920c38af
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_refs_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_theme_reference_snapshot_type::GameDistributionThemeReferenceSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionThemeRefsResult {
+    pub ok: bool,
+    pub themes: Vec<GameDistributionThemeReferenceSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for GameDistributionThemeRefsResult {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_snapshot_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_snapshot_type.rs
new file mode 100644
index 000000000..9d390e2ec
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_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};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct GameDistributionThemeSnapshot {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+}
+
+impl __sdk::InModule for GameDistributionThemeSnapshot {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_table.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_table.rs
new file mode 100644
index 000000000..c8bbd13b3
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_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_theme_type::GameDistributionTheme;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `game_distribution_theme`.
+///
+/// Obtain a handle from the [`GameDistributionThemeTableAccess::game_distribution_theme`] method on [`super::RemoteTables`],
+/// like `ctx.db.game_distribution_theme()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_theme().on_insert(...)`.
+pub struct GameDistributionThemeTableHandle<'ctx> {
+    imp: __sdk::TableHandle<GameDistributionTheme>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+/// Lifetime-aware accessor marker for the table `game_distribution_theme`.
+pub struct GameDistributionThemeTableAccessor;
+
+impl __sdk::TableAccessor<super::RemoteTables> for GameDistributionThemeTableAccessor {
+    type Row = GameDistributionTheme;
+    type Handle<'db> = GameDistributionThemeTableHandle<'db>;
+
+    fn get<'db>(db: &'db super::RemoteTables) -> Self::Handle<'db> {
+        db.game_distribution_theme()
+    }
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `game_distribution_theme`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait GameDistributionThemeTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`GameDistributionThemeTableHandle`], which mediates access to the table `game_distribution_theme`.
+    fn game_distribution_theme(&self) -> GameDistributionThemeTableHandle<'_>;
+}
+
+impl GameDistributionThemeTableAccess for super::RemoteTables {
+    fn game_distribution_theme(&self) -> GameDistributionThemeTableHandle<'_> {
+        GameDistributionThemeTableHandle {
+            imp: self
+                .imp
+                .get_table::<GameDistributionTheme>("game_distribution_theme"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct GameDistributionThemeInsertCallbackId(__sdk::CallbackId);
+pub struct GameDistributionThemeDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableLike for GameDistributionThemeTableHandle<'ctx> {
+    type Row = GameDistributionTheme;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionTheme> + '_ {
+        self.imp.iter()
+    }
+}
+
+impl<'ctx> __sdk::Table for GameDistributionThemeTableHandle<'ctx> {
+    type Row = GameDistributionTheme;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = GameDistributionTheme> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = GameDistributionThemeInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeInsertCallbackId {
+        GameDistributionThemeInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionThemeInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = GameDistributionThemeDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeDeleteCallbackId {
+        GameDistributionThemeDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionThemeDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithInsert for GameDistributionThemeTableHandle<'ctx> {
+    type InsertCallbackId = GameDistributionThemeInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeInsertCallbackId {
+        GameDistributionThemeInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: GameDistributionThemeInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithDelete for GameDistributionThemeTableHandle<'ctx> {
+    type DeleteCallbackId = GameDistributionThemeDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeDeleteCallbackId {
+        GameDistributionThemeDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: GameDistributionThemeDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct GameDistributionThemeUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for GameDistributionThemeTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionThemeUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeUpdateCallbackId {
+        GameDistributionThemeUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionThemeUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::WithUpdate for GameDistributionThemeTableHandle<'ctx> {
+    type UpdateCallbackId = GameDistributionThemeUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> GameDistributionThemeUpdateCallbackId {
+        GameDistributionThemeUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: GameDistributionThemeUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `theme_id` unique index on the table `game_distribution_theme`,
+/// which allows point queries on the field of the same name
+/// via the [`GameDistributionThemeThemeIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.game_distribution_theme().theme_id().find(...)`.
+pub struct GameDistributionThemeThemeIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<GameDistributionTheme, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> GameDistributionThemeTableHandle<'ctx> {
+    /// Get a handle on the `theme_id` unique index on the table `game_distribution_theme`.
+    pub fn theme_id(&self) -> GameDistributionThemeThemeIdUnique<'ctx> {
+        GameDistributionThemeThemeIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("theme_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> GameDistributionThemeThemeIdUnique<'ctx> {
+    /// Find the subscribed row whose `theme_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<GameDistributionTheme> {
+        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::<GameDistributionTheme>("game_distribution_theme");
+    _table.add_unique_constraint::<String>("theme_id", |row| &row.theme_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<GameDistributionTheme>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<GameDistributionTheme>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `GameDistributionTheme`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait game_distribution_themeQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `GameDistributionTheme`.
+    fn game_distribution_theme(&self) -> __sdk::__query_builder::Table<GameDistributionTheme>;
+}
+
+impl game_distribution_themeQueryTableAccess for __sdk::QueryTableAccessor {
+    fn game_distribution_theme(&self) -> __sdk::__query_builder::Table<GameDistributionTheme> {
+        __sdk::__query_builder::Table::new("game_distribution_theme")
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_type.rs
new file mode 100644
index 000000000..39e12ff97
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_theme_type.rs
@@ -0,0 +1,75 @@
+// 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 GameDistributionTheme {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub created_by_user_id: String,
+    pub created_at: __sdk::Timestamp,
+    pub updated_at: __sdk::Timestamp,
+}
+
+impl __sdk::InModule for GameDistributionTheme {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `GameDistributionTheme`.
+///
+/// Provides typed access to columns for query building.
+pub struct GameDistributionThemeCols {
+    pub theme_id: __sdk::__query_builder::Col<GameDistributionTheme, String>,
+    pub name: __sdk::__query_builder::Col<GameDistributionTheme, String>,
+    pub summary: __sdk::__query_builder::Col<GameDistributionTheme, String>,
+    pub badge: __sdk::__query_builder::Col<GameDistributionTheme, String>,
+    pub sort_order: __sdk::__query_builder::Col<GameDistributionTheme, i64>,
+    pub status: __sdk::__query_builder::Col<GameDistributionTheme, String>,
+    pub created_by_user_id: __sdk::__query_builder::Col<GameDistributionTheme, String>,
+    pub created_at: __sdk::__query_builder::Col<GameDistributionTheme, __sdk::Timestamp>,
+    pub updated_at: __sdk::__query_builder::Col<GameDistributionTheme, __sdk::Timestamp>,
+}
+
+impl __sdk::__query_builder::HasCols for GameDistributionTheme {
+    type Cols = GameDistributionThemeCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        GameDistributionThemeCols {
+            theme_id: __sdk::__query_builder::Col::new(table_name, "theme_id"),
+            name: __sdk::__query_builder::Col::new(table_name, "name"),
+            summary: __sdk::__query_builder::Col::new(table_name, "summary"),
+            badge: __sdk::__query_builder::Col::new(table_name, "badge"),
+            sort_order: __sdk::__query_builder::Col::new(table_name, "sort_order"),
+            status: __sdk::__query_builder::Col::new(table_name, "status"),
+            created_by_user_id: __sdk::__query_builder::Col::new(table_name, "created_by_user_id"),
+            created_at: __sdk::__query_builder::Col::new(table_name, "created_at"),
+            updated_at: __sdk::__query_builder::Col::new(table_name, "updated_at"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `GameDistributionTheme`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct GameDistributionThemeIxCols {
+    pub created_at: __sdk::__query_builder::IxCol<GameDistributionTheme, __sdk::Timestamp>,
+    pub theme_id: __sdk::__query_builder::IxCol<GameDistributionTheme, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for GameDistributionTheme {
+    type IxCols = GameDistributionThemeIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        GameDistributionThemeIxCols {
+            created_at: __sdk::__query_builder::IxCol::new(table_name, "created_at"),
+            theme_id: __sdk::__query_builder::IxCol::new(table_name, "theme_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for GameDistributionTheme {}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_uncollect_game_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_uncollect_game_input_type.rs
new file mode 100644
index 000000000..09ffd71de
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_uncollect_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 GameDistributionUncollectGameInput {
+    pub game_id: String,
+    pub user_id: String,
+}
+
+impl __sdk::InModule for GameDistributionUncollectGameInput {
+    type Module = super::RemoteModule;
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_update_theme_input_type.rs b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_update_theme_input_type.rs
new file mode 100644
index 000000000..47534fb45
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/game_distribution_update_theme_input_type.rs
@@ -0,0 +1,24 @@
+// 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 GameDistributionUpdateThemeInput {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub admin_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+impl __sdk::InModule for GameDistributionUpdateThemeInput {
+    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
index 7acae2d7c..3f6e84c22 100644
--- 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
@@ -22,6 +22,10 @@ pub struct GameDistributionVersionSnapshot {
     pub created_at_micros: i64,
     pub updated_at_micros: i64,
     pub metadata_json: Option<String>,
+    pub project_bundle_object_key: Option<String>,
+    pub project_bundle_bytes: u64,
+    pub project_bundle_sha_256: Option<String>,
+    pub change_summary: Option<String>,
 }
 
 impl __sdk::InModule for GameDistributionVersionSnapshot {
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
index f22d76f4c..e12683a90 100644
--- 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
@@ -32,6 +32,10 @@ pub struct GameDistributionVersion {
     pub last_error_code: Option<String>,
     pub last_error_message: Option<String>,
     pub metadata_json: Option<String>,
+    pub project_bundle_object_key: Option<String>,
+    pub project_bundle_bytes: u64,
+    pub project_bundle_sha_256: Option<String>,
+    pub change_summary: Option<String>,
 }
 
 impl __sdk::InModule for GameDistributionVersion {
@@ -69,6 +73,12 @@ pub struct GameDistributionVersionCols {
     pub last_error_code: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
     pub last_error_message: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
     pub metadata_json: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub project_bundle_object_key:
+        __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub project_bundle_bytes: __sdk::__query_builder::Col<GameDistributionVersion, u64>,
+    pub project_bundle_sha_256:
+        __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
+    pub change_summary: __sdk::__query_builder::Col<GameDistributionVersion, Option<String>>,
 }
 
 impl __sdk::__query_builder::HasCols for GameDistributionVersion {
@@ -106,6 +116,19 @@ impl __sdk::__query_builder::HasCols for GameDistributionVersion {
             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"),
             metadata_json: __sdk::__query_builder::Col::new(table_name, "metadata_json"),
+            project_bundle_object_key: __sdk::__query_builder::Col::new(
+                table_name,
+                "project_bundle_object_key",
+            ),
+            project_bundle_bytes: __sdk::__query_builder::Col::new(
+                table_name,
+                "project_bundle_bytes",
+            ),
+            project_bundle_sha_256: __sdk::__query_builder::Col::new(
+                table_name,
+                "project_bundle_sha_256",
+            ),
+            change_summary: __sdk::__query_builder::Col::new(table_name, "change_summary"),
         }
     }
 }
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_creator_profile_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_creator_profile_and_return_procedure.rs
index c15318f03..d24cb6cca 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_creator_profile_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_creator_profile_and_return_procedure.rs
@@ -30,10 +30,10 @@ pub trait get_creator_profile_and_return {
         user_id: String,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorProfileResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorProfileResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -43,10 +43,10 @@ impl get_creator_profile_and_return for super::RemoteProcedures {
         user_id: String,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorProfileResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorProfileResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, CreatorProfileResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_creator_relationship_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_creator_relationship_and_return_procedure.rs
index 4239ab6c1..441f69b33 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_creator_relationship_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_creator_relationship_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait get_creator_relationship_and_return {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl get_creator_relationship_and_return for super::RemoteProcedures {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, CreatorRelationshipResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_contribution_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_contribution_and_return_procedure.rs
new file mode 100644
index 000000000..907fe030d
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_contribution_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_contribution_input_type::GameDistributionContributionInput;
+use super::game_distribution_contribution_result_type::GameDistributionContributionResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetGameDistributionContributionAndReturnArgs {
+    pub input: GameDistributionContributionInput,
+}
+
+impl __sdk::InModule for GetGameDistributionContributionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_game_distribution_contribution_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_game_distribution_contribution_and_return {
+    fn get_game_distribution_contribution_and_return(
+        &self,
+        input: GameDistributionContributionInput,
+    ) {
+        self.get_game_distribution_contribution_and_return_then(input, |_, _| {});
+    }
+
+    fn get_game_distribution_contribution_and_return_then(
+        &self,
+        input: GameDistributionContributionInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionContributionResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl get_game_distribution_contribution_and_return for super::RemoteProcedures {
+    fn get_game_distribution_contribution_and_return_then(
+        &self,
+        input: GameDistributionContributionInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionContributionResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionContributionResult>(
+                "get_game_distribution_contribution_and_return",
+                GetGameDistributionContributionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_fork_source_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_fork_source_and_return_procedure.rs
new file mode 100644
index 000000000..6ab77ba98
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_fork_source_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_fork_source_input_type::GameDistributionForkSourceInput;
+use super::game_distribution_fork_source_result_type::GameDistributionForkSourceResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetGameDistributionForkSourceAndReturnArgs {
+    pub input: GameDistributionForkSourceInput,
+}
+
+impl __sdk::InModule for GetGameDistributionForkSourceAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_game_distribution_fork_source_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_game_distribution_fork_source_and_return {
+    fn get_game_distribution_fork_source_and_return(&self, input: GameDistributionForkSourceInput) {
+        self.get_game_distribution_fork_source_and_return_then(input, |_, _| {});
+    }
+
+    fn get_game_distribution_fork_source_and_return_then(
+        &self,
+        input: GameDistributionForkSourceInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionForkSourceResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl get_game_distribution_fork_source_and_return for super::RemoteProcedures {
+    fn get_game_distribution_fork_source_and_return_then(
+        &self,
+        input: GameDistributionForkSourceInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionForkSourceResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionForkSourceResult>(
+                "get_game_distribution_fork_source_and_return",
+                GetGameDistributionForkSourceAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_lineage_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_lineage_and_return_procedure.rs
new file mode 100644
index 000000000..8f76b2f0b
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_lineage_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_lineage_input_type::GameDistributionLineageInput;
+use super::game_distribution_lineage_result_type::GameDistributionLineageResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetGameDistributionLineageAndReturnArgs {
+    pub input: GameDistributionLineageInput,
+}
+
+impl __sdk::InModule for GetGameDistributionLineageAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_game_distribution_lineage_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_game_distribution_lineage_and_return {
+    fn get_game_distribution_lineage_and_return(&self, input: GameDistributionLineageInput) {
+        self.get_game_distribution_lineage_and_return_then(input, |_, _| {});
+    }
+
+    fn get_game_distribution_lineage_and_return_then(
+        &self,
+        input: GameDistributionLineageInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionLineageResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl get_game_distribution_lineage_and_return for super::RemoteProcedures {
+    fn get_game_distribution_lineage_and_return_then(
+        &self,
+        input: GameDistributionLineageInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionLineageResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionLineageResult>(
+                "get_game_distribution_lineage_and_return",
+                GetGameDistributionLineageAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_theme_detail_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_theme_detail_and_return_procedure.rs
new file mode 100644
index 000000000..e3f5a4ba0
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_game_distribution_theme_detail_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_theme_detail_input_type::GameDistributionThemeDetailInput;
+use super::game_distribution_theme_detail_result_type::GameDistributionThemeDetailResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetGameDistributionThemeDetailAndReturnArgs {
+    pub input: GameDistributionThemeDetailInput,
+}
+
+impl __sdk::InModule for GetGameDistributionThemeDetailAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_game_distribution_theme_detail_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_game_distribution_theme_detail_and_return {
+    fn get_game_distribution_theme_detail_and_return(
+        &self,
+        input: GameDistributionThemeDetailInput,
+    ) {
+        self.get_game_distribution_theme_detail_and_return_then(input, |_, _| {});
+    }
+
+    fn get_game_distribution_theme_detail_and_return_then(
+        &self,
+        input: GameDistributionThemeDetailInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionThemeDetailResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl get_game_distribution_theme_detail_and_return for super::RemoteProcedures {
+    fn get_game_distribution_theme_detail_and_return_then(
+        &self,
+        input: GameDistributionThemeDetailInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionThemeDetailResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionThemeDetailResult>(
+                "get_game_distribution_theme_detail_and_return",
+                GetGameDistributionThemeDetailAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_profile_agc_model_access_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_profile_agc_model_access_and_return_procedure.rs
index eca693a53..abe662e25 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_profile_agc_model_access_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_profile_agc_model_access_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait get_profile_agc_model_access_and_return {
         input: RuntimeProfileMembershipGetInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileAgcModelAccessProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileAgcModelAccessProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl get_profile_agc_model_access_and_return for super::RemoteProcedures {
         input: RuntimeProfileMembershipGetInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileAgcModelAccessProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileAgcModelAccessProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, RuntimeProfileAgcModelAccessProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_snapshot_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_snapshot_and_return_procedure.rs
index 0ea44fe05..a1d63f258 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_snapshot_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_snapshot_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait get_profile_membership_snapshot_and_return {
         input: RuntimeProfileMembershipGetInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipSnapshotProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipSnapshotProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl get_profile_membership_snapshot_and_return for super::RemoteProcedures {
         input: RuntimeProfileMembershipGetInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipSnapshotProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipSnapshotProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, RuntimeProfileMembershipSnapshotProcedureResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_upgrade_quote_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_upgrade_quote_procedure.rs
index dc37950df..3abdaae02 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_upgrade_quote_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/get_profile_membership_upgrade_quote_procedure.rs
@@ -34,10 +34,10 @@ pub trait get_profile_membership_upgrade_quote {
         input: RuntimeProfileMembershipUpgradeQuoteGetInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipUpgradeQuoteProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipUpgradeQuoteProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -47,10 +47,10 @@ impl get_profile_membership_upgrade_quote for super::RemoteProcedures {
         input: RuntimeProfileMembershipUpgradeQuoteGetInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<RuntimeProfileMembershipUpgradeQuoteProcedureResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<RuntimeProfileMembershipUpgradeQuoteProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp.invoke_procedure_with_callback::<_, RuntimeProfileMembershipUpgradeQuoteProcedureResult>(
             "get_profile_membership_upgrade_quote",
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/is_game_distribution_collected_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/is_game_distribution_collected_and_return_procedure.rs
new file mode 100644
index 000000000..7a916d327
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/is_game_distribution_collected_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_collection_state_input_type::GameDistributionCollectionStateInput;
+use super::game_distribution_collection_state_result_type::GameDistributionCollectionStateResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct IsGameDistributionCollectedAndReturnArgs {
+    pub input: GameDistributionCollectionStateInput,
+}
+
+impl __sdk::InModule for IsGameDistributionCollectedAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `is_game_distribution_collected_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait is_game_distribution_collected_and_return {
+    fn is_game_distribution_collected_and_return(
+        &self,
+        input: GameDistributionCollectionStateInput,
+    ) {
+        self.is_game_distribution_collected_and_return_then(input, |_, _| {});
+    }
+
+    fn is_game_distribution_collected_and_return_then(
+        &self,
+        input: GameDistributionCollectionStateInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionStateResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl is_game_distribution_collected_and_return for super::RemoteProcedures {
+    fn is_game_distribution_collected_and_return_then(
+        &self,
+        input: GameDistributionCollectionStateInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionStateResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionCollectionStateResult>(
+                "is_game_distribution_collected_and_return",
+                IsGameDistributionCollectedAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_theme_members_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_theme_members_and_return_procedure.rs
new file mode 100644
index 000000000..bf30095bf
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_theme_members_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_admin_theme_member_list_input_type::GameDistributionAdminThemeMemberListInput;
+use super::game_distribution_admin_theme_member_list_result_type::GameDistributionAdminThemeMemberListResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListAdminGameDistributionThemeMembersAndReturnArgs {
+    pub input: GameDistributionAdminThemeMemberListInput,
+}
+
+impl __sdk::InModule for ListAdminGameDistributionThemeMembersAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_admin_game_distribution_theme_members_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_admin_game_distribution_theme_members_and_return {
+    fn list_admin_game_distribution_theme_members_and_return(
+        &self,
+        input: GameDistributionAdminThemeMemberListInput,
+    ) {
+        self.list_admin_game_distribution_theme_members_and_return_then(input, |_, _| {});
+    }
+
+    fn list_admin_game_distribution_theme_members_and_return_then(
+        &self,
+        input: GameDistributionAdminThemeMemberListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMemberListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl list_admin_game_distribution_theme_members_and_return for super::RemoteProcedures {
+    fn list_admin_game_distribution_theme_members_and_return_then(
+        &self,
+        input: GameDistributionAdminThemeMemberListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMemberListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionAdminThemeMemberListResult>(
+                "list_admin_game_distribution_theme_members_and_return",
+                ListAdminGameDistributionThemeMembersAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_themes_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_themes_and_return_procedure.rs
new file mode 100644
index 000000000..783a5c8e8
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_admin_game_distribution_themes_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_admin_theme_list_input_type::GameDistributionAdminThemeListInput;
+use super::game_distribution_admin_theme_list_result_type::GameDistributionAdminThemeListResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListAdminGameDistributionThemesAndReturnArgs {
+    pub input: GameDistributionAdminThemeListInput,
+}
+
+impl __sdk::InModule for ListAdminGameDistributionThemesAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_admin_game_distribution_themes_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_admin_game_distribution_themes_and_return {
+    fn list_admin_game_distribution_themes_and_return(
+        &self,
+        input: GameDistributionAdminThemeListInput,
+    ) {
+        self.list_admin_game_distribution_themes_and_return_then(input, |_, _| {});
+    }
+
+    fn list_admin_game_distribution_themes_and_return_then(
+        &self,
+        input: GameDistributionAdminThemeListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl list_admin_game_distribution_themes_and_return for super::RemoteProcedures {
+    fn list_admin_game_distribution_themes_and_return_then(
+        &self,
+        input: GameDistributionAdminThemeListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionAdminThemeListResult>(
+                "list_admin_game_distribution_themes_and_return",
+                ListAdminGameDistributionThemesAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_creator_connections_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_creator_connections_and_return_procedure.rs
index 5df000f5e..a97fcf1ce 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/list_creator_connections_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_creator_connections_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait list_creator_connections_and_return {
         input: CreatorConnectionsInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorConnectionsResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorConnectionsResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl list_creator_connections_and_return for super::RemoteProcedures {
         input: CreatorConnectionsInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorConnectionsResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorConnectionsResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, CreatorConnectionsResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_collections_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_collections_and_return_procedure.rs
new file mode 100644
index 000000000..d5d61b41a
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_collections_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_collection_list_input_type::GameDistributionCollectionListInput;
+use super::game_distribution_collection_list_result_type::GameDistributionCollectionListResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListGameDistributionCollectionsAndReturnArgs {
+    pub input: GameDistributionCollectionListInput,
+}
+
+impl __sdk::InModule for ListGameDistributionCollectionsAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_game_distribution_collections_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_game_distribution_collections_and_return {
+    fn list_game_distribution_collections_and_return(
+        &self,
+        input: GameDistributionCollectionListInput,
+    ) {
+        self.list_game_distribution_collections_and_return_then(input, |_, _| {});
+    }
+
+    fn list_game_distribution_collections_and_return_then(
+        &self,
+        input: GameDistributionCollectionListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl list_game_distribution_collections_and_return for super::RemoteProcedures {
+    fn list_game_distribution_collections_and_return_then(
+        &self,
+        input: GameDistributionCollectionListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionCollectionListResult>(
+                "list_game_distribution_collections_and_return",
+                ListGameDistributionCollectionsAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_derived_games_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_derived_games_and_return_procedure.rs
new file mode 100644
index 000000000..1a1f66553
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_derived_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_derived_games_input_type::GameDistributionDerivedGamesInput;
+use super::game_distribution_derived_games_result_type::GameDistributionDerivedGamesResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListGameDistributionDerivedGamesAndReturnArgs {
+    pub input: GameDistributionDerivedGamesInput,
+}
+
+impl __sdk::InModule for ListGameDistributionDerivedGamesAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_game_distribution_derived_games_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_game_distribution_derived_games_and_return {
+    fn list_game_distribution_derived_games_and_return(
+        &self,
+        input: GameDistributionDerivedGamesInput,
+    ) {
+        self.list_game_distribution_derived_games_and_return_then(input, |_, _| {});
+    }
+
+    fn list_game_distribution_derived_games_and_return_then(
+        &self,
+        input: GameDistributionDerivedGamesInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionDerivedGamesResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl list_game_distribution_derived_games_and_return for super::RemoteProcedures {
+    fn list_game_distribution_derived_games_and_return_then(
+        &self,
+        input: GameDistributionDerivedGamesInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionDerivedGamesResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionDerivedGamesResult>(
+                "list_game_distribution_derived_games_and_return",
+                ListGameDistributionDerivedGamesAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_theme_refs_for_root_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_theme_refs_for_root_and_return_procedure.rs
new file mode 100644
index 000000000..8b81d9a61
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_theme_refs_for_root_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_theme_refs_input_type::GameDistributionThemeRefsInput;
+use super::game_distribution_theme_refs_result_type::GameDistributionThemeRefsResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListGameDistributionThemeRefsForRootAndReturnArgs {
+    pub input: GameDistributionThemeRefsInput,
+}
+
+impl __sdk::InModule for ListGameDistributionThemeRefsForRootAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_game_distribution_theme_refs_for_root_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_game_distribution_theme_refs_for_root_and_return {
+    fn list_game_distribution_theme_refs_for_root_and_return(
+        &self,
+        input: GameDistributionThemeRefsInput,
+    ) {
+        self.list_game_distribution_theme_refs_for_root_and_return_then(input, |_, _| {});
+    }
+
+    fn list_game_distribution_theme_refs_for_root_and_return_then(
+        &self,
+        input: GameDistributionThemeRefsInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionThemeRefsResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl list_game_distribution_theme_refs_for_root_and_return for super::RemoteProcedures {
+    fn list_game_distribution_theme_refs_for_root_and_return_then(
+        &self,
+        input: GameDistributionThemeRefsInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionThemeRefsResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionThemeRefsResult>(
+                "list_game_distribution_theme_refs_for_root_and_return",
+                ListGameDistributionThemeRefsForRootAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_themes_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_themes_and_return_procedure.rs
new file mode 100644
index 000000000..8b4fb0f3b
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/list_game_distribution_themes_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_theme_list_input_type::GameDistributionThemeListInput;
+use super::game_distribution_theme_list_result_type::GameDistributionThemeListResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListGameDistributionThemesAndReturnArgs {
+    pub input: GameDistributionThemeListInput,
+}
+
+impl __sdk::InModule for ListGameDistributionThemesAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_game_distribution_themes_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_game_distribution_themes_and_return {
+    fn list_game_distribution_themes_and_return(&self, input: GameDistributionThemeListInput) {
+        self.list_game_distribution_themes_and_return_then(input, |_, _| {});
+    }
+
+    fn list_game_distribution_themes_and_return_then(
+        &self,
+        input: GameDistributionThemeListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionThemeListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl list_game_distribution_themes_and_return for super::RemoteProcedures {
+    fn list_game_distribution_themes_and_return_then(
+        &self,
+        input: GameDistributionThemeListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionThemeListResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionThemeListResult>(
+                "list_game_distribution_themes_and_return",
+                ListGameDistributionThemesAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/remove_creator_follower_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/remove_creator_follower_and_return_procedure.rs
index e9d51e5f5..3d6a8a1b3 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/remove_creator_follower_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/remove_creator_follower_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait remove_creator_follower_and_return {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl remove_creator_follower_and_return for super::RemoteProcedures {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, CreatorRelationshipResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/remove_game_distribution_theme_member_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/remove_game_distribution_theme_member_and_return_procedure.rs
new file mode 100644
index 000000000..3d3d4f7f6
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/remove_game_distribution_theme_member_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_admin_theme_member_mutation_result_type::GameDistributionAdminThemeMemberMutationResult;
+use super::game_distribution_theme_member_remove_input_type::GameDistributionThemeMemberRemoveInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct RemoveGameDistributionThemeMemberAndReturnArgs {
+    pub input: GameDistributionThemeMemberRemoveInput,
+}
+
+impl __sdk::InModule for RemoveGameDistributionThemeMemberAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `remove_game_distribution_theme_member_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait remove_game_distribution_theme_member_and_return {
+    fn remove_game_distribution_theme_member_and_return(
+        &self,
+        input: GameDistributionThemeMemberRemoveInput,
+    ) {
+        self.remove_game_distribution_theme_member_and_return_then(input, |_, _| {});
+    }
+
+    fn remove_game_distribution_theme_member_and_return_then(
+        &self,
+        input: GameDistributionThemeMemberRemoveInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMemberMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl remove_game_distribution_theme_member_and_return for super::RemoteProcedures {
+    fn remove_game_distribution_theme_member_and_return_then(
+        &self,
+        input: GameDistributionThemeMemberRemoveInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMemberMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionAdminThemeMemberMutationResult>(
+                "remove_game_distribution_theme_member_and_return",
+                RemoveGameDistributionThemeMemberAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/set_game_distribution_collection_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/set_game_distribution_collection_and_return_procedure.rs
new file mode 100644
index 000000000..1e8647397
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/set_game_distribution_collection_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_collect_game_input_type::GameDistributionCollectGameInput;
+use super::game_distribution_collection_mutation_result_type::GameDistributionCollectionMutationResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct SetGameDistributionCollectionAndReturnArgs {
+    pub input: GameDistributionCollectGameInput,
+}
+
+impl __sdk::InModule for SetGameDistributionCollectionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `set_game_distribution_collection_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait set_game_distribution_collection_and_return {
+    fn set_game_distribution_collection_and_return(&self, input: GameDistributionCollectGameInput) {
+        self.set_game_distribution_collection_and_return_then(input, |_, _| {});
+    }
+
+    fn set_game_distribution_collection_and_return_then(
+        &self,
+        input: GameDistributionCollectGameInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl set_game_distribution_collection_and_return for super::RemoteProcedures {
+    fn set_game_distribution_collection_and_return_then(
+        &self,
+        input: GameDistributionCollectGameInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionCollectionMutationResult>(
+                "set_game_distribution_collection_and_return",
+                SetGameDistributionCollectionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/set_game_distribution_fork_authorization_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/set_game_distribution_fork_authorization_and_return_procedure.rs
new file mode 100644
index 000000000..4bfbec693
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/set_game_distribution_fork_authorization_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_set_fork_authorization_input_type::GameDistributionSetForkAuthorizationInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct SetGameDistributionForkAuthorizationAndReturnArgs {
+    pub input: GameDistributionSetForkAuthorizationInput,
+}
+
+impl __sdk::InModule for SetGameDistributionForkAuthorizationAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `set_game_distribution_fork_authorization_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait set_game_distribution_fork_authorization_and_return {
+    fn set_game_distribution_fork_authorization_and_return(
+        &self,
+        input: GameDistributionSetForkAuthorizationInput,
+    ) {
+        self.set_game_distribution_fork_authorization_and_return_then(input, |_, _| {});
+    }
+
+    fn set_game_distribution_fork_authorization_and_return_then(
+        &self,
+        input: GameDistributionSetForkAuthorizationInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl set_game_distribution_fork_authorization_and_return for super::RemoteProcedures {
+    fn set_game_distribution_fork_authorization_and_return_then(
+        &self,
+        input: GameDistributionSetForkAuthorizationInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionProcedureResult>(
+                "set_game_distribution_fork_authorization_and_return",
+                SetGameDistributionForkAuthorizationAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/unfollow_creator_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/unfollow_creator_and_return_procedure.rs
index 5a9045062..b379a4086 100644
--- a/server-rs/crates/spacetime-client/src/module_bindings/unfollow_creator_and_return_procedure.rs
+++ b/server-rs/crates/spacetime-client/src/module_bindings/unfollow_creator_and_return_procedure.rs
@@ -31,10 +31,10 @@ pub trait unfollow_creator_and_return {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     );
 }
 
@@ -44,10 +44,10 @@ impl unfollow_creator_and_return for super::RemoteProcedures {
         input: CreatorRelationshipInput,
 
         __callback: impl FnOnce(
-                &super::ProcedureEventContext,
-                Result<CreatorRelationshipResult, __sdk::InternalError>,
-            ) + Send
-            + 'static,
+            &super::ProcedureEventContext,
+            Result<CreatorRelationshipResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
     ) {
         self.imp
             .invoke_procedure_with_callback::<_, CreatorRelationshipResult>(
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/unset_game_distribution_collection_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/unset_game_distribution_collection_and_return_procedure.rs
new file mode 100644
index 000000000..3cdf1ece0
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/unset_game_distribution_collection_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_collection_mutation_result_type::GameDistributionCollectionMutationResult;
+use super::game_distribution_uncollect_game_input_type::GameDistributionUncollectGameInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct UnsetGameDistributionCollectionAndReturnArgs {
+    pub input: GameDistributionUncollectGameInput,
+}
+
+impl __sdk::InModule for UnsetGameDistributionCollectionAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `unset_game_distribution_collection_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait unset_game_distribution_collection_and_return {
+    fn unset_game_distribution_collection_and_return(
+        &self,
+        input: GameDistributionUncollectGameInput,
+    ) {
+        self.unset_game_distribution_collection_and_return_then(input, |_, _| {});
+    }
+
+    fn unset_game_distribution_collection_and_return_then(
+        &self,
+        input: GameDistributionUncollectGameInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl unset_game_distribution_collection_and_return for super::RemoteProcedures {
+    fn unset_game_distribution_collection_and_return_then(
+        &self,
+        input: GameDistributionUncollectGameInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionCollectionMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionCollectionMutationResult>(
+                "unset_game_distribution_collection_and_return",
+                UnsetGameDistributionCollectionAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/update_game_distribution_theme_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/update_game_distribution_theme_and_return_procedure.rs
new file mode 100644
index 000000000..f26782f6f
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/update_game_distribution_theme_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_admin_theme_mutation_result_type::GameDistributionAdminThemeMutationResult;
+use super::game_distribution_update_theme_input_type::GameDistributionUpdateThemeInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct UpdateGameDistributionThemeAndReturnArgs {
+    pub input: GameDistributionUpdateThemeInput,
+}
+
+impl __sdk::InModule for UpdateGameDistributionThemeAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `update_game_distribution_theme_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait update_game_distribution_theme_and_return {
+    fn update_game_distribution_theme_and_return(&self, input: GameDistributionUpdateThemeInput) {
+        self.update_game_distribution_theme_and_return_then(input, |_, _| {});
+    }
+
+    fn update_game_distribution_theme_and_return_then(
+        &self,
+        input: GameDistributionUpdateThemeInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl update_game_distribution_theme_and_return for super::RemoteProcedures {
+    fn update_game_distribution_theme_and_return_then(
+        &self,
+        input: GameDistributionUpdateThemeInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionAdminThemeMutationResult>(
+                "update_game_distribution_theme_and_return",
+                UpdateGameDistributionThemeAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-client/src/module_bindings/upsert_game_distribution_theme_member_and_return_procedure.rs b/server-rs/crates/spacetime-client/src/module_bindings/upsert_game_distribution_theme_member_and_return_procedure.rs
new file mode 100644
index 000000000..8c5f65edf
--- /dev/null
+++ b/server-rs/crates/spacetime-client/src/module_bindings/upsert_game_distribution_theme_member_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_admin_theme_member_mutation_result_type::GameDistributionAdminThemeMemberMutationResult;
+use super::game_distribution_theme_member_upsert_input_type::GameDistributionThemeMemberUpsertInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct UpsertGameDistributionThemeMemberAndReturnArgs {
+    pub input: GameDistributionThemeMemberUpsertInput,
+}
+
+impl __sdk::InModule for UpsertGameDistributionThemeMemberAndReturnArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `upsert_game_distribution_theme_member_and_return`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait upsert_game_distribution_theme_member_and_return {
+    fn upsert_game_distribution_theme_member_and_return(
+        &self,
+        input: GameDistributionThemeMemberUpsertInput,
+    ) {
+        self.upsert_game_distribution_theme_member_and_return_then(input, |_, _| {});
+    }
+
+    fn upsert_game_distribution_theme_member_and_return_then(
+        &self,
+        input: GameDistributionThemeMemberUpsertInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMemberMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl upsert_game_distribution_theme_member_and_return for super::RemoteProcedures {
+    fn upsert_game_distribution_theme_member_and_return_then(
+        &self,
+        input: GameDistributionThemeMemberUpsertInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<GameDistributionAdminThemeMemberMutationResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, GameDistributionAdminThemeMemberMutationResult>(
+                "upsert_game_distribution_theme_member_and_return",
+                UpsertGameDistributionThemeMemberAndReturnArgs { input },
+                __callback,
+            );
+    }
+}
diff --git a/server-rs/crates/spacetime-module/src/game_distribution.rs b/server-rs/crates/spacetime-module/src/game_distribution.rs
index 8c3d01360..d9ec03c78 100644
--- a/server-rs/crates/spacetime-module/src/game_distribution.rs
+++ b/server-rs/crates/spacetime-module/src/game_distribution.rs
@@ -768,9 +768,162 @@ pub struct GameDistributionGame {
     #[default(None::<Timestamp>)]
     pub(crate) deleted_at: Option<Timestamp>,
     /// 买断制价格（泥点）：`0` 表示免费。只在审核通过时随版本冻结资料整体生效，
-    /// 因此未通过审核的价格不会改变当前公开价格。必须保持在结构体末尾。
+    /// 因此未通过审核的价格不会改变当前公开价格。
+    ///
+    /// **列序是 wire format 的一部分**：这一列是 master 侧先追加的（第 26 位），序号必须保持不变；
+    /// 本分支后追加的 `fork_authorization` 必须排它**之后**——`check:spacetime-schema` 只允许在
+    /// 结构体末尾追加，任何相对顺序变化都会被判成字段重排（合并时正是踩了这一条）。
     #[default(0u64)]
     pub(crate) price_mud_points: u64,
+    /// 作品级共创（Fork）授权档位：`forbidden` / `nonCommercial` / `full`。
+    /// 只允许单向提升开放度；旧行按默认「禁止共创」解释。
+    ///
+    /// 写入有两种来源：母版按创建请求的档位（缺省 `forbidden`）；**衍生作品在创建时继承
+    /// 父作品当时的档位**（创建时快照，父作品之后提升不会回溯改写既有子作品的行）。
+    /// 两种口径互不冲突：提升只改被提升的那一行。
+    ///
+    /// **提升只对母版开放**：存在血缘行的作品（衍生作品）不允许再改档位——`forbidden` 之上父作品
+    /// 给的是什么就是什么（终态），否则作者能把继承来的 `nonCommercial` 提成 `full`，得到比祖先
+    /// 更宽的授权。判定与码见 `set_game_distribution_fork_authorization_tx`。
+    ///
+    /// 本分支较 master 后追加，因此留在表尾（见上一列的注释）。
+    #[default("forbidden")]
+    pub(crate) fork_authorization: String,
+}
+
+/// 作品之间的改编（Fork）血缘：一个作品最多有一个父，主键即子作品 ID。
+///
+/// 血缘在创建子作品时一次性写入，之后不可变更；父作品下架或封禁都不影响既有行。
+#[spacetimedb::table(
+    accessor = game_distribution_lineage,
+    index(
+        accessor = by_game_distribution_lineage_parent_game_id,
+        btree(columns = [parent_game_id])
+    ),
+    index(
+        accessor = by_game_distribution_lineage_root_game_id,
+        btree(columns = [root_game_id])
+    ),
+    index(
+        accessor = by_game_distribution_lineage_owner_user_id,
+        btree(columns = [owner_user_id])
+    )
+)]
+#[derive(Clone)]
+pub struct GameDistributionLineage {
+    /// 子作品；主键承载「一个作品只能有一个父」这条不变量。
+    #[primary_key]
+    pub(crate) game_id: String,
+    /// 子作品作者，冗余用于「我改编过的作品」查询，不参与授权判定。
+    pub(crate) owner_user_id: String,
+    pub(crate) parent_game_id: String,
+    /// 建立血缘时父作品的当前公开版本，不可变溯源事实。
+    pub(crate) parent_version_id: String,
+    /// 0 代母版；根作品自身不写行。
+    pub(crate) root_game_id: String,
+    /// 代际；直接改编根作品为 1。
+    pub(crate) generation: u32,
+    pub(crate) created_at: Timestamp,
+}
+
+/// 用户对公开作品的收藏（收录）事实：**真实用户态投影**，不是前端本地状态。
+///
+/// 主键是确定性构造的 `{user_id}:{game_id}`（`module_game_distribution::game_distribution_collection_id`）：
+/// 同一 (用户, 作品) 在**结构上**不可能出现第二行，去重由主键约束本身承担，而不是靠
+/// 「事务里先查后写」——那种写法只在单写者假设下成立，将来分片 / 并发写同一对组合时，
+/// 两个事务都可能先查到「不存在」再各写一行。也正因为主键已经是那条约束，这里**不需要**
+/// 再建 `(user_id, game_id)` 唯一索引；两个索引只服务两个读取方向（「我的收藏」/ 按作品）。
+///
+/// 作品下架（未公开 / 软删除）**不删除**本表行：收藏是用户态事实，读侧投影时才按当前公开性
+/// 过滤，作品重新公开后收藏自动回到列表。`created_at` 只用于列表稳定排序。
+#[spacetimedb::table(
+    accessor = game_distribution_collection,
+    index(
+        accessor = by_game_distribution_collection_user_id,
+        btree(columns = [user_id])
+    ),
+    index(
+        accessor = by_game_distribution_collection_game_id,
+        btree(columns = [game_id])
+    )
+)]
+#[derive(Clone)]
+pub struct GameDistributionCollection {
+    #[primary_key]
+    pub(crate) collection_id: String,
+    pub(crate) user_id: String,
+    pub(crate) game_id: String,
+    pub(crate) created_at: Timestamp,
+}
+
+/// 平台 / 运营命名的「共创主题」：一棵（或一组）作品树的归组实体。
+///
+/// 主题不是作品的属性，而是**运营叙事**：作品在游戏 Tab 里仍作为独立作品展示，主题只是额外
+/// 的归组维度（一个根可以同时属于多个主题）。归属关系在多对多的 `game_distribution_theme_member`
+/// 里，因此 `game` 主行（详情页热路径）不挂任何运营字段。
+///
+/// `status` 三态 `draft` / `published` / `archived`：公开侧只出现 `published`（
+/// `module_game_distribution::game_distribution_theme_public_visible`），归档不是删除——成员行
+/// 保留，只是不再进入公开投影。`created_by_user_id` 只用于审计「谁建的」，不参与鉴权判定。
+#[spacetimedb::table(
+    accessor = game_distribution_theme,
+    index(
+        accessor = by_game_distribution_theme_created_at,
+        btree(columns = [created_at])
+    ),
+)]
+#[derive(Clone)]
+pub struct GameDistributionTheme {
+    /// 平台签发的主题 ID，形如 `theme-*`；由服务端生成，不接受客户端指定。
+    #[primary_key]
+    pub(crate) theme_id: String,
+    /// 主题名（运营命名，不是根作品标题的派生）。
+    pub(crate) name: String,
+    pub(crate) summary: String,
+    /// 角标短文本（本轮用它 + 名称承担「封面」的呈现职责）。
+    pub(crate) badge: String,
+    /// 运营排序权重（成员排序使用）。
+    pub(crate) sort_order: i64,
+    /// `draft` / `published` / `archived`。
+    pub(crate) status: String,
+    /// 创建该主题的运营账号（= 后台会话主体），用于审计，不参与鉴权判定。
+    pub(crate) created_by_user_id: String,
+    pub(crate) created_at: Timestamp,
+    pub(crate) updated_at: Timestamp,
+}
+
+/// 主题成员：只允许**根作品**（该作品没有血缘行，即第 0 代）。
+///
+/// 主键是确定性构造的 `{theme_id}:{root_game_id}`
+/// （`module_game_distribution::game_distribution_theme_member_id`）：同一主题内同一根在
+/// **结构上**不可能出现第二行，去重由主键约束本身承担，而不是靠「事务里先查后写」。因此这里
+/// **不需要** `(theme_id, root_game_id)` 唯一索引；两条具名索引只服务两个真实读取方向
+/// （主题页按主题取成员、作品详情按根反查所属主题）。
+///
+/// 跨主题的同一根会有**多行**（每主题一行），这是预期行为而不是重复数据。作品下架 / 软删除
+/// **不删除**成员行：读取时按当前公开性过滤（`game_distribution_theme_member_visible`），
+/// 作品重新公开后成员自动回到主题页。`sort_order` 允许重复，排序由 `member_id` 兜底成全序。
+#[spacetimedb::table(
+    accessor = game_distribution_theme_member,
+    index(
+        accessor = by_game_distribution_theme_member_theme_id,
+        btree(columns = [theme_id])
+    ),
+    index(
+        accessor = by_game_distribution_theme_member_root_game_id,
+        btree(columns = [root_game_id])
+    ),
+)]
+#[derive(Clone)]
+pub struct GameDistributionThemeMember {
+    /// 确定性主键 `"{theme_id}:{root_game_id}"`（同 `game_distribution_collection` 的写法）。
+    #[primary_key]
+    pub(crate) member_id: String,
+    pub(crate) theme_id: String,
+    /// 只允许**根作品**。
+    pub(crate) root_game_id: String,
+    pub(crate) sort_order: i64,
+    pub(crate) created_at: Timestamp,
 }
 
 /// 游戏发行版本。包摘要、确认字节数和送审资料在创建后作为不可变快照保留；状态和
@@ -828,6 +981,28 @@ pub struct GameDistributionVersion {
     /// 该版本冻结的作者资料快照（JSON，含封面与截图素材键）。审核通过时整体生效。
     #[default(None::<String>)]
     pub(crate) metadata_json: Option<String>,
+    /// 作者**可选**上传的工程源包（可编辑源码工程）对象键。三处同时为空表示该版本没有工程源包，
+    /// 作品在该版本上退化为「产物级改编」（只能试玩与复用素材）。
+    ///
+    /// 「上传与否」就是作者唯一的开关：平台不设独立的「源码可见性」授权位——作品授权非
+    /// `forbidden` 时，工程源包与成品包走同一道鉴权与校验被他人取走；作者不想给源码，就不上传。
+    #[default(None::<String>)]
+    pub(crate) project_bundle_object_key: Option<String>,
+    /// 工程源包字节数；`0` 表示未上传（读侧只看它就能判断是否有工程源包）。
+    #[default(0)]
+    pub(crate) project_bundle_bytes: u64,
+    /// 工程源包整包 SHA-256；未上传为 `None`。与字节数成对写入，缺一即视为不可用。
+    #[default(None::<String>)]
+    pub(crate) project_bundle_sha256: Option<String>,
+    /// 本版相对**改编来源**作品的核心改动说明（衍生作品必填，母版恒为 `NULL`）。
+    ///
+    /// 挂在版本上而不是作品上：它回答的是「**这一版**改了什么」，同一作品的不同代版本各有各的
+    /// 说明；详情页与族谱溯源逐版展示它，因此必须随版本冻结、不可在之后被覆盖。
+    /// 写入前由事务 trim（首尾空白不占额度）；母版即使传了也不校验、不落库（写侧写 `NULL`），
+    /// 避免一个与血缘无关的字段在母版上分叉出第二套语义。校验规则见
+    /// `module_game_distribution::game_distribution_change_summary_violation`。
+    #[default(None::<String>)]
+    pub(crate) change_summary: Option<String>,
 }
 
 /// 买断制购买记录。每账号每游戏最多一条，`(user_id, game_id)` 唯一性由购买事务强制
@@ -914,6 +1089,7 @@ 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";
@@ -926,6 +1102,19 @@ const GAME_DISTRIBUTION_ACTION_SUSPEND: &str = "suspend";
 const GAME_DISTRIBUTION_ACTION_RESTORE: &str = "restore";
 const GAME_DISTRIBUTION_ACTION_UPDATE_METADATA: &str = "update_metadata";
 const GAME_DISTRIBUTION_ACTION_DELETE: &str = "delete";
+const GAME_DISTRIBUTION_ACTION_SET_FORK_AUTHORIZATION: &str = "set_fork_authorization";
+/// 作者确认某版本的工程源包（可选资产）；与发行包确认分开，互不影响状态机。
+const GAME_DISTRIBUTION_ACTION_UPLOAD_PROJECT_BUNDLE: &str = "upload_project_bundle";
+/// 登录用户收藏（收录）公开作品；幂等键只挂在「收藏」上（取消按确定性主键删除，天然幂等）。
+const GAME_DISTRIBUTION_ACTION_COLLECT_GAME: &str = "collect_game";
+/// 后台创建共创主题；幂等键作用域 = `(admin 主体, 动作, 键)`，与作者侧收据互不干扰。
+const GAME_DISTRIBUTION_ACTION_CREATE_THEME: &str = "create_theme";
+/// 后台整体覆盖共创主题字段。收据只用于「同键重放回同一行 + 同键不同摘要 409」。
+const GAME_DISTRIBUTION_ACTION_UPDATE_THEME: &str = "update_theme";
+/// 主题相关的幂等收据把主题 ID 存在 `outcome_json` 里（收据没有 theme 专用列，也不该为它加一列）。
+const GAME_DISTRIBUTION_THEME_RECEIPT_OUTCOME_KIND: &str = "theme";
+/// 后台主题列表一次最多回传多少条；与后台作品列表同口径（运营表格一次扫读的量级）。
+const GAME_DISTRIBUTION_ADMIN_THEME_LIST_LIMIT: u32 = 200;
 /// 购买动作：幂等收据 action 取该值，owner 为购买者本人。
 const GAME_DISTRIBUTION_ACTION_PURCHASE: &str = "purchase";
 /// 买断制购买流水 ID 前缀；与 `RuntimeProfileWalletLedgerSourceType::GamePurchase` 同名。
@@ -939,6 +1128,15 @@ const GAME_DISTRIBUTION_ADMIN_STATUS_DELETED: &str = "deleted";
 /// 软删除游戏的统一拒绝文案；api-server 按其中的"已被删除"映射成 404。
 const GAME_DISTRIBUTION_GAME_DELETED_MESSAGE: &str = "游戏已被删除";
 const GAME_DISTRIBUTION_RECEIPT_RETENTION_MICROS: i64 = 30 * 24 * 60 * 60 * 1_000_000;
+/// 公开主题详情的「不存在 / 未发布」统一文案。
+///
+/// 两种情形**共用同一句话**：客户端无法区分「主题不存在」与「主题存在但未发布」，这正是目的
+/// （不对外确认未发布主题的存在性），与族谱「不可读锚点一律按不存在处理」同一条纪律。
+///
+/// 文案落在 api-server 既有错误映射的「不存在」子串分支上 → 404；因此它**不得**出现「状态」
+/// 「不匹配」「幂等」等会把映射抢到 409 的词（`module-game-distribution` 的纯函数测试与
+/// api-server 的映射测试各钉一遍）。
+const GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE: &str = "主题不存在";
 const GAME_DISTRIBUTION_MAX_LIST_LIMIT: u32 = 48;
 const GAME_DISTRIBUTION_MAX_OWNER_VERSIONS_PER_GAME: usize = 10;
 
@@ -977,6 +1175,85 @@ pub struct GameDistributionPublishVersionInput {
     pub idempotency_key: String,
     pub request_digest: String,
     pub now_micros: i64,
+    /// 衍生作品的「本次核心改动说明」；母版传了也会被忽略（落 NULL）。
+    pub change_summary: Option<String>,
+}
+
+/// 旧两步发布路径的创建作品入参。
+#[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 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,
+    /// 上架时选择的共创授权档位（`forbidden` / `nonCommercial` / `full`）；
+    /// 由 api-server 归一后传入。
+    ///
+    /// **只对母版有效**：带改编声明（`forked_from_game_id` / `forked_from_version_id`）时，
+    /// 新作品的档位在创建时**继承父作品当时的档位**，这里的值一律被忽略（不报错——旧客户端
+    /// 会惯常带上自己的默认档位）。母版则按本字段落库：未知取值失败关闭。
+    pub fork_authorization: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+    /// 同一作者的本地项目标识；重复发布会复用既有 game_id 而不是新建游戏。
+    pub local_project_id: Option<String>,
+    /// 改编来源作品；仅新建游戏时允许携带，复用既有身份时报错。
+    pub forked_from_game_id: Option<String>,
+    /// 建立血缘时来源作品的公开版本，必须等于来源作品当前公开版本。
+    pub forked_from_version_id: Option<String>,
+    /// 创建时即持久化的封面 OSS objectKey（发布媒体直传，不再依赖 assetId）。
+    pub cover_object_key: Option<String>,
+    pub screenshots_json: Option<String>,
+}
+
+/// 作者修改作品共创授权：**只有母版可用**——母版只允许单向提升；衍生作品存在血缘行时一律拒绝
+/// （档位由创建时继承父作品决定）。两种情形都要求调用方给出期望的当前档位。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionSetForkAuthorizationInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub fork_authorization: String,
+    pub expected_fork_authorization: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCreateVersionInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+    pub version_id: String,
+    /// 用户可见的正整数版本标签；`None` 时由事务按该游戏最大版本号自动 +1（旧客户端兼容）。
+    /// 传入时只要求 `>= 1`：同一 gameId 的同一标签可以反复提交（每次生成新的 version_id），
+    /// 允许重复标签与回退，因此不再与已有最大值比较。
+    pub version_number: Option<u64>,
+    /// 由 api-server 校验并解析素材后生成的资料快照 JSON。
+    pub metadata_json: 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,
+    /// 本版相对改编来源的核心改动说明；由 api-server 原样透传，校验与 trim 全在事务里
+    /// （`ensure_game_distribution_change_summary`）——HTTP 层不预校验，避免两套判据漂移。
+    ///
+    /// 追加在末尾：本类型是 `SpacetimeType`，会被折进生成绑定的 procedure 入参。
+    pub change_summary: Option<String>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
@@ -994,6 +1271,24 @@ pub struct GameDistributionConfirmPackageInput {
     pub updated_at_micros: i64,
 }
 
+/// 作者确认某版本已上传的工程源包。
+///
+/// 与发行包确认的关键差别：工程源包是**可选**资产，不参与版本状态机，因此对象键由
+/// api-server 从（作品、版本）派生后传入，摘要与字节数也随请求带上（没有「创建版本时预登记
+/// 的包摘要」可比）。事务只负责：owner 校验、阶段门（尚未公开）、同内容幂等 / 换内容冲突、
+/// 写三个字段与幂等收据。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionConfirmProjectBundleInput {
+    pub version_id: String,
+    pub owner_user_id: String,
+    pub project_bundle_object_key: String,
+    pub project_bundle_bytes: u64,
+    pub project_bundle_sha256: 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,
@@ -1143,6 +1438,18 @@ pub struct GameDistributionPublicGameListInput {
     pub category: Option<String>,
     pub limit: u32,
     pub author_id: Option<String>,
+    /// 上一页返回的目录游标（`"{created_at_micros}:{game_id}"`）；`None` = 第一页。
+    ///
+    /// 解析在事务里（模块侧纯函数），非法格式回稳定码 `CATALOG_INVALID_CURSOR` → 400，
+    /// 而不是静默当成第一页（静默会把「游标坏了」渲染成「又回到最新一页」）。
+    pub cursor: Option<String>,
+    /// 只返回**可被共创**（`fork_authorization` 允许他人改编）的作品；AGC「共创」页用。
+    ///
+    /// `false` = 不过滤 = 本字段出现之前的既有目录行为，因此 `forkable` 省略 / `0` / `false` /
+    /// 非法取值（api-server 宽容降级成假）都落在这里，既有调用方一条行为都不会变。过滤在事务内、
+    /// **切页之前**完成（见 `list_public_game_distribution_games_tx`），禁止共创的行不占页名额，
+    /// 翻页与末页语义与不带该参数时逐字相同。
+    pub forkable: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
@@ -1150,6 +1457,170 @@ pub struct GameDistributionPublicGameInput {
     pub game_id: String,
 }
 
+/// 读取以某作品的根为顶的整棵创作族谱树。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionLineageInput {
+    pub game_id: String,
+}
+
+/// 读取某作品的直接衍生作品（「被改编」列表）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionDerivedGamesInput {
+    pub game_id: String,
+}
+
+/// 贡献归集（作者视角只读）的输入。
+///
+/// `owner_user_id` 由受信 BFF 按登录会话填入；事务内按行归属校验，不匹配即报
+/// `游戏 owner 不匹配`（api-server 映射 403）。与其它作者侧 procedure 同口径：
+/// procedure 另要求受信服务身份，SpacetimeDB 客户端身份本身不携带作品归属。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionContributionInput {
+    pub game_id: String,
+    pub owner_user_id: String,
+}
+
+/// 读取某作品的 Fork 取件信息（受鉴权内容下发通道的元数据）；只按作品 ID 查询。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionForkSourceInput {
+    pub game_id: String,
+}
+
+/// 收藏（收录）公开作品；`idempotency_key` 由 api-server 从 `Idempotency-Key` 头传入。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCollectGameInput {
+    pub game_id: String,
+    pub user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+/// 取消收藏。按确定性主键删除，天然幂等，因此**不带** `idempotency_key`
+/// （幂等键只在「重放与新手势无法从请求本身区分」时才有意义）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionUncollectGameInput {
+    pub game_id: String,
+    pub user_id: String,
+}
+
+/// 读取某用户的收藏（收录）列表。
+///
+/// 分页参数与后台列表同构：`limit` 为 0 时取默认、超界截断到上限（`module_game_distribution`
+/// 的 `GAME_DISTRIBUTION_COLLECTION_PAGE_LIMIT_*` 是唯一口径），`cursor` 为 `"{micros}:{collection_id}"`。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCollectionListInput {
+    pub user_id: String,
+    pub limit: u32,
+    pub cursor: Option<String>,
+}
+
+/// 读取「某用户是否已收藏某作品」；公开详情用它算 `collected`。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCollectionStateInput {
+    pub game_id: String,
+    pub user_id: String,
+}
+
+/// 公开主题列表输入（匿名可读）。
+///
+/// 分页口径与 `/my-collections` 同构：`limit` 为 0 时取默认、超界截断到上限（
+/// `module_game_distribution` 的 `GAME_DISTRIBUTION_THEME_PAGE_LIMIT_*` 是唯一口径），
+/// `cursor` 为 `"{created_at_micros}:{theme_id}"`。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionThemeListInput {
+    pub limit: u32,
+    pub cursor: Option<String>,
+}
+
+/// 公开主题详情输入；只按主题 ID 查询。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionThemeDetailInput {
+    pub theme_id: String,
+}
+
+/// 作品详情 `themes` 增量输入：给**作品** ID（任意代），由事务先取根再按根反查。
+///
+/// 调用方（api-server）不需要自己懂血缘：根解析在事务内用血缘行完成，避免「BFF 猜根」这种
+/// 第二份规则。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionThemeRefsInput {
+    pub game_id: String,
+}
+
+/// 后台创建主题输入（`POST /admin/api/game-distribution/themes`）。
+///
+/// `theme_id` 由 api-server 生成（`theme-` + 随机后缀，同作品的 `game_id` 口径）后再传进来：
+/// **请求体里没有这个字段**，因此外部调用方无法指定主题 ID，而事务这边又能像 `create_game` 那样
+/// 在幂等收据里记住「首次创建的是哪一行」。
+///
+/// `admin_user_id` 落到 `created_by_user_id`（审计用，不参与鉴权判定）；`idempotency_key` /
+/// `request_digest` 与既有写接口同族：同键同摘要重放，同键不同摘要 409。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCreateThemeInput {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    /// `draft` / `published` / `archived`（api-server 的 DTO 枚举已挡掉未知取值）。
+    pub status: String,
+    pub admin_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+/// 后台整体覆盖主题字段的输入（`PUT /admin/api/game-distribution/themes/{theme_id}`）。
+///
+/// 与创建分开类型而不是复用：更新必须带 `theme_id`，创建**必须不带**（由服务端生成）。把两者合成
+/// 一个带 `Option<String>` 的输入，会让「漏传就是新建」这种事故变成一次静默的成功。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionUpdateThemeInput {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub admin_user_id: String,
+    pub idempotency_key: String,
+    pub request_digest: String,
+    pub now_micros: i64,
+}
+
+/// 后台增 / 改主题成员输入（`PUT …/themes/{theme_id}/members/{root_game_id}`）。
+///
+/// **没有幂等键**：成员身份完全由 `(theme_id, root_game_id)` 这对路径参数决定，确定性主键
+/// （`game_distribution_theme_member_id`）让重复调用落在同一行上，没有「重放 vs 新意图」需要区分。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionThemeMemberUpsertInput {
+    pub theme_id: String,
+    pub root_game_id: String,
+    pub sort_order: i64,
+    pub now_micros: i64,
+}
+
+/// 后台移除主题成员输入（`DELETE …/themes/{theme_id}/members/{root_game_id}`）。
+///
+/// 同样没有幂等键：按确定性主键删除，成员不存在也算成功。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionThemeMemberRemoveInput {
+    pub theme_id: String,
+    pub root_game_id: String,
+}
+
+/// 后台主题列表输入（`GET /admin/api/game-distribution/themes`）。
+///
+/// `status` 为 `all` / `draft` / `published` / `archived`（缺省 = 全量）；非法值在事务里失败关闭，
+/// 绝不「悄悄按全量返回」。`limit` 为 0 时取后台默认上限，超界**截断**（与后台作品列表同口径）。
+/// **不带游标**：主题是运营维护的小集合，一次取全比游标翻页更符合后台表格的用法。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeListInput {
+    pub status: Option<String>,
+    pub limit: u32,
+}
+
 /// 单次游玩计数增量；api-server 已按 `game_id` 聚合，同一输入内不重复。
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
 pub struct GameDistributionPlayCountIncrement {
@@ -1200,7 +1671,12 @@ pub struct GameDistributionGameSnapshot {
     pub cover_object_key: Option<String>,
     pub screenshots_json: Option<String>,
     /// 买断制价格（泥点）；`0` 表示免费。
+    ///
+    /// 与表同一条纪律：这一列是 master 侧先追加的，序号保持不变；本分支的
+    /// `fork_authorization` 追加在它**之后**（客户端绑定与之同步生成）。
     pub price_mud_points: u64,
+    /// 作品级共创授权档位；旧行由表默认值补齐为 `forbidden`。
+    pub fork_authorization: String,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
@@ -1215,12 +1691,24 @@ pub struct GameDistributionVersionSnapshot {
     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,
     /// 该版本冻结的资料快照 JSON；旧版本为 None。
     pub metadata_json: Option<String>,
+    /// 工程源包对象键；未上传为 `None`（api-server 用它判断是否走源码级取件）。
+    pub project_bundle_object_key: Option<String>,
+    /// 工程源包字节数；`0` 表示未上传。
+    pub project_bundle_bytes: u64,
+    /// 工程源包整包 SHA-256；未上传为 `None`。
+    pub project_bundle_sha256: Option<String>,
+    /// 本版的核心改动说明（衍生作品必有；母版恒为 `None`）。
+    ///
+    /// api-server 的公开版本负载把它投影成 `changeSummary`（详情页 / 族谱溯源展示「每一代的差异」）；
+    /// 它不含任何私有字段，因此可以直接进入公开投影。
+    pub change_summary: Option<String>,
 }
 
 /// 后台游戏管理页的版本历史条目：补上审核与公开时间，供运营判断下架与恢复影响。
@@ -1254,6 +1742,14 @@ pub struct GameDistributionAdminGameSnapshot {
     pub publication_revision: u64,
     pub created_at_micros: i64,
     pub updated_at_micros: i64,
+    /// 作品级共创授权档位。
+    pub fork_authorization: String,
+    /// 改编代际；母版为 0。
+    pub lineage_generation: u32,
+    /// 改编来源作品；母版为 None。
+    pub forked_from_game_id: Option<String>,
+    /// 直接改编该作品的已公开作品数。
+    pub derived_count: u64,
     pub versions: Vec<GameDistributionAdminVersionSnapshot>,
     /// 软删除时间；为空表示未删除。后台列表用它展示"已删除"状态。
     pub deleted_at_micros: Option<i64>,
@@ -1268,12 +1764,612 @@ pub struct GameDistributionAdminGameListResult {
     pub next_cursor: Option<String>,
 }
 
+/// 公开的改编血缘摘要：只暴露作品级信息与作者名，不含对象键、素材键或私有字段。
+///
+/// `root_title` / `parent_title` 为 `None` 表示对应作品已被软删除，标题不再对外输出
+/// （由 api-server 原样发 `null`，前端降级为「原作品已不可用」）；`parent_author_name`
+/// 同理，父作品被删时不回传作者名。ID 与代际保留，用于不依赖标题的溯源展示。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionLineageSnapshot {
+    /// 代际；直接改编母版为 1。
+    pub generation: u32,
+    pub root_game_id: String,
+    pub root_title: Option<String>,
+    pub parent_game_id: String,
+    pub parent_title: Option<String>,
+    pub parent_author_name: Option<String>,
+}
+
 #[derive(Clone, Debug, PartialEq, SpacetimeType)]
 pub struct GameDistributionPublicGameSnapshot {
     pub game: GameDistributionGameSnapshot,
     pub current_version: Option<GameDistributionVersionSnapshot>,
     pub average_score: Option<f64>,
     pub rating_count: u64,
+    /// 直接改编该作品的已公开作品数。
+    pub fork_count: u64,
+    /// 该作品子树里**公开可见的全部后代**数（不含自己）。
+    ///
+    /// 与 `fork_count` 刻意不同：`fork_count` 只数**直接**子代（网页端「被改编 N」），
+    /// 本字段数**整棵子树**的可见后代（网页端「共创次数 / 子项目总数」）。口径 = 未软删除
+    /// + 已公开（`counts_as_public_derivative`），已删 / 未公开的后代不进任何一代的计数。
+    /// 由调用方在事务内用同一份 `module_game_distribution::PublicDerivativeIndex` 现算，
+    /// 不落表、不新增索引。
+    pub co_creation_count: u64,
+    /// 该作品的改编来源；母版为 None。
+    pub lineage: Option<GameDistributionLineageSnapshot>,
+}
+
+/// 族谱 / 衍生列表的对外节点。
+///
+/// 只有公开且未软删除的作品会成为节点（锚点可读性另由 `lineage_anchor_readable` 判定），
+/// 因此标题必然存在；`author_name` 为 `None` 表示作者信息不可得（账号与冻结资料都没有名字）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionLineageNodeSnapshot {
+    pub game_id: String,
+    pub title: String,
+    pub author_name: Option<String>,
+    /// 代际；母版为 0。
+    pub generation: u32,
+    /// 父作品 ID；母版为 None。父作品不可用时仍回传 ID，展示层据此降级。
+    pub parent_game_id: Option<String>,
+    pub play_count: u64,
+    /// 可见性；未公开的锚点节点原样回传 `unpublished` / `suspended`。
+    pub status: String,
+    /// 该节点作品当前生效的封面对象键（游戏行 `cover_object_key`），与公开目录 / 详情同源；
+    /// 无封面时为 `None`。只发对象键，**不带** `coverAssetId` 这类私有素材 id。
+    pub cover_object_key: Option<String>,
+}
+
+/// 族谱树读取结果；`found == false` 表示目标作品不存在或已软删除（api-server 映射 404）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionLineageResult {
+    pub ok: bool,
+    pub found: bool,
+    pub root_game_id: String,
+    pub root: Option<GameDistributionLineageNodeSnapshot>,
+    pub nodes: Vec<GameDistributionLineageNodeSnapshot>,
+    pub truncated: bool,
+    pub error_message: Option<String>,
+}
+
+/// 直接衍生作品列表结果；`found == false` 表示父作品不存在或已软删除。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionDerivedGamesResult {
+    pub ok: bool,
+    pub found: bool,
+    pub game_id: String,
+    pub nodes: Vec<GameDistributionLineageNodeSnapshot>,
+    pub truncated: bool,
+    pub error_message: Option<String>,
+}
+
+/// 归集的指标集合（当前只有游玩数）。
+///
+/// 单独成结构体而不是把字段摊进结果里：将来加点赞 / 收藏 / 收入只需在此加字段，
+/// 递归定义、归因分解与投影形状都不用动。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionContributionTotalsSnapshot {
+    pub play_count: u64,
+}
+
+/// 按代际分解的一条：只含后代，`generation` 是**绝对**代际（与族谱一致）。
+///
+/// `total` 是这一代对祖先 `inherited` 的贡献（即该代节点自身的量），`inherited` 恒为 `0`
+/// ——更深代际的量归它们自己那一条，重复计入会让分解之和大于祖先的 `inherited`。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionContributionGenerationSnapshot {
+    pub generation: u32,
+    pub game_count: u64,
+    pub own: GameDistributionContributionTotalsSnapshot,
+    pub inherited: GameDistributionContributionTotalsSnapshot,
+    pub total: GameDistributionContributionTotalsSnapshot,
+}
+
+/// 直接子代明细的一条：`total` 是该子代**含自己整棵子树**的值。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionContributionChildSnapshot {
+    pub game_id: String,
+    pub generation: u32,
+    pub own: GameDistributionContributionTotalsSnapshot,
+    pub inherited: GameDistributionContributionTotalsSnapshot,
+    pub total: GameDistributionContributionTotalsSnapshot,
+}
+
+/// 作者视角的贡献归集与归因结果（**只做计算**，不含资金 / 分成结算字段）。
+///
+/// 不变量（截断后依然成立）：`inherited == Σ by_generation.total == Σ direct_children.total`、
+/// `total == own + inherited`、`node_count == Σ by_generation.game_count`。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionContributionSnapshot {
+    pub game_id: String,
+    pub own: GameDistributionContributionTotalsSnapshot,
+    pub inherited: GameDistributionContributionTotalsSnapshot,
+    pub total: GameDistributionContributionTotalsSnapshot,
+    pub by_generation: Vec<GameDistributionContributionGenerationSnapshot>,
+    pub direct_children: Vec<GameDistributionContributionChildSnapshot>,
+    /// 参与计算的后代节点数（不含根）。
+    pub node_count: u64,
+    pub truncated: bool,
+    /// `node_limit` / `depth_limit`；未截断为 None（不发空串）。
+    pub truncated_reason: Option<String>,
+}
+
+/// 贡献归集读取结果。
+///
+/// - `ok == false`：服务端拒绝（含 `游戏 owner 不匹配` → api-server 403）；
+/// - `found == false`：作品不存在或已软删除（api-server 404）；
+/// - `contribution` 在 `found == true` 时必然存在，扁平字段无法表达这个不可能状态。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionContributionResult {
+    pub ok: bool,
+    pub found: bool,
+    pub contribution: Option<GameDistributionContributionSnapshot>,
+    pub error_message: Option<String>,
+}
+
+/// Fork 取件的可判定状态。
+///
+/// 单独成类型而不是让 api-server 自己读游戏行：`get_game_distribution_game_for_owner_or_public_tx`
+/// 那条读路径把「已软删除」与「未公开」都折叠成 `None`，HTTP 层就没法区分 404 与 409。
+/// 这里把「行是否存在」「能否作为改编来源」「授权档位」三件事分开回传，映射留给 api-server。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionForkSourceSnapshot {
+    /// 游戏行是否存在（含已软删除的行；`false` 时其余字段无意义）。
+    pub found: bool,
+    /// 是否可作为改编来源：`can_serve_as_fork_source`（未软删除 + 已公开）且存在当前公开版本。
+    pub available: bool,
+    /// 作品级共创授权档位原值；api-server 按「未知按禁止」解释。
+    pub fork_authorization: String,
+    /// 当前公开版本；不可用或没有公开版本时为 None。
+    pub version_id: Option<String>,
+    /// 当前公开版本的发行包摘要；取自版本行，不重新计算。
+    pub package_sha256: Option<String>,
+    pub package_bytes: Option<u64>,
+    /// 当前公开版本的**工程源包**摘要；未上传时为 None / 0，api-server 据此把取件来源切成
+    /// `project`（优先）或回落 `package`。字节数与摘要成对，缺一即视为没有工程源包。
+    pub project_bundle_sha256: Option<String>,
+    pub project_bundle_bytes: u64,
+}
+
+/// Fork 取件读取结果。
+///
+/// 扁平列出全部字段而不是用 `Option<Snapshot>`：`ok == true` 却没有任何判定结果是不可能状态，
+/// 扁平结构让它无法表达。`found == false`（行不存在 → api-server 404）与
+/// `available == false`（行存在但不可作为来源 → 409）由 api-server 分别映射。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionForkSourceResult {
+    pub ok: bool,
+    pub found: bool,
+    pub available: bool,
+    /// 作品级共创授权档位原值；api-server 按「未知按禁止」解释后映射 403。
+    pub fork_authorization: String,
+    /// 当前公开版本；不可用或没有公开版本时为 None。
+    pub version_id: Option<String>,
+    pub package_sha256: Option<String>,
+    pub package_bytes: Option<u64>,
+    /// 当前公开版本的工程源包摘要；未上传时为 None / 0。api-server 据此把 `source` 切成
+    /// `project`（有工程包时优先）或 `package`。
+    pub project_bundle_sha256: Option<String>,
+    pub project_bundle_bytes: u64,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionForkSourceResult {
+    /// 参数非法等服务端失败：`ok = false`，api-server 走既有错误映射。
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            found: false,
+            available: false,
+            fork_authorization: String::new(),
+            version_id: None,
+            package_sha256: None,
+            package_bytes: None,
+            project_bundle_sha256: None,
+            project_bundle_bytes: 0,
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 收藏 / 取消收藏的结果。
+///
+/// `collected` 是**调用后的权威投影值**（该用户对该作品的收藏事实），不是前端本地状态：
+/// 客户端不需要按「动词」推断结果，也不用自己维护收藏集合。`replayed == true` 表示本次命中
+/// 了同键幂等收据、没有产生新事实；取消不带幂等键，因此恒为 `false`。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCollectionMutationResult {
+    pub ok: bool,
+    pub collected: bool,
+    pub replayed: bool,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionCollectionMutationResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            collected: false,
+            replayed: false,
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 「我的收藏（收录）」列表结果；逐条用**公开游戏快照**投影，因此形状与公开目录逐字一致。
+///
+/// `next_cursor` 是真实的下一页游标：`None` 表示这一页就是最后一页。handler 原样透传成
+/// `nextCursor`（最后一页发 `null`），客户端据此决定还要不要继续拉。
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct GameDistributionCollectionListResult {
+    pub ok: bool,
+    pub games: Vec<GameDistributionPublicGameSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+/// 公开详情的收藏态；只回传布尔，不暴露收藏时间，也不暴露其它用户。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionCollectionStateResult {
+    pub ok: bool,
+    pub collected: bool,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionCollectionStateResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            collected: false,
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 公开主题的对外投影：列表条目与详情头部**共用同一个形状**。
+///
+/// `member_count` 是**当前公开可见成员数**（不截断），不是成员行总数：回报行数会让运营通过计数
+/// 变化探测出「存在草稿或被下架的成员」。它**不是**详情 `roots` 的长度——详情受响应体积上限
+/// 约束，可能只回传前 `module_game_distribution::GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX` 条，
+/// 「这份 roots 被截断了」由详情响应上独立的 `roots_truncated` 表达（与族谱 `truncated` 同约定）。
+/// 计数口径由 `game_distribution_theme_member_count` 一处定义，列表与详情都走它，因此两个入口
+/// 报的成员数永远一致。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionThemeSnapshot {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+}
+
+/// 作品详情 `themes` 增量的单个条目：只够渲染一个跳转入口。
+///
+/// 不带简介与成员数——详情页只需要「这条作品属于哪些主题」和一个能点进去的名字与角标，
+/// 完整信息在主题详情里取。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionThemeReferenceSnapshot {
+    pub theme_id: String,
+    pub name: String,
+    pub badge: String,
+}
+
+/// 公开主题列表结果；只含 `published` 主题。
+///
+/// `next_cursor` 是真实的下一页游标：`None` 表示这一页就是最后一页（handler 原样透传成
+/// `nextCursor`，末页发 `null`）。游标格式非法时 `ok = false`，api-server 映射 400。
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct GameDistributionThemeListResult {
+    pub ok: bool,
+    pub themes: Vec<GameDistributionThemeSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionThemeListResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            themes: Vec::new(),
+            next_cursor: None,
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 公开主题详情结果：字段与响应体**同形**（顶层扁平，与 `GET /games/{gameId}` 同风格），
+/// 不引入第二套包装，因此 handler 不需要再拼一次字段。
+///
+/// `ok == false` 表示主题不存在或未发布（api-server 映射 404）；两种情形**共用同一句文案**，
+/// 客户端无法区分，这正是目的。已发布但可见成员为空是**正常**结果（`ok = true` + 空 `roots`）：
+/// 主题是运营实体，不是「不可读锚点」，空主题不指向任何作品、不构成泄露。
+///
+/// `member_count`（真实可见成员数，不截断）与 `roots_truncated`（这份 `roots` 是否被截断）是
+/// **两个独立口径**：可见成员超过响应体积上限时 `roots` 只回前
+/// `module_game_distribution::GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX` 条、`member_count` 仍然
+/// 报真实数，客户端据 `roots_truncated` 得知自己拿到的是子集（沿用族谱 `truncated` 的约定），
+/// 不再靠 `member_count == roots.len()` 这种已被上限污染的等式推断。
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct GameDistributionThemeDetailResult {
+    pub ok: bool,
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub member_count: u64,
+    pub roots: Vec<GameDistributionPublicGameSnapshot>,
+    pub roots_truncated: bool,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionThemeDetailResult {
+    /// 主题不存在 / 未发布：只带错误文案，其余字段留空（不回空壳，免得客户端把它当正常主题渲染）。
+    fn not_found(error: String) -> Self {
+        Self {
+            ok: false,
+            theme_id: String::new(),
+            name: String::new(),
+            summary: String::new(),
+            badge: String::new(),
+            member_count: 0,
+            roots: Vec::new(),
+            // 失败路径没有 `roots`，也就谈不上「被截断」；显式给 `false`，不靠缺省值。
+            roots_truncated: false,
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 作品详情 `themes` 增量结果。
+///
+/// 没有所属主题时是**空数组**（不是 `None`、也不是错误）：展示层据此不渲染空容器。
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct GameDistributionThemeRefsResult {
+    pub ok: bool,
+    pub themes: Vec<GameDistributionThemeReferenceSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionThemeRefsResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            themes: Vec::new(),
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 后台主题行快照：公开投影（`GameDistributionThemeSnapshot`）**看不到**的那几列都在这里。
+///
+/// 与公开投影的两处差异都是刻意的：
+/// - 它包含 `draft` / `archived`（后台要管全量，公开侧一律不出现）；
+/// - `member_count` 是**成员行总数**（含当前对外不可见的成员），而公开投影的 `member_count` 是
+///   **当前可见成员数**。公开侧只报可见数是为了不泄露「存在草稿 / 被下架成员」；后台没有这层顾虑，
+///   运营恰恰需要知道「挂了几行、其中几行现在不可见」（本轮只给总数，标记留给后台 UI）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeSnapshot {
+    pub theme_id: String,
+    pub name: String,
+    pub summary: String,
+    pub badge: String,
+    pub sort_order: i64,
+    pub status: String,
+    pub member_count: u64,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+/// 后台创建 / 更新主题的结果。
+///
+/// `theme` 为 `None` 时 `ok` 必为 false（失败路径显式给空，不靠缺省值）。`replayed` 只在带幂等键
+/// 的两条路径（创建 / 更新）上有意义：命中同键收据且摘要一致 → `true`，且回的是**库里那一行**
+/// （不是本次请求带来的新值）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeMutationResult {
+    pub ok: bool,
+    pub replayed: bool,
+    pub theme: Option<GameDistributionAdminThemeSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionAdminThemeMutationResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            replayed: false,
+            theme: None,
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 后台主题成员行快照（回传「这次 PUT 落成了哪一行」）。
+///
+/// `created_at_micros` 是**首次写入**的时间：重复 PUT 只改 `sort_order`，不会刷新它——否则
+/// 「这个成员是什么时候挂上来的」会被一次无意义的重复调用抹掉。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeMemberSnapshot {
+    pub theme_id: String,
+    pub root_game_id: String,
+    pub sort_order: i64,
+    pub created_at_micros: i64,
+}
+
+/// 后台增 / 改 / 移除成员的结果。
+///
+/// 移除成功时 `member` 为 `None` 而 `ok` 为 true（行已经不在库里，事务不回填一个假行）；
+/// 不设 `removed` 之类的「之前存不存在」布尔，是为了让**重复 DELETE 的响应逐字节相同**——
+/// 成员不存在也算成功，客户端不该也无法据此区分「删掉了」与「本来就没有」。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeMemberMutationResult {
+    pub ok: bool,
+    pub member: Option<GameDistributionAdminThemeMemberSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionAdminThemeMemberMutationResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            member: None,
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 后台主题列表结果；含 `draft` / `archived`，按 `created_at` 倒序 + `theme_id` 升序。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeListResult {
+    pub ok: bool,
+    pub themes: Vec<GameDistributionAdminThemeSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionAdminThemeListResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            themes: Vec::new(),
+            error_message: Some(error),
+        }
+    }
+}
+
+/// 后台主题成员列表输入（`GET /admin/api/game-distribution/themes/{theme_id}/members`）。
+///
+/// 分页口径与其它列表完全一致：`limit` 为 0 取默认 20、超界截断到 50（`module_game_distribution` 的
+/// `GAME_DISTRIBUTION_THEME_PAGE_LIMIT_*` 是唯一口径），`cursor` 为
+/// `"{sort_order}:{member_id}"`（第一段是**排序键**权重，第二段是成员主键，本身自带冒号）。
+///
+/// 与公开列表的差别**只有可见性与主题状态**：这条路径返回**全部成员行**（含当前不可见的成员），
+/// 且 `draft` / `archived` 主题也照常返回（后台运营要在发布前核对名单）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeMemberListInput {
+    pub theme_id: String,
+    pub limit: u32,
+    pub cursor: Option<String>,
+}
+
+/// 后台主题成员行（含**当前对外不可见**的行）：运营核对名单用。
+///
+/// `title` 取游戏行标题，游戏行不存在时为 `None`（api-server 发 `null`）——只为后台渲染，后台本就被
+/// 允许看草稿作品。两个可见性字段**刻意分开**，不许互相推导：
+/// - `visible` = 此刻**公开投影**会不会包含它（未软删除 + `visibility == published` + 有当前公开
+///   版本），复用 [`module_game_distribution::game_distribution_theme_member_visible`]；
+/// - `visibility` = 更细的状态：软删除行 → `deleted`，游戏行不存在 → `missing`，否则取游戏行的
+///   `visibility`（`unpublished` / `published` / `suspended`）。
+///
+/// 因此 `visibility == "published"` 而**没有**当前公开版本时 `visible == false`——这是**刻意**的：
+/// 运营要能一眼看出「作品已公开、但没有公开版本」这种异常。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeMemberRowSnapshot {
+    pub root_game_id: String,
+    pub title: Option<String>,
+    pub sort_order: i64,
+    pub created_at_micros: i64,
+    pub visible: bool,
+    pub visibility: String,
+}
+
+/// 后台主题成员列表结果：**成员行总数**（不受分页影响）+ 这一页的行 + 下一页游标。
+///
+/// `total_members` 与 `members.len()` 刻意不是一回事：前者回答「这个主题挂了几行」（含当前不可见
+/// 的行），后者只是这一页；`next_cursor` 为 `None` 表示这就是最后一页（api-server 发 `null`）。
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct GameDistributionAdminThemeMemberListResult {
+    pub ok: bool,
+    pub theme_id: String,
+    pub total_members: u64,
+    pub members: Vec<GameDistributionAdminThemeMemberRowSnapshot>,
+    pub next_cursor: Option<String>,
+    pub error_message: Option<String>,
+}
+
+impl GameDistributionAdminThemeMemberListResult {
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            theme_id: String::new(),
+            total_members: 0,
+            members: Vec::new(),
+            next_cursor: None,
+            error_message: Some(error),
+        }
+    }
+}
+
+impl GameDistributionLineageResult {
+    /// 目标作品不存在或已软删除：`ok` 仍为 true，由 api-server 映射成 404。
+    fn not_found() -> Self {
+        Self {
+            ok: true,
+            found: false,
+            root_game_id: String::new(),
+            root: None,
+            nodes: Vec::new(),
+            truncated: false,
+            error_message: None,
+        }
+    }
+
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            found: false,
+            root_game_id: String::new(),
+            root: None,
+            nodes: Vec::new(),
+            truncated: false,
+            error_message: Some(error),
+        }
+    }
+}
+
+impl GameDistributionDerivedGamesResult {
+    fn not_found() -> Self {
+        Self {
+            ok: true,
+            found: false,
+            game_id: String::new(),
+            nodes: Vec::new(),
+            truncated: false,
+            error_message: None,
+        }
+    }
+
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            found: false,
+            game_id: String::new(),
+            nodes: Vec::new(),
+            truncated: false,
+            error_message: Some(error),
+        }
+    }
+}
+
+impl GameDistributionContributionResult {
+    /// 作品不存在或已软删除：`ok` 仍为 true，由 api-server 映射成 404。
+    fn not_found() -> Self {
+        Self {
+            ok: true,
+            found: false,
+            contribution: None,
+            error_message: None,
+        }
+    }
+
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            found: false,
+            contribution: None,
+            error_message: Some(error),
+        }
+    }
 }
 
 /// 作者自有游戏的聚合快照：游戏身份 + 最近若干版本，供作者管理页展示状态与驳回理由。
@@ -1281,6 +2377,8 @@ pub struct GameDistributionPublicGameSnapshot {
 pub struct GameDistributionOwnerGameSnapshot {
     pub game: GameDistributionGameSnapshot,
     pub versions: Vec<GameDistributionVersionSnapshot>,
+    /// 直接改编该作品的已公开作品数（作者页「被改编 N」入口）。
+    pub fork_count: u64,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
@@ -1297,13 +2395,32 @@ pub struct GameDistributionGameProcedureResult {
     pub error_message: Option<String>,
 }
 
+/// 公开目录列表结果；只含公开可玩作品。
+///
+/// `next_cursor` 是真实的下一页游标：`None` 表示这一页就是最后一页（handler 原样透传成
+/// `nextCursor`，末页发 `null`）。修正前这里没有游标字段、事务里写死 48 条，库里第 49 条起的
+/// 作品（含最老的母版与主干）在 HTTP 面永久不可见；游标格式非法时 `ok = false`，映射 400。
 #[derive(Clone, Debug, PartialEq, SpacetimeType)]
 pub struct GameDistributionGameListProcedureResult {
     pub ok: bool,
     pub games: Vec<GameDistributionPublicGameSnapshot>,
+    pub next_cursor: Option<String>,
     pub error_message: Option<String>,
 }
 
+impl GameDistributionGameListProcedureResult {
+    /// 失败路径显式回 `next_cursor: None`：与成功路径共用一个不带残值的形状，客户端不会在
+    /// `ok = false` 的响应里读到一个指向不存在页面的游标。
+    fn failed(error: String) -> Self {
+        Self {
+            ok: false,
+            games: Vec::new(),
+            next_cursor: None,
+            error_message: Some(error),
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
 pub struct GameDistributionVersionProcedureResult {
     pub ok: bool,
@@ -1483,6 +2600,58 @@ pub fn publish_game_distribution_version_and_return(
     }
 }
 
+/// 创建作者名下的游戏身份并在同一事务内写入幂等收据。
+///
+/// 旧两步发布路径的入口；与统一发布 procedure 并存，两条路径写入同一张表。
+#[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),
+    }
+}
+
+/// 提升作品的共创（Fork）授权档位。幂等；**母版**只升不降，**衍生作品**（有血缘行）连升都不允许
+/// （档位由创建时继承父作品决定，是终态，回 `FORK_AUTHORIZATION_INHERITED`）；降级与未知档位
+/// 一律拒绝且不写库。
+#[spacetimedb::procedure]
+pub fn set_game_distribution_fork_authorization_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionSetForkAuthorizationInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        set_game_distribution_fork_authorization_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 confirm_game_distribution_package_and_return(
@@ -1499,6 +2668,22 @@ pub fn confirm_game_distribution_package_and_return(
     }
 }
 
+/// 确认某版本已上传的工程源包（可选资产）。procedure 不读取、不执行上传内容，只登记事实。
+#[spacetimedb::procedure]
+pub fn confirm_game_distribution_project_bundle_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionConfirmProjectBundleInput,
+) -> GameDistributionProcedureResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        confirm_game_distribution_project_bundle_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(
@@ -1762,21 +2947,25 @@ pub fn list_owner_game_distribution_games_and_return(
     }
 }
 
-/// Facade 约定的公开游戏列表名称；公开筛选和排序均在事务内执行。
+/// Facade 约定的公开游戏列表名称；公开筛选、排序与游标切页均在事务内执行。
+///
+/// 该 facade 结果类型本来就带 `next_cursor`（收藏 / 主题列表共用同一形状），因此这条路径与
+/// `list_public_game_distribution_games_and_return` 共享同一份切页结果，两条 procedure 不会对
+/// 「下一页是谁」给出不同答案。
 #[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((games, next_cursor)) => GameDistributionProcedureResult {
             ok: true,
             replayed: false,
             game: None,
             games: games.into_iter().map(|item| item.game).collect(),
             version: None,
             versions: Vec::new(),
-            next_cursor: None,
+            next_cursor,
             error_message: None,
         },
         Err(error) => game_distribution_result_error(error),
@@ -1808,23 +2997,23 @@ pub fn get_game_distribution_game_and_return(
     }
 }
 
-/// 返回当前公开且已发布版本的游戏目录；审核待处理或已暂停游戏不会出现在结果中。
+/// 返回当前公开且已发布版本的游戏目录（游标分页）；审核待处理或已暂停游戏不会出现在结果中。
+///
+/// `next_cursor` 为 `None` 表示这一页就是最后一页；游标格式非法由事务回稳定码，`ok = false`
+/// 经既有映射落 400（不吞成 200 空页，否则客户端会以为目录到底了）。
 #[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((games, next_cursor)) => GameDistributionGameListProcedureResult {
             ok: true,
             games,
+            next_cursor,
             error_message: None,
         },
-        Err(error) => GameDistributionGameListProcedureResult {
-            ok: false,
-            games: Vec::new(),
-            error_message: Some(error),
-        },
+        Err(error) => GameDistributionGameListProcedureResult::failed(error),
     }
 }
 
@@ -1848,6 +3037,197 @@ pub fn get_public_game_distribution_game_and_return(
     }
 }
 
+/// 返回以该作品根为顶的整棵创作族谱树；公开只读，匿名可读。
+///
+/// 锚点必须公开可读：不存在、已软删除或未公开（`visibility != published`）一律 `found = false`
+/// （api-server 映射 404）。**不允许**用「标题降级为空的锚点节点」或空树代替 404——那等于对外
+/// 确认该 gameId 存在、它是第几代、它在血缘里的位置，本身就是未公开作品的信息泄露。
+/// 树内也只出现未软删除且已公开的作品；父/祖辈被排除时孩子照常出现并保留 `generation` 与
+/// `parent_game_id`，不补占位节点。
+#[spacetimedb::procedure]
+pub fn get_game_distribution_lineage_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionLineageInput,
+) -> GameDistributionLineageResult {
+    match ctx.try_with_tx(|tx| game_distribution_lineage_tx(tx, input.clone())) {
+        Ok(Some(read)) => GameDistributionLineageResult {
+            ok: true,
+            found: true,
+            root_game_id: read.root_game_id,
+            root: read.root.map(game_distribution_lineage_node_snapshot),
+            nodes: read
+                .nodes
+                .into_iter()
+                .map(game_distribution_lineage_node_snapshot)
+                .collect(),
+            truncated: read.truncated,
+            error_message: None,
+        },
+        Ok(None) => GameDistributionLineageResult::not_found(),
+        Err(error) => GameDistributionLineageResult::failed(error),
+    }
+}
+
+/// 作者视角读取自己作品的贡献归集与归因（递归：子代所有的都算父代的）。
+///
+/// 要求受信服务身份（与其它作者侧 procedure 同口径）：归属判定靠 `owner_user_id`，而
+/// SpacetimeDB 客户端身份本身不携带作品归属，所以这一层只允许 api-server 调。
+/// HTTP 语义（未登录 401、非作者 403、作品不存在 404）全部由 api-server 映射：
+/// `found = false` → 404，`ok = false`（含 `游戏 owner 不匹配`）→ 403。
+/// **本期只做计算**：结果里没有资金 / 分成 / 结算字段。
+#[spacetimedb::procedure]
+pub fn get_game_distribution_contribution_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionContributionInput,
+) -> GameDistributionContributionResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        game_distribution_contribution_tx(tx, input.clone())
+    }) {
+        Ok(Some(contribution)) => GameDistributionContributionResult {
+            ok: true,
+            found: true,
+            contribution: Some(contribution),
+            error_message: None,
+        },
+        Ok(None) => GameDistributionContributionResult::not_found(),
+        Err(error) => GameDistributionContributionResult::failed(error),
+    }
+}
+
+/// 返回某作品的直接衍生作品（「被改编」列表）；公开只读，匿名可读。
+///
+/// 与公开详情 `forkCount` 同口径：只列未软删除且已公开的直接子代。父作品被软删除时按
+/// 「不存在」处理（`found = false`）。
+#[spacetimedb::procedure]
+pub fn list_game_distribution_derived_games_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionDerivedGamesInput,
+) -> GameDistributionDerivedGamesResult {
+    match ctx.try_with_tx(|tx| game_distribution_derived_games_tx(tx, input.clone())) {
+        Ok(Some(read)) => GameDistributionDerivedGamesResult {
+            ok: true,
+            found: true,
+            game_id: read.game_id,
+            nodes: read
+                .nodes
+                .into_iter()
+                .map(game_distribution_lineage_node_snapshot)
+                .collect(),
+            truncated: read.truncated,
+            error_message: None,
+        },
+        Ok(None) => GameDistributionDerivedGamesResult::not_found(),
+        Err(error) => GameDistributionDerivedGamesResult::failed(error),
+    }
+}
+
+/// 读取某作品的 Fork 取件信息；受信服务身份只读，api-server 侧另外要求 Bearer 登录。
+///
+/// 行不存在时 `found = false`（api-server → 404）；行存在但不可作为来源（已软删除 / 未公开 /
+/// 没有当前公开版本）时 `found = true, available = false`（→ 409）；授权为禁止或未知由
+/// api-server 按 `fork_authorization` 判成 403。响应只含版本身份与摘要，不含对象键。
+#[spacetimedb::procedure]
+pub fn get_game_distribution_fork_source_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionForkSourceInput,
+) -> GameDistributionForkSourceResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        get_game_distribution_fork_source_tx(tx, input.clone())
+    }) {
+        Ok(source) => GameDistributionForkSourceResult {
+            ok: true,
+            found: source.found,
+            available: source.available,
+            fork_authorization: source.fork_authorization,
+            version_id: source.version_id,
+            package_sha256: source.package_sha256,
+            package_bytes: source.package_bytes,
+            project_bundle_sha256: source.project_bundle_sha256,
+            project_bundle_bytes: source.project_bundle_bytes,
+            error_message: None,
+        },
+        Err(error) => GameDistributionForkSourceResult::failed(error),
+    }
+}
+
+/// 收藏（收录）某公开作品；受信服务身份只读之外，api-server 侧要求 Bearer 登录。
+///
+/// 幂等：同一 `Idempotency-Key` 重放返回同一结果并带 `replayed = true`；同键不同摘要冲突。
+/// 重复收藏（不同键）不产生第二行（确定性主键），仍然成功。
+#[spacetimedb::procedure]
+pub fn set_game_distribution_collection_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionCollectGameInput,
+) -> GameDistributionCollectionMutationResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        set_game_distribution_collection_tx(tx, input.clone())
+    }) {
+        Ok((collected, replayed)) => GameDistributionCollectionMutationResult {
+            ok: true,
+            collected,
+            replayed,
+            error_message: None,
+        },
+        Err(error) => GameDistributionCollectionMutationResult::failed(error),
+    }
+}
+
+/// 取消收藏（收录）。
+///
+/// **不要求幂等键、也不要求作品仍公开**：按确定性主键删除，重复调用结果相同（不存在也算成功）；
+/// 作品已下架时若拒绝取消，只会在库里留下用户清理不掉的脏行。
+#[spacetimedb::procedure]
+pub fn unset_game_distribution_collection_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionUncollectGameInput,
+) -> GameDistributionCollectionMutationResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        unset_game_distribution_collection_tx(tx, input.clone())
+    }) {
+        Ok(collected) => GameDistributionCollectionMutationResult {
+            ok: true,
+            collected,
+            replayed: false,
+            error_message: None,
+        },
+        Err(error) => GameDistributionCollectionMutationResult::failed(error),
+    }
+}
+
+/// 「我的收藏（收录）」列表；逐条用公开游戏快照投影，只返回当前公开可读的作品。
+#[spacetimedb::procedure]
+pub fn list_game_distribution_collections_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionCollectionListInput,
+) -> GameDistributionCollectionListResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        list_game_distribution_collections_tx(tx, input.clone())
+    }) {
+        Ok((games, next_cursor)) => GameDistributionCollectionListResult {
+            ok: true,
+            games,
+            next_cursor,
+            error_message: None,
+        },
+        Err(error) => GameDistributionCollectionListResult {
+            ok: false,
+            games: Vec::new(),
+            next_cursor: None,
+            error_message: Some(error),
+        },
+    }
+}
+
 /// 按 OSS objectKey 判定公开可读：只读判定，不接受 assetId。
 ///
 /// 与资产读链路解耦：公开游戏的封面 objectKey 或截图 objectKey 列表命中即授权；
@@ -1881,6 +3261,247 @@ pub fn get_game_distribution_media_read_access_and_return(
     }
 }
 
+/// 公开详情的收藏态查询：给 `collected` 一个真实投影来源，**不改动既有公开快照契约**。
+#[spacetimedb::procedure]
+pub fn is_game_distribution_collected_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionCollectionStateInput,
+) -> GameDistributionCollectionStateResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        let game_id = required_game_distribution_text(input.game_id.clone(), "game_id")?;
+        let user_id = required_game_distribution_text(input.user_id.clone(), "user_id")?;
+        Ok(game_distribution_collected(
+            tx,
+            user_id.as_str(),
+            game_id.as_str(),
+        ))
+    }) {
+        Ok(collected) => GameDistributionCollectionStateResult {
+            ok: true,
+            collected,
+            error_message: None,
+        },
+        Err(error) => GameDistributionCollectionStateResult::failed(error),
+    }
+}
+
+/// 公开共创主题列表（匿名可读、游标分页）；只含 `published` 主题。
+///
+/// 与公开目录 / 族谱一样是**纯读**通道：不要求调用方持有服务身份，也不改任何行。可见性过滤在
+/// 切页之前完成，成员数逐条现算，规则都写在 `module_game_distribution::theme` 里。
+#[spacetimedb::procedure]
+pub fn list_game_distribution_themes_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionThemeListInput,
+) -> GameDistributionThemeListResult {
+    match ctx.try_with_tx(|tx| list_game_distribution_themes_tx(tx, input.clone())) {
+        Ok((themes, next_cursor)) => GameDistributionThemeListResult {
+            ok: true,
+            themes,
+            next_cursor,
+            error_message: None,
+        },
+        Err(error) => GameDistributionThemeListResult::failed(error),
+    }
+}
+
+/// 公开共创主题详情（匿名可读）：主题头 + 可见成员根清单（逐条公开目录同一份投影）。
+///
+/// 主题不存在 / 未发布 → `ok = false`，由 api-server 映射 404；已发布但可见成员为空是正常结果。
+/// `member_count` 是真实可见成员数，`roots_truncated` 说明这份 `roots` 有没有被响应体积上限截断。
+#[spacetimedb::procedure]
+pub fn get_game_distribution_theme_detail_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionThemeDetailInput,
+) -> GameDistributionThemeDetailResult {
+    match ctx.try_with_tx(|tx| get_game_distribution_theme_detail_tx(tx, input.clone())) {
+        Ok((theme, roots, roots_truncated)) => GameDistributionThemeDetailResult {
+            ok: true,
+            theme_id: theme.theme_id,
+            name: theme.name,
+            summary: theme.summary,
+            badge: theme.badge,
+            member_count: theme.member_count,
+            roots,
+            roots_truncated,
+            error_message: None,
+        },
+        Err(error) => GameDistributionThemeDetailResult::not_found(error),
+    }
+}
+
+/// 作品详情 `themes` 增量（匿名可读）：先取作品的根，再列出包含该根的**公开**主题。
+///
+/// 按根反查（不是按作品自身）是契约的一部分：成员只允许根，第 N 代作品若按自身查会永远查不到
+/// 任何主题，而它恰恰是最需要「跳回主题页」的那一批。
+#[spacetimedb::procedure]
+pub fn list_game_distribution_theme_refs_for_root_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionThemeRefsInput,
+) -> GameDistributionThemeRefsResult {
+    match ctx.try_with_tx(|tx| list_game_distribution_theme_refs_for_root_tx(tx, input.clone())) {
+        Ok(themes) => GameDistributionThemeRefsResult {
+            ok: true,
+            themes,
+            error_message: None,
+        },
+        Err(error) => GameDistributionThemeRefsResult::failed(error),
+    }
+}
+
+/// 后台创建共创主题（`POST /admin/api/game-distribution/themes`）。
+///
+/// 鉴权分两层：这里要求**受信服务身份**（只有 api-server 能调模块），HTTP 层的 admin 会话由
+/// api-server 的 `require_admin_auth` 负责——两条都在，缺一条都不算通过。
+/// 幂等：同键同摘要 → `replayed = true` 且回库里那一行；同键不同摘要 → 409。
+#[spacetimedb::procedure]
+pub fn create_game_distribution_theme_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionCreateThemeInput,
+) -> GameDistributionAdminThemeMutationResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        create_game_distribution_theme_tx(tx, input.clone())
+    }) {
+        Ok((theme, replayed)) => GameDistributionAdminThemeMutationResult {
+            ok: true,
+            replayed,
+            theme: Some(theme),
+            error_message: None,
+        },
+        Err(error) => GameDistributionAdminThemeMutationResult::failed(error),
+    }
+}
+
+/// 后台整体覆盖主题字段（`PUT /admin/api/game-distribution/themes/{theme_id}`）。
+///
+/// `theme_id` 不存在 → `THEME_NOT_FOUND`（404）；字段非法 → `THEME_BAD_REQUEST`（400）。
+/// 每次**生效**的更新刷新 `updated_at`；命中幂等收据的重放**不写库**（因此也不刷新）。
+#[spacetimedb::procedure]
+pub fn update_game_distribution_theme_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionUpdateThemeInput,
+) -> GameDistributionAdminThemeMutationResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        update_game_distribution_theme_tx(tx, input.clone())
+    }) {
+        Ok((theme, replayed)) => GameDistributionAdminThemeMutationResult {
+            ok: true,
+            replayed,
+            theme: Some(theme),
+            error_message: None,
+        },
+        Err(error) => GameDistributionAdminThemeMutationResult::failed(error),
+    }
+}
+
+/// 后台增 / 改主题成员（`PUT …/themes/{theme_id}/members/{root_game_id}`）。
+///
+/// 幂等由确定性主键保证（同主题同根只有一行）；只允许**根作品**（有血缘行 → 409）。
+/// 不做「成员必须公开」的前置校验：运营可以先挂草稿根，作品公开后成员自动进入公开投影。
+#[spacetimedb::procedure]
+pub fn upsert_game_distribution_theme_member_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionThemeMemberUpsertInput,
+) -> GameDistributionAdminThemeMemberMutationResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        upsert_game_distribution_theme_member_tx(tx, input.clone())
+    }) {
+        Ok(member) => GameDistributionAdminThemeMemberMutationResult {
+            ok: true,
+            member: Some(member),
+            error_message: None,
+        },
+        Err(error) => GameDistributionAdminThemeMemberMutationResult::failed(error),
+    }
+}
+
+/// 后台移除主题成员（`DELETE …/themes/{theme_id}/members/{root_game_id}`）。
+///
+/// **不要求幂等键**：按确定性主键删除，成员不存在也算成功（`ok = true`、`member = None`），
+/// 重复调用的响应因此逐字节相同。主题不存在仍是 404 —— 那是路径错了，不是「已经删过了」。
+#[spacetimedb::procedure]
+pub fn remove_game_distribution_theme_member_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionThemeMemberRemoveInput,
+) -> GameDistributionAdminThemeMemberMutationResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        remove_game_distribution_theme_member_tx(tx, input.clone())
+    }) {
+        Ok(()) => GameDistributionAdminThemeMemberMutationResult {
+            ok: true,
+            member: None,
+            error_message: None,
+        },
+        Err(error) => GameDistributionAdminThemeMemberMutationResult::failed(error),
+    }
+}
+
+/// 后台主题列表（`GET /admin/api/game-distribution/themes`）：含 `draft` / `archived`。
+///
+/// 需要服务身份（后台只读同样是后台数据）；`status` 过滤与 `limit` 归一化都在事务内完成，
+/// 非法过滤值失败关闭而不是退化成全量。
+#[spacetimedb::procedure]
+pub fn list_admin_game_distribution_themes_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionAdminThemeListInput,
+) -> GameDistributionAdminThemeListResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        list_admin_game_distribution_themes_tx(tx, input.clone())
+    }) {
+        Ok(themes) => GameDistributionAdminThemeListResult {
+            ok: true,
+            themes,
+            error_message: None,
+        },
+        Err(error) => GameDistributionAdminThemeListResult::failed(error),
+    }
+}
+
+/// 后台主题成员列表（`GET /admin/api/game-distribution/themes/{theme_id}/members`）。
+///
+/// 需要服务身份（后台只读同样是后台数据），与同族五条后台写接口**同一层**的第二道鉴权：HTTP 层的
+/// admin 会话由 api-server 的 `require_admin_auth` 负责，这里只保证「只有 api-server 能调」。
+///
+/// 与公开投影的关键差异：**不套公开可见性过滤**、**也不要求主题已发布**——返回该主题的**全部成员行**
+/// （含当前不可见的行），`draft` / `archived` 主题照常可读；每行带当前可见性与更细的
+/// `visibility` 状态，让运营在发布前就能核对名单（这正是原「后台要成员名单只能借公开投影、
+/// 于是草稿 / 归档主题看不到成员」那个缺口的补法）。
+#[spacetimedb::procedure]
+pub fn list_admin_game_distribution_theme_members_and_return(
+    ctx: &mut ProcedureContext,
+    input: GameDistributionAdminThemeMemberListInput,
+) -> GameDistributionAdminThemeMemberListResult {
+    let caller = ctx.sender();
+    match ctx.try_with_tx(|tx| {
+        require_editor_generation_runtime_service_identity(tx, caller)?;
+        list_admin_game_distribution_theme_members_tx(tx, input.clone())
+    }) {
+        Ok((theme_id, total_members, members, next_cursor)) => {
+            GameDistributionAdminThemeMemberListResult {
+                ok: true,
+                theme_id,
+                total_members,
+                members,
+                next_cursor,
+                error_message: None,
+            }
+        }
+        Err(error) => GameDistributionAdminThemeMemberListResult::failed(error),
+    }
+}
+
 /// 管理员读取任意版本状态；admin 权限由 api-server 在调用前校验，procedure 只接受受信服务身份。
 #[spacetimedb::procedure]
 pub fn get_game_distribution_version_and_return(
@@ -1929,6 +3550,105 @@ pub fn get_owner_game_distribution_version_and_return(
     }
 }
 
+/// 校验改编（Fork）声明并返回（根作品 ID、子作品代际、**父作品当时的共创授权档位**）。
+///
+/// 第三个返回值就是衍生作品在创建时要继承的档位：**创建时快照**——父作品之后提升档位不会
+/// 回溯改写既有子作品的行，因此它与「只升不降」（作用在被提升的那一行自身）不冲突。
+///
+/// 失败关闭：来源必须存在且未软删除、已公开、授权档位非「禁止共创」（父档位为禁止时这里就
+/// 失败，因此继承到的档位必然是 `nonCommercial` 或 `full`）、来源版本必须恰好是
+/// 该作品当前公开版本（禁止指向历史版本或伪造）。
+///
+/// 「未软删除 + 已公开」这条规则本身放在 `module_game_distribution::can_serve_as_fork_source`，
+/// 这里只负责把行状态折叠成两个布尔并统一映射成 `FORK_SOURCE_NOT_AVAILABLE`
+/// （api-server 映射 409）：不额外区分「已删除」与「未公开」，免得用错误码把删除事实泄露给
+/// 非作者。规则不在这里重写一遍，避免与领域层单测钉住的口径漂移。
+fn resolve_game_distribution_fork_declaration_tx(
+    ctx: &ReducerContext,
+    forked_from_game_id: &str,
+    forked_from_version_id: &str,
+) -> Result<(String, u32, module_game_distribution::ForkAuthorization), String> {
+    let source = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&forked_from_game_id.to_string())
+        .ok_or_else(|| {
+            module_game_distribution::GameDistributionError::ForkSourceNotFound.to_string()
+        })?;
+    if !module_game_distribution::can_serve_as_fork_source(
+        source.deleted_at.is_some(),
+        source.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+    ) {
+        return Err(
+            module_game_distribution::GameDistributionError::ForkSourceNotAvailable.to_string(),
+        );
+    }
+    let authorization =
+        module_game_distribution::ForkAuthorization::parse(source.fork_authorization.as_str())
+            .unwrap_or(module_game_distribution::ForkAuthorization::Forbidden);
+    if !authorization.allows_fork() {
+        return Err(module_game_distribution::GameDistributionError::ForkNotAuthorized.to_string());
+    }
+    let current_version_id = source
+        .active_version_id
+        .as_ref()
+        .filter(|version_id| {
+            ctx.db
+                .game_distribution_version()
+                .version_id()
+                .find(*version_id)
+                .map(|version| version.status == GAME_DISTRIBUTION_VERSION_PUBLISHED)
+                .unwrap_or(false)
+        })
+        .ok_or_else(|| {
+            module_game_distribution::GameDistributionError::ForkSourceNotAvailable.to_string()
+        })?;
+    if current_version_id.as_str() != forked_from_version_id {
+        return Err(
+            module_game_distribution::GameDistributionError::ForkSourceVersionMismatch.to_string(),
+        );
+    }
+    let (root_game_id, parent_generation) = match ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&forked_from_game_id.to_string())
+    {
+        Some(lineage) => (lineage.root_game_id, lineage.generation),
+        None => (source.game_id.clone(), 0),
+    };
+    Ok((
+        root_game_id,
+        module_game_distribution::next_generation(parent_generation),
+        authorization,
+    ))
+}
+
+/// 决定新作品行要写入的共创授权档位。
+///
+/// - **衍生作品**（有改编声明，`parent` 为 `Some`）：直接取父作品**当时**的档位快照，
+///   **忽略**客户端在 `fork_authorization` 里传的值（旧客户端惯常带自己的默认档位，这里不报错）。
+/// - **母版**（`parent` 为 `None`）：按请求值落库；未知取值失败关闭——**绝不**静默落成
+///   `forbidden`（否则作者会以为自己设成功了）。
+///
+/// 抽成纯函数是为了让「继承」这条口径能被单测直接钉住：事务本身需要 `ReducerContext`，
+/// 在 host 测试里起不了真库。继承是**创建时快照**，与「只升不降」作用在同一行数据上不冲突。
+fn resolve_game_distribution_creation_fork_authorization(
+    parent: Option<module_game_distribution::ForkAuthorization>,
+    requested: &str,
+) -> Result<module_game_distribution::ForkAuthorization, String> {
+    match parent {
+        Some(authorization) => Ok(authorization),
+        None => module_game_distribution::ForkAuthorization::parse(requested).ok_or_else(|| {
+            module_game_distribution::GameDistributionError::ForkAuthorizationUnknown {
+                value: requested.to_string(),
+            }
+            .to_string()
+        }),
+    }
+}
+
 /// 买断制购买：同一事务内校验可见性/价格/未购买，走 runtime profile 钱包扣费并写购买行。
 ///
 /// 幂等由 `game_distribution_idempotency_receipt`（action = `purchase`，owner = 购买者）
@@ -1976,12 +3696,28 @@ pub fn get_game_distribution_purchase_and_return(
     }
 }
 
-/// 校验客户端提交的版本号；版本号必填，服务端不再自增，也不与已有最大值比较。
+/// 解析本次创建的版本号（用户可见版本标签；具体提交实例由 `version_id` 区分）。
 ///
 /// 规则本体在 `module-game-distribution` 的 `resolve_version_number`，这里只把领域错误映射成
-/// 传输层错误字符串；`0` 是普通参数错误（不带冲突前缀，api-server 映射成 400）。
-fn resolve_game_distribution_version_number(requested: u64) -> Result<u64, String> {
-    module_game_distribution::resolve_version_number(requested).map_err(|error| error.to_string())
+/// 传输层错误字符串：
+/// - `None`：旧客户端兼容路径，取该游戏已有最大版本号 +1；溢出时失败关闭并带上冲突前缀。
+/// - `Some(requested)`：只要求正整数。同一个 gameId 的同一个版本号可以反复提交（每次生成新的
+///   `version_id`，旧公开实例不原地修改），所以**不再与已有最大值比较**，允许重复标签与回退。
+/// - `Some(0)` / 非法值：普通参数错误（不带冲突前缀，api-server 映射成 400）。
+fn resolve_game_distribution_version_number(
+    max_existing: u64,
+    requested: Option<u64>,
+) -> Result<u64, String> {
+    match module_game_distribution::resolve_version_number(max_existing, requested) {
+        Ok(version_number) => Ok(version_number),
+        Err(module_game_distribution::GameDistributionFieldError::VersionNumberExhausted) => {
+            Err(format!(
+                "{}: 版本号已达上限 {max_existing}，无法自动递增",
+                shared_contracts::game_distribution::GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT
+            ))
+        }
+        Err(error) => Err(error.to_string()),
+    }
 }
 
 /// 发布路径命中既有作品后的统一拦截：被平台暂停的作品不能创建新版本。
@@ -2070,6 +3806,8 @@ fn get_or_create_game_distribution_game_for_publish_tx(
             screenshots_json: input.screenshots_json.clone(),
             deleted_at: None,
             price_mud_points: 0,
+            // 统一发布路径暂不解析共创声明：作品行按最保守档位落库，派生作品走旧两步路径。
+            fork_authorization: module_game_distribution::FORK_AUTHORIZATION_FORBIDDEN.to_string(),
         });
     ctx.db
         .game_distribution_game()
@@ -2078,6 +3816,206 @@ fn get_or_create_game_distribution_game_for_publish_tx(
         .ok_or_else(|| "创建游戏后读取失败".to_string())
 }
 
+/// 旧两步发布路径的创建作品事务：解析血缘与共创授权档位、落游戏行与血缘行、
+/// 写 `create_game` 收据。与统一发布的 get-or-create 并存，两条路径共用同一张表与
+/// 同一套自然幂等语义。
+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);
+    let forked_from_game_id =
+        normalize_game_distribution_optional(input.forked_from_game_id.unwrap_or_default());
+    let forked_from_version_id =
+        normalize_game_distribution_optional(input.forked_from_version_id.unwrap_or_default());
+    if forked_from_game_id.is_some() != forked_from_version_id.is_some() {
+        return Err("改编声明必须同时给出来源作品与来源版本".to_string());
+    }
+    let fork_resolution = match (
+        forked_from_game_id.as_deref(),
+        forked_from_version_id.as_deref(),
+    ) {
+        (Some(parent_game_id), Some(parent_version_id)) => Some(
+            resolve_game_distribution_fork_declaration_tx(ctx, parent_game_id, parent_version_id)?,
+        ),
+        _ => None,
+    };
+    // 共创授权档位：衍生作品**在创建时继承父作品当时的档位**（父行已在上面校验过，档位必然
+    // 是允许共创的一档），客户端在请求里带的值一律被忽略——旧客户端惯常带自己的默认档位，
+    // 这里不报错；母版仍按请求值，未知取值失败关闭（见
+    // `resolve_game_distribution_creation_fork_authorization`）。授权裁决必须排在血缘解析
+    // **之后**：没有父行就没有可继承的档位。
+    let fork_authorization = resolve_game_distribution_creation_fork_authorization(
+        fork_resolution
+            .as_ref()
+            .map(|(_, _, parent_authorization)| *parent_authorization),
+        input.fork_authorization.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_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.deleted_at.is_none() && game.project_key.as_deref() == Some(local_project_id)
+            });
+        if let Some(game) = existing {
+            // 复用既有作品身份时不允许再声明改编来源：否则会把别人的原创作改判成衍生作品。
+            if fork_resolution.is_some() {
+                return Err(
+                    module_game_distribution::GameDistributionError::ForkDeclarationOnExistingGame
+                        .to_string(),
+                );
+            }
+            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: None,
+            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,
+            project_key: local_project_id,
+            cover_object_key: input.cover_object_key,
+            screenshots_json: input.screenshots_json,
+            deleted_at: None,
+            fork_authorization: fork_authorization.as_str().to_string(),
+            // 新建游戏固定免费；付费价格只在审核通过时随版本冻结资料生效。
+            price_mud_points: 0,
+        });
+    // 血缘与游戏行同事务写入：只有全新作品才会走到这里，复用身份已在上面被拒绝。
+    if let (Some(parent_game_id), Some(parent_version_id), Some((root_game_id, generation, _))) = (
+        forked_from_game_id.as_deref(),
+        forked_from_version_id.as_deref(),
+        fork_resolution,
+    ) {
+        ctx.db
+            .game_distribution_lineage()
+            .insert(GameDistributionLineage {
+                game_id: game_id.clone(),
+                owner_user_id: owner_user_id.clone(),
+                parent_game_id: parent_game_id.to_string(),
+                parent_version_id: parent_version_id.to_string(),
+                root_game_id,
+                generation,
+                created_at: now,
+            });
+    }
+    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))
+}
+
 /// 软删作品复活后的行：清空公开态与历史指标，用本次发布的作品级资料整体覆盖。
 ///
 /// 保留 `game_id`（确定性身份不变）与历史版本行；`publication_revision` 归零，公开切换回到未公开。
@@ -2191,7 +4129,7 @@ fn publish_game_distribution_version_tx(
         required_game_distribution_text(input.idempotency_key.clone(), "idempotency_key")?;
     let request_digest =
         required_game_distribution_text(input.request_digest.clone(), "request_digest")?;
-    let version_number = resolve_game_distribution_version_number(input.version_number)?;
+    let version_number = resolve_game_distribution_version_number(0, Some(input.version_number))?;
     let receipt_id = game_distribution_receipt_id(
         owner_user_id.as_str(),
         GAME_DISTRIBUTION_ACTION_CREATE_VERSION,
@@ -2269,6 +4207,16 @@ fn publish_game_distribution_version_tx(
         .map(str::trim)
         .filter(|value| !value.is_empty())
         .map(str::to_string);
+    // 统一发布与旧两步路径共用同一份「衍生作品必须有改动说明」的领域校验：先按血缘行算出
+    // `is_derivative`，母版忽略该字段，衍生作品缺说明/超短/超长都失败关闭。
+    let is_derivative = ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&game.game_id)
+        .is_some();
+    let change_summary =
+        ensure_game_distribution_change_summary(input.change_summary.as_deref(), is_derivative)?;
     let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
     ctx.db
         .game_distribution_version()
@@ -2298,6 +4246,10 @@ fn publish_game_distribution_version_tx(
             last_error_code: None,
             last_error_message: None,
             metadata_json: Some(metadata_json),
+            project_bundle_object_key: None,
+            project_bundle_bytes: 0,
+            project_bundle_sha256: None,
+            change_summary,
         });
     insert_game_distribution_receipt(
         ctx,
@@ -2329,6 +4281,210 @@ fn publish_game_distribution_version_tx(
     ))
 }
 
+/// 规范化并校验「本次核心改动说明」；母版（`is_derivative == false`）恒回 `Ok(None)`。
+///
+/// 规则本身只有一份实现（`module_game_distribution::game_distribution_change_summary_violation`），
+/// 这里只把「违规码」映射成领域错误类型的文案：HTTP 层按 `"{CODE}: "` 前缀映射状态码，因此码必须
+/// 原样透出，不能在这里自拼一句中文（那会退化成通用 `BAD_REQUEST`）。
+///
+/// 失败关闭：衍生作品缺说明或超限都直接 `Err`，不会被静默降级成「没有说明也照发」；
+/// 合法值统一按 **trim 后**的形态落库，与计数口径（trim 后字符数）保持一致。
+fn ensure_game_distribution_change_summary(
+    change_summary: Option<&str>,
+    is_derivative: bool,
+) -> Result<Option<String>, String> {
+    if !is_derivative {
+        // 母版：**忽略**而不是「可选」——传了也不校验、不落库（写 NULL）。否则一个与血缘无关的
+        // 字段会在母版上分叉出第二套语义（母版有了说明，展示层就要判断该不该显示）。
+        return Ok(None);
+    }
+    match module_game_distribution::game_distribution_change_summary_violation(
+        change_summary,
+        is_derivative,
+    ) {
+        Some(module_game_distribution::GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE) => Err(
+            module_game_distribution::GameDistributionError::ForkChangeSummaryRequired.to_string(),
+        ),
+        Some(_) => Err(
+            module_game_distribution::GameDistributionError::ForkChangeSummaryInvalid.to_string(),
+        ),
+        None => Ok(change_summary
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(str::to_string)),
+    }
+}
+
+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 metadata_json = required_game_distribution_text(input.metadata_json, "metadata_json")?;
+    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());
+    }
+    ensure_game_distribution_game_not_deleted(&game)?;
+    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 is_derivative = ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&game_id)
+        .is_some();
+    let change_summary =
+        ensure_game_distribution_change_summary(input.change_summary.as_deref(), is_derivative)?;
+
+    let max_existing_version = ctx
+        .db
+        .game_distribution_version()
+        .iter()
+        .filter(|version| version.game_id == game_id)
+        .map(|version| version.version_number)
+        .max()
+        .unwrap_or(0);
+    let version_number =
+        resolve_game_distribution_version_number(max_existing_version, input.version_number)?;
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    for mut pending in ctx
+        .db
+        .game_distribution_version()
+        .by_game_distribution_version_game_id()
+        .filter(&game_id)
+        .filter(|version| {
+            version.version_number == version_number
+                && version.status == GAME_DISTRIBUTION_VERSION_PENDING_REVIEW
+        })
+    {
+        pending.status = GAME_DISTRIBUTION_VERSION_CANCELLED.to_string();
+        pending.review_reason = Some("被同一项目版本的新提交替代".to_string());
+        pending.updated_at = now;
+        ctx.db
+            .game_distribution_version()
+            .version_id()
+            .update(pending);
+    }
+    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,
+            project_key: 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,
+            metadata_json: Some(metadata_json),
+            // 工程源包是可选资产：新建版本时一律没有，作者随后单独上传并确认。
+            project_bundle_object_key: None,
+            project_bundle_bytes: 0,
+            project_bundle_sha256: None,
+            // 衍生作品必填、母版恒为 `None`（见上面的校验：母版传入也被忽略）。
+            change_summary,
+        });
+    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,
@@ -2435,6 +4591,116 @@ fn confirm_game_distribution_package_tx(
     ))
 }
 
+/// 确认某版本已上传的工程源包。
+///
+/// 与 `confirm_game_distribution_package_tx` 的差别：这是**可选**资产，不驱动版本状态机，
+/// 因此摘要与字节数由请求带上（没有创建版本时预登记的包摘要可比），阶段门只看「尚未公开」。
+/// 业务口径（产品已拍板）：平台**不做**独立的「源码可见性」开关——作者上传即表示作品授权非
+/// `forbidden` 时他人可取走源码；不想给源码就不上传，作品自然退化为产物级改编。
+fn confirm_game_distribution_project_bundle_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionConfirmProjectBundleInput,
+) -> 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 project_bundle_object_key = required_game_distribution_text(
+        input.project_bundle_object_key,
+        "project_bundle_object_key",
+    )?;
+    let project_bundle_sha256 =
+        required_game_distribution_text(input.project_bundle_sha256, "project_bundle_sha256")?;
+    if input.project_bundle_bytes == 0 {
+        return Err("工程源包字节数必须大于 0".to_string());
+    }
+    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_UPLOAD_PROJECT_BUNDLE,
+        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.project_bundle_object_key.is_some() || version.project_bundle_bytes > 0 {
+        let same_as_before = version.project_bundle_object_key.as_deref()
+            == Some(project_bundle_object_key.as_str())
+            && version.project_bundle_sha256.as_deref() == Some(project_bundle_sha256.as_str())
+            && version.project_bundle_bytes == input.project_bundle_bytes;
+        if same_as_before {
+            return Ok((
+                game_distribution_version_snapshot_for_game(ctx, &version),
+                true,
+            ));
+        }
+        return Err("同一版本已存在不同的工程源包".to_string());
+    }
+    // 阶段门与发行包确认同一口径：只有还没确认过发行包的版本能写。已公开、已撤回或已取消的
+    // 版本一律拒绝（版本不可变：公开后的内容不接受替换；历史版本也不做回溯补齐）。
+    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.project_bundle_object_key = Some(project_bundle_object_key);
+    version.project_bundle_bytes = input.project_bundle_bytes;
+    version.project_bundle_sha256 = Some(project_bundle_sha256);
+    // 不含 `uploaded_at`（那是发行包的字段），但行确实变了，`updated_at` 照常推进。
+    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_UPLOAD_PROJECT_BUNDLE.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,
@@ -2997,6 +5263,102 @@ fn unpublish_game_distribution_game_tx(
     Ok((game_distribution_game_snapshot(&game), false))
 }
 
+/// 提升作品的共创授权档位，要求调用方给出期望的当前档位。
+///
+/// 裁决（衍生作品终态 / CAS / 只升不降）只有一份实现，在
+/// `module_game_distribution::resolve_fork_authorization_promotion`；这里只做取数与落库。
+///
+/// 关键一步是**在 CAS 之前**按**血缘行**判定该作品是不是衍生作品（有血缘行即衍生，不接受客户端
+/// 自称）：衍生作品的档位由创建时继承父作品决定，是**终态**，任何 PUT 一律拒绝（连「传同值」的
+/// 幂等重试也拒绝，客户端因此不会遇到「有时成功有时失败」）。母版（无血缘行）照旧只升不降。
+///
+/// 失败一律不写库；幂等重放分支在这之前，只有曾成功提升过的母版才会有收据，衍生作品永远走不到它。
+fn set_game_distribution_fork_authorization_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionSetForkAuthorizationInput,
+) -> 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_SET_FORK_AUTHORIZATION,
+        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 target =
+        module_game_distribution::ForkAuthorization::parse(input.fork_authorization.as_str())
+            .ok_or_else(|| {
+                module_game_distribution::GameDistributionError::ForkAuthorizationUnknown {
+                    value: input.fork_authorization.clone(),
+                }
+                .to_string()
+            })?;
+    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());
+    }
+    let current =
+        module_game_distribution::ForkAuthorization::parse(game.fork_authorization.as_str())
+            .unwrap_or(module_game_distribution::ForkAuthorization::Forbidden);
+    // 衍生作品判定取**血缘行**本身（有父即衍生），不接受客户端自称；必须在 CAS 之前，
+    // 否则同一个衍生作品会按载荷不同回不同的码：传同值/CAS 相等会走到「只升不降」，
+    // 传旧期望值会走到 CAS 不符。终态口径是「一律拒绝」，码也必须是同一个。
+    let has_lineage_row = ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&game_id)
+        .is_some();
+    let target = module_game_distribution::resolve_fork_authorization_promotion(
+        has_lineage_row,
+        current,
+        input.expected_fork_authorization.as_str(),
+        target,
+    )?;
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    game.fork_authorization = target.as_str().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_SET_FORK_AUTHORIZATION.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,
@@ -3515,6 +5877,15 @@ fn admin_game_distribution_game_snapshot(
     let author_avatar_url = account
         .and_then(|user| user.avatar_url)
         .or_else(|| game.author_avatar_url.clone());
+    let lineage = ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&game.game_id);
+    let (lineage_generation, forked_from_game_id) = lineage
+        .map(|lineage| (lineage.generation, Some(lineage.parent_game_id)))
+        .unwrap_or((0, None));
+    let derived_count = game_distribution_public_fork_count(ctx, game.game_id.as_str());
     GameDistributionAdminGameSnapshot {
         game_id: game.game_id.clone(),
         owner_user_id: game.owner_user_id.clone(),
@@ -3528,6 +5899,10 @@ fn admin_game_distribution_game_snapshot(
         publication_revision: game.publication_revision,
         created_at_micros: game.created_at.to_micros_since_unix_epoch(),
         updated_at_micros: game.updated_at.to_micros_since_unix_epoch(),
+        fork_authorization: game.fork_authorization.clone(),
+        lineage_generation,
+        forked_from_game_id,
+        derived_count,
         versions: versions
             .iter()
             .map(admin_game_distribution_version_snapshot)
@@ -3670,33 +6045,48 @@ fn list_owner_game_distribution_games_tx(
                     })
                     .collect(),
                 game: game_distribution_game_snapshot(&game),
+                // 与公开详情的 `forkCount` 同一口径（只算未软删除且已公开的直接子代），
+                // 作者页「被改编 N」入口据此展示，避免两处各算一套。
+                fork_count: game_distribution_public_fork_count(ctx, game.game_id.as_str()),
             }
         })
         .collect())
 }
 
+/// 公开游戏目录（游标分页）。
+///
+/// 顺序纪律是「**先过滤、再排序切页**」：作者 / 可见性 / 软删除 / 当前公开版本 / 分类 / 关键词 /
+/// `forkable` 全部在切页之前完成，游标位置因此定义在已过滤序列上。反过来先把未过滤序列切页、
+/// 再逐页过滤，被滤掉的行会凭空占掉名额，下一页的游标又指回过滤前的序列，于是每翻一页都漏掉
+/// 自己的若干条（与 `/my-collections`、公开主题列表同一条纪律）。排序 / 切页走
+/// `page_public_game_distribution_catalog`（`created_at` 倒序 + `game_id` 升序兜底的全序），
+/// 翻页不重不漏；页大小由同一个纯函数归一（缺省 48 / 上限 100 / 超界截断），事务与 handler 的
+/// 日志口径因此同源。
 fn list_public_game_distribution_games_tx(
     ctx: &ReducerContext,
     input: GameDistributionPublicGameListInput,
-) -> Result<Vec<GameDistributionPublicGameSnapshot>, String> {
+) -> Result<(Vec<GameDistributionPublicGameSnapshot>, Option<String>), String> {
+    let forkable = input.forkable;
     let author_id = input
         .author_id
         .as_deref()
         .map(module_auth::creator::normalize_user_id)
         .transpose()
         .map_err(|error| error.to_string())?;
-    let limit = if input.limit == 0 {
-        GAME_DISTRIBUTION_MAX_LIST_LIMIT
-    } else {
-        input.limit.min(GAME_DISTRIBUTION_MAX_LIST_LIMIT)
-    } as usize;
+    let cursor = input
+        .cursor
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| {
+            module_game_distribution::parse_game_distribution_catalog_cursor(value.as_str())
+        })
+        .transpose()?;
     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
+    let visible = ctx
         .db
         .game_distribution_game()
         .iter()
@@ -3721,18 +6111,36 @@ fn list_public_game_distribution_games_tx(
             })
         })
         .filter(|game| public_game_distribution_version(ctx, game).is_some())
+        .map(
+            |game| module_game_distribution::GameDistributionCatalogPageItem {
+                game_id: game.game_id.clone(),
+                created_at_micros: game.created_at.to_micros_since_unix_epoch(),
+                payload: game,
+            },
+        )
         .collect::<Vec<_>>();
-    games.sort_by(|left, right| {
-        right
-            .created_at
-            .cmp(&left.created_at)
-            .then_with(|| left.game_id.cmp(&right.game_id))
-    });
-    games.truncate(limit);
-    Ok(games
-        .into_iter()
-        .filter_map(|game| public_game_distribution_snapshot(ctx, &game))
-        .collect())
+    // `forkable` 是**同一条过滤链上的最后一道**，仍然发生在切页之前：禁止共创的行既不出现在
+    // 任何一页，也不占页名额（占位会让第一页少回传、下一页游标错位，每翻一页就漏若干条）。
+    // 判据复用模块纯函数（未知档位按禁止解释，与 fork 门禁同源），`forkable == false` 时原样
+    // 返回，因此「不传该参数」与改动前的既有目录行为逐条相同。
+    let visible = module_game_distribution::filter_public_game_distribution_catalog_by_forkable(
+        visible,
+        forkable,
+        |game| game.fork_authorization.as_str(),
+    );
+    let (page, next_cursor) = module_game_distribution::page_public_game_distribution_catalog(
+        visible,
+        cursor,
+        input.limit,
+    );
+    // 索引只在事务里建一次：一页最多 100 行，每行的 `coCreationCount` 都在内存里数子树。
+    let co_creation_index = game_distribution_public_derivative_index(ctx);
+    Ok((
+        page.into_iter()
+            .filter_map(|game| public_game_distribution_snapshot(ctx, &game, &co_creation_index))
+            .collect(),
+        next_cursor,
+    ))
 }
 
 fn get_public_game_distribution_game_tx(
@@ -3746,7 +6154,1385 @@ fn get_public_game_distribution_game_tx(
     if !game_distribution_game_is_publicly_visible(&game) {
         return Ok(None);
     }
-    Ok(public_game_distribution_snapshot(ctx, &game))
+    // 详情一次只投影一行，但索引仍按「事务内建一次」的统一形状传给投影，避免两条路径两套写法。
+    let co_creation_index = game_distribution_public_derivative_index(ctx);
+    Ok(public_game_distribution_snapshot(
+        ctx,
+        &game,
+        &co_creation_index,
+    ))
+}
+
+/// 族谱树读取的领域结果（procedure 只做 ok/error 包装）。
+struct GameDistributionLineageRead {
+    root_game_id: String,
+    root: Option<module_game_distribution::LineageTreeNode>,
+    nodes: Vec<module_game_distribution::LineageTreeNode>,
+    truncated: bool,
+}
+
+/// 直接衍生作品列表的领域结果。
+struct GameDistributionDerivedGamesRead {
+    game_id: String,
+    nodes: Vec<module_game_distribution::LineageTreeNode>,
+    truncated: bool,
+}
+
+/// 读取以目标作品根为顶的整棵族谱树。
+///
+/// 锚点必须公开可读：不存在、已软删除或未公开时返回 `Ok(None)`（api-server 映射 404）。
+/// 不允许「降级返回一个空标题节点」——那等于对外确认该 gameId 存在、代际与血缘位置，属于泄露。
+fn game_distribution_lineage_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionLineageInput,
+) -> Result<Option<GameDistributionLineageRead>, 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 !module_game_distribution::lineage_anchor_readable(
+        game.deleted_at.is_some(),
+        game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+    ) {
+        return Ok(None);
+    }
+    // 有血缘行就按行的根走；没有血缘行说明目标自身就是母版（0 代）。根解析只有一份实现，
+    // 与作品详情的 `themes` 增量共用（见 `game_distribution_theme_root_of`）。
+    let root_game_id = game_distribution_theme_root_of(ctx, game_id.as_str());
+    let entries = game_distribution_lineage_entries(ctx, root_game_id.as_str());
+    let tree = module_game_distribution::build_lineage_tree(
+        &entries,
+        root_game_id.as_str(),
+        module_game_distribution::GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT,
+    );
+    Ok(Some(GameDistributionLineageRead {
+        root_game_id,
+        root: tree.root,
+        nodes: tree.nodes,
+        truncated: tree.truncated,
+    }))
+}
+
+/// 读取某作品的直接衍生作品（「被改编」列表）。
+///
+/// 只折叠直接子代的行事实；可见性（未软删除 + 已公开）由纯函数判定，与公开详情 `forkCount`
+/// 用同一批规则，因此「被改编 N」与列表条数必然一致。锚点必须公开可读（同族谱口径），
+/// 否则返回 `Ok(None)`。
+fn game_distribution_derived_games_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionDerivedGamesInput,
+) -> Result<Option<GameDistributionDerivedGamesRead>, 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 !module_game_distribution::lineage_anchor_readable(
+        game.deleted_at.is_some(),
+        game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+    ) {
+        return Ok(None);
+    }
+    let entries = ctx
+        .db
+        .game_distribution_lineage()
+        .by_game_distribution_lineage_parent_game_id()
+        .filter(&game_id)
+        .filter_map(|lineage| {
+            let child = ctx
+                .db
+                .game_distribution_game()
+                .game_id()
+                .find(&lineage.game_id)?;
+            // 字段映射只有一份：复用与族谱装配同一个构造函数，避免两条路径各写一套。
+            Some(module_game_distribution::lineage_entry_from_game_facts(
+                game_distribution_lineage_game_facts(ctx, &child),
+                lineage.generation,
+                Some(lineage.parent_game_id.clone()),
+            ))
+        })
+        .collect::<Vec<_>>();
+    let list = module_game_distribution::build_derived_node_list(
+        &entries,
+        module_game_distribution::GAME_DISTRIBUTION_LINEAGE_NODE_LIMIT,
+    );
+    Ok(Some(GameDistributionDerivedGamesRead {
+        game_id,
+        nodes: list.nodes,
+        truncated: list.truncated,
+    }))
+}
+
+/// 贡献归集的节点集合：根 + 按血缘索引逐层下钻得到的后代。
+///
+/// 只用血缘表既有的 `by_game_distribution_lineage_parent_game_id` 索引，不新增表 / 索引。
+/// 两点刻意的「多收一点」，都是为了让纯函数能**如实**判定截断：
+/// - 后代多收一条（`NODE_LIMIT + 1`）：只收满 `NODE_LIMIT` 条时「刚好满」与「还有更多」不可分辨，
+///   截断会被静默吞掉；
+/// - 相对深度多收一层（`DEPTH_LIMIT + 1`）：纯函数要看见更深一层确实存在，才能标注 `depth_limit`。
+///
+/// 同层按 `gameId` 升序下钻，保证两次读收集到同一批节点（截断点不漂移）。子孙的游戏行缺失
+/// （脏数据 / 历史遗留）按不存在处理：跳过该节点，也不拿它当父继续下钻——与族谱装配同一口径。
+/// 不查可见性：这是作者自己血缘子树的账目，入参与纯函数里都没有可见性维度。
+fn collect_game_distribution_contribution_nodes(
+    ctx: &ReducerContext,
+    root: &GameDistributionGame,
+) -> Vec<module_game_distribution::ContributionNode> {
+    let limit = module_game_distribution::GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT + 1;
+    let depth_limit = module_game_distribution::GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT;
+    let root_game_id = root.game_id.clone();
+    // 根自身：父引用与代际取自它自己的血缘行（没有血缘行即 0 代母版）；根不参与按代际分解。
+    let root_lineage = ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&root_game_id);
+    let mut nodes = vec![module_game_distribution::ContributionNode {
+        game_id: root_game_id.clone(),
+        parent_game_id: root_lineage
+            .as_ref()
+            .map(|lineage| lineage.parent_game_id.clone()),
+        generation: root_lineage
+            .as_ref()
+            .map(|lineage| lineage.generation)
+            .unwrap_or(0),
+        totals: module_game_distribution::ContributionTotals::from_play_count(root.play_count),
+    }];
+    let mut seen = std::collections::HashSet::new();
+    seen.insert(root_game_id.clone());
+    let mut frontier = vec![root_game_id];
+    let mut depth = 0u32;
+    while !frontier.is_empty() && depth < depth_limit + 1 && nodes.len() < limit {
+        let mut next = Vec::new();
+        for parent_game_id in &frontier {
+            let mut children = ctx
+                .db
+                .game_distribution_lineage()
+                .by_game_distribution_lineage_parent_game_id()
+                .filter(parent_game_id)
+                .collect::<Vec<_>>();
+            children.sort_by(|left, right| left.game_id.cmp(&right.game_id));
+            for lineage in children {
+                if !seen.insert(lineage.game_id.clone()) {
+                    continue;
+                }
+                let Some(child) = ctx
+                    .db
+                    .game_distribution_game()
+                    .game_id()
+                    .find(&lineage.game_id)
+                else {
+                    continue;
+                };
+                nodes.push(module_game_distribution::ContributionNode {
+                    game_id: child.game_id.clone(),
+                    parent_game_id: Some(lineage.parent_game_id.clone()),
+                    generation: lineage.generation,
+                    totals: module_game_distribution::ContributionTotals::from_play_count(
+                        child.play_count,
+                    ),
+                });
+                next.push(lineage.game_id.clone());
+                if nodes.len() >= limit {
+                    return nodes;
+                }
+            }
+        }
+        frontier = next;
+        depth += 1;
+    }
+    nodes
+}
+
+fn game_distribution_contribution_totals(
+    totals: module_game_distribution::ContributionTotals,
+) -> GameDistributionContributionTotalsSnapshot {
+    GameDistributionContributionTotalsSnapshot {
+        play_count: totals.play_count,
+    }
+}
+
+/// 把纯函数的归集结果折成 procedure 快照；字段映射只有这一份。
+fn game_distribution_contribution_snapshot(
+    breakdown: module_game_distribution::ContributionBreakdown,
+) -> GameDistributionContributionSnapshot {
+    GameDistributionContributionSnapshot {
+        game_id: breakdown.game_id,
+        own: game_distribution_contribution_totals(breakdown.own),
+        inherited: game_distribution_contribution_totals(breakdown.inherited),
+        total: game_distribution_contribution_totals(breakdown.total),
+        by_generation: breakdown
+            .by_generation
+            .into_iter()
+            .map(|entry| GameDistributionContributionGenerationSnapshot {
+                generation: entry.generation,
+                game_count: entry.game_count,
+                own: game_distribution_contribution_totals(entry.own),
+                inherited: game_distribution_contribution_totals(entry.inherited),
+                total: game_distribution_contribution_totals(entry.total),
+            })
+            .collect(),
+        direct_children: breakdown
+            .direct_children
+            .into_iter()
+            .map(|entry| GameDistributionContributionChildSnapshot {
+                game_id: entry.game_id,
+                generation: entry.generation,
+                own: game_distribution_contribution_totals(entry.own),
+                inherited: game_distribution_contribution_totals(entry.inherited),
+                total: game_distribution_contribution_totals(entry.total),
+            })
+            .collect(),
+        node_count: breakdown.node_count,
+        truncated: breakdown.truncated,
+        truncated_reason: breakdown
+            .truncated_reason
+            .map(|reason| reason.as_str().to_string()),
+    }
+}
+
+/// 读取作者自己作品的贡献归集与归因：`inherited(W) = Σ 直接子代 total`、`total = own + inherited`。
+///
+/// 与族谱 / 衍生列表不同，这里把三件事分开回传（都发生在同一事务里）：
+/// - 行不存在或已软删除 → `Ok(None)`（api-server 404）；
+/// - 行存在但归属不是调用者 → `Err("游戏 owner 不匹配")`（api-server 403，沿用仓库既有
+///   owner-mismatch → FORBIDDEN 惯例；这样作者页能分辨「没有权限」与「作品已不存在」）；
+/// - 其余 → `Ok(Some(快照))`，其中 `truncated` / `truncated_reason` 如实标注上限截断。
+fn game_distribution_contribution_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionContributionInput,
+) -> Result<Option<GameDistributionContributionSnapshot>, String> {
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let owner_user_id = required_game_distribution_text(input.owner_user_id, "owner_user_id")?;
+    let Some(game) = ctx.db.game_distribution_game().game_id().find(&game_id) else {
+        return Ok(None);
+    };
+    if game.owner_user_id != owner_user_id {
+        return Err("游戏 owner 不匹配".to_string());
+    }
+    if game.deleted_at.is_some() {
+        return Ok(None);
+    }
+    let nodes = collect_game_distribution_contribution_nodes(ctx, &game);
+    let Some(breakdown) = module_game_distribution::build_contribution_breakdown(
+        &nodes,
+        game_id.as_str(),
+        module_game_distribution::GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT,
+        module_game_distribution::GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT,
+    ) else {
+        // 根行刚读过、也刚放进集合，这个分支不可达。真到了这里说明构造逻辑坏了：
+        // 返回 404 会把缺陷说成「作品不存在」，所以失败关闭（api-server 落通用 400）。
+        return Err(format!("归集计算失败：根节点不在集合里（{game_id}）"));
+    };
+    Ok(Some(game_distribution_contribution_snapshot(breakdown)))
+}
+
+/// 读取某作品的 Fork 取件信息（受鉴权内容下发通道的元数据）。
+///
+/// 与族谱 / 衍生列表不同，这里**必须**区分「行不存在」与「行存在但不可用」：HTTP 合同要求
+/// 前者 404、后者 409，所以不复用「折叠成 `None`」的写法，而是把三件事分开回传——行是否存在、
+/// 能否作为改编来源（`can_serve_as_fork_source` **且**存在当前公开版本）、授权档位原值。
+/// 授权是否生效、以及「未知档位按禁止解释」留给 api-server，与 procedure 侧创建血缘时同一口径。
+/// 只回传版本身份与摘要，不回传对象键。
+fn get_game_distribution_fork_source_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionForkSourceInput,
+) -> Result<GameDistributionForkSourceSnapshot, 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(GameDistributionForkSourceSnapshot {
+            found: false,
+            available: false,
+            fork_authorization: String::new(),
+            version_id: None,
+            package_sha256: None,
+            package_bytes: None,
+            project_bundle_sha256: None,
+            project_bundle_bytes: 0,
+        });
+    };
+    // 取件必须有「当前公开版本」，否则没有可下发的内容。
+    let version = public_game_distribution_version(ctx, &game);
+    let available = module_game_distribution::can_serve_as_fork_source(
+        game.deleted_at.is_some(),
+        game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+    ) && version.is_some();
+    Ok(GameDistributionForkSourceSnapshot {
+        found: true,
+        available,
+        fork_authorization: game.fork_authorization.clone(),
+        version_id: version.as_ref().map(|version| version.version_id.clone()),
+        package_sha256: version
+            .as_ref()
+            .map(|version| version.package_sha256.clone()),
+        package_bytes: version.as_ref().map(|version| version.package_bytes),
+        // 工程源包：字节数与摘要成对才有意义（缺一视为没有工程包，取件回落到成品包）。
+        project_bundle_sha256: version
+            .as_ref()
+            .filter(|version| version.project_bundle_bytes > 0)
+            .and_then(|version| version.project_bundle_sha256.clone()),
+        project_bundle_bytes: version
+            .as_ref()
+            .map(|version| version.project_bundle_bytes)
+            .unwrap_or_default(),
+    })
+}
+
+/// 收藏的前置：作品必须存在，且当前公开可读。
+///
+/// 与 `get_game_distribution_fork_source_tx` 同口径折叠行状态（未软删除 + 已公开 + 存在当前
+/// 公开版本），但这里**失败关闭**：不存在返回「作品不存在」（api-server → 404），存在但不可读
+/// 返回 `GAME_DISTRIBUTION_COLLECTION_STATE_CONFLICT`（→ 409）。该文案刻意命中 api-server
+/// 错误映射里的 `状态` 子串，且**不含**「不存在」/「已被删除」——否则会先命中 404 分支，等于用
+/// 错误码对外确认未公开作品的存在性。
+fn ensure_game_distribution_collectable(ctx: &ReducerContext, game_id: &str) -> Result<(), String> {
+    let Some(game) = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(game_id.to_string())
+    else {
+        return Err("作品不存在".to_string());
+    };
+    if game.deleted_at.is_some()
+        || game.visibility != GAME_DISTRIBUTION_VISIBILITY_PUBLISHED
+        || public_game_distribution_version(ctx, &game).is_none()
+    {
+        return Err(
+            shared_contracts::game_distribution::GAME_DISTRIBUTION_COLLECTION_STATE_CONFLICT
+                .to_string(),
+        );
+    }
+    Ok(())
+}
+
+/// 某用户是否已收藏某作品：按确定性主键直查，不扫描、不依赖游戏行状态。
+fn game_distribution_collected(ctx: &ReducerContext, user_id: &str, game_id: &str) -> bool {
+    let collection_id = module_game_distribution::game_distribution_collection_id(user_id, game_id);
+    ctx.db
+        .game_distribution_collection()
+        .collection_id()
+        .find(&collection_id)
+        .is_some()
+}
+
+/// 收藏（收录）某公开作品。
+///
+/// 幂等：`(user_id, action, idempotency_key)` 命中收据时先校验 `request_digest`，通过即
+/// `replayed = true` 返回，不再写库；不同摘要冲突。摘要由 api-server 从 `(user_id, game_id)`
+/// 派生，因此不同用户 / 不同作品即使共用同一个 `Idempotency-Key` 也不会互相命中。
+///
+/// 防重：写入前只判「主键是否已存在」，存在即跳过写入——它只是省一次写入，不是去重依据；
+/// 真正保证「同一 (用户, 作品) 只有一行」的是确定性主键本身。
+fn set_game_distribution_collection_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionCollectGameInput,
+) -> Result<(bool, bool), String> {
+    let user_id = required_game_distribution_text(input.user_id, "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(
+        user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_COLLECT_GAME,
+        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())?;
+        // 收据只可能由一次成功的收藏写入，因此重放直接回「已收藏」，不再复核当前可见性
+        // （下发时的可见性可能与首次调用时不同，重放必须回同一结果）。
+        return Ok((true, true));
+    }
+    ensure_game_distribution_collectable(ctx, game_id.as_str())?;
+    let collection_id = module_game_distribution::game_distribution_collection_id(
+        user_id.as_str(),
+        game_id.as_str(),
+    );
+    if ctx
+        .db
+        .game_distribution_collection()
+        .collection_id()
+        .find(&collection_id)
+        .is_none()
+    {
+        ctx.db
+            .game_distribution_collection()
+            .insert(GameDistributionCollection {
+                collection_id,
+                user_id: user_id.clone(),
+                game_id: game_id.clone(),
+                created_at: Timestamp::from_micros_since_unix_epoch(input.now_micros),
+            });
+    }
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id: user_id,
+            action: GAME_DISTRIBUTION_ACTION_COLLECT_GAME.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: Some(game_id.clone()),
+            version_id: None,
+            outcome_kind: "collection".to_string(),
+            outcome_game_id: Some(game_id),
+            outcome_version_id: None,
+            outcome_json: None,
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((true, false))
+}
+
+/// 取消收藏（收录）：按确定性主键删除，**不存在也算成功**（幂等）。
+///
+/// 这里刻意**不要求作品仍公开**：作品下架后若拒绝取消，用户就没法清理自己的收藏，库里会留下
+/// 永远删不掉的脏行；而「取消」这个意图与作品当前状态无关。返回值是调用后的投影值
+/// （`false` = 未收藏），客户端不需要按动词推断。
+fn unset_game_distribution_collection_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionUncollectGameInput,
+) -> Result<bool, String> {
+    let user_id = required_game_distribution_text(input.user_id, "user_id")?;
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let collection_id = module_game_distribution::game_distribution_collection_id(
+        user_id.as_str(),
+        game_id.as_str(),
+    );
+    if ctx
+        .db
+        .game_distribution_collection()
+        .collection_id()
+        .find(&collection_id)
+        .is_some()
+    {
+        ctx.db
+            .game_distribution_collection()
+            .collection_id()
+            .delete(&collection_id);
+    }
+    Ok(false)
+}
+
+/// 「我的收藏（收录）」列表（分页）。
+///
+/// 按 `user_id` 索引取该用户的收藏行，逐条用**既有** `public_game_distribution_snapshot` 投影
+/// （与公开目录 / 公开详情同一份），因此形状与公开目录逐字一致。
+///
+/// 只返回当前公开可读的作品：未公开 / 已软删除 / 没有当前公开版本的行在**投影时**被跳过，
+/// 但**不删除行**（`module_game_distribution::game_distribution_collection_visible` 就是这条
+/// 判定的纯函数形式）。作品重新公开后，同一行会自动回到列表里。
+///
+/// 顺序**必须先过滤、再排序切页**：可见性是一条**过滤**规则，游标位置定义在已过滤的序列上。
+/// 若先把未过滤的行切页、再逐页过滤，被滤掉的行会凭空占掉这一页的名额（用户看到「不足一页」），
+/// 而下一页的游标又指回过滤前的序列，于是每翻一页都会漏掉自己的若干条收藏——页越大漏得越多。
+fn list_game_distribution_collections_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionCollectionListInput,
+) -> Result<(Vec<GameDistributionPublicGameSnapshot>, Option<String>), String> {
+    let user_id = required_game_distribution_text(input.user_id, "user_id")?;
+    let cursor = input
+        .cursor
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| {
+            module_game_distribution::parse_game_distribution_collection_cursor(value.as_str())
+        })
+        .transpose()?;
+    let visible = ctx
+        .db
+        .game_distribution_collection()
+        .by_game_distribution_collection_user_id()
+        .filter(&user_id)
+        .filter_map(|collection| {
+            let game = ctx
+                .db
+                .game_distribution_game()
+                .game_id()
+                .find(&collection.game_id)?;
+            let has_public_version = public_game_distribution_version(ctx, &game).is_some();
+            let visible = module_game_distribution::game_distribution_collection_visible(
+                game.deleted_at.is_some(),
+                game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+                has_public_version,
+            );
+            if !visible {
+                return None;
+            }
+            Some(
+                module_game_distribution::GameDistributionCollectionPageItem {
+                    collection_id: collection.collection_id.clone(),
+                    created_at_micros: collection.created_at.to_micros_since_unix_epoch(),
+                    payload: game,
+                },
+            )
+        })
+        .collect::<Vec<_>>();
+    let (page, next_cursor) =
+        module_game_distribution::game_distribution_collection_page(visible, cursor, input.limit);
+    // 与公开目录同一份投影、同一份计数：索引同样在事务里建一次。
+    let co_creation_index = game_distribution_public_derivative_index(ctx);
+    Ok((
+        page.iter()
+            .filter_map(|game| public_game_distribution_snapshot(ctx, game, &co_creation_index))
+            .collect(),
+        next_cursor,
+    ))
+}
+
+/// 取某作品的**根**：有血缘行就用行上的 `root_game_id`，没有血缘行说明目标自身就是母版（0 代）。
+///
+/// 这里就是 `game_distribution_lineage_tx` 里那段根解析的抽取，两处共用同一个函数：根的语义只
+/// 有一份，主题归属反查与族谱锚点因此不可能得出不同的根（「拿不到血缘行就回退用自身」这类
+/// 降级只在一处）。
+fn game_distribution_theme_root_of(ctx: &ReducerContext, game_id: &str) -> String {
+    ctx.db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&game_id.to_string())
+        .map(|lineage| lineage.root_game_id)
+        .unwrap_or_else(|| game_id.to_string())
+}
+
+/// 主题当前可见成员清单：按主题索引取成员行，只保留**当前公开可读**的根，并带出排序键。
+///
+/// 可见性判定委托 `module_game_distribution::game_distribution_theme_member_visible`（与公开目录 /
+/// 收藏同一条「未删 + 已公开 + 有当前公开版本」口径），被滤掉的行**不删除**——作品重新公开后
+/// 同一行会自动回来。返回的是「排序键 + 游戏行」的绑定值，交给 `sort_theme_members` /
+/// `page_theme_members`，因此不可能出现「按 A 排序、按 B 切页」的错位。
+fn game_distribution_theme_visible_members(
+    ctx: &ReducerContext,
+    theme_id: &str,
+) -> Vec<module_game_distribution::GameDistributionThemeMemberPageItem<GameDistributionGame>> {
+    ctx.db
+        .game_distribution_theme_member()
+        .by_game_distribution_theme_member_theme_id()
+        .filter(theme_id)
+        .filter_map(|member| {
+            let game = ctx
+                .db
+                .game_distribution_game()
+                .game_id()
+                .find(&member.root_game_id)?;
+            let visible = module_game_distribution::game_distribution_theme_member_visible(
+                game.deleted_at.is_some(),
+                game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+                public_game_distribution_version(ctx, &game).is_some(),
+            );
+            if !visible {
+                return None;
+            }
+            Some(
+                module_game_distribution::GameDistributionThemeMemberPageItem {
+                    member_id: member.member_id.clone(),
+                    sort_order: member.sort_order,
+                    payload: game,
+                },
+            )
+        })
+        .collect()
+}
+
+/// 主题的 `member_count`：当前公开可见成员数，**不受响应体积上限约束**。
+///
+/// 就是 `game_distribution_theme_visible_members` 的长度：口径只有一份（同一份成员可见性判定），
+/// 列表与详情都从这里取，两个入口报的数因此永远一致；也不会因为「存在草稿或被下架的成员」而
+/// 虚高——那正是运营不该被外部探测到的信息。不新增物化计数字段（与仓库「实时算」的既有取舍一致）。
+///
+/// 刻意**不**再走 `page_theme_members`：那个函数施加的是**展示上限**（详情一次最多回 50 条
+/// `roots`），把它用在计数上会让「这个主题有多少棵作品树」随响应体积漂移——可见成员 120 的主题
+/// 会被报成 50，且客户端无从分辨。上限只约束 `roots` 的条数，其信号是详情上的 `roots_truncated`。
+fn game_distribution_theme_member_count(ctx: &ReducerContext, theme_id: &str) -> u64 {
+    game_distribution_theme_visible_members(ctx, theme_id).len() as u64
+}
+
+/// 主题行 → 对外投影（含当前可见成员数）。
+fn game_distribution_theme_snapshot(
+    ctx: &ReducerContext,
+    theme: &GameDistributionTheme,
+) -> GameDistributionThemeSnapshot {
+    GameDistributionThemeSnapshot {
+        theme_id: theme.theme_id.clone(),
+        name: theme.name.clone(),
+        summary: theme.summary.clone(),
+        badge: theme.badge.clone(),
+        member_count: game_distribution_theme_member_count(ctx, theme.theme_id.as_str()),
+    }
+}
+
+/// 公开主题列表（游标分页）。
+///
+/// 只取 `status == published` 的主题（`game_distribution_theme_public_visible`），并且**先过滤
+/// 可见性、再排序切页**：游标位置定义在已过滤序列上。反过来先把未过滤的主题切页、再逐页过滤，
+/// 被滤掉的行会凭空占掉名额，下一页的游标又指回过滤前的序列，于是每翻一页都漏掉自己的若干条
+/// （与 `/my-collections` 同一条纪律）。排序 / 切页走 `page_public_themes`（`created_at` 倒序 +
+/// `theme_id` 升序兜底的全序），翻页不重不漏；`member_count` 只为**这一页**的主题现算，且是
+/// **真实可见成员数**（不套响应体积上限——那个上限只约束详情 `roots` 的条数，见
+/// `get_game_distribution_theme_detail_tx`）。
+fn list_game_distribution_themes_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionThemeListInput,
+) -> Result<(Vec<GameDistributionThemeSnapshot>, Option<String>), String> {
+    let cursor = input
+        .cursor
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| module_game_distribution::parse_game_distribution_theme_cursor(value.as_str()))
+        .transpose()?;
+    let visible = ctx
+        .db
+        .game_distribution_theme()
+        .iter()
+        .filter(|theme| {
+            module_game_distribution::game_distribution_theme_public_visible(theme.status.as_str())
+        })
+        .map(
+            |theme| module_game_distribution::GameDistributionThemePageItem {
+                theme_id: theme.theme_id.clone(),
+                created_at_micros: theme.created_at.to_micros_since_unix_epoch(),
+                payload: theme,
+            },
+        )
+        .collect::<Vec<_>>();
+    let (page, next_cursor) =
+        module_game_distribution::page_public_themes(visible, cursor, input.limit);
+    Ok((
+        page.iter()
+            .map(|theme| game_distribution_theme_snapshot(ctx, theme))
+            .collect(),
+        next_cursor,
+    ))
+}
+
+/// 公开主题详情：主题行 + 可见成员根清单（逐条公开目录同一份 `public_game_distribution_snapshot`）。
+///
+/// 主题不存在 / 未发布（`draft` / `archived`）一律 `Err` 同一句文案，由 api-server 映射 404，
+/// 且**不区分**两种情形（不对外确认未发布主题的存在性）。
+///
+/// **已发布但可见成员为空**是正常结果（`Ok` + 空 `roots`）：主题是运营实体，不是「不可读锚点」——
+/// 它的存在由运营的发布行为对外确认，空树不指向任何作品、不构成泄露；用 404 反而会把「刚建好
+/// 还没挂作品」这种正常运营状态误报成故障。成员清单按 `sort_order` 升序 + `member_id` 升序稳定
+/// 排序（`sort_order` 允许重复，兜底键保证全序），并受与列表同一个响应体积上限约束。
+///
+/// 返回三元组 `(主题头, roots, roots_truncated)`：**`member_count` 数的是全部可见成员**
+/// （`game_distribution_theme_member_count`，与上限无关），**`roots` 才是被上限截断的那一份**
+/// （`page_theme_members` + `GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX`）。两者不再恒等——
+/// 可见成员超过上限时 `member_count` 报真实数、`roots` 只回前 50 条，差额由
+/// `game_distribution_theme_roots_truncated` 折成一个显式信号（与族谱 `truncated` 同约定），
+/// 客户端不必再靠两个数相等来推断「有没有少看」。
+fn get_game_distribution_theme_detail_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionThemeDetailInput,
+) -> Result<
+    (
+        GameDistributionThemeSnapshot,
+        Vec<GameDistributionPublicGameSnapshot>,
+        bool,
+    ),
+    String,
+> {
+    let theme_id = required_game_distribution_text(input.theme_id, "theme_id")?;
+    let Some(theme) = ctx.db.game_distribution_theme().theme_id().find(&theme_id) else {
+        return Err(GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE.to_string());
+    };
+    if !module_game_distribution::game_distribution_theme_public_visible(theme.status.as_str()) {
+        return Err(GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE.to_string());
+    }
+    // 计数与切页读的是**同一份**可见成员清单：`member_count` 取它的全长（不截断），`roots` 取排序
+    // 后的前 50 条。顺序不能反：先切页再计数就会把「这个主题有多少棵树」变成「这次回了多少条」。
+    let member_count = game_distribution_theme_member_count(ctx, theme.theme_id.as_str());
+    // `roots` 逐条是公开目录同一份投影：计数索引同样在事务里建一次（不是每条建一次）。
+    let co_creation_index = game_distribution_public_derivative_index(ctx);
+    let roots = module_game_distribution::page_theme_members(
+        game_distribution_theme_visible_members(ctx, theme.theme_id.as_str()),
+        module_game_distribution::GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX as usize,
+    )
+    .iter()
+    .filter_map(|game| public_game_distribution_snapshot(ctx, game, &co_creation_index))
+    .collect::<Vec<_>>();
+    // 信号由「真实可见数 vs 实际回传条数」现算，不写死「超过 50 就 true」：上限一旦调整、
+    // 或某个成员的公开投影此刻不可得（`filter_map` 少一条），信号都跟着走，不需要改第二处。
+    let roots_truncated = module_game_distribution::game_distribution_theme_roots_truncated(
+        member_count as usize,
+        roots.len(),
+    );
+    Ok((
+        GameDistributionThemeSnapshot {
+            theme_id: theme.theme_id.clone(),
+            name: theme.name.clone(),
+            summary: theme.summary.clone(),
+            badge: theme.badge.clone(),
+            // 真实可见成员数：**不是** `roots.len()`（后者被响应体积上限约束）。
+            member_count,
+        },
+        roots,
+        roots_truncated,
+    ))
+}
+
+/// 作品详情 `themes` 增量：先取该作品的**根**，再按根反查所属的**公开**主题。
+///
+/// 按根（而不是按作品自身）反查是契约的一部分：成员只允许根，若按 `game_id` 自身查，第 N 代
+/// 作品会永远查不到任何主题，而它恰恰是最需要「跳回主题页」的那一批。
+/// 排序用与公开主题列表**同一份**比较器（创建时间倒序 + `theme_id` 升序兜底），避免「列表一种
+/// 顺序、详情另一种顺序」的第二套语义；数组顺序不承载运营意图（运营侧顺序是成员的 `sort_order`）。
+/// 没有所属主题时返回空数组，不是错误。
+fn list_game_distribution_theme_refs_for_root_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionThemeRefsInput,
+) -> Result<Vec<GameDistributionThemeReferenceSnapshot>, String> {
+    let game_id = required_game_distribution_text(input.game_id, "game_id")?;
+    let root_game_id = game_distribution_theme_root_of(ctx, game_id.as_str());
+    let visible = ctx
+        .db
+        .game_distribution_theme_member()
+        .by_game_distribution_theme_member_root_game_id()
+        .filter(root_game_id.as_str())
+        .filter_map(|member| {
+            let theme = ctx
+                .db
+                .game_distribution_theme()
+                .theme_id()
+                .find(&member.theme_id)?;
+            if !module_game_distribution::game_distribution_theme_public_visible(
+                theme.status.as_str(),
+            ) {
+                return None;
+            }
+            Some(module_game_distribution::GameDistributionThemePageItem {
+                theme_id: theme.theme_id.clone(),
+                created_at_micros: theme.created_at.to_micros_since_unix_epoch(),
+                payload: theme,
+            })
+        })
+        .collect::<Vec<_>>();
+    // 同一份全序比较器；这条路径不分页（详情入口是全集），所以不套 `page_public_themes`。
+    Ok(module_game_distribution::sort_public_themes(visible)
+        .into_iter()
+        .map(|item| GameDistributionThemeReferenceSnapshot {
+            theme_id: item.payload.theme_id,
+            name: item.payload.name,
+            badge: item.payload.badge,
+        })
+        .collect())
+}
+
+/// 后台主题写接口的参数非法（`THEME_BAD_REQUEST`）：错误码前缀由领域错误统一给出，
+/// 这里只做「拼一句带码的文案」这一件事，避免每个分支各写一遍前缀字符串。
+fn theme_bad_request(reason: impl Into<String>) -> String {
+    module_game_distribution::GameDistributionError::ThemeBadRequest {
+        reason: reason.into(),
+    }
+    .to_string()
+}
+
+/// 后台主题写接口的幂等摘要校验。
+///
+/// 复用同一个收据判定（`ensure_game_distribution_receipt_digest`），只把「摘要不一致」重新命名成
+/// 主题自己的码：客户端因此能按 `THEME_IDEMPOTENCY_CONFLICT` 分支，而不是从 409 的文案里猜这是
+/// 哪一类冲突。判据本身**不在**这里重写一遍——那样迟早会出现两套「什么算同一次请求」的实现。
+fn ensure_game_distribution_theme_receipt_digest(
+    receipt: &GameDistributionIdempotencyReceipt,
+    request_digest: &str,
+) -> Result<(), String> {
+    ensure_game_distribution_receipt_digest(receipt, request_digest).map_err(|_| {
+        module_game_distribution::GameDistributionError::ThemeIdempotencyConflict.to_string()
+    })
+}
+
+/// 后台主题写接口的文本与状态校验：空名 / 超长 / 未知状态一律失败关闭。
+///
+/// 文本规则来自纯函数 `game_distribution_theme_text_violation`，状态白名单来自
+/// `game_distribution_theme_status_valid`——两处都不在这里重写（也**只有这里**调用它们：
+/// api-server 不做 HTTP 层预校验，违规一律由本函数回 `THEME_BAD_REQUEST:` 再映射 400），
+/// 否则「HTTP 挡住的」与「落库挡住的」会各长一套判据。
+fn ensure_game_distribution_theme_write_fields(
+    name: &str,
+    summary: &str,
+    badge: &str,
+    status: &str,
+) -> Result<(), String> {
+    if let Some(reason) =
+        module_game_distribution::game_distribution_theme_text_violation(name, summary, badge)
+    {
+        return Err(theme_bad_request(reason));
+    }
+    if !module_game_distribution::game_distribution_theme_status_valid(status) {
+        return Err(theme_bad_request(format!("未知的主题状态 {status}")));
+    }
+    Ok(())
+}
+
+/// 主题的成员**行**总数（含当前对外不可见的成员），只供后台视图使用。
+///
+/// 公开投影用的是 `game_distribution_theme_member_count`（只算可见成员）。两个数字刻意不同：
+/// 公开侧报总数会泄露「存在草稿 / 被下架成员」，后台侧藏起来则让运营看不见自己挂过什么。
+fn game_distribution_theme_member_row_count(ctx: &ReducerContext, theme_id: &str) -> u64 {
+    ctx.db
+        .game_distribution_theme_member()
+        .by_game_distribution_theme_member_theme_id()
+        .filter(theme_id)
+        .count() as u64
+}
+
+/// 主题行 → 后台快照（含 `draft` / `archived`、运营排序、时间戳与成员行总数）。
+fn game_distribution_admin_theme_snapshot(
+    ctx: &ReducerContext,
+    theme: &GameDistributionTheme,
+) -> GameDistributionAdminThemeSnapshot {
+    GameDistributionAdminThemeSnapshot {
+        theme_id: theme.theme_id.clone(),
+        name: theme.name.clone(),
+        summary: theme.summary.clone(),
+        badge: theme.badge.clone(),
+        sort_order: theme.sort_order,
+        status: theme.status.clone(),
+        member_count: game_distribution_theme_member_row_count(ctx, theme.theme_id.as_str()),
+        created_at_micros: theme.created_at.to_micros_since_unix_epoch(),
+        updated_at_micros: theme.updated_at.to_micros_since_unix_epoch(),
+    }
+}
+
+/// 主题成员行 → 后台行快照（含当前对外不可见的行）。
+///
+/// `visible` 复用公开投影那条**同一份**判定（[`module_game_distribution::game_distribution_theme_member_visible`]：
+/// 未删 + 已公开 + 有当前公开版本），绝不在这里重写第二个同义判定——否则「公开侧看得见 / 后台说
+/// 看不见」这类漂移会立刻出现。`visibility` 只回答「**为什么**」，由模块侧纯函数给出（软删除 /
+/// 作品行不存在 / 原样透传作品行的 `visibility`）；两者是独立字段，`visibility == "published"`
+/// 且无当前公开版本时 `visible == false` 是刻意的。
+///
+/// 游戏行不存在时 `title = None`（api-server 发 `null`）：那是历史脏行，行本身仍要出现在名单里，
+/// 让运营看到「这里挂着一个已经查不到的作品」——静默跳过反而会让名单与 `totalMembers` 对不上。
+fn game_distribution_admin_theme_member_row_snapshot(
+    ctx: &ReducerContext,
+    member: &GameDistributionThemeMember,
+) -> GameDistributionAdminThemeMemberRowSnapshot {
+    let game = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&member.root_game_id);
+    let is_deleted = game.as_ref().is_some_and(|game| game.deleted_at.is_some());
+    let is_published = game
+        .as_ref()
+        .is_some_and(|game| game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED);
+    let has_public_version = game
+        .as_ref()
+        .is_some_and(|game| public_game_distribution_version(ctx, game).is_some());
+    let visible = module_game_distribution::game_distribution_theme_member_visible(
+        is_deleted,
+        is_published,
+        has_public_version,
+    );
+    let visibility = module_game_distribution::game_distribution_theme_member_visibility(
+        game.is_some(),
+        is_deleted,
+        game.as_ref()
+            .map(|game| game.visibility.as_str())
+            .unwrap_or_default(),
+    );
+    GameDistributionAdminThemeMemberRowSnapshot {
+        root_game_id: member.root_game_id.clone(),
+        title: game.map(|game| game.title),
+        sort_order: member.sort_order,
+        created_at_micros: member.created_at.to_micros_since_unix_epoch(),
+        visible,
+        visibility,
+    }
+}
+
+/// 后台创建主题。
+///
+/// 幂等：命中同键收据且摘要一致时回**首次创建的那一行**（`replayed = true`），而不是拿本次请求
+/// 带来的新 `theme_id` 再插一次——重试的客户端不该得到两个主题。摘要不一致 → 409。
+/// `created_by_user_id` 取调用方给的会话主体（只作审计），`created_at = updated_at = now`。
+fn create_game_distribution_theme_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionCreateThemeInput,
+) -> Result<(GameDistributionAdminThemeSnapshot, bool), String> {
+    let theme_id = required_game_distribution_text(input.theme_id, "theme_id")?;
+    let admin_user_id = required_game_distribution_text(input.admin_user_id, "admin_user_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 name = input.name.trim().to_string();
+    let summary = input.summary.trim().to_string();
+    let badge = input.badge.trim().to_string();
+    let status = input.status.trim().to_lowercase();
+    ensure_game_distribution_theme_write_fields(
+        name.as_str(),
+        summary.as_str(),
+        badge.as_str(),
+        status.as_str(),
+    )?;
+    let receipt_id = game_distribution_receipt_id(
+        admin_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_CREATE_THEME,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_theme_receipt_digest(&receipt, request_digest.as_str())?;
+        let created_theme_id = receipt
+            .outcome_json
+            .ok_or_else(|| "幂等收据缺少主题 ID".to_string())?;
+        let theme = ctx
+            .db
+            .game_distribution_theme()
+            .theme_id()
+            .find(&created_theme_id)
+            .ok_or_else(|| {
+                module_game_distribution::GameDistributionError::ThemeNotFound.to_string()
+            })?;
+        return Ok((game_distribution_admin_theme_snapshot(ctx, &theme), true));
+    }
+    if ctx
+        .db
+        .game_distribution_theme()
+        .theme_id()
+        .find(&theme_id)
+        .is_some()
+    {
+        // 同一个 ID 只会由 api-server 生成一次（随机后缀），走到这里说明调用方自己拼了 ID：
+        // 直接拒绝，而不是把别人的主题覆盖成我的内容。
+        return Err(theme_bad_request("主题 ID 已存在"));
+    }
+    let now = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    let theme = GameDistributionTheme {
+        theme_id: theme_id.clone(),
+        name,
+        summary,
+        badge,
+        sort_order: input.sort_order,
+        status,
+        created_by_user_id: admin_user_id.clone(),
+        created_at: now,
+        updated_at: now,
+    };
+    ctx.db.game_distribution_theme().insert(theme.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id: admin_user_id,
+            action: GAME_DISTRIBUTION_ACTION_CREATE_THEME.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: None,
+            version_id: None,
+            outcome_kind: GAME_DISTRIBUTION_THEME_RECEIPT_OUTCOME_KIND.to_string(),
+            outcome_game_id: None,
+            outcome_version_id: None,
+            // 主题没有专用结果列：把主题 ID 放进 `outcome_json`（重放时据此取回那一行）。
+            outcome_json: Some(theme_id),
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((game_distribution_admin_theme_snapshot(ctx, &theme), false))
+}
+
+/// 后台整体覆盖主题字段（改名 / 简介 / 角标 / 排序 / 状态）。
+///
+/// 顺序：先校字段（400）→ 再找主题（404）→ 再判收据（409 / 重放）。把「主题不存在」放在收据判定
+/// 之前，是为了让「ID 打错了」永远是 404，而不是在同键不同摘要时被 409 抢走。
+/// 生效的更新刷新 `updated_at`；重放不写库，因此也不会刷新。
+fn update_game_distribution_theme_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionUpdateThemeInput,
+) -> Result<(GameDistributionAdminThemeSnapshot, bool), String> {
+    let theme_id = required_game_distribution_text(input.theme_id, "theme_id")?;
+    let admin_user_id = required_game_distribution_text(input.admin_user_id, "admin_user_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 name = input.name.trim().to_string();
+    let summary = input.summary.trim().to_string();
+    let badge = input.badge.trim().to_string();
+    let status = input.status.trim().to_lowercase();
+    ensure_game_distribution_theme_write_fields(
+        name.as_str(),
+        summary.as_str(),
+        badge.as_str(),
+        status.as_str(),
+    )?;
+    let Some(mut theme) = ctx.db.game_distribution_theme().theme_id().find(&theme_id) else {
+        return Err(module_game_distribution::GameDistributionError::ThemeNotFound.to_string());
+    };
+    let receipt_id = game_distribution_receipt_id(
+        admin_user_id.as_str(),
+        GAME_DISTRIBUTION_ACTION_UPDATE_THEME,
+        idempotency_key.as_str(),
+    );
+    if let Some(receipt) = find_game_distribution_receipt(ctx, receipt_id.as_str()) {
+        ensure_game_distribution_theme_receipt_digest(&receipt, request_digest.as_str())?;
+        // 重放回**当前**行（与 `create_game` 的重放同一取舍：收据只保证「同一意图只生效一次」，
+        // 不冻结响应内容）。因此这里不写库、不刷新 `updated_at`。
+        return Ok((game_distribution_admin_theme_snapshot(ctx, &theme), true));
+    }
+    theme.name = name;
+    theme.summary = summary;
+    theme.badge = badge;
+    theme.sort_order = input.sort_order;
+    theme.status = status;
+    theme.updated_at = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+    ctx.db
+        .game_distribution_theme()
+        .theme_id()
+        .update(theme.clone());
+    insert_game_distribution_receipt(
+        ctx,
+        GameDistributionReceiptInput {
+            receipt_id,
+            owner_user_id: admin_user_id,
+            action: GAME_DISTRIBUTION_ACTION_UPDATE_THEME.to_string(),
+            idempotency_key,
+            request_digest,
+            game_id: None,
+            version_id: None,
+            outcome_kind: GAME_DISTRIBUTION_THEME_RECEIPT_OUTCOME_KIND.to_string(),
+            outcome_game_id: None,
+            outcome_version_id: None,
+            outcome_json: Some(theme_id),
+            now_micros: input.now_micros,
+        },
+    )?;
+    Ok((game_distribution_admin_theme_snapshot(ctx, &theme), false))
+}
+
+/// 后台增 / 改主题成员（幂等 upsert，只允许根作品）。
+///
+/// 判定顺序是有意的：**主题存在 → 作品存在 → 是否根**。反过来的话，「挂一个不存在的作品」
+/// 与「挂一个非根作品」会共用同一个状态码，运营分不清是 ID 打错了还是应该改挂它的根。
+/// 不做「成员必须公开」的前置校验：草稿 / 已下架 / 软删除的作品都能先挂上（公开投影按可见性
+/// 跳过），作品公开后成员自动出现——这正是「投影跳过但不删行」的正面用法。
+fn upsert_game_distribution_theme_member_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionThemeMemberUpsertInput,
+) -> Result<GameDistributionAdminThemeMemberSnapshot, String> {
+    let theme_id = required_game_distribution_text(input.theme_id, "theme_id")?;
+    let root_game_id = required_game_distribution_text(input.root_game_id, "root_game_id")?;
+    if ctx
+        .db
+        .game_distribution_theme()
+        .theme_id()
+        .find(&theme_id)
+        .is_none()
+    {
+        return Err(module_game_distribution::GameDistributionError::ThemeNotFound.to_string());
+    }
+    if ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&root_game_id)
+        .is_none()
+    {
+        return Err(
+            module_game_distribution::GameDistributionError::ThemeMemberGameNotFound {
+                game_id: root_game_id,
+            }
+            .to_string(),
+        );
+    }
+    // 「是不是根」的事实只能由血缘行给出：有行 ⇒ 这个作品自己是别人的衍生，不能作为成员。
+    // 与 `game_distribution_theme_root_of` 用同一张表 / 同一个键，但方向相反——那里是「顺着行找根」，
+    // 这里是「有行就不是根」，两处都不是「先查后写」的流程假设。
+    let has_lineage_row = ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&root_game_id)
+        .is_some();
+    if !module_game_distribution::game_distribution_theme_root_acceptable(has_lineage_row) {
+        return Err(
+            module_game_distribution::GameDistributionError::ThemeMemberNotRoot {
+                game_id: root_game_id,
+            }
+            .to_string(),
+        );
+    }
+    let member_id = module_game_distribution::game_distribution_theme_member_id(
+        theme_id.as_str(),
+        root_game_id.as_str(),
+    );
+    let created_at = match ctx
+        .db
+        .game_distribution_theme_member()
+        .member_id()
+        .find(&member_id)
+    {
+        Some(existing) => {
+            // 幂等 upsert：主键已经保证「同主题同根一行」，这里只更新运营权重，**不动 `created_at`**
+            // ——「这个成员是什么时候挂上来的」不该被一次重复 PUT 改写。
+            let mut updated = existing;
+            updated.sort_order = input.sort_order;
+            ctx.db
+                .game_distribution_theme_member()
+                .member_id()
+                .update(updated.clone());
+            updated.created_at
+        }
+        None => {
+            let created_at = Timestamp::from_micros_since_unix_epoch(input.now_micros);
+            ctx.db
+                .game_distribution_theme_member()
+                .insert(GameDistributionThemeMember {
+                    member_id,
+                    theme_id: theme_id.clone(),
+                    root_game_id: root_game_id.clone(),
+                    sort_order: input.sort_order,
+                    created_at,
+                });
+            created_at
+        }
+    };
+    Ok(GameDistributionAdminThemeMemberSnapshot {
+        theme_id,
+        root_game_id,
+        sort_order: input.sort_order,
+        created_at_micros: created_at.to_micros_since_unix_epoch(),
+    })
+}
+
+/// 后台移除主题成员：按确定性主键删除，**成员不存在也算成功**（幂等）。
+///
+/// 主题不存在仍是 `THEME_NOT_FOUND`：那是路径里的主题 ID 错了，与「成员早就删掉了」是两回事。
+/// 归档主题**不清理**成员行（`status = archived` 只是不再公开），因此这里也不做任何级联。
+fn remove_game_distribution_theme_member_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionThemeMemberRemoveInput,
+) -> Result<(), String> {
+    let theme_id = required_game_distribution_text(input.theme_id, "theme_id")?;
+    let root_game_id = required_game_distribution_text(input.root_game_id, "root_game_id")?;
+    if ctx
+        .db
+        .game_distribution_theme()
+        .theme_id()
+        .find(&theme_id)
+        .is_none()
+    {
+        return Err(module_game_distribution::GameDistributionError::ThemeNotFound.to_string());
+    }
+    let member_id = module_game_distribution::game_distribution_theme_member_id(
+        theme_id.as_str(),
+        root_game_id.as_str(),
+    );
+    if ctx
+        .db
+        .game_distribution_theme_member()
+        .member_id()
+        .find(&member_id)
+        .is_some()
+    {
+        ctx.db
+            .game_distribution_theme_member()
+            .member_id()
+            .delete(&member_id);
+    }
+    Ok(())
+}
+
+/// 后台主题列表：含 `draft` / `archived`，`status` 过滤 + `limit` 截断，按 `created_at` 倒序 +
+/// `theme_id` 升序。**不带游标**（主题是运营维护的小集合）。
+///
+/// 排序刻意复用公开列表那份全序比较器 `sort_public_themes`：后台与公开对「主题之间谁在前」不该有
+/// 两套语义，复用同一份实现就不会漂移。`limit` 的 0 / 超界语义与后台作品列表同口径（取默认 /
+/// 截断到 200），不是「返回 0 条」也不是报错。
+fn list_admin_game_distribution_themes_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionAdminThemeListInput,
+) -> Result<Vec<GameDistributionAdminThemeSnapshot>, String> {
+    let limit = if input.limit == 0 {
+        GAME_DISTRIBUTION_ADMIN_THEME_LIST_LIMIT
+    } else {
+        input.limit.min(GAME_DISTRIBUTION_ADMIN_THEME_LIST_LIMIT)
+    } as usize;
+    let status = input
+        .status
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| value.to_lowercase());
+    if let Some(status) = status.as_deref() {
+        // api-server 已经挡过一次；这里再挡一次是为了让非 HTTP 调用方也失败关闭，而不是拿到一份
+        // 「悄悄按全量返回」的列表——那会让运营以为自己筛了、其实没筛。
+        if !module_game_distribution::game_distribution_theme_admin_status_filter_valid(status) {
+            return Err(theme_bad_request(format!("未知的主题状态过滤值 {status}")));
+        }
+    }
+    let themes = ctx
+        .db
+        .game_distribution_theme()
+        .iter()
+        .filter(|theme| match status.as_deref() {
+            None | Some(module_game_distribution::GAME_DISTRIBUTION_THEME_ADMIN_STATUS_ALL) => true,
+            Some(value) => theme.status == value,
+        })
+        .map(
+            |theme| module_game_distribution::GameDistributionThemePageItem {
+                theme_id: theme.theme_id.clone(),
+                created_at_micros: theme.created_at.to_micros_since_unix_epoch(),
+                payload: theme,
+            },
+        )
+        .collect::<Vec<_>>();
+    Ok(module_game_distribution::sort_public_themes(themes)
+        .into_iter()
+        .take(limit)
+        .map(|item| game_distribution_admin_theme_snapshot(ctx, &item.payload))
+        .collect())
+}
+
+/// 后台主题成员列表：返回该主题的**全部成员行**（含当前对外不可见的行），游标分页。
+///
+/// 三条与公开投影**刻意不同**的口径：
+/// 1. **不套公开可见性过滤**：成员行的全集就是切页序列，一行都不会在切页前被滤掉（后台运营要在发布
+///    前核对名单，包括当前不可见的成员）。这与 `/my-collections` 的「先过滤再切页」不同，因此这里
+///    也不需要那条纪律——没有行会被滤掉，就不存在「被滤掉的行占掉名额」的问题。
+/// 2. **主题 `draft` / `archived` 照常可读**：只判主题**存在**（不存在 → `THEME_NOT_FOUND` → 404），
+///    不套 `game_distribution_theme_public_visible`。后台看得到草稿主题的成员，这是本接口存在的理由。
+/// 3. **排序复用公开侧同一份比较器**（`sort_theme_members`：`sort_order` 升序 + `member_id` 升序
+///    兜底，全序），只是额外套上游标与 `limit`（`page_admin_theme_members`）。
+///
+/// `total_members` 是**成员行总数**（`game_distribution_theme_member_row_count`，不受分页影响）：
+/// 运营要知道「这个主题一共挂了几行」，而不是「这一页回了几行」。
+///
+/// 返回 `(theme_id, total_members, 这一页的行, 下一页游标)`。
+fn list_admin_game_distribution_theme_members_tx(
+    ctx: &ReducerContext,
+    input: GameDistributionAdminThemeMemberListInput,
+) -> Result<
+    (
+        String,
+        u64,
+        Vec<GameDistributionAdminThemeMemberRowSnapshot>,
+        Option<String>,
+    ),
+    String,
+> {
+    let theme_id = required_game_distribution_text(input.theme_id, "theme_id")?;
+    if ctx
+        .db
+        .game_distribution_theme()
+        .theme_id()
+        .find(&theme_id)
+        .is_none()
+    {
+        return Err(module_game_distribution::GameDistributionError::ThemeNotFound.to_string());
+    }
+    let cursor = input
+        .cursor
+        .and_then(normalize_game_distribution_optional)
+        .map(|value| {
+            // 薄封装（只委托主题列表那套解析）：非法游标因此仍是可达的 `THEME_INVALID_CURSOR`。
+            module_game_distribution::parse_game_distribution_theme_member_cursor(value.as_str())
+        })
+        .transpose()?;
+    // 计数在切页**之前**取：`total_members` 是行总数，与这一页回了几行无关。
+    let total_members = game_distribution_theme_member_row_count(ctx, theme_id.as_str());
+    let rows = ctx
+        .db
+        .game_distribution_theme_member()
+        .by_game_distribution_theme_member_theme_id()
+        .filter(theme_id.as_str())
+        .map(
+            |member| module_game_distribution::GameDistributionThemeMemberPageItem {
+                member_id: member.member_id.clone(),
+                sort_order: member.sort_order,
+                payload: game_distribution_admin_theme_member_row_snapshot(ctx, &member),
+            },
+        )
+        .collect::<Vec<_>>();
+    let (members, next_cursor) =
+        module_game_distribution::page_admin_theme_members(rows, cursor, input.limit);
+    Ok((theme_id, total_members, members, next_cursor))
+}
+
+///
+/// 这里只负责取行（根游戏行、按根索引命中的血缘行、以及每行引用的游戏行），
+/// 「家族归属校验、根自身入集合、游戏行缺失跳过、重复行去重」全部交给
+/// `module_game_distribution::assemble_lineage_tree_entries` 这个纯函数，
+/// 既避免同一口径长出第二套实现，也让树形状能在不起 `ReducerContext` 的前提下被单测钉住。
+fn game_distribution_lineage_entries(
+    ctx: &ReducerContext,
+    root_game_id: &str,
+) -> Vec<module_game_distribution::LineageTreeEntry> {
+    let root = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&root_game_id.to_string())
+        .map(|game| game_distribution_lineage_game_facts(ctx, &game));
+    let resolved_links = ctx
+        .db
+        .game_distribution_lineage()
+        .by_game_distribution_lineage_root_game_id()
+        .filter(&root_game_id.to_string())
+        .map(|lineage| module_game_distribution::LineageResolvedLink {
+            link: module_game_distribution::LineageLink {
+                game_id: lineage.game_id.clone(),
+                parent_game_id: lineage.parent_game_id.clone(),
+                root_game_id: lineage.root_game_id.clone(),
+                generation: lineage.generation,
+            },
+            game: ctx
+                .db
+                .game_distribution_game()
+                .game_id()
+                .find(&lineage.game_id)
+                .map(|game| game_distribution_lineage_game_facts(ctx, &game)),
+        })
+        .collect::<Vec<_>>();
+    module_game_distribution::assemble_lineage_tree_entries(root_game_id, root, &resolved_links)
+}
+
+/// 把一个游戏行折叠成族谱装配用的行事实（含作者名的读时联账号）。
+fn game_distribution_lineage_game_facts(
+    ctx: &ReducerContext,
+    game: &GameDistributionGame,
+) -> module_game_distribution::LineageGameFacts {
+    module_game_distribution::LineageGameFacts {
+        game_id: game.game_id.clone(),
+        title: game.title.clone(),
+        author_name: game_distribution_lineage_author_name(ctx, game),
+        play_count: game.play_count,
+        is_deleted: game.deleted_at.is_some(),
+        is_published: game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+        status: game.visibility.clone(),
+        created_at_micros: game.created_at.to_micros_since_unix_epoch(),
+        cover_object_key: game.cover_object_key.clone(),
+    }
+}
+
+/// 族谱节点的作者名：与公开详情同样读时联账号表（账号改名/换头像立即跟随），
+/// 账号信息不可得时退回发布时冻结的作者名。
+///
+/// 归一规则（账号昵称优先、两者都空白则 `None`）放在
+/// `module_game_distribution::resolve_lineage_author_name`，这里只做账号查询。
+fn game_distribution_lineage_author_name(
+    ctx: &ReducerContext,
+    game: &GameDistributionGame,
+) -> Option<String> {
+    let account_display_name = ctx
+        .db
+        .user_account()
+        .user_id()
+        .find(&game.owner_user_id)
+        .map(|account| account.display_name);
+    module_game_distribution::resolve_lineage_author_name(
+        account_display_name.as_deref(),
+        game.author_name.as_deref(),
+    )
+}
+
+fn game_distribution_lineage_node_snapshot(
+    node: module_game_distribution::LineageTreeNode,
+) -> GameDistributionLineageNodeSnapshot {
+    GameDistributionLineageNodeSnapshot {
+        game_id: node.game_id,
+        title: node.title,
+        author_name: node.author_name,
+        generation: node.generation,
+        parent_game_id: node.parent_game_id,
+        play_count: node.play_count,
+        status: node.status,
+        cover_object_key: node.cover_object_key,
+    }
 }
 
 fn get_game_distribution_game_for_owner_or_public_tx(
@@ -3769,7 +7555,8 @@ fn get_game_distribution_game_for_owner_or_public_tx(
         }
         return Ok(Some(game_distribution_game_snapshot(&game)));
     }
-    Ok(public_game_distribution_snapshot(ctx, &game).map(|item| item.game))
+    let co_creation_index = game_distribution_public_derivative_index(ctx);
+    Ok(public_game_distribution_snapshot(ctx, &game, &co_creation_index).map(|item| item.game))
 }
 
 fn get_game_distribution_version_tx(
@@ -4166,6 +7953,7 @@ fn game_distribution_game_snapshot(game: &GameDistributionGame) -> GameDistribut
         project_key: game.project_key.clone(),
         cover_object_key: game.cover_object_key.clone(),
         screenshots_json: game.screenshots_json.clone(),
+        fork_authorization: game.fork_authorization.clone(),
         price_mud_points: game.price_mud_points,
     }
 }
@@ -4302,6 +8090,10 @@ fn game_distribution_version_snapshot(
         created_at_micros: version.created_at.to_micros_since_unix_epoch(),
         updated_at_micros: version.updated_at.to_micros_since_unix_epoch(),
         metadata_json: version.metadata_json.clone(),
+        project_bundle_object_key: version.project_bundle_object_key.clone(),
+        project_bundle_bytes: version.project_bundle_bytes,
+        project_bundle_sha256: version.project_bundle_sha256.clone(),
+        change_summary: version.change_summary.clone(),
     }
 }
 
@@ -4333,17 +8125,171 @@ fn public_game_distribution_version(
         })
 }
 
+/// 直接改编该作品的**已公开且未软删除**作品数。按血缘索引实时统计，不维护物化计数，
+/// 避免与下架/封禁/删除状态产生第二份真相。
+///
+/// 「该不该计入」的规则放在 `module_game_distribution::counts_as_public_derivative`：删除只
+/// 下线游戏行、保留血缘行，若不排除已删子作品，父作品的「已被改编 N 次」会虚报改编热度，
+/// 并对外泄露「这里曾经有个作品」。这里只折叠行状态，不重写规则。
+fn game_distribution_public_fork_count(ctx: &ReducerContext, game_id: &str) -> u64 {
+    let derived_game_ids: Vec<String> = ctx
+        .db
+        .game_distribution_lineage()
+        .by_game_distribution_lineage_parent_game_id()
+        .filter(&game_id.to_string())
+        .map(|lineage| lineage.game_id)
+        .collect();
+    derived_game_ids
+        .into_iter()
+        .filter(|derived_game_id| {
+            ctx.db
+                .game_distribution_game()
+                .game_id()
+                .find(derived_game_id)
+                .map(|game| {
+                    module_game_distribution::counts_as_public_derivative(
+                        game.deleted_at.is_some(),
+                        game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+                    )
+                })
+                .unwrap_or(false)
+        })
+        .count() as u64
+}
+
+/// 公开后代计数索引（血缘边 + 公开可见集合）：**同一事务内建一次**，供该事务里的多个作品复用。
+///
+/// 为什么允许在事务侧全表扫：目录事务本来就要遍历 `game_distribution_game` 过滤 / 排序 / 切页，
+/// 这里只多折叠一次「父 → 直接子代」的血缘边与一次可见性集合，边际成本 O(作品数)；之后每行数
+/// 子树都在内存里走边。表规模 = 作品数（当前 51），且**不新增表 / 列 / 索引**，也不在 api-server
+/// 里遍历。若将来作品量级真的上来，再换成物化计数或按根索引，读路径形状不变。
+fn game_distribution_public_derivative_index(
+    ctx: &ReducerContext,
+) -> module_game_distribution::PublicDerivativeIndex {
+    module_game_distribution::PublicDerivativeIndex::new(
+        ctx.db
+            .game_distribution_lineage()
+            .iter()
+            .map(|lineage| (lineage.parent_game_id.clone(), lineage.game_id.clone())),
+        // 可见性只折叠行状态；「该不该计入」的规则仍由纯函数 `counts_as_public_derivative` 判，
+        // 这里不重写一遍（与 `game_distribution_public_fork_count` 同一口径来源）。
+        ctx.db.game_distribution_game().iter().map(|game| {
+            (
+                game.game_id.clone(),
+                game.deleted_at.is_some(),
+                game.visibility == GAME_DISTRIBUTION_VISIBILITY_PUBLISHED,
+            )
+        }),
+    )
+}
+
+/// 公开血缘摘要。父作品被下架或封禁时仍然返回（作品行不会被删除），
+/// 只有父行真的缺失时才整体降级为 None。
+///
+/// 软删除（#565 的 `deleted_at`）按「不可用」处理：父作品已被作者删除时不得再把它的标题
+/// 与作者名回传给任何人（包括改编者），否则删除就等于没删——公开详情、公开目录早已下线，
+/// 却能在别人的溯源卡里继续读到。这里把标题/作者名置空（api-server 原样发 `null`），
+/// 前端降级为「原作品已不可用」。根作品同理：它是更远的祖先，标题同样是已删作品的信息。
+/// 只保留不透明的 ID 与代际，删掉的作品不因为血缘关系继续对外输出内容。
+///
+/// 「可用时才透传、不可用就 `(None, None)`」这条规则放在
+/// `module_game_distribution::fork_lineage_visible_identity`，这里只负责判定行是否可用并调用它，
+/// 不在 module 里重写一遍（否则「拿不到标题就回退用行数据」这类降级会悄悄长回来）。
+fn game_distribution_lineage_snapshot(
+    ctx: &ReducerContext,
+    game_id: &str,
+) -> Option<GameDistributionLineageSnapshot> {
+    let lineage = ctx
+        .db
+        .game_distribution_lineage()
+        .game_id()
+        .find(&game_id.to_string())?;
+    let parent = ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&lineage.parent_game_id)?;
+    let parent_available = parent.deleted_at.is_none();
+    // 父作品作者名与公开投影/族谱节点同一口径：**账号显示名优先**，账号不可得或昵称为空时退回
+    // 发布时冻结的 `author_name`，两者都为空白则 `None`（不占位）。
+    //
+    // 这里必须**读时联 `user_account`**：冻结值在老数据与程序化创建的作品上常常是 `None`（真实库里
+    // 就出现过 `parentTitle` 有值而 `parentAuthorName` 为 `null`），而溯源条要展示「父作品 · 作者名」。
+    // 规则复用 `game_distribution_lineage_author_name`（与族谱节点同一实现），不在本函数里再写一遍。
+    let parent_author_fallback = game_distribution_lineage_author_name(ctx, &parent);
+    let (parent_title, parent_author_name) =
+        module_game_distribution::fork_lineage_visible_identity(
+            parent_available,
+            parent.title.as_str(),
+            parent_author_fallback.as_deref(),
+        );
+    // 根作品与父作品同一口径：标题同样只在根行可用时外发；根行缺失（历史数据）退回父标题，
+    // 且同样受父的可用性约束。规则复用同一个纯函数，不在 module 里再写一遍。
+    let root_title = match ctx
+        .db
+        .game_distribution_game()
+        .game_id()
+        .find(&lineage.root_game_id)
+    {
+        Some(root) => {
+            let (title, _) = module_game_distribution::fork_lineage_visible_identity(
+                root.deleted_at.is_none(),
+                root.title.as_str(),
+                None,
+            );
+            title
+        }
+        None => {
+            let (title, _) = module_game_distribution::fork_lineage_visible_identity(
+                parent_available,
+                parent.title.as_str(),
+                None,
+            );
+            title
+        }
+    };
+    Some(GameDistributionLineageSnapshot {
+        generation: lineage.generation,
+        root_game_id: lineage.root_game_id,
+        root_title,
+        parent_game_id: lineage.parent_game_id,
+        parent_title,
+        parent_author_name,
+    })
+}
+
 fn public_game_distribution_snapshot(
     ctx: &ReducerContext,
     game: &GameDistributionGame,
+    co_creation_index: &module_game_distribution::PublicDerivativeIndex,
 ) -> Option<GameDistributionPublicGameSnapshot> {
     let version = public_game_distribution_version(ctx, game)?;
     let (average_score, rating_count) = game_distribution_user_rating_summary(ctx, &game.game_id);
+    let fork_count = game_distribution_public_fork_count(ctx, game.game_id.as_str());
+    // 共创次数（全部后代）与 forkCount（直接子代）来自同一份索引 / 同一批可见性规则，只是深度
+    // 不同；索引由调用方在**同一事务里建一次**，这里只做内存里的子树计数。
+    let co_creation_count = co_creation_index.public_derivative_count(game.game_id.as_str());
+    let lineage = game_distribution_lineage_snapshot(ctx, game.game_id.as_str());
+    let mut game_snapshot = game_distribution_game_snapshot(game);
+    // 作者名/头像读时联账号表：发布时冻结的资料可能是空的（历史数据），而公开页展示的是
+    // 作者身份，账号改名或换头像后应当立即跟随，与后台游戏管理页保持同一口径。
+    if let Some(account) = ctx.db.user_account().user_id().find(&game.owner_user_id) {
+        let display_name = account.display_name.trim().to_string();
+        if !display_name.is_empty() {
+            game_snapshot.author_name = Some(display_name);
+        }
+        if account.avatar_url.is_some() {
+            game_snapshot.author_avatar_url = account.avatar_url;
+        }
+    }
     Some(GameDistributionPublicGameSnapshot {
-        game: game_distribution_game_snapshot(game),
+        game: game_snapshot,
         current_version: Some(game_distribution_version_snapshot_for_game(ctx, &version)),
         average_score,
         rating_count,
+        fork_count,
+        co_creation_count,
+        lineage,
     })
 }
 
@@ -4351,26 +8297,32 @@ fn public_game_distribution_snapshot(
 mod tests {
     use super::*;
 
+    fn conflict(error: &str) -> bool {
+        error.starts_with(
+            shared_contracts::game_distribution::GAME_DISTRIBUTION_VERSION_NUMBER_CONFLICT,
+        )
+    }
+
     #[test]
     fn version_number_is_required_and_only_rejects_zero() {
         assert_eq!(
-            resolve_game_distribution_version_number(1).expect("首版 v1"),
+            resolve_game_distribution_version_number(0, Some(1)).expect("首版 v1"),
             1
         );
         assert_eq!(
-            resolve_game_distribution_version_number(5).expect("跳号应接受"),
+            resolve_game_distribution_version_number(0, Some(5)).expect("跳号应接受"),
             5
         );
         assert_eq!(
-            resolve_game_distribution_version_number(3).expect("同号重放应接受"),
+            resolve_game_distribution_version_number(0, Some(3)).expect("同号重放应接受"),
             3
         );
         assert_eq!(
-            resolve_game_distribution_version_number(2).expect("回退标签应接受"),
+            resolve_game_distribution_version_number(0, Some(2)).expect("回退标签应接受"),
             2
         );
         assert_eq!(
-            resolve_game_distribution_version_number(u64::MAX).expect("u64 上限应接受"),
+            resolve_game_distribution_version_number(0, Some(u64::MAX)).expect("u64 上限应接受"),
             u64::MAX
         );
     }
@@ -4378,10 +8330,1303 @@ mod tests {
     #[test]
     fn version_number_zero_is_rejected_as_a_plain_bad_request() {
         // 0 不是合法的版本标签；这类参数错误不带冲突前缀，api-server 映射成 400。
-        let zero = resolve_game_distribution_version_number(0).expect_err("版本号 0 应被拒绝");
+        let zero =
+            resolve_game_distribution_version_number(0, Some(0)).expect_err("版本号 0 应被拒绝");
         assert!(zero.contains("大于 0"), "应说明合法形状：{zero}");
     }
 
+    #[test]
+    fn auto_increment_overflow_is_reported_as_conflict() {
+        let overflow = resolve_game_distribution_version_number(u64::MAX, None)
+            .expect_err("最大版本号下自动递增应失败关闭");
+        assert!(conflict(&overflow), "应带冲突前缀：{overflow}");
+        // 溢出不能回绕成 0 或静默改写已有版本。
+        assert!(!overflow.contains("版本号 0"));
+    }
+
+    /// 取 `fn <marker>` 的函数体文本（按花括号配平），供「事务结构」类断言使用。
+    ///
+    /// 这些事务需要 `ReducerContext`，host 测试起不了真库；因此与
+    /// `editor_project_storage` 的同类测试一样，用源码文本钉住「必须走哪几步、
+    /// 绝不能出现哪一步」这类结构性不变量，行为证据留给 dev 栈端到端。
+    fn function_body<'a>(source: &'a str, marker: &str) -> &'a str {
+        let start = source
+            .find(marker)
+            .unwrap_or_else(|| panic!("{marker} 必须存在"));
+        let open = source[start..]
+            .find('{')
+            .map(|offset| start + offset)
+            .expect("函数必须有函数体");
+        let mut depth = 0usize;
+        for (index, character) in source[open..].char_indices() {
+            match character {
+                '{' => depth += 1,
+                '}' => {
+                    depth -= 1;
+                    if depth == 0 {
+                        return &source[open..=open + index];
+                    }
+                }
+                _ => {}
+            }
+        }
+        panic!("{marker} 的函数体不闭合");
+    }
+
+    /// 版本表的 `change_summary` 必须留在**表尾**并带默认值。
+    ///
+    /// schema guard 只允许「末尾追加 + 显式默认」：插在中间会让既有行的列序整体错位（不是迁移能补
+    /// 的事），漏了默认值则旧行没有可填充的值。版本快照（procedure 出参）也必须带上它，否则
+    /// 公开投影根本读不到这一列。
+    #[test]
+    fn version_change_summary_stays_at_the_table_tail_with_a_default() {
+        let source = include_str!("game_distribution.rs");
+        let table = function_body(source, "pub struct GameDistributionVersion {");
+        let lines = table.lines().map(str::trim).collect::<Vec<_>>();
+        let field_at = lines
+            .iter()
+            .position(|line| line.starts_with("pub(crate) change_summary"))
+            .expect("版本表必须有 change_summary 字段");
+        assert_eq!(
+            lines[field_at], "pub(crate) change_summary: Option<String>,",
+            "字段形状必须与设计一致"
+        );
+        assert_eq!(
+            lines[field_at - 1],
+            "#[default(None::<String>)]",
+            "表尾追加的列必须带默认值，旧行才有可填的值"
+        );
+        let last_field = lines
+            .iter()
+            .rev()
+            .find(|line| line.starts_with("pub(crate) ") && line.ends_with(','))
+            .expect("版本表必须有字段");
+        assert!(
+            last_field.starts_with("pub(crate) change_summary"),
+            "change_summary 必须是版本表的最后一个字段（只能末尾追加）：{last_field}"
+        );
+
+        let snapshot = function_body(source, "pub struct GameDistributionVersionSnapshot {");
+        assert!(
+            snapshot
+                .lines()
+                .any(|line| line.trim() == "pub change_summary: Option<String>,"),
+            "版本快照必须带上 change_summary，否则公开投影读不到"
+        );
+    }
+
+    /// 创建版本事务：**是否衍生**取血缘行（不接受客户端自称），说明只对衍生作品校验。
+    ///
+    /// 顺序同样是不变量：幂等重放先返回（重放不重复校验）、判定早于校验、校验早于写库。
+    #[test]
+    fn create_version_tx_validates_change_summary_against_the_lineage_row() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn create_game_distribution_version_tx(");
+        for required in [
+            "ensure_game_distribution_change_summary(input.change_summary.as_deref(), is_derivative)",
+            "game_distribution_lineage()",
+            "change_summary,",
+        ] {
+            assert!(body.contains(required), "创建版本事务缺少：{required}");
+        }
+        let receipt_at = body
+            .find("find_game_distribution_receipt")
+            .expect("幂等收据必须存在");
+        let lineage_at = body
+            .find("game_distribution_lineage()")
+            .expect("必须按血缘行判定是否衍生");
+        let ensure_at = body
+            .find("ensure_game_distribution_change_summary(")
+            .expect("必须调用说明校验");
+        let insert_at = body
+            .find(".insert(GameDistributionVersion {")
+            .expect("必须插入版本行");
+        assert!(
+            receipt_at < lineage_at,
+            "幂等重放必须先返回：重放不该因为「这次没带说明」而被拒"
+        );
+        assert!(
+            lineage_at < ensure_at,
+            "先按血缘行算出 is_derivative、再校验说明"
+        );
+        assert!(
+            ensure_at < insert_at,
+            "校验必须在写库之前：失败关闭，不能留下没有说明的衍生版本"
+        );
+    }
+
+    /// 统一发布事务复用同一条领域规则：按血缘行判定衍生，说明只对衍生作品校验并落库，
+    /// 母版一律忽略；校验必须先于写库，失败关闭。
+    #[test]
+    fn publish_version_tx_reuses_the_change_summary_rule() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn publish_game_distribution_version_tx(");
+        for required in [
+            "ensure_game_distribution_change_summary(input.change_summary.as_deref(), is_derivative)",
+            "game_distribution_lineage()",
+            "change_summary,",
+        ] {
+            assert!(body.contains(required), "统一发布事务缺少：{required}");
+        }
+        let lineage_at = body
+            .find("game_distribution_lineage()")
+            .expect("必须按血缘行判定是否衍生");
+        let ensure_at = body
+            .find("ensure_game_distribution_change_summary(")
+            .expect("必须调用说明校验");
+        let insert_at = body
+            .find(".insert(GameDistributionVersion {")
+            .expect("必须插入版本行");
+        assert!(
+            lineage_at < ensure_at,
+            "先按血缘行算出 is_derivative、再校验说明"
+        );
+        assert!(
+            ensure_at < insert_at,
+            "校验必须在写库之前：失败关闭，不能留下没有说明的衍生版本"
+        );
+    }
+
+    /// 提升事务：衍生的判定取**血缘行**，且必须**先于 CAS**；规则本身不在事务里重写。
+    ///
+    /// 顺序是不变量：幂等重放先返回（重放不该被新规则改写）→ 取血缘行 → 裁决（衍生终态 / CAS /
+    /// 只升不降）→ 写库。错位会让衍生作品按载荷不同回不同的码，或让「传同值」被误放行。
+    #[test]
+    fn set_fork_authorization_tx_rejects_derivatives_before_cas() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn set_game_distribution_fork_authorization_tx(");
+        for required in [
+            "resolve_fork_authorization_promotion(",
+            "game_distribution_lineage()",
+            "has_lineage_row",
+        ] {
+            assert!(body.contains(required), "提升事务缺少：{required}");
+        }
+        assert!(
+            !body.contains("can_promote_to"),
+            "只升不降只能有一处实现（module 的裁决函数），事务里不得再写一遍"
+        );
+        assert!(
+            !body.contains("input.expected_fork_authorization.trim()"),
+            "CAS 判定也必须走裁决函数，避免两套判据漂移"
+        );
+        let receipt_at = body
+            .find("find_game_distribution_receipt")
+            .expect("幂等收据必须存在");
+        let lineage_at = body
+            .find("game_distribution_lineage()")
+            .expect("必须按血缘行判定是否衍生");
+        let resolve_at = body
+            .find("resolve_fork_authorization_promotion(")
+            .expect("必须调用裁决函数");
+        let update_at = body.find(".update(game.clone())").expect("必须写库");
+        assert!(
+            receipt_at < lineage_at,
+            "幂等重放必须先返回：重放不该被新的衍生判定改写"
+        );
+        assert!(
+            lineage_at < resolve_at,
+            "先取血缘行再裁决：衍生判定先于 CAS 就靠这一步"
+        );
+        assert!(resolve_at < update_at, "裁决失败必须不写库");
+    }
+
+    /// 创建作品事务：授权档位必须来自**父作品行**（衍生作品继承）或请求值（母版）。
+    ///
+    /// 三条父档位分支的证据分两处：
+    /// - `full` / `nonCommercial`：父行必然允许共创，档位由血缘解析原样返回并在创建时落进新行
+    ///   （行为矩阵见下一个用例）。
+    /// - `forbidden`：父行**在血缘解析里就被拒**（`allows_fork()` → `FORK_NOT_AUTHORIZED`），
+    ///   继承函数拿不到它，所以不可能落出一个「继承到禁止共创」的衍生作品。
+    #[test]
+    fn create_game_tx_takes_fork_authorization_from_the_parent_row() {
+        let source = include_str!("game_distribution.rs");
+        let resolver = function_body(source, "fn resolve_game_distribution_fork_declaration_tx(");
+        for required in [
+            "ForkAuthorization::parse(source.fork_authorization.as_str())",
+            "authorization.allows_fork()",
+            "GameDistributionError::ForkNotAuthorized",
+            "next_generation(parent_generation)",
+            "        authorization,",
+        ] {
+            assert!(resolver.contains(required), "血缘解析缺少：{required}");
+        }
+
+        let body = function_body(source, "fn create_game_distribution_game_tx(");
+        assert!(
+            body.contains("resolve_game_distribution_creation_fork_authorization("),
+            "创建事务必须经继承函数裁决授权档位"
+        );
+        assert!(
+            !body.contains("ForkAuthorization::parse(input.fork_authorization"),
+            "创建事务不得直接解析请求档位：那会让衍生作品按客户端传值落库"
+        );
+        let resolve_at = body
+            .find("resolve_game_distribution_fork_declaration_tx(")
+            .expect("必须先解析血缘");
+        let inherit_at = body
+            .find("resolve_game_distribution_creation_fork_authorization(")
+            .expect("必须继承父档位");
+        let insert_at = body
+            .find("fork_authorization: fork_authorization.as_str().to_string(),")
+            .expect("必须把裁决结果写进游戏行");
+        assert!(
+            resolve_at < inherit_at,
+            "继承必须排在父行解析之后：没有父行就没有可继承的档位"
+        );
+        assert!(inherit_at < insert_at, "继承必须在写库之前");
+    }
+
+    /// 继承矩阵：父档位逐一走一遍，客户端传值一律被忽略且不报错。
+    ///
+    /// - 父 `full` / `nonCommercial`：请求里带另一个合法档位、带未知取值、带空串，落库的都是
+    ///   **父档位**（旧客户端会惯常带自己的默认档位，因此这条不能报错）。
+    /// - 父 `forbidden`：创建在血缘解析里就被 `FORK_NOT_AUTHORIZED` 拒掉（结构性用例钉住），
+    ///   继承函数永远拿不到 forbidden；这里用「`forbidden` 不允许共创」把这条前提钉住。
+    #[test]
+    fn creation_authorization_inherits_the_parent_tier_and_ignores_the_request() {
+        use module_game_distribution::ForkAuthorization::{Forbidden, Full, NonCommercial};
+
+        assert!(
+            !Forbidden.allows_fork(),
+            "父 forbidden 必须在上游被拒：继承到的档位只可能是允许共创的两档"
+        );
+
+        for (parent, requested) in [
+            (Full, "forbidden"),
+            (Full, "nonCommercial"),
+            (Full, "full"),
+            (NonCommercial, "forbidden"),
+            (NonCommercial, "full"),
+            // 未知取值同样被忽略：HTTP 面由 DTO 枚举先挡成 400，这里证明非 HTTP 调用方也安全。
+            (Full, "allowed"),
+            (NonCommercial, ""),
+        ] {
+            assert_eq!(
+                resolve_game_distribution_creation_fork_authorization(Some(parent), requested),
+                Ok(parent),
+                "衍生作品必须继承父档位 parent={parent:?} requested={requested:?}"
+            );
+        }
+    }
+
+    /// 母版：按请求值落库（缺省值由 DTO 归一成 `forbidden`，到事务里就是 `"forbidden"`）；
+    /// 未知取值失败关闭——**绝不**静默落成 `forbidden`（否则作者会以为自己设成功了）。
+    #[test]
+    fn creation_authorization_uses_the_request_for_masters_and_fails_closed_on_unknown() {
+        use module_game_distribution::ForkAuthorization::{Forbidden, Full, NonCommercial};
+
+        for (requested, expected) in [
+            ("forbidden", Forbidden),
+            ("nonCommercial", NonCommercial),
+            ("full", Full),
+        ] {
+            assert_eq!(
+                resolve_game_distribution_creation_fork_authorization(None, requested),
+                Ok(expected),
+                "母版必须按请求值落库：requested={requested:?}"
+            );
+        }
+        for requested in ["", "allowed", "FULL", "non_commercial"] {
+            let error = resolve_game_distribution_creation_fork_authorization(None, requested)
+                .expect_err("母版未知档位必须失败关闭");
+            assert!(
+                error.starts_with("FORK_AUTHORIZATION_UNKNOWN:"),
+                "value={requested:?} got={error}"
+            );
+        }
+    }
+
+    /// 说明校验助手只做「违规码 → 领域错误文案」的映射，规则本身仍由模块纯函数单点持有：
+    /// 两个码分别映射到两个不同变体，HTTP 面才分得清「没填」与「超限」。
+    #[test]
+    fn change_summary_helper_maps_each_code_to_its_own_error_and_trims() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn ensure_game_distribution_change_summary(");
+        for required in [
+            "module_game_distribution::game_distribution_change_summary_violation",
+            "GAME_DISTRIBUTION_FORK_CHANGE_SUMMARY_REQUIRED_CODE",
+            "GameDistributionError::ForkChangeSummaryRequired",
+            "GameDistributionError::ForkChangeSummaryInvalid",
+            // 合法值按 trim 后的形态落库，与计数口径（trim 后字符数）一致。
+            "str::trim",
+        ] {
+            assert!(body.contains(required), "说明校验助手缺少：{required}");
+        }
+        assert!(
+            !body.contains("20") && !body.contains("500"),
+            "阈值不得在事务里再抄一遍：区间只由模块常量持有"
+        );
+    }
+
+    /// 说明校验助手的**行为**（不依赖 `ReducerContext`，因此可以直接跑）：
+    /// 衍生作品缺说明 / 超短 / 超长都失败关闭并带上各自的稳定码；母版一律忽略；
+    /// 合法值按 trim 后的形态落库。
+    #[test]
+    fn change_summary_helper_fails_closed_for_derivatives_and_ignores_masters() {
+        let valid = "把跳台改成三段，并重画全部背景与角色立绘";
+        let too_short = "改了";
+        let too_long =
+            "改".repeat(module_game_distribution::GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS + 1);
+
+        // 合法：trim 后落库（首尾空白不进列，也不占额度）。
+        assert_eq!(
+            ensure_game_distribution_change_summary(Some(&format!("  {valid}\n")), true),
+            Ok(Some(valid.to_string()))
+        );
+
+        // 缺失 / 空白 → 必填码；超短 / 超长 → 非法码。文案必须带 `"{CODE}: "` 前缀，
+        // 否则 api-server 的 FORK 分支抓不到码（会退化成 FORK_ERROR / 409）。
+        let required = ensure_game_distribution_change_summary(None, true)
+            .expect_err("衍生作品缺说明必须失败关闭");
+        assert!(
+            required.starts_with("FORK_CHANGE_SUMMARY_REQUIRED:"),
+            "必填失败必须带稳定码前缀：{required}"
+        );
+        for value in [Some("   "), Some(too_short), Some(too_long.as_str())] {
+            let error = ensure_game_distribution_change_summary(value, true)
+                .expect_err("衍生作品缺说明或超限必须失败关闭");
+            let expected = if value == Some("   ") {
+                "FORK_CHANGE_SUMMARY_REQUIRED:"
+            } else {
+                "FORK_CHANGE_SUMMARY_INVALID:"
+            };
+            assert!(error.starts_with(expected), "value={value:?} got={error}");
+        }
+
+        // 母版：无论传什么（含超长）都回 `Ok(None)` —— 忽略而不是「可选」，不校验也不落库。
+        for value in [
+            None,
+            Some(""),
+            Some(too_short),
+            Some(too_long.as_str()),
+            Some(valid),
+        ] {
+            assert_eq!(
+                ensure_game_distribution_change_summary(value, false),
+                Ok(None),
+                "母版必须忽略该字段：value={value:?}"
+            );
+        }
+    }
+
+    /// 收藏事务：收据命中先校验摘要（重放不写库）、写入前只判主键是否存在（**不是**去重依据，
+    /// 去重由确定性主键承担），且同一次调用只可能插入一行。
+    #[test]
+    fn collection_collect_is_idempotent_and_cannot_write_a_second_row() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn set_game_distribution_collection_tx(");
+        for required in [
+            "GAME_DISTRIBUTION_ACTION_COLLECT_GAME",
+            "find_game_distribution_receipt",
+            "ensure_game_distribution_receipt_digest",
+            "module_game_distribution::game_distribution_collection_id",
+            "insert_game_distribution_receipt",
+            "ensure_game_distribution_collectable",
+        ] {
+            assert!(body.contains(required), "收藏事务必须包含 {required}");
+        }
+        // 「已存在就不写」的守卫 + 一次插入：重复收藏不会产生第二行。
+        assert!(body.contains(".find(&collection_id)"), "必须先按主键查行");
+        assert!(body.contains(".is_none()"), "存在时必须跳过写入");
+        assert_eq!(
+            body.matches(".insert(GameDistributionCollection {").count(),
+            1,
+            "同一次调用只能有一处收藏行插入"
+        );
+        // 收据只有在成功路径末尾才写：命中收据时提前 `return Ok((true, true))`。
+        assert!(body.contains("return Ok((true, true))"));
+    }
+
+    /// 取消事务：按确定性主键删除、不存在也算成功，**不**要求作品仍公开（下架后拒绝取消会留下脏行）。
+    #[test]
+    fn collection_unset_is_idempotent_and_ignores_current_visibility() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn unset_game_distribution_collection_tx(");
+        assert!(body.contains("module_game_distribution::game_distribution_collection_id"));
+        assert!(body.contains(".delete(&collection_id)"), "必须按主键删除");
+        assert!(body.contains("Ok(false)"), "取消后的权威值恒为 false");
+        assert!(
+            !body.contains("ensure_game_distribution_collectable"),
+            "取消不得要求作品仍公开：作品下架后用户仍必须能清理自己的收藏"
+        );
+    }
+
+    /// 列表事务：按 `user_id` 索引取行，只投影当前公开可读的作品，不删除任何行，
+    /// 并且**先过滤再切页**（游标位置必须落在已过滤的序列上）。
+    #[test]
+    fn collection_list_projects_only_currently_public_games() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn list_game_distribution_collections_tx(");
+        assert!(body.contains("by_game_distribution_collection_user_id()"));
+        assert!(body.contains("module_game_distribution::game_distribution_collection_visible"));
+        assert!(body.contains("public_game_distribution_snapshot"));
+        assert!(
+            !body.contains(".delete("),
+            "投影阶段不得删除收藏行：作品重新公开后同一行必须自动回来"
+        );
+        // 分页必须走共享纯函数（游标解析 + 排序切页），而不是在事务里另写一套 sort/truncate。
+        assert!(
+            body.contains("module_game_distribution::parse_game_distribution_collection_cursor")
+        );
+        assert!(body.contains("module_game_distribution::game_distribution_collection_page"));
+        let visible_at = body
+            .find("game_distribution_collection_visible")
+            .expect("可见性判定必须在事务内");
+        let page_at = body
+            .find("game_distribution_collection_page(")
+            .expect("切页必须在事务内");
+        assert!(
+            visible_at < page_at,
+            "必须先按可见性过滤、再排序切页：反过来会每翻一页漏掉自己的若干条收藏"
+        );
+    }
+
+    /// 列表结果必须带真实的 `next_cursor`：过程成功路径回传它，失败路径回 `None`。
+    #[test]
+    fn collection_list_result_carries_next_cursor() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(
+            source,
+            "pub fn list_game_distribution_collections_and_return(",
+        );
+        assert!(body.contains("Ok((games, next_cursor))"));
+        assert!(
+            body.contains("next_cursor,"),
+            "成功路径必须把事务返回的真实游标放进结果"
+        );
+        assert!(
+            body.contains("next_cursor: None,"),
+            "失败路径必须显式给出 next_cursor（不能靠缺省值）"
+        );
+    }
+
+    /// 收藏前置失败关闭：作品不存在与「状态不允许收藏」必须用不同文案，后者命中 api-server 的
+    /// 409 分支（`状态` 子串），且不得含「不存在」/「已被删除」（会先命中 404 分支）。
+    #[test]
+    fn collection_precondition_keeps_404_and_409_messages_distinct() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn ensure_game_distribution_collectable(");
+        assert!(body.contains("\"作品不存在\""), "行不存在必须是 404 文案");
+        assert!(
+            body.contains("GAME_DISTRIBUTION_COLLECTION_STATE_CONFLICT"),
+            "状态不允许必须复用跨端常量，避免只改一边让映射漂移"
+        );
+        let conflict_message =
+            shared_contracts::game_distribution::GAME_DISTRIBUTION_COLLECTION_STATE_CONFLICT;
+        assert!(conflict_message.contains("状态"));
+        assert!(!conflict_message.contains("不存在"));
+        assert!(!conflict_message.contains("已被删除"));
+    }
+
+    /// 根解析只有**一份**实现：族谱锚点与作品详情 `themes` 增量共用同一个函数。
+    ///
+    /// 两处各自写一遍 `lineage().game_id().find(...)...unwrap_or(自身)` 迟早会漂移成「主题查不到
+    /// 第 N 代作品的归属」这类只在一侧发生的 bug；这条断言让第二份实现无法存在。
+    #[test]
+    fn root_resolution_has_a_single_implementation() {
+        let source = include_str!("game_distribution.rs");
+        let helper = function_body(source, "fn game_distribution_theme_root_of(");
+        assert!(helper.contains(".game_distribution_lineage()"));
+        assert!(helper.contains(".game_id()"));
+        assert!(
+            helper.contains(".map(|lineage| lineage.root_game_id)"),
+            "有血缘行就用行上的根"
+        );
+        assert!(
+            helper.contains(".unwrap_or_else(|| game_id.to_string())"),
+            "没有血缘行说明目标自身就是母版（0 代）"
+        );
+        let lineage = function_body(source, "fn game_distribution_lineage_tx(");
+        assert!(
+            lineage.contains("game_distribution_theme_root_of(ctx, game_id.as_str())"),
+            "族谱锚点必须复用同一份根解析"
+        );
+        assert!(
+            !lineage.contains(".game_distribution_lineage()"),
+            "族谱事务里不得再写第二份血缘查根"
+        );
+        let refs = function_body(source, "fn list_game_distribution_theme_refs_for_root_tx(");
+        assert!(
+            refs.contains("game_distribution_theme_root_of(ctx, game_id.as_str())"),
+            "作品详情 themes 增量必须先取根再反查"
+        );
+        assert!(
+            !refs.contains(".game_distribution_lineage()"),
+            "反查事务里不得自己解析根"
+        );
+    }
+
+    /// 主题公开列表：只取 `published`、**先过滤再排序切页**、投影不删行、成员数只算可见成员。
+    #[test]
+    fn public_theme_list_filters_before_paging_and_never_deletes_rows() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn list_game_distribution_themes_tx(");
+        assert!(
+            body.contains("module_game_distribution::game_distribution_theme_public_visible"),
+            "可见性判定必须走共享纯函数（status == published）"
+        );
+        assert!(
+            body.contains("module_game_distribution::parse_game_distribution_theme_cursor"),
+            "游标解析必须走共享纯函数（非法游标 → 400）"
+        );
+        assert!(
+            body.contains("module_game_distribution::page_public_themes"),
+            "排序切页必须走共享纯函数（created_at 倒序 + theme_id 升序兜底）"
+        );
+        let visible_at = body
+            .find("game_distribution_theme_public_visible")
+            .expect("可见性判定必须在事务内");
+        let page_at = body
+            .find("module_game_distribution::page_public_themes(")
+            .expect("切页必须在事务内");
+        assert!(
+            visible_at < page_at,
+            "必须先按可见性过滤、再排序切页：反过来会每翻一页漏掉自己的若干条主题"
+        );
+        assert!(
+            !body.contains(".delete("),
+            "投影阶段不得删除主题行：归档 / 未发布只是不进入公开投影"
+        );
+        // `memberCount` 数的是**全部**可见成员（不套响应体积上限），且只在**这一页**的主题上现算
+        // （不为被切掉的条目白算）。
+        assert!(body.contains("game_distribution_theme_snapshot"));
+        assert!(body.contains("page.iter()"), "成员数必须在切页之后再算");
+        let counter = function_body(source, "fn game_distribution_theme_member_count(");
+        assert!(
+            counter.contains("game_distribution_theme_visible_members"),
+            "成员数必须与 roots 共用同一份可见成员清单"
+        );
+        assert!(
+            counter.contains(".len()"),
+            "成员数就是可见成员清单的长度（一次遍历，不额外物化）"
+        );
+        assert!(
+            !counter.contains("GAME_DISTRIBUTION_THEME_PAGE_LIMIT_MAX")
+                && !counter.contains("page_theme_members"),
+            "成员数必须数**全部**可见成员：套上响应体积上限（或走 page_theme_members）会让 120 个 \
+             成员的主题报成 50，客户端看不出少了"
+        );
+        let members = function_body(source, "fn game_distribution_theme_visible_members(");
+        assert!(
+            members.contains("by_game_distribution_theme_member_theme_id()"),
+            "按主题索引取成员，不扫描全表"
+        );
+        assert!(
+            members.contains("module_game_distribution::game_distribution_theme_member_visible"),
+            "成员可见性必须委托共享判定（未删 + 已公开 + 有当前公开版本）"
+        );
+        assert!(
+            !members.contains(".delete("),
+            "投影阶段不得删除成员行：作品重新公开后同一行必须自动回来"
+        );
+        assert!(
+            members.contains("GameDistributionThemeMemberPageItem"),
+            "排序键与负载必须绑定成一条值（避免按 A 排序、按 B 切页）"
+        );
+    }
+
+    /// 公开游戏目录：**先过滤再排序切页**、投影不删行、结果带回真实 `next_cursor`。
+    ///
+    /// 这是「写死 48 + 无游标 ⇒ 库里第 49 条起的作品（含最老的母版与主干）永久不可见」那个真缺陷
+    /// 的结构回归网：谁把切页换回 `truncate(limit)`、把页大小换回 `GAME_DISTRIBUTION_MAX_LIST_LIMIT`，
+    /// 或把 `next_cursor` 从结果类型里丢掉，这条断言都会红。
+    #[test]
+    fn public_game_catalog_filters_before_paging_and_returns_a_real_cursor() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn list_public_game_distribution_games_tx(");
+        assert!(
+            body.contains("module_game_distribution::parse_game_distribution_catalog_cursor"),
+            "游标解析必须走共享纯函数（非法游标 → 400 稳定码 CATALOG_INVALID_CURSOR）"
+        );
+        assert!(
+            body.contains("module_game_distribution::page_public_game_distribution_catalog"),
+            "排序切页必须走共享纯函数（created_at 倒序 + game_id 升序兜底）"
+        );
+        assert!(
+            body.contains("module_game_distribution::GameDistributionCatalogPageItem"),
+            "排序键与负载必须绑定成一条值（避免按 A 排序、按 B 切页）"
+        );
+        let filter_at = body
+            .find("GAME_DISTRIBUTION_VISIBILITY_PUBLISHED")
+            .expect("可见性过滤必须在事务内");
+        let page_at = body
+            .find("module_game_distribution::page_public_game_distribution_catalog(")
+            .expect("切页必须在事务内");
+        assert!(
+            filter_at < page_at,
+            "必须先按可见性过滤、再排序切页：反过来会每翻一页漏掉自己的若干条作品"
+        );
+        assert!(
+            !body.contains(".delete("),
+            "投影阶段不得删除作品行：下架 / 未公开只是不进入公开投影"
+        );
+        assert!(
+            !body.contains("GAME_DISTRIBUTION_MAX_LIST_LIMIT"),
+            "目录页大小必须走自己的归一函数（缺省 48 / 上限 100）；用 48 那个常量会让 48 又变回硬上限"
+        );
+        assert!(
+            !body.contains(".truncate("),
+            "截断必须由纯函数完成（多取一条判 has_more），事务里自己 truncate 会丢掉下一页游标"
+        );
+        // 结果类型必须给出真实游标字段：成功路径透传，失败路径显式回 None。
+        let procedure = function_body(
+            source,
+            "pub fn list_public_game_distribution_games_and_return(",
+        );
+        assert!(procedure.contains("Ok((games, next_cursor))"));
+        assert!(procedure.contains("next_cursor,"));
+        assert!(procedure.contains("GameDistributionGameListProcedureResult::failed(error)"));
+        let failed = function_body(source, "impl GameDistributionGameListProcedureResult {");
+        assert!(
+            failed.contains("next_cursor: None"),
+            "失败路径必须显式回 None，不能在 ok = false 的响应里带一个残值游标"
+        );
+        // facade 那条 procedure 与公开列表共享同一份切页结果，不会各答一个「下一页」。
+        let facade = function_body(source, "pub fn list_game_distribution_games_and_return(");
+        assert!(facade.contains("Ok((games, next_cursor))"));
+        assert!(
+            facade.contains("next_cursor,"),
+            "facade 结果类型本来就带 next_cursor，必须一并透传"
+        );
+    }
+
+    /// 公开目录 `forkable` 过滤：入参真的落到事务里、判据唯一、且发生在**切页之前**。
+    ///
+    /// 「切页之前」是这条功能唯一的正确性要点：禁止共创的行若先占掉页名额再被滤掉，第一页就会
+    /// 少回传、下一页游标又指回过滤前的序列，每翻一页漏掉自己的若干条。断言用**顺序**而不是
+    /// 「函数里出现了这个调用」，因此把过滤挪到 `page_public_game_distribution_catalog` 之后
+    /// （例如在 api-server 里滤返回结果）会立刻变红。
+    #[test]
+    fn public_game_catalog_forkable_filters_before_paging() {
+        let source = include_str!("game_distribution.rs");
+        assert!(
+            source.contains("pub forkable: bool"),
+            "公开目录入参必须带 `forkable`（procedure 入参变更需同步重生成客户端绑定）"
+        );
+        let body = function_body(source, "fn list_public_game_distribution_games_tx(");
+        assert!(
+            body.contains("input.forkable"),
+            "事务必须真的读入参，不能只在类型里挂一个字段"
+        );
+        assert!(
+            body.contains(
+                "module_game_distribution::filter_public_game_distribution_catalog_by_forkable("
+            ),
+            "过滤判据必须走模块纯函数（唯一实现：未知档位按禁止解释，与 fork 门禁同源）"
+        );
+        assert!(
+            body.contains("|game| game.fork_authorization.as_str()"),
+            "过滤必须看作品行里真实的授权列，而不是别的字段或客户端自称的档位"
+        );
+        for inline_compare in ["fork_authorization == ", "fork_authorization != "] {
+            assert!(
+                !body.contains(inline_compare),
+                "不得在事务里另写一套字符串比较（`{inline_compare}`）：判据只能有一份实现，\
+                 否则未知档位会在这里被当成「非 forbidden」而列进共创页"
+            );
+        }
+        let forkable_at = body
+            .find("filter_public_game_distribution_catalog_by_forkable(")
+            .expect("forkable 过滤必须在事务内");
+        let page_at = body
+            .find("module_game_distribution::page_public_game_distribution_catalog(")
+            .expect("切页必须在事务内");
+        assert!(
+            forkable_at < page_at,
+            "必须先按 forkable 过滤、再排序切页：反过来会让 forbidden 行占掉页名额并让游标错位"
+        );
+        // 该过滤只属于公开目录：作者 / 收藏 / 主题列表各自有自己的可见性口径，不得顺手复用。
+        for other in [
+            "fn list_owner_game_distribution_games_tx(",
+            "fn list_game_distribution_collections_tx(",
+        ] {
+            let other_body = function_body(source, other);
+            assert!(
+                !other_body.contains("forkable"),
+                "{other} 不得被 forkable 过滤污染"
+            );
+        }
+    }
+
+    /// 公开投影的 `coCreationCount`：事务里**建一次**索引、逐行数子树；与 `forkCount` 并存但口径不同。
+    ///
+    /// 结构性不变量用源码文本钉住（行为证据在 `module-game-distribution` 的纯函数测试与
+    /// api-server 的 payload 测试里）：
+    /// - 索引每个事务只建一次，且**在循环之外**（否则一页 100 行就扫 100 次血缘表）；
+    /// - 四条复用公开投影的事务都必须把索引传进去（漏一处 = 该路径静默少一个键）；
+    /// - `forkCount` 的旧口径（只数直接子代）不得被改写成全后代计数。
+    #[test]
+    fn public_projection_counts_co_creation_from_one_transaction_index() {
+        let source = include_str!("game_distribution.rs");
+        let catalog = function_body(source, "fn list_public_game_distribution_games_tx(");
+        assert_eq!(
+            catalog
+                .matches("game_distribution_public_derivative_index(ctx)")
+                .count(),
+            1,
+            "目录事务必须只建一次索引（页内多行复用同一份）"
+        );
+        let index_at = catalog
+            .find("let co_creation_index = game_distribution_public_derivative_index(ctx);")
+            .expect("目录事务必须在切页之后建一次索引");
+        let page_at = catalog
+            .find("module_game_distribution::page_public_game_distribution_catalog(")
+            .expect("切页必须在事务内");
+        assert!(
+            index_at > page_at,
+            "索引必须建在切页之后：切页前的过滤链不该为被滤掉的行做计数"
+        );
+        assert!(
+            catalog.contains("public_game_distribution_snapshot(ctx, &game, &co_creation_index)"),
+            "目录每一行都必须把同一份索引传给公开投影"
+        );
+        // 复用同一份公开投影的其余事务：各自建一次、各自传进去。
+        for name in [
+            "fn get_public_game_distribution_game_tx(",
+            "fn list_game_distribution_collections_tx(",
+            "fn get_game_distribution_theme_detail_tx(",
+            "fn get_game_distribution_game_for_owner_or_public_tx(",
+        ] {
+            let body = function_body(source, name);
+            assert!(
+                body.contains("game_distribution_public_derivative_index(ctx)"),
+                "{name} 必须自建索引（事务内一次），否则该路径没有 coCreationCount"
+            );
+            assert!(
+                body.contains("&co_creation_index"),
+                "{name} 必须把索引传进公开投影"
+            );
+        }
+        // 索引折叠的是「血缘边 + 作品行可见性」，不新增表 / 列 / 索引，也不在 api-server 里遍历。
+        let index = function_body(source, "fn game_distribution_public_derivative_index(");
+        assert!(index.contains(".game_distribution_lineage()"));
+        assert!(index.contains(".game_distribution_game()"));
+        assert!(index.contains("module_game_distribution::PublicDerivativeIndex::new("));
+        // 投影：两个计数并存，深口径来自索引、直接子代口径仍走原函数。
+        let snapshot = function_body(source, "fn public_game_distribution_snapshot(");
+        assert!(
+            snapshot.contains("co_creation_index.public_derivative_count(game.game_id.as_str())")
+        );
+        assert!(
+            snapshot.contains("game_distribution_public_fork_count(ctx, game.game_id.as_str())")
+        );
+        assert!(snapshot.contains("co_creation_count,"));
+        // forkCount 不得被改成全后代计数：它仍然按 parent 索引取一次直接子代。
+        let fork = function_body(source, "fn game_distribution_public_fork_count(");
+        assert!(fork.contains("by_game_distribution_lineage_parent_game_id()"));
+        assert!(
+            !fork.contains("public_derivative_count"),
+            "forkCount 口径 = 直接子代，不得改成全部后代"
+        );
+    }
+
+    /// 主题详情：不存在 / 未发布用同一句 404 文案；已发布空成员是正常结果；roots 复用公开投影。
+    #[test]
+    fn public_theme_detail_maps_missing_to_not_found_and_empty_members_to_success() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn get_game_distribution_theme_detail_tx(");
+        // 两种不可见情形共用同一句文案：客户端无法区分「不存在」与「未发布」，这正是目的。
+        assert_eq!(
+            body.matches("GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE")
+                .count(),
+            2,
+            "不存在与未发布必须各有一处（且共用同一条文案）"
+        );
+        assert!(
+            body.contains("game_distribution_theme_public_visible"),
+            "未发布（draft / archived）也必须按 404 处理"
+        );
+        assert!(
+            body.contains("module_game_distribution::page_theme_members"),
+            "成员排序切页必须走共享纯函数（sort_order 升序 + member_id 升序兜底）"
+        );
+        assert!(
+            body.contains("public_game_distribution_snapshot"),
+            "roots 必须复用公开目录同一份投影，不自己拼字段"
+        );
+        assert_eq!(
+            body.matches("return Err(GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE.to_string());")
+                .count(),
+            2,
+            "不存在与未发布各一处，且共用同一条 404 文案"
+        );
+        assert_eq!(
+            body.matches("Err(").count(),
+            2,
+            "详情只允许这两种失败：不得为「已发布但可见成员为空」再造一种错误（那是 200 + 空 roots）"
+        );
+        // 两个成员数相关的口径必须**分开**：`memberCount` 数全部可见成员（不截断），`roots` 才是被
+        // 响应体积上限切过的那一份，差额由 `rootsTruncated` 显式表达。
+        assert!(
+            body.contains("game_distribution_theme_member_count(ctx, theme.theme_id.as_str())"),
+            "memberCount 必须走可见成员计数（数的是全部可见成员），不是切完页的那一份"
+        );
+        assert!(
+            !body.contains("member_count: roots.len() as u64"),
+            "memberCount 不得再恒等于 roots.len()：那正是「可见成员 > 50 时静默截断且无信号」的成因"
+        );
+        assert!(
+            body.contains("module_game_distribution::game_distribution_theme_roots_truncated("),
+            "roots 被截断必须由共享纯函数折成显式信号（rootsTruncated），不写死「> 50 就 true」"
+        );
+        assert!(
+            body.contains("roots_truncated,"),
+            "rootsTruncated 必须原样进入事务返回值（算了不传 = 客户端仍然看不到）"
+        );
+        assert!(!body.contains(".delete("), "详情是纯读，不得删除任何行");
+        // 公开 404 文案必须落在 api-server 的 404 子串分支上，且不得带会把映射抢到 409 的词。
+        for forbidden in [
+            "状态",
+            "不匹配",
+            "幂等",
+            "已存在",
+            "已被删除",
+            "FORK_",
+            "THEME_",
+        ] {
+            assert!(
+                !GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE.contains(forbidden),
+                "公开 404 文案不得含「{forbidden}」"
+            );
+        }
+        assert!(GAME_DISTRIBUTION_THEME_NOT_FOUND_MESSAGE.contains("不存在"));
+    }
+
+    /// 作品详情 `themes` 增量：按**根**索引反查、只保留公开主题、排序复用同一份比较器、不写库。
+    #[test]
+    fn theme_refs_for_root_uses_root_index_and_public_themes_only() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn list_game_distribution_theme_refs_for_root_tx(");
+        assert!(
+            body.contains("by_game_distribution_theme_member_root_game_id()"),
+            "必须走按根反查的具名索引，不扫描全表"
+        );
+        assert!(
+            body.contains("game_distribution_theme_public_visible"),
+            "只保留已发布主题（草稿 / 归档主题不得出现在作品详情里）"
+        );
+        assert!(
+            body.contains("module_game_distribution::sort_public_themes"),
+            "排序必须与公开主题列表共用同一份比较器"
+        );
+        assert!(
+            !body.contains("page_public_themes("),
+            "详情入口是全集，不套列表分页"
+        );
+        assert!(
+            !body.contains(".insert(") && !body.contains(".update(") && !body.contains(".delete("),
+            "作品详情 themes 是纯读路径"
+        );
+        // 结果类型必须给出真实游标字段（与收藏列表同一纪律）：成功路径透传，失败路径显式回 None。
+        let procedure = function_body(source, "pub fn list_game_distribution_themes_and_return(");
+        assert!(procedure.contains("Ok((themes, next_cursor))"));
+        assert!(procedure.contains("next_cursor,"));
+        assert!(
+            procedure.contains("GameDistributionThemeListResult::failed(error)"),
+            "失败路径必须显式给出空结果（不能靠缺省值）"
+        );
+        let list_result_start = source
+            .find("impl GameDistributionThemeListResult {")
+            .expect("主题列表结果类型必须有 failed()");
+        let list_result = &source[list_result_start..];
+        let list_result = &list_result[..list_result.find("\nimpl ").unwrap_or(list_result.len())];
+        assert!(list_result.contains("themes: Vec::new()"));
+        assert!(
+            list_result.contains("next_cursor: None"),
+            "失败路径必须显式给出 next_cursor（不能靠缺省值）"
+        );
+    }
+
+    /// 后台创建主题：先判幂等收据再写库，重放回**收据里记下的那一行**（不是本次请求带来的新 ID），
+    /// `created_by_user_id` 取调用方给的会话主体，`created_at` 与 `updated_at` 同为 now。
+    #[test]
+    fn admin_theme_create_is_idempotent_and_audits_the_admin_subject() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn create_game_distribution_theme_tx(");
+        for required in [
+            "GAME_DISTRIBUTION_ACTION_CREATE_THEME",
+            "find_game_distribution_receipt",
+            "ensure_game_distribution_theme_receipt_digest",
+            "outcome_json",
+            "created_by_user_id: admin_user_id.clone()",
+            "created_at: now",
+            "updated_at: now",
+        ] {
+            assert!(body.contains(required), "创建主题事务缺少：{required}");
+        }
+        // 重放必须按收据里那个主题 ID 取回原行（把 ID 丢掉就等于把重放变成二次创建）。
+        assert!(
+            body.contains("find(&created_theme_id)"),
+            "重放必须按收据记下的主题 ID 取回原行"
+        );
+        let receipt_at = body
+            .find("find_game_distribution_receipt")
+            .expect("必须判幂等收据");
+        let insert_at = body.find(".insert(theme.clone())").expect("必须写主题行");
+        assert!(receipt_at < insert_at, "必须先判收据再写库");
+        // 一次调用最多插一行：重放走的是 return，不是第二次 insert。
+        assert_eq!(body.matches(".insert(").count(), 1, "主题行只能插一次");
+        // api-server 生成的 ID 撞车（调用方自己拼 ID）必须失败关闭，而不是覆盖别人的主题。
+        assert!(body.contains("主题 ID 已存在"));
+        assert!(body.contains("theme_bad_request"));
+    }
+
+    /// 后台更新主题：404 先于收据判定（ID 打错永远 404），重放**在刷新 `updated_at` 之前返回**
+    /// （不写库、不刷新时间），只有真正生效的更新才整组覆盖字段并写收据。
+    #[test]
+    fn admin_theme_update_refreshes_updated_at_only_on_effective_write() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn update_game_distribution_theme_tx(");
+        for required in [
+            "GAME_DISTRIBUTION_ACTION_UPDATE_THEME",
+            "ensure_game_distribution_theme_receipt_digest",
+            "ensure_game_distribution_theme_write_fields",
+            "theme.name = name",
+            "theme.summary = summary",
+            "theme.badge = badge",
+            "theme.sort_order = input.sort_order",
+            "theme.status = status",
+            "theme.updated_at = Timestamp::from_micros_since_unix_epoch(input.now_micros)",
+        ] {
+            assert!(body.contains(required), "更新主题事务缺少：{required}");
+        }
+        let not_found_at = body
+            .find("GameDistributionError::ThemeNotFound")
+            .expect("必须按主题 ID 判 404");
+        let receipt_at = body
+            .find("find_game_distribution_receipt")
+            .expect("必须判幂等收据");
+        assert!(not_found_at < receipt_at, "主题不存在必须先于摘要冲突判定");
+        let replay_return_at = body
+            .find("return Ok((game_distribution_admin_theme_snapshot(ctx, &theme), true));")
+            .expect("重放分支必须显式返回");
+        let refresh_at = body
+            .find("theme.updated_at =")
+            .expect("必须刷新 updated_at");
+        assert!(
+            replay_return_at < refresh_at,
+            "重放必须先于刷新返回：重放不写库、不刷新 updated_at"
+        );
+        // 覆盖式更新只 `update` 既有行，不插新行，也不删任何行。
+        assert_eq!(body.matches(".update(").count(), 1);
+        assert!(!body.contains(".insert("));
+        assert!(!body.contains(".delete("));
+    }
+
+    /// 后台增 / 改成员：确定性主键决定「同主题同根一行」，重复 PUT 只改 `sort_order` 且
+    /// **不动 `created_at`**；判定顺序是 主题 → 作品 → 是否根；不做任何「必须公开」的前置校验。
+    #[test]
+    fn admin_theme_member_upsert_is_idempotent_and_root_only() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn upsert_game_distribution_theme_member_tx(");
+        for required in [
+            "module_game_distribution::game_distribution_theme_member_id",
+            ".member_id()",
+            "find(&member_id)",
+            "module_game_distribution::game_distribution_theme_root_acceptable",
+            "GameDistributionError::ThemeMemberNotRoot",
+            "GameDistributionError::ThemeMemberGameNotFound",
+            "GameDistributionError::ThemeNotFound",
+            "updated.sort_order = input.sort_order",
+        ] {
+            assert!(body.contains(required), "增改成员事务缺少：{required}");
+        }
+        // 重复 PUT 不刷新 `created_at`：它是「什么时候挂上来的」，不该被一次重复调用改写。
+        assert!(
+            !body.contains("updated.created_at ="),
+            "重复 PUT 不得改写 created_at"
+        );
+        // 一行只可能被插一次、被 update 一次；成员行在这条路径上永不被删。
+        assert_eq!(body.matches(".insert(").count(), 1);
+        assert_eq!(body.matches(".update(").count(), 1);
+        assert!(!body.contains(".delete("));
+        // 判定顺序：主题存在 → 作品存在 → 是否根（反了就分不清「ID 打错」与「该挂根」）。
+        let theme_at = body
+            .find("GameDistributionError::ThemeNotFound")
+            .expect("必须判主题存在");
+        let game_at = body
+            .find("GameDistributionError::ThemeMemberGameNotFound")
+            .expect("必须判作品存在");
+        let root_at = body
+            .find("GameDistributionError::ThemeMemberNotRoot")
+            .expect("必须判是否根");
+        assert!(theme_at < game_at, "主题存在必须先于作品存在");
+        assert!(game_at < root_at, "作品存在必须先于是否根");
+        // 「是不是根」只能由血缘行给出。
+        assert!(body.contains(".game_distribution_lineage()"));
+        assert!(body.contains(".game_id()"));
+        // **不做**公开性前置校验：草稿 / 下架 / 软删除的作品也要能先挂上（公开后自动出现）。
+        assert!(
+            !body.contains("visibility") && !body.contains("deleted_at"),
+            "不得把「作品当前是否公开」当成入成员的前置条件"
+        );
+        assert!(!body.contains("game_distribution_theme_member_visible"));
+    }
+
+    /// 后台移除成员：按确定性主键删一行，成员不存在也算成功（主题不存在才是 404）；
+    /// 整份模块里**只有这里**会删成员行——归档 / 下架都不清理。
+    #[test]
+    fn admin_theme_member_remove_is_idempotent_and_never_cascades() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn remove_game_distribution_theme_member_tx(");
+        assert!(body.contains("module_game_distribution::game_distribution_theme_member_id"));
+        assert!(body.contains("find(&member_id)"));
+        // 断言用的针在源码里拼出来，避免 `source.matches` 把本测试自己的字面量也算进去。
+        let deletion = [".delete(&", "member_id)"].concat();
+        assert!(body.contains(deletion.as_str()));
+        assert!(
+            body.contains("GameDistributionError::ThemeNotFound"),
+            "主题不存在仍是 404：路径里的主题 ID 错了，与「成员早删掉了」是两回事"
+        );
+        // 只有主题不存在会 `return Err`：成员不存在不是错误，直接走成功路径。
+        assert_eq!(body.matches("return Err(").count(), 1);
+        // 不做批量清理（不按主题索引扫成员），也不因为主题归档而级联。
+        assert!(!body.contains("by_game_distribution_theme_member_theme_id"));
+        assert_eq!(
+            source.matches(deletion.as_str()).count(),
+            1,
+            "整份模块里只有后台显式移除会删成员行"
+        );
+        // 改状态（含归档）的事务完全不碰成员表。
+        let update = function_body(source, "fn update_game_distribution_theme_tx(");
+        assert!(
+            !update.contains("theme_member") && !update.contains("ThemeMember"),
+            "归档只是「不再公开」，不得清理成员行"
+        );
+    }
+
+    /// 后台主题列表：含 `draft` / `archived`（**不**套公开可见性过滤），排序复用公开列表同一份
+    /// 全序比较器，超界截断，非法过滤值失败关闭。
+    #[test]
+    fn admin_theme_list_keeps_drafts_and_shares_the_public_comparator() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn list_admin_game_distribution_themes_tx(");
+        for required in [
+            "GAME_DISTRIBUTION_ADMIN_THEME_LIST_LIMIT",
+            "GAME_DISTRIBUTION_THEME_ADMIN_STATUS_ALL",
+            "module_game_distribution::game_distribution_theme_admin_status_filter_valid",
+            "module_game_distribution::sort_public_themes",
+            ".take(limit)",
+        ] {
+            assert!(body.contains(required), "后台主题列表缺少：{required}");
+        }
+        assert!(
+            !body.contains("game_distribution_theme_public_visible"),
+            "后台列表必须含 draft / archived，不能套公开可见性过滤"
+        );
+        assert!(
+            !body.contains("game_distribution_theme_member_visible"),
+            "成员可见性不参与后台列表"
+        );
+        assert!(
+            body.contains("return Err("),
+            "非法 status 过滤值必须失败关闭，而不是悄悄按全量返回"
+        );
+    }
+
+    /// 后台快照的 `member_count` 是**成员行总数**，公开投影的 `member_count` 仍是可见成员数：
+    /// 两个函数刻意不同，合并任意一个方向都会出事（后台看不见自己的草稿成员 / 公开侧泄露它）。
+    #[test]
+    fn admin_theme_snapshot_counts_member_rows_not_visible_members() {
+        let source = include_str!("game_distribution.rs");
+        let snapshot = function_body(source, "fn game_distribution_admin_theme_snapshot(");
+        assert!(snapshot.contains("game_distribution_theme_member_row_count"));
+        assert!(
+            !snapshot.contains("game_distribution_theme_visible_members"),
+            "后台计数不按公开可见性过滤"
+        );
+        assert!(snapshot.contains("sort_order: theme.sort_order"));
+        assert!(snapshot.contains("status: theme.status.clone()"));
+        let row_count = function_body(source, "fn game_distribution_theme_member_row_count(");
+        assert!(
+            row_count.contains("by_game_distribution_theme_member_theme_id()"),
+            "按主题索引计数，不扫全表"
+        );
+        assert!(row_count.contains(".count()"));
+        let public_count = function_body(source, "fn game_distribution_theme_member_count(");
+        assert!(
+            public_count.contains("game_distribution_theme_visible_members"),
+            "公开计数仍然只算可见成员"
+        );
+    }
+
+    /// 五条后台主题路由对应的 procedure：都必须要求受信服务身份（HTTP 层的 admin 会话是另一条），
+    /// 且失败路径显式给出空结果。
+    #[test]
+    fn admin_theme_procedures_require_service_identity_and_fail_closed() {
+        let source = include_str!("game_distribution.rs");
+        for marker in [
+            "pub fn create_game_distribution_theme_and_return(",
+            "pub fn update_game_distribution_theme_and_return(",
+            "pub fn upsert_game_distribution_theme_member_and_return(",
+            "pub fn remove_game_distribution_theme_member_and_return(",
+            "pub fn list_admin_game_distribution_themes_and_return(",
+            "pub fn list_admin_game_distribution_theme_members_and_return(",
+        ] {
+            let body = function_body(source, marker);
+            assert!(
+                body.contains("require_editor_generation_runtime_service_identity(tx, caller)?"),
+                "{marker} 必须要求受信服务身份"
+            );
+            assert!(
+                body.contains("ctx.try_with_tx("),
+                "{marker} 必须在单一事务里完成"
+            );
+        }
+        // 失败路径显式给空：不靠 `Default`、也不回一个「看起来成功」的空间。
+        let failed_result = |marker: &str, field: &str| {
+            let start = source
+                .find(marker)
+                .unwrap_or_else(|| panic!("{marker} 必须存在"));
+            let tail = &source[start..];
+            let end = tail.find("\nimpl ").unwrap_or(tail.len());
+            assert!(
+                tail[..end].contains(field),
+                "{marker} 的失败路径必须显式给出 {field}"
+            );
+        };
+        failed_result(
+            "impl GameDistributionAdminThemeMutationResult {",
+            "theme: None",
+        );
+        failed_result(
+            "impl GameDistributionAdminThemeMemberMutationResult {",
+            "member: None",
+        );
+        failed_result(
+            "impl GameDistributionAdminThemeListResult {",
+            "themes: Vec::new()",
+        );
+        failed_result(
+            "impl GameDistributionAdminThemeMemberListResult {",
+            "members: Vec::new()",
+        );
+        // 创建 / 更新的成功路径必须把 `replayed` 透传给 handler（否则重放会被说成新建）。
+        let create_procedure =
+            function_body(source, "pub fn create_game_distribution_theme_and_return(");
+        assert!(create_procedure.contains("Ok((theme, replayed))"));
+        assert!(create_procedure.contains("replayed,"));
+    }
+
+    /// 后台主题写接口的错误码一律来自领域错误类型（`THEME_BAD_REQUEST` / `THEME_NOT_FOUND` / …），
+    /// 不在事务里手写前缀字符串——手写就会与 api-server 的映射表各走一套。
+    #[test]
+    fn admin_theme_write_errors_come_from_the_domain_error_type() {
+        let source = include_str!("game_distribution.rs");
+        for marker in [
+            "fn create_game_distribution_theme_tx(",
+            "fn update_game_distribution_theme_tx(",
+            "fn upsert_game_distribution_theme_member_tx(",
+            "fn remove_game_distribution_theme_member_tx(",
+            "fn list_admin_game_distribution_themes_tx(",
+        ] {
+            let body = function_body(source, marker);
+            assert!(
+                !body.contains("\"THEME_"),
+                "{marker} 里的错误码必须来自领域错误类型，不是手写字符串"
+            );
+        }
+        // 文本校验只走共享纯函数：事务里不出现第二套长度判据。
+        let fields = function_body(source, "fn ensure_game_distribution_theme_write_fields(");
+        assert!(fields.contains("game_distribution_theme_text_violation"));
+        assert!(fields.contains("game_distribution_theme_status_valid"));
+        assert!(fields.contains("theme_bad_request"));
+        // 收据判定的三处幂等入口：冲突必须换成主题自己的码（`THEME_IDEMPOTENCY_CONFLICT`），
+        // 但**判据**仍然只有一份（复用共享的收据摘要比较）。
+        let digest_guard =
+            function_body(source, "fn ensure_game_distribution_theme_receipt_digest(");
+        assert!(
+            digest_guard.contains("ensure_game_distribution_receipt_digest("),
+            "冲突判据必须复用共享收据判定，不能长出第二套「什么算同一次请求」"
+        );
+        assert!(
+            digest_guard.contains("GameDistributionError::ThemeIdempotencyConflict"),
+            "摘要不一致必须换成 THEME_IDEMPOTENCY_CONFLICT"
+        );
+        let update = function_body(source, "fn update_game_distribution_theme_tx(");
+        assert!(update.contains("ensure_game_distribution_theme_receipt_digest"));
+        let create = function_body(source, "fn create_game_distribution_theme_tx(");
+        assert!(create.contains("ensure_game_distribution_theme_receipt_digest"));
+    }
+
+    /// 后台成员列表：**不套**可见性过滤、**不要求主题已发布**、复用公开侧的排序切页纯函数、不删行，
+    /// 且 `totalMembers` 取的是**行总数**（切页之前算，与这一页回了几行无关）。
+    #[test]
+    fn admin_theme_member_list_keeps_invisible_rows_and_drafts() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn list_admin_game_distribution_theme_members_tx(");
+        for required in [
+            // 按主题索引取全部成员行（不扫描全表、也不走「只取可见成员」的公开投影助手）。
+            "by_game_distribution_theme_member_theme_id()",
+            // 排序 + 切页走共享纯函数（内部即 `sort_theme_members`：sort_order 升序 + member_id 兜底）。
+            "module_game_distribution::page_admin_theme_members",
+            // 游标解析走共享纯函数（非法游标 → 可达的 `THEME_INVALID_CURSOR`）。
+            "module_game_distribution::parse_game_distribution_theme_member_cursor",
+            "GameDistributionError::ThemeNotFound",
+            "game_distribution_theme_member_row_count",
+        ] {
+            assert!(body.contains(required), "后台成员列表事务缺少：{required}");
+        }
+        // 后台要看全部行：不得套公开可见性过滤，也不得借道「只取可见成员」的助手。
+        assert!(
+            !body.contains("game_distribution_theme_public_visible"),
+            "后台成员列表不得因主题 draft / archived 而拒绝：那是本接口存在的理由"
+        );
+        assert!(
+            !body.contains("game_distribution_theme_visible_members"),
+            "后台成员列表必须含当前不可见的行，不能复用「只取可见成员」的公开投影助手"
+        );
+        assert!(
+            !body.contains("game_distribution_theme_member_visible"),
+            "可见性判定只属于逐行投影（行快照），不属于「要不要返回这一行」"
+        );
+        // 排序只有一份实现：事务里不得自己 `sort_by`，必须走共享纯函数。
+        assert!(
+            !body.contains("sort_by"),
+            "事务里不得自写比较器：排序必须复用 `sort_theme_members`（经 `page_admin_theme_members`）"
+        );
+        assert!(
+            !body.contains(".delete("),
+            "后台成员列表是纯读：不得以任何理由删除成员行"
+        );
+        // 计数必须在切页之前取，才可能是「行总数」而不是「这一页的行数」。
+        let count_at = body
+            .find("game_distribution_theme_member_row_count")
+            .expect("必须取行总数");
+        let page_at = body
+            .find("module_game_distribution::page_admin_theme_members")
+            .expect("必须切页");
+        assert!(
+            count_at < page_at,
+            "totalMembers 必须在切页之前取：反了就退化成「这一页回了几行」"
+        );
+
+        // 行快照：`visible` 复用公开侧同一份判定，`visibility` 走模块侧纯函数拆分「为什么」；
+        // 游戏行缺失时仍然产出**一行**（title = None），不得静默跳过（否则名单与计数对不上）。
+        let row = function_body(
+            source,
+            "fn game_distribution_admin_theme_member_row_snapshot(",
+        );
+        assert!(
+            row.contains("module_game_distribution::game_distribution_theme_member_visible"),
+            "visible 必须复用公开投影的同一份判定，不许在这里重写一套"
+        );
+        assert!(
+            row.contains("module_game_distribution::game_distribution_theme_member_visibility"),
+            "visibility 必须走模块侧纯函数（missing 优先于 deleted）"
+        );
+        assert!(
+            row.contains("public_game_distribution_version(ctx, game)"),
+            "「有当前公开版本」必须与公开侧用同一个查法"
+        );
+        assert!(
+            !row.contains("return None"),
+            "作品行缺失的行仍要回传（title = null），否则名单与 totalMembers 对不上"
+        );
+        assert!(!row.contains(".delete("), "行快照是纯读");
+    }
+
     fn game_row(
         visibility: &str,
         owner_user_id: &str,
@@ -4413,6 +9658,7 @@ mod tests {
             cover_object_key: None,
             screenshots_json: None,
             deleted_at: None,
+            fork_authorization: "forbidden".to_string(),
             price_mud_points,
         }
     }
@@ -4446,6 +9692,8 @@ mod tests {
             idempotency_key: "proj-1:v1".to_string(),
             request_digest: "digest".to_string(),
             now_micros: 42,
+            // 默认母版：这些辅助只覆盖作品行 bootstrap/复用，不涉及血缘说明校验。
+            change_summary: None,
         }
     }
 
@@ -4589,6 +9837,133 @@ mod tests {
         assert_eq!(game.price_mud_points, 100);
     }
 
+    /// 贡献归集事务：归属 / 软删除口径、只用血缘表既有父索引、多收一点的截断信号。
+    ///
+    /// 行为证据（真实读数与截断标志）由纯函数单测 + api-server 断言承担——事务需要
+    /// `ReducerContext`，host 测试起不了真库，这里只钉住结构性不变量。
+    #[test]
+    fn contribution_tx_reads_by_parent_index_and_stays_owner_scoped() {
+        let source = include_str!("game_distribution.rs");
+        let tx = function_body(source, "fn game_distribution_contribution_tx(");
+        for required in [
+            // 非作者按既有 owner-mismatch 文案拒绝（api-server 映射 403），与其它作者侧入口同一句。
+            "\"游戏 owner 不匹配\"",
+            // 软删除按不存在处理（api-server 404），不用错误码区分「已删除」与「不存在」。
+            "deleted_at.is_some()",
+            // 计算只有一份实现：事务不自己算递归。
+            "module_game_distribution::build_contribution_breakdown",
+            "module_game_distribution::GAME_DISTRIBUTION_CONTRIBUTION_NODE_LIMIT",
+            "module_game_distribution::GAME_DISTRIBUTION_CONTRIBUTION_DEPTH_LIMIT",
+        ] {
+            assert!(tx.contains(required), "贡献归集事务缺少：{required}");
+        }
+        // 本期只做计算：事务里不得出现资金 / 分成 / 结算语义。
+        for forbidden in ["settlement", "revenue", "money", "资金"] {
+            assert!(!tx.contains(forbidden), "贡献归集事务不得引入 {forbidden}");
+        }
+
+        // 遍历只用血缘表既有索引，不新增表 / 索引，也不得扫描游戏表。
+        let collect = function_body(source, "fn collect_game_distribution_contribution_nodes(");
+        assert!(
+            collect.contains("by_game_distribution_lineage_parent_game_id()"),
+            "必须按既有父索引逐层下钻"
+        );
+        assert!(!collect.contains(".iter()"), "不得扫全表：游戏行只按主键取");
+        // 多收一条 / 多收一层：纯函数要看见「还有更多」才能如实标注截断，而不是静默给半个数。
+        assert!(
+            collect.contains("CONTRIBUTION_NODE_LIMIT + 1"),
+            "必须多收一条后代作为 node_limit 的判据"
+        );
+        assert!(
+            collect.contains("depth < depth_limit + 1"),
+            "必须多收一层作为 depth_limit 的判据"
+        );
+        // 同层按 gameId 排序后下钻：截断点确定，两次读不会换一批节点。
+        assert!(collect.contains("sort_by"), "同层必须排序，保证截断点确定");
+        // 根不在集合里的分支在事务里失败关闭（不回 404、不 panic）。
+        assert!(tx.contains("归集计算失败"));
+    }
+
+    /// 贡献归集 procedure：受信服务身份 + 单一事务 + 失败路径显式给空。
+    #[test]
+    fn contribution_procedure_requires_service_identity_and_fails_closed() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(
+            source,
+            "pub fn get_game_distribution_contribution_and_return(",
+        );
+        assert!(
+            body.contains("require_editor_generation_runtime_service_identity(tx, caller)?"),
+            "作者侧只读 procedure 同样必须要求受信服务身份"
+        );
+        assert!(body.contains("ctx.try_with_tx("));
+        assert!(body.contains("Ok(None) => GameDistributionContributionResult::not_found()"));
+
+        let start = source
+            .find("impl GameDistributionContributionResult {")
+            .expect("贡献归集失败路径必须存在");
+        let tail = &source[start..];
+        let end = tail.find("\nimpl ").unwrap_or(tail.len());
+        assert!(
+            tail[..end].contains("contribution: None"),
+            "失败 / 不存在路径必须显式给出空结果"
+        );
+        assert!(tail[..end].contains("found: false"));
+    }
+
+    /// 贡献归集快照是合同形状：只有「指标 + 归因 + 截断」三类字段，没有资金 / 分成的位置。
+    #[test]
+    fn contribution_snapshot_shape_matches_the_contract() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "pub struct GameDistributionContributionSnapshot {");
+        for field in [
+            "pub game_id:",
+            "pub own:",
+            "pub inherited:",
+            "pub total:",
+            "pub by_generation:",
+            "pub direct_children:",
+            "pub node_count:",
+            "pub truncated:",
+            "pub truncated_reason:",
+        ] {
+            assert!(body.contains(field), "贡献归集快照缺少合同字段：{field}");
+        }
+        for forbidden in ["money", "revenue", "settlement", "share"] {
+            assert!(
+                !body.contains(forbidden),
+                "本期只做计算，快照不得出现 {forbidden}"
+            );
+        }
+        // 指标集合是独立结构体：将来加指标只动它，不动递归与归因形状。
+        let totals = function_body(
+            source,
+            "pub struct GameDistributionContributionTotalsSnapshot {",
+        );
+        assert!(totals.contains("pub play_count: u64"));
+    }
+
+    /// 公开详情的**血缘摘要**必须读时联账号表取父作者名。
+    ///
+    /// 真实库缺陷：`parentTitle` 有值而 `parentAuthorName` 为 `null`（详情页溯源条要展示
+    /// 「父作品 · 作者名」，于是开天窗）。根因是这里直接用了发布时冻结的 `parent.author_name`，
+    /// 而老数据 / 程序化创建的作品上该列常为 `None`——公开投影与族谱节点早已改成读时联
+    /// `user_account`（账号昵称优先 → 退回冻结值 → 空白为 `None`），只有血缘摘要没跟上。
+    /// 归一规则复用族谱节点那一份实现（`game_distribution_lineage_author_name`），不在这里重写。
+    #[test]
+    fn lineage_summary_resolves_parent_author_name_at_read_time() {
+        let source = include_str!("game_distribution.rs");
+        let body = function_body(source, "fn game_distribution_lineage_snapshot(");
+        assert!(
+            body.contains("game_distribution_lineage_author_name(ctx, &parent)"),
+            "血缘摘要必须用「账号兜底」的作者名：{body}"
+        );
+        assert!(
+            !body.contains("parent.author_name"),
+            "不得再直接读冻结列 `parent.author_name`（老数据常为 None，会重现空作者名缺陷）：{body}"
+        );
+    }
+
     #[test]
     fn media_object_key_game_id_is_derived_without_scanning_all_games() {
         const PREFIX: &str = shared_contracts::game_distribution::GAME_DISTRIBUTION_MEDIA_PREFIX;
diff --git a/server-rs/crates/spacetime-module/src/migration.rs b/server-rs/crates/spacetime-module/src/migration.rs
index 02a838de7..31571aa96 100644
--- a/server-rs/crates/spacetime-module/src/migration.rs
+++ b/server-rs/crates/spacetime-module/src/migration.rs
@@ -215,6 +215,8 @@ macro_rules! migration_tables {
             // 定价：游戏表末尾追加 price_mud_points（默认 0），购买记录含成交价快照与钱包流水 ID。
             // 资料随版本冻结：版本表末尾追加 metadata_json，游戏表末尾追加
             // cover_object_key / screenshots_json，均为可空列，旧行按“未冻结资料”处理。
+            // 核心改动说明（共创）：版本表末尾再追加可空 change_summary（衍生作品必填、母版为
+            // NULL），随版本导出/导入——它是「这一版改了什么」的版本级事实，不是可重算的投影。
             // 媒体去 assetId 化：游戏表保留 cover_asset_id 但标记退役（不再写入、仅占位），
             // 封面/截图改用 OSS objectKey（封面 cover_object_key、截图 screenshots_json 为 objectKey 字符串数组）。
             // 软删除：游戏表末尾追加可空 deleted_at；非空表示作者已删除该作品，
@@ -226,6 +228,15 @@ macro_rules! migration_tables {
             game_distribution_review_moderation_log,
             game_distribution_version,
             game_distribution_idempotency_receipt,
+            // 作品之间的改编血缘：业务事实，随迁移导出/导入；父作品下架不删除历史行。
+            game_distribution_lineage,
+            // 用户对公开作品的收藏（收录）：真实用户态投影，随迁移导出/导入；
+            // 作品下架不删除行（读取时按当前公开性过滤，重新公开后自动回来）。
+            game_distribution_collection,
+            // 共创主题与成员：主题是运营命名实体、成员是「主题 ↔ 根作品」的运营归组事实，
+            // 随迁移导出/导入；归档 / 下架只改变公开投影，**不删除成员行**。
+            game_distribution_theme,
+            game_distribution_theme_member,
             game_distribution_purchase,
             llm_router_account,
             llm_router_billing_checkpoint,
diff --git a/src/components/common/PlatformToastHost.tsx b/src/components/common/PlatformToastHost.tsx
new file mode 100644
index 000000000..6b3d88cd3
--- /dev/null
+++ b/src/components/common/PlatformToastHost.tsx
@@ -0,0 +1,100 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+
+import { PlatformRuntimeStatusToast } from './PlatformRuntimeStatusToast';
+import {
+  normalizePlatformToast,
+  type PlatformToastInput,
+  type PlatformToastTone,
+  subscribePlatformToast,
+} from './platformToast';
+
+type ToastItem = {
+  id: number;
+  text: string;
+  tone: PlatformToastTone;
+  durationMs: number | null;
+};
+
+/** 定时器句柄：浏览器是 number、Node 下是 Timeout 对象，直接用 `clearTimeout` 的入参类型。 */
+type ToastTimerHandle = Parameters<typeof clearTimeout>[0];
+
+let toastSeed = 0;
+
+/**
+ * 轻提示宿主：在页面里**只挂一次**。
+ *
+ * - **portal 到 `body`** + `position: fixed`（右下角堆叠），因此完全不参与页面布局 ——
+ *   这正是用户口径「显示成 toast，不要在这里挤占别的元素的空间」的落点；
+ * - 视觉与无障碍复用共享组件 `PlatformRuntimeStatusToast`（`role=status`/`alert` + `aria-live`）；
+ * - 自动消失（默认 5s；**错误/警告不自动消失**）+ 每条都能手动关闭（键盘可达）；
+ * - 多条可堆叠；**不抢焦点**（除非是错误级 —— 错误级也只做 `role=alert` 播报，不 programmatic focus，
+ *   避免打断用户正在输入的内容）。
+ */
+export function PlatformToastHost() {
+  const [toasts, setToasts] = useState<ToastItem[]>([]);
+  const timersRef = useRef(new Map<number, ToastTimerHandle>());
+
+  const dismiss = useCallback((id: number) => {
+    const timer = timersRef.current.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      timersRef.current.delete(id);
+    }
+    setToasts((current) => current.filter((toast) => toast.id !== id));
+  }, []);
+
+  useEffect(() => {
+    const unsubscribe = subscribePlatformToast((input: PlatformToastInput) => {
+      if (!input.text?.trim()) return;
+      const normalized = normalizePlatformToast(input);
+      toastSeed += 1;
+      const id = toastSeed;
+      setToasts((current) => [...current.slice(-3), { id, ...normalized }]);
+      if (normalized.durationMs !== null) {
+        timersRef.current.set(
+          id,
+          setTimeout(() => dismiss(id), normalized.durationMs),
+        );
+      }
+    });
+    const timers = timersRef.current;
+    return () => {
+      unsubscribe();
+      for (const timer of timers.values()) clearTimeout(timer);
+      timers.clear();
+    };
+  }, [dismiss]);
+
+  if (toasts.length === 0) return null;
+
+  return createPortal(
+    <div className="platform-toast-host" data-testid="platform-toast-host">
+      {toasts.map((toast) => (
+        <PlatformRuntimeStatusToast
+          key={toast.id}
+          tone={toast.tone}
+          size="sm"
+          shape="rounded"
+          className="platform-toast-host__item"
+          // 错误级用 alert（立即播报），其余 status（礼貌播报）。
+          role={toast.tone === 'error' ? 'alert' : 'status'}
+          aria-live={toast.tone === 'error' ? 'assertive' : 'polite'}
+        >
+          <span className="platform-toast-host__text">{toast.text}</span>
+          <button
+            type="button"
+            className="platform-toast-host__close"
+            aria-label={`关闭提示：${toast.text}`}
+            onClick={() => dismiss(toast.id)}
+          >
+            关闭
+          </button>
+        </PlatformRuntimeStatusToast>
+      ))}
+    </div>,
+    document.body,
+  );
+}
+
+export default PlatformToastHost;
diff --git a/src/components/common/platformToast.ts b/src/components/common/platformToast.ts
new file mode 100644
index 000000000..ea67d2b7c
--- /dev/null
+++ b/src/components/common/platformToast.ts
@@ -0,0 +1,68 @@
+/**
+ * 平台级轻提示（toast）的最小总线。
+ *
+ * 为什么要有它：页面上「状态/错误/未安装提示」这类**一次性反馈**不该内联渲染在操作行里
+ * （会把同行按钮挤成两行、竖排）。这里给一个收口：任何地方 `showPlatformToast(...)`，
+ * 由唯一挂载的 `<PlatformToastHost />` 统一渲染（portal 到 `body` + 固定定位 + 自动消失 + 可手动关闭）。
+ *
+ * 视觉与无障碍**复用既有共享组件** `PlatformRuntimeStatusToast`（`role=status|alert` +
+ * `aria-live` 已由它处理），不另造一套 toast 外观。总线本身用最小的事件方案，和
+ * `clientDownloadLauncher` 同一套做法，避免为这一个能力引入全局 store。
+ */
+export type PlatformToastTone =
+  | 'info'
+  | 'success'
+  | 'warning'
+  | 'error'
+  | 'neutral';
+
+export type PlatformToastInput = {
+  text: string;
+  tone?: PlatformToastTone;
+  /** 自动消失毫秒数；`null` = 不自动消失（错误类默认如此，只能手动关）。 */
+  durationMs?: number | null;
+};
+
+export const PLATFORM_TOAST_EVENT = 'genarrative:platform-toast';
+
+/** 默认自动消失时间；错误类不自动消失（见 `normalizeToast`）。 */
+export const PLATFORM_TOAST_DEFAULT_DURATION_MS = 5000;
+
+export function normalizePlatformToast(input: PlatformToastInput): {
+  text: string;
+  tone: PlatformToastTone;
+  durationMs: number | null;
+} {
+  const tone = input.tone ?? 'info';
+  const durationMs =
+    input.durationMs === undefined
+      ? // 错误/警告都要用户看清，默认不自动消失；其余 5s 消失。
+        tone === 'error' || tone === 'warning'
+        ? null
+        : PLATFORM_TOAST_DEFAULT_DURATION_MS
+      : input.durationMs;
+  return { text: input.text, tone, durationMs };
+}
+
+/** 弹一条轻提示（等价于把文案交给唯一的 toast 宿主）。 */
+export function showPlatformToast(input: PlatformToastInput | string) {
+  if (typeof window === 'undefined') return;
+  const payload = typeof input === 'string' ? { text: input } : input;
+  window.dispatchEvent(
+    new CustomEvent<PlatformToastInput>(PLATFORM_TOAST_EVENT, {
+      detail: payload,
+    }),
+  );
+}
+
+/** 订阅轻提示请求；返回取消订阅函数。 */
+export function subscribePlatformToast(
+  handler: (input: PlatformToastInput) => void,
+) {
+  if (typeof window === 'undefined') return () => {};
+  const listener = (event: Event) => {
+    handler((event as CustomEvent<PlatformToastInput>).detail ?? { text: '' });
+  };
+  window.addEventListener(PLATFORM_TOAST_EVENT, listener);
+  return () => window.removeEventListener(PLATFORM_TOAST_EVENT, listener);
+}
diff --git a/src/components/creation-home/ClientDownloadEntry.test.tsx b/src/components/creation-home/ClientDownloadEntry.test.tsx
index 36a3df98a..57a546922 100644
--- a/src/components/creation-home/ClientDownloadEntry.test.tsx
+++ b/src/components/creation-home/ClientDownloadEntry.test.tsx
@@ -12,6 +12,7 @@ import {
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { ClientDownloadEntry } from './ClientDownloadEntry';
+import { requestClientDownload } from './clientDownloadLauncher';
 
 const fetchMock = vi.fn();
 const installerUrl = (version: string) =>
@@ -39,6 +40,30 @@ const macDownload = (architecture: 'aarch64' | 'x86_64') => ({
 });
 
 describe('官网下载入口', () => {
+  it('任何地方请求下载入口都能打开同一个弹窗（开始共创未检测到客户端时的落点）', async () => {
+    fetchMock.mockResolvedValueOnce(releaseResponse('0.2.0'));
+    render(<ClientDownloadEntry />);
+
+    // 还没点：不请求、不渲染弹窗。
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(screen.queryByText(/最新版本/u)).toBeNull();
+
+    act(() => {
+      requestClientDownload();
+    });
+
+    // 与点「下载客户端」完全一样：拉取 /api/client-downloads 并给出平台下载链接。
+    expect(
+      (
+        await screen.findByRole('link', { name: '下载 Windows 版' })
+      ).getAttribute('href'),
+    ).toBe(installerUrl('0.2.0'));
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/client-downloads',
+      expect.objectContaining({ cache: 'no-store' }),
+    );
+  });
+
   beforeEach(() => {
     fetchMock.mockReset();
     vi.stubGlobal('fetch', fetchMock);
diff --git a/src/components/creation-home/ClientDownloadEntry.tsx b/src/components/creation-home/ClientDownloadEntry.tsx
index 6d228ec92..0c4e18be4 100644
--- a/src/components/creation-home/ClientDownloadEntry.tsx
+++ b/src/components/creation-home/ClientDownloadEntry.tsx
@@ -11,6 +11,7 @@ import { PlatformActionButton } from '../common/PlatformActionButton';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
 import { PlatformSubpanel } from '../common/PlatformSubpanel';
 import { UnifiedModal } from '../common/UnifiedModal';
+import { subscribeClientDownloadRequest } from './clientDownloadLauncher';
 
 const DOWNLOAD_ERROR = '暂时无法获取最新版本，请稍后重试';
 
@@ -47,6 +48,9 @@ export function ClientDownloadEntry({
   const [attempt, setAttempt] = useState(0);
   const [state, setState] = useState<DownloadState>({ status: 'loading' });
 
+  // 「开始共创」检测不到客户端时也会打开这里：同一个下载入口，不另写一套下载页。
+  useEffect(() => subscribeClientDownloadRequest(() => setOpen(true)), []);
+
   useEffect(() => {
     if (!open) return;
     const controller = new AbortController();
diff --git a/src/components/creation-home/clientDownloadLauncher.ts b/src/components/creation-home/clientDownloadLauncher.ts
new file mode 100644
index 000000000..c9d0b1052
--- /dev/null
+++ b/src/components/creation-home/clientDownloadLauncher.ts
@@ -0,0 +1,26 @@
+/**
+ * 「打开客户端下载入口」的跨组件触发器。
+ *
+ * 为什么需要它：下载 UI（`ClientDownloadEntry`）自带弹窗与 `/api/client-downloads` 取数逻辑，
+ * 而「开始共创」在检测不到客户端时也要落到**同一个**下载入口（不能自己再写一套下载页/直链）。
+ * 这里用最小的进程内事件做收口：任何地方 `requestClientDownload()`，挂着的下载入口自己打开，
+ * 平台顶栏那个「下载客户端」按钮仍然是同一个组件、同一个目标。
+ *
+ * 局限（有意为之）：纯 web 拿不到系统级「是否安装」信息，所以这只是「把用户送到正确的下载入口」，
+ * 不做任何安装状态的判定或缓存。
+ */
+export const CLIENT_DOWNLOAD_REQUEST_EVENT = 'genarrative:open-client-download';
+
+/** 打开客户端下载入口（与顶栏「下载客户端」同一个弹窗）。 */
+export function requestClientDownload() {
+  if (typeof window === 'undefined') return;
+  window.dispatchEvent(new Event(CLIENT_DOWNLOAD_REQUEST_EVENT));
+}
+
+/** 订阅下载入口请求；返回取消订阅函数。 */
+export function subscribeClientDownloadRequest(handler: () => void) {
+  if (typeof window === 'undefined') return () => {};
+  window.addEventListener(CLIENT_DOWNLOAD_REQUEST_EVENT, handler);
+  return () =>
+    window.removeEventListener(CLIENT_DOWNLOAD_REQUEST_EVENT, handler);
+}
diff --git a/src/components/creator/CreatorPage.tsx b/src/components/creator/CreatorPage.tsx
index 3d462a2e6..072614f83 100644
--- a/src/components/creator/CreatorPage.tsx
+++ b/src/components/creator/CreatorPage.tsx
@@ -71,12 +71,17 @@ function CreatorProfileContent({
   const [profile, setProfile] = useState<CreatorProfile | null>(null);
   const [error, setError] = useState('');
   const [games, setGames] = useState<GameDistributionGame[] | null>(null);
+  /** 下一页游标（公开目录真分页）：非空才渲染「加载更多」。 */
+  const [nextCursor, setNextCursor] = useState<string | null>(null);
+  const [isLoadingMore, setIsLoadingMore] = useState(false);
+  const [loadMoreError, setLoadMoreError] = useState('');
   const [gameError, setGameError] = useState('');
   const serial = useRef(0);
   const load = useCallback(() => {
     const request = ++serial.current;
     setError('');
     setGameError('');
+    setLoadMoreError('');
     void getCreator(id)
       .then((value) => {
         if (serial.current === request) setProfile(value);
@@ -85,13 +90,45 @@ function CreatorProfileContent({
         if (serial.current === request) setError(reason.message);
       });
     void listGames({ authorId: id })
-      .then((value) => {
-        if (serial.current === request) setGames(value);
+      .then((page) => {
+        if (serial.current !== request) return;
+        setGames(page.games);
+        setNextCursor(page.nextCursor);
       })
       .catch((reason) => {
         if (serial.current === request) setGameError(reason.message);
       });
   }, [id]);
+  /**
+   * 创作者主页的「加载更多」：与广场同一套（游标原样回传、按 gameId 去重追加、
+   * 失败保留已加载内容）。创作者的作品同样可能超过一页（默认 48）。
+   */
+  const loadMoreGames = useCallback(() => {
+    if (!nextCursor || isLoadingMore) return;
+    const request = serial.current;
+    setIsLoadingMore(true);
+    setLoadMoreError('');
+    void listGames({ authorId: id, cursor: nextCursor })
+      .then((page) => {
+        if (serial.current !== request) return;
+        setGames((current) => {
+          const base = current ?? [];
+          const seen = new Set(base.map((game) => game.id));
+          const appended = page.games.filter((game) => !seen.has(game.id));
+          return appended.length === 0 ? base : [...base, ...appended];
+        });
+        setNextCursor(page.nextCursor);
+      })
+      .catch((reason) => {
+        if (serial.current !== request) return;
+        setLoadMoreError(
+          reason instanceof Error ? reason.message : '加载下一页失败',
+        );
+      })
+      .finally(() => {
+        if (serial.current === request) setIsLoadingMore(false);
+      });
+  }, [id, isLoadingMore, nextCursor]);
   useEffect(() => {
     load();
     window.addEventListener('focus', load);
@@ -161,16 +198,35 @@ function CreatorProfileContent({
           ) : games.length === 0 ? (
             <p>还没有公开游戏</p>
           ) : (
-            <div className="game-grid">
-              {games.map((game) => (
-                <GameCard
-                  key={game.id}
-                  game={game}
-                  cover={<GameCover game={game} />}
-                  onOpen={() => onOpenGame(game.id)}
-                />
-              ))}
-            </div>
+            <>
+              <div className="game-grid">
+                {games.map((game) => (
+                  <GameCard
+                    key={game.id}
+                    game={game}
+                    cover={<GameCover game={game} />}
+                    onOpen={() => onOpenGame(game.id)}
+                  />
+                ))}
+              </div>
+              {nextCursor || loadMoreError ? (
+                <div className="game-empty-actions">
+                  {loadMoreError ? (
+                    <span role="status">{loadMoreError}</span>
+                  ) : null}
+                  {nextCursor ? (
+                    <button
+                      type="button"
+                      className="creator-follow"
+                      disabled={isLoadingMore}
+                      onClick={() => void loadMoreGames()}
+                    >
+                      {isLoadingMore ? '正在加载…' : '加载更多'}
+                    </button>
+                  ) : null}
+                </div>
+              ) : null}
+            </>
           )}
         </>
       )}
diff --git a/src/components/creator/CreatorPages.test.tsx b/src/components/creator/CreatorPages.test.tsx
index 2db17b131..84cf1d96b 100644
--- a/src/components/creator/CreatorPages.test.tsx
+++ b/src/components/creator/CreatorPages.test.tsx
@@ -11,10 +11,42 @@ import {
 import { afterEach, beforeEach, expect, it, vi } from 'vitest';
 
 import type { CreatorConnection } from '../../../packages/shared/src/contracts/creator';
+import type { GameDistributionGame } from '../../services/gameDistributionClient';
 import { CreatorConnectionsPage } from './CreatorConnectionsPage';
 import { CreatorPage } from './CreatorPage';
 import { CreatorAuthor } from './CreatorRelationshipControl';
 import { seedRelationship, setCreatorViewer } from './creatorRelationshipState';
+
+/** 主页公开游戏列表的最小公开投影（分页用例只需要 id / 标题 / 封面位）。 */
+function createGame(
+  overrides: Partial<GameDistributionGame> = {},
+): GameDistributionGame {
+  return {
+    id: 'game-1',
+    title: '作品',
+    summary: '',
+    description: '',
+    category: '动作',
+    tags: [],
+    coverColor: '#d77a51',
+    icon: '✦',
+    author: { id: 'a', name: '作者' },
+    deviceSupport: { desktop: true, mobile: true, touch: true },
+    status: 'published',
+    publicationRevision: 1,
+    currentVersion: {
+      id: 'version-1',
+      version: '1.0.0',
+      entryUrl: 'https://play.example.test/v1/index.html',
+      sha256: 'sha256',
+      publishedAt: '2026-09-18T00:00:00.000Z',
+      controls: ['键盘'],
+    },
+    playCount: 0,
+    createdAt: '2026-09-18T00:00:00.000Z',
+    ...overrides,
+  } as GameDistributionGame;
+}
 const api = vi.hoisted(() => ({
   viewer: 'a' as string | null,
   list: vi.fn(),
@@ -78,7 +110,7 @@ beforeEach(() => {
   api.read.mockResolvedValue({ relationship: following });
   api.list.mockResolvedValue({ items: [row()], nextCursor: null, total: 1 });
   api.profile.mockResolvedValue({ user, followingCount: 1, followerCount: 2 });
-  api.games.mockResolvedValue([]);
+  api.games.mockResolvedValue({ games: [], nextCursor: null });
 });
 afterEach(cleanup);
 it.each(['following', 'followers'] as const)(
@@ -196,6 +228,52 @@ it('主页查询作者游戏，自己不显示关注按钮，空游戏仍有主
   fireEvent.click(screen.getByRole('link', { name: '2 粉丝' }));
   expect(callbacks.onOpenConnections).toHaveBeenCalledWith('a', 'followers');
 });
+it('主页作品列表支持游标「加载更多」：去重追加、末页隐藏入口、失败保留内容', async () => {
+  api.games
+    .mockResolvedValueOnce({
+      games: [
+        createGame({ id: 'game-1', title: '作者第一款' }),
+        createGame({ id: 'game-2', title: '作者第二款' }),
+      ],
+      nextCursor: 'c1',
+    })
+    .mockRejectedValueOnce(new Error('网络开小差了'))
+    .mockResolvedValueOnce({
+      // 第二页故意含重复 id
+      games: [
+        createGame({ id: 'game-2', title: '作者第二款' }),
+        createGame({ id: 'game-3', title: '作者第三款' }),
+      ],
+      nextCursor: null,
+    });
+  render(
+    <CreatorPage
+      id="a"
+      onOpenConnections={callbacks.onOpenConnections}
+      onOpenGame={vi.fn()}
+      onBack={vi.fn()}
+    />,
+  );
+
+  await screen.findByText('作者第一款');
+  expect(api.games).toHaveBeenCalledWith({ authorId: 'a' });
+  // 有下一页就露出「加载更多」。
+  fireEvent.click(await screen.findByRole('button', { name: '加载更多' }));
+  // 失败不清空已加载内容，只提示。
+  expect(await screen.findByText('网络开小差了')).toBeTruthy();
+  expect(screen.getByText('作者第一款')).toBeTruthy();
+
+  // 重试成功：追加去重（game-2 不重复）、末页隐藏入口。
+  fireEvent.click(screen.getByRole('button', { name: '加载更多' }));
+  await screen.findByText('作者第三款');
+  expect(api.games.mock.calls[1]?.[0]).toEqual({
+    authorId: 'a',
+    cursor: 'c1',
+  });
+  expect(screen.getAllByText('作者第二款')).toHaveLength(1);
+  expect(screen.queryByRole('button', { name: '加载更多' })).toBeNull();
+  expect(screen.queryByText('网络开小差了')).toBeNull();
+});
 it('游客点击关注仅唤起登录，自己作者也能打开主页', async () => {
   api.viewer = null;
   const view = render(
diff --git a/src/components/game-distribution/CoCreationLineageSection.tsx b/src/components/game-distribution/CoCreationLineageSection.tsx
new file mode 100644
index 000000000..f17d11362
--- /dev/null
+++ b/src/components/game-distribution/CoCreationLineageSection.tsx
@@ -0,0 +1,73 @@
+import { useRef, useState } from 'react';
+
+import { GameLineagePage } from './GameLineagePage';
+import { LineageFullscreenOverlay } from './LineageFullscreenOverlay';
+
+/**
+ * 详情页正文之后的**整宽血缘图区块**。
+ *
+ * 需求（2026-10-06）：「这个图可能非常大，不建议放在侧边栏里」→ 从 ~230px 的共创信息卡里
+ * 搬到正文之后，直接展示与这部作品相关的**整棵树**。
+ *
+ * 渲染**就是**族谱页组件（`GameLineagePage embedded`）：树查询、可见性过滤（未公开 / 已删不出现）、
+ * 布局与连线、移动端大纲形态、初始定位到当前作品全部复用同一份实现，详情页不引入第二套树渲染。
+ * 区块自己只负责：标题 + 「全屏查看族谱」入口（复用共创卡的按钮样式），并把当前作品作为
+ * 高亮锚点传下去——图里因此会标出「当前作品」、高亮它的父代（祖先链）与子代。
+ */
+export function CoCreationLineageSection({
+  rootGameId,
+  currentGameId,
+  onOpenGameDetail,
+}: {
+  /** 树的作用域：当前作品所在分支的**根**（详情 DTO 的 `lineage.rootGameId`）；默认展示以根为顶的整棵树。 */
+  rootGameId: string;
+  /** 当前作品：作为高亮锚点与「父代 / 子代」区分的基准。 */
+  currentGameId: string;
+  onOpenGameDetail: (gameId: string) => void;
+}) {
+  const [isFullscreen, setIsFullscreen] = useState(false);
+  const triggerRef = useRef<HTMLButtonElement>(null);
+  return (
+    <section className="game-lineage-block" aria-label="创作血缘">
+      <div className="game-lineage-block__heading">
+        <div className="game-lineage-block__title">
+          <span className="game-eyebrow">创作血缘</span>
+          <h2>这部作品的血缘图</h2>
+        </div>
+        <button
+          ref={triggerRef}
+          type="button"
+          className="game-fork-lineage-link"
+          aria-haspopup="dialog"
+          aria-expanded={isFullscreen}
+          onClick={() => setIsFullscreen(true)}
+        >
+          全屏查看族谱
+        </button>
+      </div>
+      {/*
+        全屏时**卸载**内嵌那棵树：同一棵树的两次渲染既重复请求又可能与 overlay 抢事件，
+        用户此刻看的就是 overlay 里的那一份。
+      */}
+      {isFullscreen ? null : (
+        <GameLineagePage
+          embedded
+          rootGameId={rootGameId}
+          highlightGameId={currentGameId}
+          onOpenDetail={onOpenGameDetail}
+        />
+      )}
+      {isFullscreen ? (
+        <LineageFullscreenOverlay
+          rootGameId={rootGameId}
+          currentGameId={currentGameId}
+          onOpenGameDetail={onOpenGameDetail}
+          onClose={() => setIsFullscreen(false)}
+          triggerRef={triggerRef}
+        />
+      ) : null}
+    </section>
+  );
+}
+
+export default CoCreationLineageSection;
diff --git a/src/components/game-distribution/GameComparePage.tsx b/src/components/game-distribution/GameComparePage.tsx
new file mode 100644
index 000000000..147688f08
--- /dev/null
+++ b/src/components/game-distribution/GameComparePage.tsx
@@ -0,0 +1,207 @@
+import './gameDistribution.css';
+
+import { ArrowLeft } 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,
+} from './gameDistributionGuards';
+import { GamePlayFrame } from './GamePlayFrame';
+import { useGameAuthorDisplayName } from './useGameAuthorName';
+
+type GameComparePageProps = {
+  leftGameId: string | null;
+  rightGameId: string | null;
+  onBack: () => void;
+  onOpenDetail: (gameId: string) => void;
+};
+
+function generationLabel(game: GameDistributionGame) {
+  const generation = game.lineage?.generation ?? 0;
+  return generation === 0 ? '母版' : `第 ${generation} 代`;
+}
+
+/**
+ * 单侧对比栏：自己负责取数与降级，不阻塞另一侧。
+ *
+ * 作品不可读（不存在 / 未公开 / 已软删除）时给出明确文案而不是空白——与族谱页同一口径：
+ * 公开页面不展示未公开作品，也不假装它存在。
+ */
+function GameCompareSide({
+  role,
+  gameId,
+  onOpenDetail,
+}: {
+  role: '原版' | '二创';
+  gameId: string | null;
+  onOpenDetail: (gameId: string) => void;
+}) {
+  const normalizedGameId = normalizeGameId(gameId);
+  const [game, setGame] = useState<GameDistributionGame | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState('');
+  const [isFrameReady, setIsFrameReady] = useState(false);
+  const requestSerialRef = useRef(0);
+  const authorName = useGameAuthorDisplayName(game?.author);
+
+  const loadGame = useCallback(() => {
+    const requestSerial = ++requestSerialRef.current;
+    setIsFrameReady(false);
+    setGame(null);
+    setError('');
+    if (!normalizedGameId) {
+      setIsLoading(false);
+      setError('缺少作品编号');
+      return;
+    }
+    setIsLoading(true);
+    void getGame(normalizedGameId)
+      .then((value) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        if (!value) {
+          setError('这部作品不可读或未公开');
+          return;
+        }
+        setGame(value);
+      })
+      .catch((loadError: unknown) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setError(
+          loadError instanceof Error
+            ? loadError.message
+            : '这部作品不可读或未公开',
+        );
+      })
+      .finally(() => {
+        if (requestSerial === requestSerialRef.current) setIsLoading(false);
+      });
+  }, [normalizedGameId]);
+
+  useEffect(() => {
+    loadGame();
+    return () => {
+      requestSerialRef.current += 1;
+    };
+  }, [loadGame]);
+
+  const entryUrl = game?.currentVersion
+    ? normalizeGameEntryUrl(game.currentVersion.entryUrl)
+    : '';
+
+  return (
+    <section className="game-compare-side" aria-label={role}>
+      <header className="game-compare-side__head">
+        <span className="game-compare-side__role">{role}</span>
+        <h3 className="game-compare-side__title">
+          {game?.title?.trim() || '（未命名作品）'}
+        </h3>
+        {game ? (
+          <p className="game-compare-side__meta">
+            <span>{authorName?.trim() || '未署名作者'}</span>
+            <span aria-hidden="true">·</span>
+            <span>{generationLabel(game)}</span>
+          </p>
+        ) : null}
+      </header>
+      {isLoading ? (
+        <div className="game-loading-panel">正在加载作品…</div>
+      ) : error || !game ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          <span>{error || '这部作品不可读或未公开'}</span>
+          {normalizedGameId ? (
+            <button
+              type="button"
+              className="game-lineage-retry"
+              onClick={() => loadGame()}
+            >
+              重试
+            </button>
+          ) : null}
+        </PlatformStatusMessage>
+      ) : !entryUrl ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          <span>这部作品暂无可玩版本，无法并排对比。</span>
+          <button
+            type="button"
+            className="game-lineage-retry"
+            onClick={() => onOpenDetail(game.id)}
+          >
+            查看详情
+          </button>
+        </PlatformStatusMessage>
+      ) : (
+        <div className="game-compare-side__frame">
+          <GamePlayFrame
+            entryUrl={entryUrl}
+            title={`${game.title} 在线游玩`}
+            ready={isFrameReady}
+            onLoad={() => setIsFrameReady(true)}
+          />
+        </div>
+      )}
+    </section>
+  );
+}
+
+/**
+ * 「原版与二创对比」页：左侧原版（父作品）、右侧二创（当前作品），各自独立取数与降级。
+ *
+ * 公开只读页面，不触发登录门禁；iframe 复用游玩页同一份嵌入组件（`GamePlayFrame`），
+ * 因此发行入口口径与安全属性不会与游玩页漂移。
+ */
+export function GameComparePage({
+  leftGameId,
+  rightGameId,
+  onBack,
+  onOpenDetail,
+}: GameComparePageProps) {
+  return (
+    <div className="game-page game-compare-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>
+        <PlatformActionButton
+          tone="secondary"
+          size="sm"
+          shape="pill"
+          onClick={() => {
+            const target = normalizeGameId(leftGameId);
+            if (target) onOpenDetail(target);
+          }}
+          disabled={!normalizeGameId(leftGameId)}
+        >
+          查看原版详情
+        </PlatformActionButton>
+      </div>
+      <div className="game-compare-grid">
+        <GameCompareSide
+          role="原版"
+          gameId={leftGameId}
+          onOpenDetail={onOpenDetail}
+        />
+        <GameCompareSide
+          role="二创"
+          gameId={rightGameId}
+          onOpenDetail={onOpenDetail}
+        />
+      </div>
+      <p className="game-detail-footnote">
+        两侧各自加载：任一侧不可读或没有可玩版本时只降级那一侧，不影响另一侧。
+      </p>
+    </div>
+  );
+}
+
+export default GameComparePage;
diff --git a/src/components/game-distribution/GameDetailPage.tsx b/src/components/game-distribution/GameDetailPage.tsx
index e8d9fdecf..793a349d0 100644
--- a/src/components/game-distribution/GameDetailPage.tsx
+++ b/src/components/game-distribution/GameDetailPage.tsx
@@ -6,33 +6,51 @@ import {
 } from '@genarrative/shared/components';
 import { ArrowLeft, Gamepad2, Maximize2 } from 'lucide-react';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
 
-import type {
-  GameDistributionRecoveryAction,
-  GameDistributionVersionSummary,
+import {
+  GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS,
+  type GameDistributionRecoveryAction,
+  type GameDistributionVersionSummary,
+  resolveGameForkAuthorization,
 } from '../../../packages/shared/src/contracts/gameDistribution';
 import { ApiClientError } from '../../services/apiClient';
 import {
   type GameDistributionGame,
   type GameDistributionInputMode,
+  type GameDistributionLineageNode,
   type GameDistributionMyGame,
   type GameDistributionVersionStatusEntry,
+  getDerivedGames,
   getGame,
+  getGameLineage,
   getMyGame,
   loadVersionRecoveryActions,
   purchaseGame,
+  setGameCollection,
 } from '../../services/gameDistributionClient';
 import { usePlatformWalletStore } from '../../stores/usePlatformWalletStore';
 import { useAuthUi } from '../auth/AuthUiContext';
+import { CopyFeedbackButton } from '../common/CopyFeedbackButton';
 import { PlatformActionButton } from '../common/PlatformActionButton';
 import { PlatformMudPointConfirmDialog } from '../common/PlatformMudPointConfirmDialog';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import { showPlatformToast } from '../common/platformToast';
+import { PlatformToastHost } from '../common/PlatformToastHost';
+import { useCopyFeedback } from '../common/useCopyFeedback';
+import { requestClientDownload } from '../creation-home/clientDownloadLauncher';
 import { CreatorAuthor } from '../creator/CreatorRelationshipControl';
+import { coCreationGenerationTagLabel } from './coCreationCopy';
+import { CoCreationLineageSection } from './CoCreationLineageSection';
 import {
   normalizeGameEntryUrl,
   normalizeGameId,
   useIsMobileViewport,
 } from './gameDistributionGuards';
+import {
+  FORK_LAUNCH_FALLBACK_DELAY_MS,
+  openForkProtocol,
+} from './gameForkProtocol';
 import { GAME_METADATA_INPUT_MODE_LABELS } from './gameMetadataOptions';
 import { GameRatingSummary, GameReviews } from './GameReviews';
 import { GameVersionHistory } from './GameVersionHistory';
@@ -42,6 +60,13 @@ import {
   VERSION_STATUS_LABEL,
   VERSION_STATUS_NEEDS_AUTHOR_ACTION,
 } from './gameVersionHistoryModel';
+import { isCoCreator, resolveGameViewerContext } from './gameViewerRole';
+import {
+  collectLineageAncestorChain,
+  collectLineagePlayCountTotals,
+  collectLineageSubtreeDepth,
+  type LineagePlayCountBreakdown,
+} from './lineageTreeLayout';
 import { useGameAuthorDisplayName } from './useGameAuthorName';
 import { useGameDistributionMediaReadUrl } from './useGameDistributionMediaReadUrl';
 import { useGameReviews } from './useGameReviews';
@@ -51,6 +76,20 @@ type GameDetailPageProps = {
   onBack: () => void;
   onPlay: (gameId: string) => void;
   onOpenCreator?: (id: string) => void;
+  /**
+   * 打开创作族谱页；参数是根作品 ID 与「当前作品」ID（用于族谱页高亮）。
+   * 回调缺失时不渲染族谱入口（测试或没有导航能力的宿主）。
+   */
+  onOpenLineage?: (rootGameId: string, fromGameId?: string) => void;
+  /**
+   * 打开「原版与二创对比」页；参数是原版（父作品）与二创（当前作品）。
+   * 只有存在父作品的二创作品才渲染该入口。
+   */
+  onOpenCompare?: (leftGameId: string, rightGameId: string) => void;
+  /** 打开所属共创主题页（`/games/theme?id=<themeId>`）。 */
+  onOpenTheme?: (themeId: string) => void;
+  /** 打开另一部作品的详情页（血缘溯源条 / 热门衍生卡片跳转用）。 */
+  onOpenGameDetail?: (gameId: string) => void;
   /**
    * 打开平台充值面板；余额不足以购买付费作品时由宿主提供入口。
    * 宿主没有充值能力时（例如独立嵌入）传入空值，页面只保留余额提示。
@@ -66,6 +105,13 @@ type GameDetailPageProps = {
   ownerView?: boolean;
 };
 
+let collectionKeySeed = 0;
+
+/** 每次收藏尝试一个幂等键：同一次尝试重试时键不变，重复点击则算新的意图。 */
+function createCollectionKey(gameId: string) {
+  collectionKeySeed += 1;
+  return `game-collection:${gameId}:${collectionKeySeed}`;
+}
 /** 购买后的页面级反馈：成功、余额不足（带充值入口）与失败共用一套展示。 */
 type GamePurchaseNotice = {
   tone: 'info' | 'error';
@@ -136,11 +182,27 @@ function GameDetailResolvedAsset({
   );
 }
 
+/**
+ * 详情页的**入口来源**：导航层写在 URL 上的 `from`（`/games/detail?id=…&from=co-creation`）。
+ *
+ * 为什么用 query 而不是内存里的 stage：刷新 / 深链 / 分享链接都要稳定，
+ * 而 stage 只活在内存里（`/games/detail` 刷新后 stage 仍是 `game-detail`，来源会丢）。
+ * 非浏览器环境按「没有来源」处理 ⇒ 玩家侧。
+ */
+function readDetailEntrySource() {
+  if (typeof window === 'undefined') return null;
+  return new URLSearchParams(window.location.search).get('from');
+}
+
 export function GameDetailPage({
   gameId,
   onBack,
   onPlay,
+  onOpenLineage,
   onOpenCreator,
+  onOpenCompare,
+  onOpenTheme,
+  onOpenGameDetail,
   onOpenRecharge,
   ownerView = false,
 }: GameDetailPageProps) {
@@ -424,6 +486,11 @@ export function GameDetailPage({
         onLogin={() => authUi?.openLoginModal()}
         onBack={onBack}
         onPlay={onPlay}
+        onOpenLineage={onOpenLineage}
+        onOpenCompare={onOpenCompare}
+        onOpenTheme={onOpenTheme}
+        onOpenGameDetail={onOpenGameDetail}
+        isAuthenticated={Boolean(authUi?.user)}
       />
       <PlatformMudPointConfirmDialog
         open={isPurchaseDialogOpen}
@@ -455,6 +522,7 @@ function GameDetailContent({
   recoveryActions,
   isMobileViewport,
   canReview,
+  isAuthenticated,
   isPurchasing,
   purchaseNotice,
   onOpenPurchase,
@@ -462,7 +530,11 @@ function GameDetailContent({
   onLogin,
   onBack,
   onPlay,
+  onOpenLineage,
   onOpenCreator,
+  onOpenCompare,
+  onOpenTheme,
+  onOpenGameDetail,
 }: {
   game: GameDistributionGame;
   ownerView: boolean;
@@ -470,6 +542,8 @@ function GameDetailContent({
   recoveryActions: Record<string, GameDistributionRecoveryAction>;
   isMobileViewport: boolean;
   canReview: boolean;
+  /** 是否已登录；未登录时「改造这个作品」按仓库既有门禁显示「登录后可改造」并触发登录弹窗。 */
+  isAuthenticated: boolean;
   isPurchasing: boolean;
   purchaseNotice: GamePurchaseNotice | null;
   onOpenPurchase: () => void;
@@ -477,8 +551,25 @@ function GameDetailContent({
   onLogin: () => void;
   onBack: () => void;
   onPlay: (gameId: string) => void;
+  onOpenLineage?: (rootGameId: string, fromGameId?: string) => void;
   onOpenCreator?: (id: string) => void;
+  onOpenCompare?: (leftGameId: string, rightGameId: string) => void;
+  onOpenTheme?: (themeId: string) => void;
+  onOpenGameDetail?: (gameId: string) => void;
 }) {
+  /**
+   * 观看者所处的**入口上下文**（2026-10-07 产品口径更正：游客 = 点开游戏界面的玩家，
+   * 不是「未登录访客」）：由导航层写在 URL 上的来源决定，**与登录态无关**；
+   * 作者本人进自己的作品（`?owner=1`）**一律算共创者侧**。
+   * **判据只有一处**（`resolveGameViewerContext` + `isCoCreator`，见该模块的说明），
+   * 页面上所有差异都用这一个布尔量驱动，不在 JSX 里散写来源判断。
+   */
+  const coCreator = isCoCreator(
+    resolveGameViewerContext({
+      source: readDetailEntrySource(),
+      isAuthorViewer: ownerView,
+    }),
+  );
   /**
    * 只有已公开作品才有公开评价/评分投影；审核中、审核未通过、未公开、已下架
    * 一律不请求评价接口，封面位改为状态文案。
@@ -490,9 +581,23 @@ function GameDetailContent({
    * （见 useGameAuthorName）；查不到时不显示昵称，仍保留头像、主页入口和关注操作。
    */
   const authorName = useGameAuthorDisplayName(game.author);
+  /**
+   * 游玩次数的**显示**口径（2026-10-06）：父代展示的是「自己 + 全部后代的合计」。
+   * 用详情页本来就拿到的这棵 `/lineage` 树**在前端算**（零额外请求、服务端零改动），
+   * 整棵树的分解都留着，因为「热门衍生栏」也要显示各自子树的合计。
+   * 树还没回来 / 拿不到时为 `null`，各处回退成服务端的**自身值**，并且不说「含衍生」。
+   */
+  const [lineageTotals, setLineageTotals] = useState<ReadonlyMap<
+    string,
+    LineagePlayCountBreakdown
+  > | null>(null);
+  const playCountBreakdown = lineageTotals?.get(game.id) ?? null;
   const displayGame = {
     ...game,
     author: { ...game.author, name: authorName ?? '' },
+    // hero 的「N 次游玩」按同口径显示**子树合计**；树还没回来时回退服务端自身值
+    // （公开接口的 `playCount` 字段本身仍是自身值，这里只改展示）。
+    playCount: playCountBreakdown?.total ?? game.playCount,
   };
   /** 作者视角的条目没有公开投影 `currentVersion`，可玩版本取版本历史里的已发布版本。 */
   const publishedVersion =
@@ -508,6 +613,236 @@ function GameDetailContent({
     ? ''
     : resolveNonPublicCoverLabel(game.status, latestVersion?.status);
   const latestReviewReason = latestVersion?.reviewReason?.trim() ?? '';
+  const forkAuthorization = resolveGameForkAuthorization(
+    game.forkAuthorization,
+  );
+  const lineage = game.lineage ?? null;
+  const forkCount = game.forkCount ?? 0;
+  // 所属共创主题：匿名也返回；没有主题时是空数组（不渲染空容器）。
+  const themes = game.themes ?? [];
+  /**
+   * 共创模块的附加数据：血缘链（根 → … → 当前）与热门衍生（`/derived`）。
+   * 两者都是**公开读接口**，失败只影响这一块，不影响作品主信息（各自 catch 成空）。
+   */
+  const [lineageChain, setLineageChain] = useState<
+    GameDistributionLineageNode[]
+  >([]);
+  const [derivedNodes, setDerivedNodes] = useState<
+    GameDistributionLineageNode[]
+  >([]);
+  /**
+   * 正文之后那块整宽血缘图是否渲染：**共创者**（游客整块不渲染）+ 公开可见 +
+   * 有可跳转详情的回调 + **确实有亲戚**（有父代链或已有衍生作品）。
+   * 孤立原创作品的详情页不该多出一块只有一个节点的图。
+   * 游客口径：血缘/族谱是「共创者」的结构信息，游客（只玩游戏）不渲染图、也不渲染图下的父代/子代清单。
+   */
+  const showLineageBlock =
+    coCreator &&
+    publiclyVisible &&
+    Boolean(onOpenGameDetail) &&
+    (lineageChain.length > 1 || derivedNodes.length > 0);
+  /**
+   * 「累计创作世代数」＝**本作品子树的深度**（子树最大代际 − 本作品代际）。
+   * 用详情页已经拿到的 `/lineage` 同一份数据在前端算，不发新请求；
+   * 空树 / 只有自己时是 0（界面上给出「暂无衍生」文案）。
+   */
+  const [descendantDepth, setDescendantDepth] = useState<number | null>(null);
+  const loadCoCreationData = useCallback(async () => {
+    if (!publiclyVisible) {
+      setLineageChain([]);
+      setDerivedNodes([]);
+      setLineageTotals(null);
+      return;
+    }
+    // 每个调用各自兜底（含同步抛错）：附加数据失败不能影响作品主信息。
+    const [tree, derived] = await Promise.all([
+      (async () => {
+        try {
+          return await getGameLineage(game.id);
+        } catch {
+          return null;
+        }
+      })(),
+      (async () => {
+        try {
+          return await getDerivedGames(game.id);
+        } catch {
+          return null;
+        }
+      })(),
+    ]).catch(() => [null, null] as const);
+    setLineageChain(
+      tree ? collectLineageAncestorChain(tree.nodes, game.id) : [],
+    );
+    setDescendantDepth(
+      tree ? collectLineageSubtreeDepth(tree.nodes, game.id) : null,
+    );
+    setDerivedNodes(derived?.nodes ?? []);
+    // 游玩次数显示口径（2026-10-06）：父代展示「自己 + 全部后代的合计」；
+    // 用同一棵 /lineage 在前端算，零额外请求、服务端零改动。
+    setLineageTotals(tree ? collectLineagePlayCountTotals(tree.nodes) : null);
+  }, [game.id, publiclyVisible]);
+  useEffect(() => {
+    void loadCoCreationData();
+  }, [loadCoCreationData]);
+  // Fork 的主路径是唤起客户端；只有「没失焦（没客户端接手）」或「平台不可能唤起」才降级成
+  // 「复制作品 ID / 链接 → 到客户端粘贴」。降级面板同理只在降级时出现。
+  const [isForkPanelOpen, setIsForkPanelOpen] = useState(false);
+  const [forkLaunchNotice, setForkLaunchNotice] = useState('');
+  const forkLaunchTimerRef = useRef<number | null>(null);
+  const forkLaunchHandlersRef = useRef<(() => void) | null>(null);
+  // 复制反馈保留更久：默认 1.4s 在真实浏览器里太短，用户与验收脚本都可能错过那一瞬；
+  // 旁边另有常驻的 role=status 说明，标签复位后依然能看到结果。
+  const { copyState: forkIdCopyState, copyText: copyForkId } = useCopyFeedback({
+    resetDelayMs: 5000,
+  });
+  const { copyState: forkLinkCopyState, copyText: copyForkLink } =
+    useCopyFeedback({ resetDelayMs: 5000 });
+  const workLink =
+    typeof window === 'undefined'
+      ? `/games/detail?id=${encodeURIComponent(game.id)}`
+      : `${window.location.origin}/games/detail?id=${encodeURIComponent(game.id)}`;
+  // 收藏态：服务端只在**已认证**时返回 `collected`，匿名请求完全没有这个键。
+  // 因此「缺字段」一律按不可判定处理（未登录 / 过期 token 被按匿名处理），
+  // 绝不落成「未收藏」——否则未登录用户会看到一个假的已收藏/未收藏结论。
+  const [collectionOverride, setCollectionOverride] = useState<boolean | null>(
+    null,
+  );
+  const [isCollectionBusy, setIsCollectionBusy] = useState(false);
+  const [collectionNotice, setCollectionNotice] = useState('');
+  const serverCollected = game.collected;
+  /**
+   * 操作行的状态/提示一律走 toast（portal + fixed）：**不在行内占位**，否则会把
+   * 「开始游戏 / 收藏 / 开始共创」挤成两行甚至竖排（2026-10-07 用户口径）。
+   */
+  useEffect(() => {
+    if (!collectionNotice) return;
+    showPlatformToast({ text: collectionNotice, tone: 'warning' });
+  }, [collectionNotice]);
+  useEffect(() => {
+    if (!forkLaunchNotice) return;
+    // 「已唤起…」是信息，其余（没检测到客户端 / 禁止共创 / 无法直接唤起）是要用户处理的警告。
+    const tone = /没有检测到|无法直接唤起|禁止/u.test(forkLaunchNotice)
+      ? 'warning'
+      : 'info';
+    showPlatformToast({ text: forkLaunchNotice, tone });
+  }, [forkLaunchNotice]);
+  const isCollected = collectionOverride ?? serverCollected ?? false;
+  const canKnowCollectionState =
+    typeof serverCollected === 'boolean' || collectionOverride !== null;
+
+  /**
+   * 收藏 / 取消收藏：先乐观切换，失败回滚到服务端给的值并提示错误文案。
+   * 未登录（或状态不可判定又未登录）走既有登录门禁，不伪造本地收藏态。
+   */
+  async function toggleCollection() {
+    if (!isAuthenticated) {
+      onLogin();
+      return;
+    }
+    const next = !isCollected;
+    setIsCollectionBusy(true);
+    setCollectionNotice('');
+    setCollectionOverride(next);
+    try {
+      const result = await setGameCollection(
+        game.id,
+        next,
+        createCollectionKey(game.id),
+      );
+      // 以服务端返回为准（收藏可能已被别人/别的标签页改过）。
+      setCollectionOverride(result.collected);
+    } catch (updateError: unknown) {
+      // 回滚：清掉乐观值，重新以服务端投影为准。
+      setCollectionOverride(null);
+      setCollectionNotice(
+        updateError instanceof Error
+          ? updateError.message
+          : next
+            ? '收藏失败'
+            : '取消收藏失败',
+      );
+    } finally {
+      setIsCollectionBusy(false);
+    }
+  }
+
+  /**
+   * 清理唤起流程留下的定时器与失焦监听；组件卸载、重复点击、超时三条路径都走这里，
+   * 避免监听器滞留到下一次渲染或卸载之后。
+   */
+  const clearForkLaunch = useCallback(() => {
+    if (forkLaunchTimerRef.current !== null) {
+      window.clearTimeout(forkLaunchTimerRef.current);
+      forkLaunchTimerRef.current = null;
+    }
+    const handOff = forkLaunchHandlersRef.current;
+    if (handOff) {
+      window.removeEventListener('blur', handOff);
+      document.removeEventListener('visibilitychange', handOff);
+      forkLaunchHandlersRef.current = null;
+    }
+  }, []);
+
+  useEffect(() => clearForkLaunch, [clearForkLaunch]);
+
+  function handleForkLaunch() {
+    if (!isAuthenticated) {
+      onLogin();
+      return;
+    }
+    // 降级面板已展开时再点一次 = 收起。
+    if (isForkPanelOpen) {
+      clearForkLaunch();
+      setIsForkPanelOpen(false);
+      setForkLaunchNotice('');
+      return;
+    }
+    clearForkLaunch();
+    setForkLaunchNotice('');
+    // 移动端/未知平台不尝试唤起：协议没注册时移动浏览器只是「什么都没发生」，
+    // 还可能先弹一个系统确认框；直接给手动路径更干脆。
+    if (isMobileViewport) {
+      setIsForkPanelOpen(true);
+      setForkLaunchNotice(
+        '当前设备无法直接唤起客户端，已在下方给出作品 ID；也可以先下载电脑版客户端。',
+      );
+      // 移动端平台客户端是桌面版：直接打开同一个下载入口（不自己造下载页）。
+      requestClientDownload();
+      return;
+    }
+    setForkLaunchNotice('正在唤起陶泥儿客户端…');
+    // 失焦（blur）或页面转入后台（visibilitychange=hidden）都视为客户端接手：
+    // 浏览器把焦点交给外部协议处理器时两个信号都会出现，但不同平台只给其中一个。
+    const handOffToClient = () => {
+      clearForkLaunch();
+      setForkLaunchNotice(
+        '已唤起陶泥儿客户端。若没有自动打开，请再点一次「开始共创」手动获取作品 ID。',
+      );
+    };
+    forkLaunchHandlersRef.current = handOffToClient;
+    window.addEventListener('blur', handOffToClient, { once: true });
+    document.addEventListener('visibilitychange', handOffToClient, {
+      once: true,
+    });
+    openForkProtocol(game.id);
+    forkLaunchTimerRef.current = window.setTimeout(() => {
+      forkLaunchTimerRef.current = null;
+      const handOff = forkLaunchHandlersRef.current;
+      if (handOff) {
+        window.removeEventListener('blur', handOff);
+        document.removeEventListener('visibilitychange', handOff);
+        forkLaunchHandlersRef.current = null;
+      }
+      // 未失焦 = 没有客户端接手（未安装 / 协议未注册 / 老客户端不响应深链）：
+      // 打开**与顶栏「下载客户端」同一个**下载入口，并给一句人话提示 + 保留手动复制路径。
+      setForkLaunchNotice(
+        '没有检测到陶泥儿客户端，已打开下载入口；也可以复制下面的作品 ID 手动开始共创。',
+      );
+      setIsForkPanelOpen(true);
+      requestClientDownload();
+    }, FORK_LAUNCH_FALLBACK_DELAY_MS);
+  }
   const mobilePlaybackBlocked = isMobileViewport && !game.deviceSupport.mobile;
   /**
    * 买断价与购买态：缺字段按免费/未购买兜底。
@@ -529,7 +864,7 @@ function GameDetailContent({
     : !hasPlayableEntry || mobilePlaybackBlocked;
   /**
    * 付费作品在旧响应缺 `priceMudPoints` 时会被判成免费，同时服务端又没下发入口，
-   * 于是「立即玩」只是灰着——必须说明原因，否则用户只看到一个点不动的按钮。
+   * 于是「开始游戏」只是灰着——必须说明原因，否则用户只看到一个点不动的按钮。
    */
   const isEntryMissing = !isPaidLocked && !ownerView && !hasPlayableEntry;
   const playbackBlockedReasonId = mobilePlaybackBlocked
@@ -547,11 +882,35 @@ function GameDetailContent({
           },
         ]
       : [];
+  /** 设备/归属类警告同样走 toast（行内那份只留给读屏）。 */
+  useEffect(() => {
+    const warning =
+      !isPaidLocked && mobilePlaybackBlocked
+        ? '请在电脑上游玩'
+        : isEntryMissing && !mobilePlaybackBlocked
+          ? '暂时拿不到可玩入口，请刷新页面后重试。'
+          : ownerView && !publishedVersion
+            ? '作品尚未公开，暂时没有在线可玩版本'
+            : '';
+    if (warning) showPlatformToast({ text: warning, tone: 'warning' });
+  }, [
+    isEntryMissing,
+    isPaidLocked,
+    mobilePlaybackBlocked,
+    ownerView,
+    publishedVersion,
+  ]);
   return (
-    <div className="game-detail-page">
+    <div
+      className="game-detail-page"
+      // 入口上下文的可观测面（探针/验收用）：玩家侧 / 共创者侧。
+      data-viewer-context={coCreator ? 'co-creator' : 'player'}
+    >
       <button type="button" className="game-back-button" onClick={onBack}>
         <ArrowLeft /> 返回
       </button>
+      {/* toast 宿主：portal 到 body、固定定位，因此完全不参与本页布局。 */}
+      <PlatformToastHost />
       <GameDetailDisplay
         game={displayGame}
         authorContent={
@@ -583,8 +942,145 @@ function GameDetailContent({
         }
         controlsLabel={resolveControlsLabel(version, game.inputModes)}
         versionLabel={versionLabel}
-        infoCards={priceInfoCards}
         rating={publiclyVisible ? <GameRatingSummary state={reviews} /> : null}
+        infoCards={[
+          // 定价卡片来自 master、共创卡片来自本分支：两侧都要显示（合并时一度各留了一个
+          // `infoCards` 属性，而 JSX 不允许同名属性重复）。
+          ...priceInfoCards,
+          {
+            label: '共创',
+            value: (
+              <span className="game-fork-card">
+                {/*
+                  游客（只玩游戏）不显示**共创标签**：世代（第 N 代 / 母版）与授权档位
+                  （允许共创 / 非商用 / 禁止共创）都是「共创者视角」的档位标签。
+                  共创者与改动前完全一致。
+                */}
+                {coCreator ? (
+                  <span className="co-creation-tags">
+                    {/* 世代标签（文档口径：0 代原创 / 1 代二创 / 2 代三创 / N 代迭代）。 */}
+                    <span className="co-creation-tag co-creation-tag--generation">
+                      {coCreationGenerationTagLabel(lineage?.generation ?? 0)}
+                    </span>
+                    {/* 授权类型标签：沿用平台既有 constants（含「允许」前缀），不另造一套文案。 */}
+                    <span
+                      className={`co-creation-tag co-creation-tag--authorization game-fork-badge game-fork-badge--${forkAuthorization}`}
+                    >
+                      {
+                        GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS[
+                          forkAuthorization
+                        ]
+                      }
+                    </span>
+                  </span>
+                ) : null}
+                {/* 血缘关系文字行（改编自父代《…》/ 父代作者）同样只给共创者看。 */}
+                {coCreator && lineage ? (
+                  <>
+                    {/*
+                      父作品被软删除时服务端不再回传它的标题与作者名（见
+                      module-game-distribution 的血缘快照），这里降级成「原作品已不可用」，
+                      既不猜测也不回显已下线作品的信息。
+                    */}
+                    <span className="game-fork-lineage">
+                      {lineage.parentTitle
+                        ? `${coCreationGenerationTagLabel(lineage.generation)} · 改编自父代《${lineage.parentTitle}》`
+                        : `${coCreationGenerationTagLabel(lineage.generation)} · 原作品已不可用`}
+                    </span>
+                    {lineage.parentAuthorName ? (
+                      <span className="game-fork-lineage__author">
+                        父代作者 {lineage.parentAuthorName}
+                      </span>
+                    ) : null}
+                  </>
+                ) : null}
+                {/* 数据概览：累计衍生作品数 + 累计创作世代数（子树深度，前端用同一份 lineage 数据算）。 */}
+                <span className="co-creation-stats">
+                  {/*
+                    游玩次数按「子代叠加到父代」显示：合计 = 自身 + 全部后代，并**给出分解**，
+                    避免只给一个会让人误解的数字（数据来自同一棵 /lineage，零额外请求）。
+                    树还没回来 / 拿不到时不显示这一项（不伪造、也不暗示含衍生）。
+                  */}
+                  {playCountBreakdown ? (
+                    <span
+                      className="co-creation-stat"
+                      aria-label="游玩次数合计"
+                    >
+                      游玩 {playCountBreakdown.total} 次（自身{' '}
+                      {playCountBreakdown.own} + 衍生{' '}
+                      {playCountBreakdown.inherited}）
+                    </span>
+                  ) : null}
+                  <span className="co-creation-stat">
+                    累计衍生作品 {forkCount}
+                  </span>
+                  {descendantDepth === null ? null : (
+                    <span className="co-creation-stat">
+                      累计创作世代数 {descendantDepth}
+                      {descendantDepth === 0 ? '（暂无衍生）' : ''}
+                    </span>
+                  )}
+                </span>
+                {/* 进入血缘视图的入口（族谱 / 与原版对比）也只给共创者。 */}
+                {coCreator && onOpenLineage && publiclyVisible ? (
+                  /*
+                    族谱入口放在共创信息卡里：它属于「这部作品的改编关系」这件事，
+                    点进去是以母版为顶的整棵族谱树；`from` 带上当前作品供页面高亮。
+                    只有已公开作品才渲染：族谱接口要求锚点公开可读，未公开作品点进去必然 404。
+                  */
+                  <button
+                    type="button"
+                    className="game-fork-lineage-link"
+                    onClick={() =>
+                      onOpenLineage(lineage?.rootGameId ?? game.id, game.id)
+                    }
+                  >
+                    查看创作族谱
+                  </button>
+                ) : null}
+                {coCreator &&
+                publiclyVisible &&
+                lineage?.parentGameId &&
+                onOpenCompare ? (
+                  /*
+                    有父作品（二创作品）时给出「与原版对比」：左侧原版、右侧当前作品，
+                    两侧各自取数与降级（父作品不可读时只降级那一侧）。
+                  */
+                  <button
+                    type="button"
+                    className="game-fork-compare-link"
+                    onClick={() => onOpenCompare(lineage.parentGameId, game.id)}
+                  >
+                    与原版对比
+                  </button>
+                ) : null}
+                {onOpenTheme && themes.length > 0 ? (
+                  /*
+                    所属共创主题入口：服务端按作品的**根**反查，所以第 N 代作品也会有值；
+                    没有所属主题时是空数组（不是缺键），这里不渲染空容器。
+                  */
+                  <span className="game-fork-theme-list">
+                    {themes.map((theme) => (
+                      <button
+                        key={theme.themeId}
+                        type="button"
+                        className="game-fork-theme-link"
+                        onClick={() => onOpenTheme(theme.themeId)}
+                      >
+                        {theme.badge ? (
+                          <span className="game-fork-theme-badge">
+                            {theme.badge}
+                          </span>
+                        ) : null}
+                        {theme.name}
+                      </button>
+                    ))}
+                  </span>
+                ) : null}
+              </span>
+            ),
+          },
+        ]}
         actions={
           <>
             {isPaidLocked ? (
@@ -606,13 +1102,167 @@ function GameDetailContent({
                   playbackBlocked ? playbackBlockedReasonId : undefined
                 }
               >
-                <Gamepad2 /> 立即玩
+                <Gamepad2 /> 开始游戏
               </PlatformActionButton>
             )}
+            {/*
+              收藏是玩家级动作：放在主行动作旁边（与「开始游戏」同一区），而不是共创信息卡里
+              ——那张卡讲的是「这部作品的改编关系」。未登录时不伪造收藏态：点击走登录门禁。
+            */}
+            <PlatformActionButton
+              tone={isCollected ? 'primary' : 'secondary'}
+              size="sm"
+              shape="pill"
+              disabled={isCollectionBusy}
+              title={
+                isAuthenticated
+                  ? canKnowCollectionState
+                    ? isCollected
+                      ? '取消收藏'
+                      : '收藏'
+                    : '收藏状态未知，点击将收藏'
+                  : '登录后可收藏'
+              }
+              onClick={() => void toggleCollection()}
+            >
+              {isCollected ? '已收藏' : '收藏'}
+            </PlatformActionButton>
+            {/*
+              「开始共创」从共创信息卡搬到主操作行（2026-10-07 用户口径）：
+              它是这部作品的主操作之一，和「开始游戏 / 收藏」并列；共创卡内不再重复出现该按钮。
+              **入口上下文差异**（判据 `isCoCreator`，来源写在 URL 的 `from` 上）：
+              - 共创者侧（共创 Tab / 族谱 / 对比页进来）：与改动前**完全一致**——实心强调 + lg 尺寸
+                （48px / 0.94rem），文案「开始共创」（与玩家侧同一词表），禁止共创时置灰 + 原因；
+              - 玩家侧（游戏 Tab / 广场 / 搜索 / 收藏 / 我的游戏 / 默认深链）：**不占用重点色**，缩成
+                次要小按钮（描边 + 次要底色、32px / 0.78rem，见 `.game-fork-remix-guest`），
+                文案如实写「开始共创」/未登录时「登录后开始共创」——不喊「一键共创」这种大口号。
+                但**仍然可点可达**：未登录走仓库既有的登录门禁（`onLogin`），既不禁用也不隐藏，
+                登录态只决定「能不能真的开始共创」，不再决定「看不看得到血缘」。
+            */}
+            {publiclyVisible ? (
+              <>
+                <button
+                  type="button"
+                  className={
+                    coCreator
+                      ? `game-fork-remix-link co-creation-fork-primary${
+                          forkAuthorization === 'forbidden'
+                            ? ' co-creation-fork-primary--blocked'
+                            : ''
+                        }`
+                      : 'game-fork-remix-link game-fork-remix-guest'
+                  }
+                  data-viewer-context={coCreator ? 'co-creator' : 'player'}
+                  aria-disabled={forkAuthorization === 'forbidden'}
+                  aria-expanded={
+                    isAuthenticated && forkAuthorization !== 'forbidden'
+                      ? isForkPanelOpen
+                      : undefined
+                  }
+                  aria-controls={
+                    isAuthenticated && forkAuthorization !== 'forbidden'
+                      ? 'game-fork-remix-panel'
+                      : undefined
+                  }
+                  title={
+                    forkAuthorization === 'forbidden'
+                      ? '作者未开放共创授权（禁止共创），无法开始共创这部作品'
+                      : undefined
+                  }
+                  onClick={() => {
+                    if (forkAuthorization === 'forbidden') {
+                      setForkLaunchNotice(
+                        '作者未开放共创授权（禁止共创），无法开始共创这部作品。',
+                      );
+                      return;
+                    }
+                    if (!isAuthenticated) {
+                      onLogin();
+                      return;
+                    }
+                    handleForkLaunch();
+                  }}
+                >
+                  {coCreator
+                    ? '开始共创'
+                    : forkAuthorization === 'forbidden'
+                      ? '禁止共创'
+                      : isAuthenticated
+                        ? '开始共创'
+                        : '登录后开始共创'}
+                </button>
+                {isAuthenticated && isForkPanelOpen
+                  ? createPortal(
+                      <div
+                        className="game-fork-remix-panel game-fork-remix-panel--portal"
+                        id="game-fork-remix-panel"
+                        role="dialog"
+                        aria-label="手动开始共创"
+                      >
+                        <span className="game-fork-remix-steps">
+                          在陶泥儿客户端里打开「从平台作品开始创作」，粘贴下面的作品
+                          ID 或作品链接。
+                        </span>
+                        <span className="game-fork-remix-value">
+                          作品 ID：<code>{game.id}</code>
+                        </span>
+                        <span className="game-fork-remix-value">
+                          作品链接：<code>{workLink}</code>
+                        </span>
+                        <span className="game-fork-remix-actions">
+                          <CopyFeedbackButton
+                            state={forkIdCopyState}
+                            idleLabel="复制作品 ID"
+                            copiedLabel="作品 ID 已复制"
+                            failedLabel="复制失败"
+                            className="game-fork-remix-copy"
+                            onClick={() => void copyForkId(game.id)}
+                          />
+                          <CopyFeedbackButton
+                            state={forkLinkCopyState}
+                            idleLabel="复制作品链接"
+                            copiedLabel="作品链接已复制"
+                            failedLabel="复制失败"
+                            className="game-fork-remix-copy"
+                            onClick={() => void copyForkLink(workLink)}
+                          />
+                        </span>
+                        <span className="game-fork-remix-note">
+                          开始共创会把这部作品的整个工程（含素材与文档）复制到你的项目里继续改造；
+                          复制后对他人可见，且不可撤销。
+                        </span>
+                        {forkIdCopyState === 'copied' ? (
+                          <span
+                            className="game-fork-remix-status"
+                            role="status"
+                          >
+                            作品 ID
+                            已复制，可在客户端「从平台作品开始创作」里粘贴。
+                          </span>
+                        ) : null}
+                        {forkIdCopyState === 'failed' ? (
+                          <span
+                            className="game-fork-remix-status"
+                            role="status"
+                          >
+                            复制失败：请手动选中作品 ID 文本。
+                          </span>
+                        ) : null}
+                      </div>,
+                      document.body,
+                    )
+                  : null}
+              </>
+            ) : null}
+            {/*
+              这些警告过去是行内 span，会把同行按钮挤成两行。现在：**视觉上隐藏但保留 id**
+              （`aria-describedby` 还指着 `#game-mobile-playback-warning` / `#game-entry-missing-warning`，
+              读屏仍能关联到），可见提示改由 toast 承担。
+            */}
             {!isPaidLocked && mobilePlaybackBlocked ? (
               <span
                 id="game-mobile-playback-warning"
-                className="game-device-warning"
+                className="game-device-warning game-device-warning--sr"
                 role="status"
               >
                 请在电脑上游玩
@@ -621,14 +1271,17 @@ function GameDetailContent({
             {isEntryMissing && !mobilePlaybackBlocked ? (
               <span
                 id="game-entry-missing-warning"
-                className="game-device-warning"
+                className="game-device-warning game-device-warning--sr"
                 role="status"
               >
                 暂时拿不到可玩入口，请刷新页面后重试。
               </span>
             ) : null}
             {ownerView && !publishedVersion ? (
-              <span className="game-device-warning" role="status">
+              <span
+                className="game-device-warning game-device-warning--sr"
+                role="status"
+              >
                 作品尚未公开，暂时没有在线可玩版本
               </span>
             ) : null}
@@ -684,6 +1337,18 @@ function GameDetailContent({
           </section>
         ) : null}
       </GameDetailDisplay>
+      {/*
+        血缘图放在**正文之后**（需求 2026-10-06）：图可能很大，~230px 的侧栏只够画一条链。
+        整宽区块内嵌的就是族谱页组件（`GameLineagePage embedded`），不新建第二套树渲染；
+        侧栏共创卡保留世代 / 授权 / 累计数据与四个入口（含「查看创作族谱」全屏入口）。
+      */}
+      {showLineageBlock && onOpenGameDetail ? (
+        <CoCreationLineageSection
+          rootGameId={lineage?.rootGameId ?? game.id}
+          currentGameId={game.id}
+          onOpenGameDetail={onOpenGameDetail}
+        />
+      ) : null}
       <GameReviews
         state={reviews}
         canReview={canReview}
diff --git a/src/components/game-distribution/GameDistributionPages.test.tsx b/src/components/game-distribution/GameDistributionPages.test.tsx
index 762b76d5a..fff756642 100644
--- a/src/components/game-distribution/GameDistributionPages.test.tsx
+++ b/src/components/game-distribution/GameDistributionPages.test.tsx
@@ -1,5 +1,7 @@
 /* @vitest-environment jsdom */
 
+import { readFileSync } from 'node:fs';
+
 import { PLATFORM_GAME_LOADING_TIMEOUT_MS } from '@genarrative/shared/components';
 import {
   act,
@@ -19,17 +21,36 @@ import type {
 import { ApiClientError } from '../../services/apiClient';
 import type {
   GameDistributionGame,
+  GameDistributionGameWithCollection,
+  GameDistributionLineageNode,
   GameDistributionMyGame,
   GameDistributionVersionStatusEntry,
 } from '../../services/gameDistributionClient';
+import {
+  normalizePlatformToast,
+  PLATFORM_TOAST_DEFAULT_DURATION_MS,
+  showPlatformToast,
+} from '../common/platformToast';
+import { PlatformToastHost } from '../common/PlatformToastHost';
 import { setCreatorViewer } from '../creator/creatorRelationshipState';
+import { GameComparePage } from './GameComparePage';
 import { GameDetailPage } from './GameDetailPage';
+import { FORK_LAUNCH_FALLBACK_DELAY_MS } from './gameForkProtocol';
 import { GameGalleryPage } from './GameGalleryPage';
+import { GameLineagePage } from './GameLineagePage';
 import { GamePlayPage } from './GamePlayPage';
+import { GameThemePage } from './GameThemePage';
+import { GameThemesPage } from './GameThemesPage';
 import { resolveNonPublicCoverLabel } from './gameVersionHistoryModel';
+import { LINEAGE_COVER_ASPECT } from './lineageTreeLayout';
 
 const listGamesMock = vi.hoisted(() => vi.fn());
+const setGameCollectionMock = vi.hoisted(() => vi.fn());
+const listThemesMock = vi.hoisted(() => vi.fn());
+const getThemeMock = vi.hoisted(() => vi.fn());
 const getGameMock = vi.hoisted(() => vi.fn());
+const getGameLineageMock = vi.hoisted(() => vi.fn());
+const getDerivedGamesMock = vi.hoisted(() => vi.fn());
 const getMyGameMock = vi.hoisted(() => vi.fn());
 const loadVersionRecoveryActionsMock = vi.hoisted(() => vi.fn());
 const recordGamePlayMock = vi.hoisted(() => vi.fn());
@@ -55,7 +76,12 @@ vi.mock('../../services/creatorProfileClient', async (original) => ({
 
 vi.mock('../../services/gameDistributionClient', () => ({
   listGames: listGamesMock,
+  setGameCollection: setGameCollectionMock,
+  listThemes: listThemesMock,
+  getTheme: getThemeMock,
   getGame: getGameMock,
+  getGameLineage: getGameLineageMock,
+  getDerivedGames: getDerivedGamesMock,
   getMyGame: getMyGameMock,
   loadVersionRecoveryActions: loadVersionRecoveryActionsMock,
   recordGamePlay: recordGamePlayMock,
@@ -78,13 +104,40 @@ vi.mock('../../stores/usePlatformWalletStore', () => ({
     selector(walletMocks),
 }));
 
-// 作者视角详情页要按登录身份渲染评价区，这里固定一个可访问受保护数据的用户。
-vi.mock('../auth/AuthUiContext', () => ({
-  useAuthUi: () => ({
-    user: { id: 'author-1' },
+/**
+ * 详情页的登录态：默认一个可访问受保护数据的用户（作者视角评价区要用）。
+ * 「未登录」用例会把它改成 null 再断言登录门禁行为；openLoginModal 用同一实例便于断言。
+ */
+const authUiMock = vi.hoisted(() => ({
+  value: {
+    user: { id: 'author-1' } as { id: string } | null,
     canAccessProtectedData: true,
     openLoginModal: vi.fn(),
-  }),
+  },
+}));
+
+vi.mock('../auth/AuthUiContext', () => ({
+  useAuthUi: () => authUiMock.value,
+}));
+
+/** 改造入口的复制走统一的剪贴板服务；这里只断言「复制了什么」。 */
+const copyTextToClipboardMock = vi.hoisted(() => vi.fn());
+
+vi.mock('../../services/clipboard', () => ({
+  copyTextToClipboard: copyTextToClipboardMock,
+}));
+
+/** 开始共创唤起：只打桩「发出唤起」这一动作，协议常量仍用真实值（测试按同一阈值推进定时器）。 */
+const openForkProtocolMock = vi.hoisted(() => vi.fn());
+const requestClientDownloadMock = vi.hoisted(() => vi.fn());
+
+vi.mock('../creation-home/clientDownloadLauncher', () => ({
+  requestClientDownload: requestClientDownloadMock,
+  subscribeClientDownloadRequest: () => () => {},
+}));
+vi.mock('./gameForkProtocol', async (original) => ({
+  ...(await original<typeof import('./gameForkProtocol')>()),
+  openForkProtocol: openForkProtocolMock,
 }));
 
 // 只替换换签结果，测试不发起任何真实请求；返回空串即代表签名失败或字段为空。
@@ -129,8 +182,8 @@ function deferred<T>() {
 }
 
 function createGame(
-  overrides: Partial<GameDistributionGame> = {},
-): GameDistributionGame {
+  overrides: Partial<GameDistributionGameWithCollection> = {},
+): GameDistributionGameWithCollection {
   return {
     id: 'game-1',
     title: '星轨防线',
@@ -178,23 +231,57 @@ function setViewportWidth(width: number) {
 }
 
 afterEach(() => {
+  vi.useRealTimers();
   cleanup();
 });
 
 beforeEach(() => {
   vi.clearAllMocks();
+  /*
+   * 详情页的默认 fixture = **共创者侧**（`?from=co-creation`）：这是 2026-10-07 之前
+   * 唯一被实现/验收过的一侧，绝大多数用例（血缘图、共创标签、开始共创）讲的都是它。
+   * 玩家侧的用例各自把 URL 显式设回 `/games/detail?id=…`（见「入口上下文」那两条）。
+   */
+  window.history.replaceState(
+    null,
+    '',
+    '/games/detail?id=game-1&from=co-creation',
+  );
+  authUiMock.value.user = { id: 'author-1' };
+  authUiMock.value.canAccessProtectedData = true;
+  authUiMock.value.openLoginModal.mockReset();
+  copyTextToClipboardMock.mockReset();
+  copyTextToClipboardMock.mockResolvedValue(true);
+  openForkProtocolMock.mockReset();
+  requestClientDownloadMock.mockReset();
+  setGameCollectionMock.mockReset();
+  setGameCollectionMock.mockResolvedValue({ collected: true });
+  listThemesMock.mockReset();
+  listThemesMock.mockResolvedValue({ themes: [], nextCursor: null });
+  getThemeMock.mockReset();
+  getThemeMock.mockResolvedValue(null);
   setCreatorViewer(null);
+  getCreatorRelationshipMock.mockReset();
   getCreatorRelationshipMock.mockResolvedValue({
     relationship: { isSelf: false, isFollowing: false, isFollowedBy: false },
   });
+  changeCreatorRelationshipMock.mockReset();
   changeCreatorRelationshipMock.mockResolvedValue({
     relationship: { isSelf: false, isFollowing: true, isFollowedBy: false },
   });
   setViewportWidth(1024);
-  listGamesMock.mockResolvedValue([]);
+  listGamesMock.mockReset();
+  listGamesMock.mockResolvedValue({ games: [], nextCursor: null });
+  getGameMock.mockReset();
   getGameMock.mockResolvedValue(createGame());
+  getGameLineageMock.mockReset();
+  getGameLineageMock.mockResolvedValue(null);
+  getDerivedGamesMock.mockReset();
+  getDerivedGamesMock.mockResolvedValue(null);
+  getMyGameMock.mockReset();
   getMyGameMock.mockResolvedValue(null);
   loadVersionRecoveryActionsMock.mockResolvedValue({});
+  listGameReviewsMock.mockReset();
   listGameReviewsMock.mockResolvedValue({
     reviews: [],
     page: 1,
@@ -203,7 +290,9 @@ beforeEach(() => {
     totalPages: 0,
     ratingSummary: { averageScore: null, ratingCount: 0 },
   });
+  getMyGameReviewMock.mockReset();
   getMyGameReviewMock.mockResolvedValue({ review: null });
+  recordGamePlayMock.mockReset();
   recordGamePlayMock.mockResolvedValue(undefined);
   purchaseGameMock.mockReset();
   createGamePlaySessionMock.mockReset();
@@ -220,15 +309,332 @@ describe('GameGalleryPage', () => {
     [{ averageScore: null, ratingCount: 0 }, '暂无评分'],
     [undefined, '评分暂不可用'],
   ])('显示列表返回的评分摘要 %#', async (ratingSummary, expected) => {
-    listGamesMock.mockResolvedValueOnce([createGame({ ratingSummary })]);
+    listGamesMock.mockResolvedValueOnce({
+      games: [createGame({ ratingSummary })],
+      nextCursor: null,
+    });
     render(<GameGalleryPage onOpenDetail={vi.fn()} />);
 
     expect(await screen.findByText(expected)).toBeTruthy();
   });
 
+  it('游标分页：加载更多按 gameId 去重追加，末页隐藏入口', async () => {
+    const firstPage = Array.from({ length: 48 }, (_, index) =>
+      createGame({ id: `game-${index + 1}`, title: `目录第 ${index + 1} 款` }),
+    );
+    // 第二页故意含一条与本页重复的 id（服务端稳定序下不该发生，但客户端必须去重）+ 两条新的。
+    const secondPage = [
+      createGame({ id: 'game-48', title: '目录第 48 款' }),
+      createGame({ id: 'game-49', title: '目录第 49 款' }),
+      createGame({ id: 'game-50', title: '目录第 50 款' }),
+    ];
+    listGamesMock
+      .mockResolvedValueOnce({ games: firstPage, nextCursor: 'c1' })
+      .mockResolvedValueOnce({ games: secondPage, nextCursor: null });
+    render(<GameGalleryPage onOpenDetail={vi.fn()} />);
+
+    // 首屏 48 条（服务端默认页大小）+ 「加载更多」入口：不再是「永远只有 48 条」。
+    await screen.findByText('目录第 48 款');
+    const grid = document.querySelectorAll('.game-grid > *');
+    expect(grid.length).toBe(48);
+    // 第一次请求不带游标（缺省页大小交给服务端）。
+    expect(listGamesMock.mock.calls[0]?.[0]).toEqual({
+      keyword: '',
+      category: '全部',
+    });
+
+    fireEvent.click(screen.getByRole('button', { name: '加载更多' }));
+    await screen.findByText('目录第 50 款');
+    // 第二次请求原样回传服务端游标（不自己拼）。
+    expect(listGamesMock.mock.calls[1]?.[0]).toEqual({
+      keyword: '',
+      category: '全部',
+      cursor: 'c1',
+    });
+    // 追加 + 去重：48 + 2（重复的 game-48 只留一份）。
+    expect(document.querySelectorAll('.game-grid > *').length).toBe(50);
+    expect(screen.getAllByText('目录第 48 款')).toHaveLength(1);
+    expect(screen.queryByText('目录第 51 款')).toBeNull();
+    // 末页 nextCursor = null：入口消失。
+    expect(screen.queryByRole('button', { name: '加载更多' })).toBeNull();
+  });
+
+  it('加载更多失败：保留已加载内容 + 可读提示，重试成功后追加', async () => {
+    listGamesMock
+      .mockResolvedValueOnce({
+        games: [createGame({ id: 'game-1', title: '第一页作品' })],
+        nextCursor: 'c1',
+      })
+      .mockRejectedValueOnce(new Error('网络开小差了'))
+      .mockResolvedValueOnce({
+        games: [createGame({ id: 'game-2', title: '第二页作品' })],
+        nextCursor: null,
+      });
+    render(<GameGalleryPage onOpenDetail={vi.fn()} />);
+
+    await screen.findByText('第一页作品');
+    fireEvent.click(await screen.findByRole('button', { name: '加载更多' }));
+
+    // 失败：已加载内容**不清空**，提示可读，入口还在（可重试）。
+    expect(await screen.findByText('网络开小差了')).toBeTruthy();
+    expect(screen.getByText('第一页作品')).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: '加载更多' }));
+
+    await screen.findByText('第二页作品');
+    expect(screen.getByText('第一页作品')).toBeTruthy();
+    expect(screen.queryByText('网络开小差了')).toBeNull();
+    expect(screen.queryByRole('button', { name: '加载更多' })).toBeNull();
+  });
+
+  it('窄屏同样有「加载更多」且不横向溢出', async () => {
+    setViewportWidth(390);
+    listGamesMock.mockResolvedValueOnce({
+      games: [createGame({ id: 'game-1', title: '窄屏第一页' })],
+      nextCursor: 'c1',
+    });
+    render(<GameGalleryPage onOpenDetail={vi.fn()} />);
+
+    expect(await screen.findByText('窄屏第一页')).toBeTruthy();
+    const more = screen.getByRole('button', { name: '加载更多' });
+    expect(more).toBeTruthy();
+    // 入口在页面容器内、不是浮层：容器宽度受约束（jsdom 无量宽，这里钉结构与样式契约）。
+    expect(more.closest('.game-empty-actions')).toBeTruthy();
+    const css = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    expect(css).toMatch(
+      /\.game-empty-actions \{[\s\S]{0,300}?flex-wrap: wrap;/u,
+    );
+  });
+
+  it('scope=forkable（共创页）：请求带 forkable、渲染游戏卡片而非主题卡、无主题入口', async () => {
+    listGamesMock.mockResolvedValueOnce({
+      games: [
+        createGame({
+          id: 'game-forkable',
+          title: '可以共创的作品',
+          forkAuthorization: 'full',
+        }),
+      ],
+      nextCursor: null,
+    });
+    render(<GameGalleryPage scope="forkable" onOpenDetail={vi.fn()} />);
+
+    // ① 请求带 forkable（服务端未上线时参数会被忽略，客户端还有同义兜底过滤）。
+    await screen.findByText('可以共创的作品');
+    expect(listGamesMock.mock.calls[0]?.[0]).toEqual({
+      keyword: '',
+      category: '全部',
+      forkable: true,
+    });
+    // ② 卡片来自广场同一套组件（`.game-grid` + 卡片），不是主题卡。
+    expect(document.querySelectorAll('.game-grid > *').length).toBe(1);
+    expect(document.querySelector('.game-themes-page')).toBeNull();
+    expect(screen.queryByText(/棵作品树/u)).toBeNull();
+    // ③ 「游戏 / 共创」子页签已删除（共创升为侧边栏顶层入口）：
+    //    本页不再有任何「游戏区」页签，也不再有指向主题列表的入口。
+    expect(screen.queryByRole('tablist', { name: '游戏区' })).toBeNull();
+    expect(screen.queryByRole('tab', { name: '共创' })).toBeNull();
+    // 分类 / 设备筛选页签仍在。
+    expect(screen.getByRole('tablist', { name: '游戏分类' })).toBeTruthy();
+    // ④ 封面角标已删除：同一张卡上只留指标位那一处共创计数。
+    expect(document.querySelector('.game-card__badges')).toBeNull();
+    expect(document.querySelector('.game-card__co-creation-badge')).toBeNull();
+  });
+
+  it('scope=forkable：指标位换成「被共创 N 次」，优先 coCreationCount、回退 forkCount、0 也显示', async () => {
+    listGamesMock.mockResolvedValueOnce({
+      games: [
+        {
+          ...createGame({
+            id: 'game-new-field',
+            title: '服务端新字段',
+            forkAuthorization: 'full',
+          }),
+          coCreationCount: 7,
+          forkCount: 3,
+        },
+        {
+          ...createGame({
+            id: 'game-legacy-field',
+            title: '老字段回退',
+            forkAuthorization: 'full',
+          }),
+          forkCount: 3,
+        },
+        {
+          ...createGame({
+            id: 'game-zero',
+            title: '还没人共创',
+            forkAuthorization: 'full',
+          }),
+          coCreationCount: 0,
+          forkCount: 0,
+        },
+      ],
+      nextCursor: null,
+    });
+    render(<GameGalleryPage scope="forkable" onOpenDetail={vi.fn()} />);
+
+    const newFieldCard = (await screen.findByText('服务端新字段')).closest(
+      '.game-card',
+    ) as HTMLElement;
+    // 新字段优先：7（不是 forkCount 的 3）。
+    expect(
+      newFieldCard.querySelector('.game-card__co-creation-count')?.textContent,
+    ).toBe('被共创 7 次');
+    expect(newFieldCard.querySelector('.game-card__play-count')).toBeNull();
+    const legacyCard = screen
+      .getByText('老字段回退')
+      .closest('.game-card') as HTMLElement;
+    // 老响应回退到 forkCount：3。
+    expect(
+      legacyCard.querySelector('.game-card__co-creation-count')?.textContent,
+    ).toBe('被共创 3 次');
+    const zeroCard = screen
+      .getByText('还没人共创')
+      .closest('.game-card') as HTMLElement;
+    // 0 是信息（还没人接着做）→ 照常显示，不是缺省。
+    expect(
+      zeroCard.querySelector('.game-card__co-creation-count')?.textContent,
+    ).toBe('被共创 0 次');
+    // 无障碍名带口径，不是只有一个数字。
+    expect(
+      zeroCard
+        .querySelector('.game-card__co-creation-count')
+        ?.getAttribute('aria-label'),
+    ).toBe('被共创 0 次');
+  });
+
+  it('scope=forkable：两个计数字段都没有时退回默认的「N 次游玩」而不是伪造 0', async () => {
+    const bare = createGame({
+      id: 'game-bare',
+      title: '没有计数字段',
+      forkAuthorization: 'full',
+    });
+    delete (bare as { forkCount?: number }).forkCount;
+    delete (bare as { coCreationCount?: number }).coCreationCount;
+    listGamesMock.mockResolvedValueOnce({ games: [bare], nextCursor: null });
+    render(<GameGalleryPage scope="forkable" onOpenDetail={vi.fn()} />);
+
+    const card = (await screen.findByText('没有计数字段')).closest(
+      '.game-card',
+    ) as HTMLElement;
+    expect(card.querySelector('.game-card__co-creation-count')).toBeNull();
+    expect(card.querySelector('.game-card__play-count')?.textContent).toContain(
+      '次游玩',
+    );
+  });
+
+  it('游戏广场（scope=all）**保持**「N 次游玩」，不显示共创计数、也没有封面角标', async () => {
+    listGamesMock.mockResolvedValueOnce({
+      games: [
+        {
+          ...createGame({ id: 'game-plain', title: '广场作品', playCount: 42 }),
+          forkCount: 5,
+          coCreationCount: 5,
+        },
+      ],
+      nextCursor: null,
+    });
+    render(<GameGalleryPage onOpenDetail={vi.fn()} />);
+
+    const card = (await screen.findByText('广场作品')).closest(
+      '.game-card',
+    ) as HTMLElement;
+    expect(card.querySelector('.game-card__co-creation-count')).toBeNull();
+    expect(card.querySelector('.game-card__badges')).toBeNull();
+    expect(
+      card.querySelector('.game-card__play-count')?.textContent?.trim(),
+    ).toBe('42 次游玩');
+  });
+
+  it('scope=forkable：客户端兜底过滤掉禁止共创的作品（与服务端 forkable 同义）', async () => {
+    listGamesMock.mockResolvedValueOnce({
+      games: [
+        createGame({
+          id: 'game-open',
+          title: '开放共创',
+          forkAuthorization: 'full',
+        }),
+        createGame({
+          id: 'game-forbidden',
+          title: '禁止共创',
+          forkAuthorization: 'forbidden',
+        }),
+      ],
+      nextCursor: null,
+    });
+    render(<GameGalleryPage scope="forkable" onOpenDetail={vi.fn()} />);
+
+    expect(await screen.findByText('开放共创')).toBeTruthy();
+    expect(screen.queryByText('禁止共创')).toBeNull();
+  });
+
+  it('scope=forkable：空态说明「暂时没有开放共创的作品」，加载更多仍可用', async () => {
+    // ③ 空态
+    listGamesMock.mockResolvedValueOnce({ games: [], nextCursor: null });
+    const empty = render(
+      <GameGalleryPage scope="forkable" onOpenDetail={vi.fn()} />,
+    );
+    expect(await screen.findByText('暂时没有开放共创的作品')).toBeTruthy();
+    expect(
+      screen.getByText('作者把作品开放共创授权后，它会出现在这里。'),
+    ).toBeTruthy();
+    empty.unmount();
+
+    // ④ 加载更多在共创页签同样可用，且**第二页请求也带 forkable**。
+    listGamesMock
+      .mockResolvedValueOnce({
+        games: [
+          createGame({
+            id: 'game-1',
+            title: '第一页共创作品',
+            forkAuthorization: 'full',
+          }),
+        ],
+        nextCursor: 'c1',
+      })
+      .mockResolvedValueOnce({
+        games: [
+          createGame({
+            id: 'game-2',
+            title: '第二页共创作品',
+            forkAuthorization: 'full',
+          }),
+        ],
+        nextCursor: null,
+      });
+    render(<GameGalleryPage scope="forkable" onOpenDetail={vi.fn()} />);
+
+    await screen.findByText('第一页共创作品');
+    fireEvent.click(await screen.findByRole('button', { name: '加载更多' }));
+    await screen.findByText('第二页共创作品');
+    // 「加载更多」那一次请求 = 带游标的那一次（前面的调用都是首屏加载）。
+    const loadMoreCall = listGamesMock.mock.calls.find(
+      ([query]) => query && typeof query === 'object' && 'cursor' in query,
+    );
+    expect(loadMoreCall?.[0]).toEqual({
+      keyword: '',
+      category: '全部',
+      cursor: 'c1',
+      forkable: true,
+    });
+    expect(screen.queryByRole('button', { name: '加载更多' })).toBeNull();
+  });
+
   it('ignores a stale response after search keyword changes', async () => {
-    const first = deferred<GameDistributionGame[]>();
-    const second = deferred<GameDistributionGame[]>();
+    const first = deferred<{
+      games: GameDistributionGame[];
+      nextCursor: string | null;
+    }>();
+    const second = deferred<{
+      games: GameDistributionGame[];
+      nextCursor: string | null;
+    }>();
     listGamesMock
       .mockImplementationOnce(() => first.promise)
       .mockImplementationOnce(() => second.promise);
@@ -244,9 +650,12 @@ describe('GameGalleryPage', () => {
     await waitFor(() => expect(listGamesMock).toHaveBeenCalledTimes(2));
 
     const newerGame = createGame({ id: 'game-new', title: '新搜索结果' });
-    second.resolve([newerGame]);
+    second.resolve({ games: [newerGame], nextCursor: null });
     await screen.findByText('新搜索结果');
-    first.resolve([createGame({ id: 'game-old', title: '旧搜索结果' })]);
+    first.resolve({
+      games: [createGame({ id: 'game-old', title: '旧搜索结果' })],
+      nextCursor: null,
+    });
     await waitFor(() => expect(screen.queryByText('旧搜索结果')).toBeNull());
   });
 });
@@ -276,6 +685,8 @@ describe('GameDetailPage', () => {
       const link = await screen.findByRole('link', { name: '查看创作者主页' });
       expect(link.getAttribute('href')).toBe('/creators?id=author-2');
       expect(link.querySelector('strong')?.textContent).toBe('');
+      // 补查由 effect 发起、提交后一拍才发出：这里等它发生，避免断言与 React 提交竞态
+      // （此前偶发 0 次调用，会让整份文件的门禁随机变红）。
       // 占位昵称的补查发生在渲染后的 effect 里：并发负载下首帧可能还没触发，必须等。
       await waitFor(() =>
         expect(getPublicAuthUserByIdMock).toHaveBeenCalledWith('author-2'),
@@ -317,9 +728,17 @@ describe('GameDetailPage', () => {
       <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
     );
 
-    const playButton = await screen.findByRole('button', { name: /立即玩/u });
+    const playButton = await screen.findByRole('button', { name: /开始游戏/u });
     expect((playButton as HTMLButtonElement).disabled).toBe(true);
-    expect(screen.getByText('请在电脑上游玩')).toBeTruthy();
+    expect(
+      within(await screen.findByTestId('platform-toast-host')).getByText(
+        '请在电脑上游玩',
+      ),
+    ).toBeTruthy();
+    // 行内那份保留（读屏用 `aria-describedby` 关联），但视觉隐藏、不占布局空间。
+    expect(
+      document.getElementById('game-mobile-playback-warning')?.className,
+    ).toContain('game-device-warning--sr');
   });
 
   it('rejects an invalid query id without requesting the API', async () => {
@@ -366,14 +785,80 @@ describe('GameDetailPage', () => {
     expect(await screen.findByText('暂未发布可玩版本')).toBeTruthy();
   });
 
-  it('付费已购买时显示立即玩并可进入游玩页', async () => {
+  it('展示共创授权、代际与溯源信息，并给出「开始共创」入口', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        forkAuthorization: 'nonCommercial',
+        forkCount: 3,
+        lineage: {
+          generation: 2,
+          rootGameId: 'game-root',
+          rootTitle: '根作品',
+          parentGameId: 'game-parent',
+          parentTitle: '原初之光',
+          parentAuthorName: '原作者',
+        },
+      }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('允许非商用共创')).toBeTruthy();
+    expect(screen.getByText('2 代三创 · 改编自父代《原初之光》')).toBeTruthy();
+    expect(screen.getByText('父代作者 原作者')).toBeTruthy();
+    expect(screen.getByText('累计衍生作品 3')).toBeTruthy();
+    // 已公开 + 授权开放 → 「开始共创」入口出现（M1 时它还不存在，这里钉住新契约）。
+    expect(screen.getByRole('button', { name: '开始共创' })).toBeTruthy();
+  });
+
+  it('旧数据缺少授权与血缘字段时只按禁止共创渲染', async () => {
+    getGameMock.mockResolvedValueOnce(createGame());
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('禁止共创')).toBeTruthy();
+    expect(screen.queryByText(/代作品/u)).toBeNull();
+    expect(screen.queryByText(/已被改编/u)).toBeNull();
+    expect(screen.queryByText(/允许/u)).toBeNull();
+  });
+
+  it('父作品已被软删除时不展示被删作品标题与作者名', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        forkAuthorization: 'full',
+        forkCount: 0,
+        lineage: {
+          generation: 2,
+          rootGameId: 'game-root',
+          rootTitle: null,
+          parentGameId: 'game-parent',
+          parentTitle: null,
+          parentAuthorName: null,
+        },
+      }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('允许全开放共创')).toBeTruthy();
+    expect(screen.getByText('2 代三创 · 原作品已不可用')).toBeTruthy();
+    expect(screen.queryByText(/改编自/u)).toBeNull();
+    // 血缘作者行（卡内 `.game-fork-lineage__author`）不该出现；hero 里的
+    // 「由 测试作者 制作」是作品自身署名，不在断言范围内。
+    expect(document.querySelector('.game-fork-lineage__author')).toBeNull();
+  });
+
+  it('付费已购买时显示开始游戏并可进入游玩页', async () => {
     const onPlay = vi.fn();
     getGameMock.mockResolvedValueOnce(
       createGame({ priceMudPoints: 120, purchased: true }),
     );
     render(<GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={onPlay} />);
 
-    const playButton = await screen.findByRole('button', { name: /立即玩/u });
+    const playButton = await screen.findByRole('button', { name: /开始游戏/u });
     expect((playButton as HTMLButtonElement).disabled).toBe(false);
     expect(screen.queryByRole('button', { name: /泥点购买/u })).toBeNull();
     expect(screen.getByText('120 泥点')).toBeTruthy();
@@ -382,7 +867,7 @@ describe('GameDetailPage', () => {
     expect(onPlay).toHaveBeenCalledWith('game-1');
   });
 
-  it('付费未购买但服务端已下发公开入口（作者/管理员）时显示立即玩而不是购买', async () => {
+  it('付费未购买但服务端已下发公开入口（作者/管理员）时显示开始游戏而不是购买', async () => {
     const onPlay = vi.fn();
     // 作者本人与管理员不会被记为已购买（purchased=false），但后端仍授予可玩入口。
     getGameMock.mockResolvedValueOnce(
@@ -390,7 +875,7 @@ describe('GameDetailPage', () => {
     );
     render(<GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={onPlay} />);
 
-    const playButton = await screen.findByRole('button', { name: /立即玩/u });
+    const playButton = await screen.findByRole('button', { name: /开始游戏/u });
     expect((playButton as HTMLButtonElement).disabled).toBe(false);
     expect(screen.queryByRole('button', { name: /泥点购买/u })).toBeNull();
     expect(screen.getByText('120 泥点')).toBeTruthy();
@@ -416,7 +901,7 @@ describe('GameDetailPage', () => {
     const buyButton = await screen.findByRole('button', {
       name: /120 泥点购买/u,
     });
-    expect(screen.queryByRole('button', { name: /立即玩/u })).toBeNull();
+    expect(screen.queryByRole('button', { name: /开始游戏/u })).toBeNull();
     // 定价资料卡展示价格；入口为空是服务端口径，不是「入口地址无效」。
     expect(screen.getByText('120 泥点')).toBeTruthy();
     expect(screen.queryByText('游戏入口地址无效')).toBeNull();
@@ -477,7 +962,9 @@ describe('GameDetailPage', () => {
     expect(
       await screen.findByText('购买成功，现在可以直接开始游玩。'),
     ).toBeTruthy();
-    expect(await screen.findByRole('button', { name: /立即玩/u })).toBeTruthy();
+    expect(
+      await screen.findByRole('button', { name: /开始游戏/u }),
+    ).toBeTruthy();
   });
 
   it('余额不足时失败关闭并给出充值入口', async () => {
@@ -510,7 +997,7 @@ describe('GameDetailPage', () => {
     fireEvent.click(screen.getByRole('button', { name: '去充值' }));
     expect(onOpenRecharge).toHaveBeenCalledTimes(1);
     // 失败关闭：既没有游玩入口，也没有伪造成功。
-    expect(screen.queryByRole('button', { name: /立即玩/u })).toBeNull();
+    expect(screen.queryByRole('button', { name: /开始游戏/u })).toBeNull();
     expect(screen.queryByText('购买成功，现在可以直接开始游玩。')).toBeNull();
     expect(screen.getByRole('button', { name: /120 泥点购买/u })).toBeTruthy();
   });
@@ -544,7 +1031,7 @@ describe('GameDetailPage', () => {
     expect(screen.getByRole('button', { name: /120 泥点购买/u })).toBeTruthy();
   });
 
-  it('旧响应缺价格且没有可玩入口时说明「立即玩」为何不可用', async () => {
+  it('旧响应缺价格且没有可玩入口时说明「开始游戏」为何不可用', async () => {
     getGameMock.mockResolvedValueOnce(
       createGame({
         // 旧响应没有买断价：按免费兜底会被判成可玩，但服务端并没有下发入口。
@@ -557,14 +1044,22 @@ describe('GameDetailPage', () => {
       <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
     );
 
-    const playButton = await screen.findByRole('button', { name: /立即玩/u });
+    const playButton = await screen.findByRole('button', { name: /开始游戏/u });
     await waitFor(() =>
       expect((playButton as HTMLButtonElement).disabled).toBe(true),
     );
     // 禁用按钮必须带可操作说明，否则用户只看到一个点不动的按钮。
-    const reason = screen.getByText('暂时拿不到可玩入口，请刷新页面后重试。');
-    expect(reason.id).toBe('game-entry-missing-warning');
-    expect(playButton.getAttribute('aria-describedby')).toBe(reason.id);
+    // 可见提示走 toast（不占操作行布局）；行内那份保留 id 供 aria-describedby 关联，但视觉隐藏。
+    expect(
+      within(await screen.findByTestId('platform-toast-host')).getByText(
+        '暂时拿不到可玩入口，请刷新页面后重试。',
+      ),
+    ).toBeTruthy();
+    const reason = document.getElementById('game-entry-missing-warning');
+    expect(reason?.className).toContain('game-device-warning--sr');
+    expect(playButton.getAttribute('aria-describedby')).toBe(
+      'game-entry-missing-warning',
+    );
   });
 });
 
@@ -627,9 +1122,13 @@ describe('GameDetailPage 作者视角', () => {
     expect(getMyGameMock).toHaveBeenCalledWith('game-1');
     expect(getGameMock).not.toHaveBeenCalled();
 
-    const playButton = screen.getByRole('button', { name: /立即玩/u });
+    const playButton = screen.getByRole('button', { name: /开始游戏/u });
     expect((playButton as HTMLButtonElement).disabled).toBe(true);
-    expect(screen.getByText('作品尚未公开，暂时没有在线可玩版本')).toBeTruthy();
+    expect(
+      within(await screen.findByTestId('platform-toast-host')).getByText(
+        '作品尚未公开，暂时没有在线可玩版本',
+      ),
+    ).toBeTruthy();
   });
 
   it('作者视角的封面换签带上 gameId，走 owner 作用域路由', async () => {
@@ -778,7 +1277,7 @@ describe('GameDetailPage 作者视角', () => {
       expect(listGameReviewsMock).toHaveBeenCalledWith('game-1', 1),
     );
     expect(getMyGameReviewMock).toHaveBeenCalledWith('game-1');
-    const playButton = screen.getByRole('button', { name: /立即玩/u });
+    const playButton = screen.getByRole('button', { name: /开始游戏/u });
     expect((playButton as HTMLButtonElement).disabled).toBe(false);
   });
 
@@ -993,18 +1492,21 @@ describe('GameGalleryPage 筛选与返回上下文', () => {
 
   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 },
-      }),
-    ]);
+    listGamesMock.mockResolvedValue({
+      games: [
+        createGame({
+          id: 'game-desktop',
+          title: '桌面专属',
+          deviceSupport: { desktop: true, mobile: false, touch: false },
+        }),
+        createGame({
+          id: 'game-mobile',
+          title: '移动可玩',
+          deviceSupport: { desktop: false, mobile: true, touch: true },
+        }),
+      ],
+      nextCursor: null,
+    });
     render(<GameGalleryPage onOpenDetail={vi.fn()} />);
 
     expect(await screen.findByText('桌面专属')).toBeTruthy();
@@ -1021,13 +1523,16 @@ describe('GameGalleryPage 筛选与返回上下文', () => {
 
   it('筛选结果为空时提供重置筛选，并清理地址栏条件', async () => {
     resetGalleryContext();
-    listGamesMock.mockResolvedValue([
-      createGame({
-        id: 'game-desktop',
-        title: '桌面专属',
-        deviceSupport: { desktop: true, mobile: false, touch: false },
-      }),
-    ]);
+    listGamesMock.mockResolvedValue({
+      games: [
+        createGame({
+          id: 'game-desktop',
+          title: '桌面专属',
+          deviceSupport: { desktop: true, mobile: false, touch: false },
+        }),
+      ],
+      nextCursor: null,
+    });
     render(<GameGalleryPage onOpenDetail={vi.fn()} />);
     expect(await screen.findByText('桌面专属')).toBeTruthy();
 
@@ -1051,7 +1556,10 @@ describe('GameGalleryPage 筛选与返回上下文', () => {
       '',
       '/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: '星轨防线' })]);
+    listGamesMock.mockResolvedValue({
+      games: [createGame({ title: '星轨防线' })],
+      nextCursor: null,
+    });
     render(<GameGalleryPage onOpenDetail={vi.fn()} />);
 
     await waitFor(() =>
@@ -1079,18 +1587,21 @@ describe('GameGalleryPage 筛选与返回上下文', () => {
       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 },
-      }),
-    ]);
+    listGamesMock.mockResolvedValue({
+      games: [
+        createGame({
+          id: 'game-desktop',
+          title: '桌面专属',
+          deviceSupport: { desktop: true, mobile: false, touch: false },
+        }),
+        createGame({
+          id: 'game-mobile',
+          title: '移动可玩',
+          deviceSupport: { desktop: false, mobile: true, touch: true },
+        }),
+      ],
+      nextCursor: null,
+    });
 
     const { container } = render(
       <div className="platform-tab-panel">
@@ -1109,7 +1620,10 @@ describe('GameGalleryPage 筛选与返回上下文', () => {
   it('打开详情时保存目录滚动位置，返回后按同一容器复位', async () => {
     resetGalleryContext();
     const onOpenDetail = vi.fn();
-    listGamesMock.mockResolvedValue([createGame({ title: '星轨防线' })]);
+    listGamesMock.mockResolvedValue({
+      games: [createGame({ title: '星轨防线' })],
+      nextCursor: null,
+    });
     const { container } = render(
       <div className="platform-tab-panel">
         <GameGalleryPage onOpenDetail={onOpenDetail} />
@@ -1131,13 +1645,16 @@ describe('GameGalleryPage 筛选与返回上下文', () => {
     );
   });
 
-  it('首屏「立即试玩」滚动到列表，而不是打开第一款游戏详情', async () => {
+  it('首屏「浏览作品」滚动到列表，而不是打开第一款游戏详情', async () => {
     resetGalleryContext();
     const onOpenDetail = vi.fn();
-    listGamesMock.mockResolvedValue([
-      createGame({ id: 'game-1', title: '星轨防线' }),
-      createGame({ id: 'game-2', title: '第二款' }),
-    ]);
+    listGamesMock.mockResolvedValue({
+      games: [
+        createGame({ id: 'game-1', title: '星轨防线' }),
+        createGame({ id: 'game-2', title: '第二款' }),
+      ],
+      nextCursor: null,
+    });
     const scrollTo = vi.fn();
     const originalScrollTo = Object.getOwnPropertyDescriptor(
       Element.prototype,
@@ -1156,7 +1673,7 @@ describe('GameGalleryPage 筛选与返回上下文', () => {
       );
       expect(await screen.findByText('星轨防线')).toBeTruthy();
 
-      fireEvent.click(screen.getByRole('button', { name: /立即试玩/u }));
+      fireEvent.click(screen.getByRole('button', { name: /浏览作品/u }));
 
       expect(onOpenDetail).not.toHaveBeenCalled();
       expect(scrollTo).toHaveBeenCalledTimes(1);
@@ -1245,9 +1762,12 @@ describe('游戏封面与截图展示', () => {
 
   it('广场卡片用签名地址展示真实封面', async () => {
     resetGalleryContext();
-    listGamesMock.mockResolvedValue([
-      createGame({ coverObjectKey: 'game-distribution/cover/alpha.png' }),
-    ]);
+    listGamesMock.mockResolvedValue({
+      games: [
+        createGame({ coverObjectKey: 'game-distribution/cover/alpha.png' }),
+      ],
+      nextCursor: null,
+    });
     render(<GameGalleryPage onOpenDetail={vi.fn()} />);
 
     const card = (await screen.findByText('星轨防线')).closest('button');
@@ -1265,14 +1785,21 @@ describe('游戏封面与截图展示', () => {
         ? `https://assets.example.test/${objectKey}`
         : '',
     );
-    listGamesMock.mockResolvedValue([
-      createGame({ id: 'game-none', title: '没有封面', coverObjectKey: null }),
-      createGame({
-        id: 'game-broken',
-        title: '换签失败',
-        coverObjectKey: 'game-distribution/cover/broken.png',
-      }),
-    ]);
+    listGamesMock.mockResolvedValue({
+      games: [
+        createGame({
+          id: 'game-none',
+          title: '没有封面',
+          coverObjectKey: null,
+        }),
+        createGame({
+          id: 'game-broken',
+          title: '换签失败',
+          coverObjectKey: 'game-distribution/cover/broken.png',
+        }),
+      ],
+      nextCursor: null,
+    });
     render(<GameGalleryPage onOpenDetail={vi.fn()} />);
 
     expect(await screen.findByText('没有封面')).toBeTruthy();
@@ -1347,3 +1874,3846 @@ describe('游戏封面与截图展示', () => {
     );
   });
 });
+
+function createLineageNode(
+  overrides: Partial<GameDistributionLineageNode> = {},
+): GameDistributionLineageNode {
+  return {
+    gameId: 'game-1',
+    title: '作品',
+    authorName: '作者',
+    generation: 1,
+    parentGameId: null,
+    playCount: 0,
+    status: 'published',
+    ...overrides,
+  };
+}
+
+describe('GameLineagePage', () => {
+  it('渲染整棵树、高亮来源作品，并把父作品不可用的节点降级展示', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: createLineageNode({
+        gameId: 'game-root',
+        title: '母版',
+        generation: 0,
+        parentGameId: null,
+      }),
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root',
+          title: '母版',
+          generation: 0,
+          parentGameId: null,
+          playCount: 30,
+        }),
+        createLineageNode({
+          gameId: 'game-mid',
+          title: '中间代',
+          generation: 1,
+          parentGameId: 'game-root',
+        }),
+        createLineageNode({
+          gameId: 'game-leaf',
+          title: '叶节点',
+          generation: 2,
+          parentGameId: 'game-removed',
+        }),
+      ],
+      truncated: false,
+    });
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-leaf"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    expect(await findTreeText('叶节点')).toBeTruthy();
+    expect(screen.getByText('中间代')).toBeTruthy();
+    // 当前作品高亮在它自己的节点卡片上。
+    expect(
+      screen.getByText('叶节点').closest('.game-lineage-node')?.className,
+    ).toContain('game-lineage-node--anchor');
+    // 父作品不在可见集合里：只标注「原作品已不可用」，不回显父作品内容。
+    expect(screen.getByText('原作品已不可用')).toBeTruthy();
+    // 任一公开节点都能进入对应详情页。
+    fireEvent.click(openButton('母版'));
+    expect(onOpenDetail).toHaveBeenCalledWith('game-root');
+  });
+
+  it('没有衍生作品时给出明确空态', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: createLineageNode({
+        gameId: 'game-root',
+        title: '母版',
+        generation: 0,
+        parentGameId: null,
+      }),
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root',
+          title: '母版',
+          generation: 0,
+          parentGameId: null,
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByText('这部作品还没有衍生作品，欢迎从它开始共创。'),
+    ).toBeTruthy();
+  });
+
+  it('没有任何可见节点时只渲染一条整体空态，不叠加衍生空态', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: null,
+      nodes: [],
+      truncated: false,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByText('这部作品还没有可展示的族谱节点。'),
+    ).toBeTruthy();
+    // 双重空态回归：整体空态已覆盖「没有节点」，不能再叠一条衍生空态。
+    expect(
+      screen.queryByText('这部作品还没有衍生作品，欢迎从它开始共创。'),
+    ).toBeNull();
+    expect(document.querySelectorAll('.game-lineage-tree')).toHaveLength(0);
+  });
+
+  it('只有母版时渲染母版节点并只给衍生空态，不给整体空态', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: createLineageNode({
+        gameId: 'game-root',
+        title: '母版',
+        generation: 0,
+        parentGameId: null,
+      }),
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root',
+          title: '母版',
+          generation: 0,
+          parentGameId: null,
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(await cardOf('母版')).toBeTruthy();
+    expect(
+      screen.getByText('这部作品还没有衍生作品，欢迎从它开始共创。'),
+    ).toBeTruthy();
+    expect(screen.queryByText('这部作品还没有可展示的族谱节点。')).toBeNull();
+  });
+
+  it('超出节点上限时如实标注截断，不静默丢弃', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: createLineageNode({
+        gameId: 'game-root',
+        title: '母版',
+        generation: 0,
+      }),
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root',
+          title: '母版',
+          generation: 0,
+        }),
+        createLineageNode({ gameId: 'game-2', title: '第二部', generation: 1 }),
+      ],
+      truncated: true,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByText('这部作品衍生较多，这里只展示前 2 个节点。'),
+    ).toBeTruthy();
+  });
+
+  it('根作品不可用时按代际回退展示，不空白也不报错', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: null,
+      nodes: [
+        createLineageNode({
+          gameId: 'game-leaf',
+          title: '叶节点',
+          generation: 1,
+          parentGameId: 'game-root',
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByText(
+        '母版已不可用，下面按代际关系展示仍可阅读的衍生作品。',
+      ),
+    ).toBeTruthy();
+    expect((await treeTexts('叶节点')).length).toBeGreaterThan(0);
+    expect(screen.getByText('原作品已不可用')).toBeTruthy();
+  });
+
+  it('未公开作品的详情页不渲染族谱入口', async () => {
+    getMyGameMock.mockResolvedValueOnce({
+      ...createGame({ status: 'unpublished' }),
+      latestVersion: null,
+      versions: [],
+    } as GameDistributionMyGame);
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        ownerView
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenLineage={vi.fn()}
+      />,
+    );
+
+    await screen.findByText('作品状态');
+    expect(screen.queryByRole('button', { name: '查看创作族谱' })).toBeNull();
+  });
+
+  it('加载失败走平台错误态并可重试', async () => {
+    getGameLineageMock
+      .mockRejectedValueOnce(new Error('网络错误'))
+      .mockResolvedValueOnce({
+        rootGameId: 'game-root',
+        root: createLineageNode({ gameId: 'game-root', title: '母版' }),
+        nodes: [
+          createLineageNode({ gameId: 'game-root', title: '母版' }),
+          createLineageNode({ gameId: 'game-2', title: '第二部' }),
+        ],
+        truncated: false,
+      });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText('网络错误')).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: '重试' }));
+    expect(await screen.findByText('第二部')).toBeTruthy();
+  });
+
+  it('缺少根作品编号时不发请求并提示编号无效', async () => {
+    render(
+      <GameLineagePage rootGameId="" onBack={vi.fn()} onOpenDetail={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('游戏编号无效')).toBeTruthy();
+    expect(getGameLineageMock).not.toHaveBeenCalled();
+  });
+
+  it('详情页共创卡里的族谱入口带上根作品与当前作品', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        lineage: {
+          generation: 1,
+          rootGameId: 'game-root',
+          rootTitle: '母版',
+          parentGameId: 'game-root',
+          parentTitle: '母版',
+          parentAuthorName: '原作者',
+        },
+      }),
+    );
+    const onOpenLineage = vi.fn();
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenLineage={onOpenLineage}
+      />,
+    );
+
+    fireEvent.click(
+      await screen.findByRole('button', { name: '查看创作族谱' }),
+    );
+    expect(onOpenLineage).toHaveBeenCalledWith('game-root', 'game-1');
+  });
+
+  it('没有族谱导航回调时不渲染族谱入口', async () => {
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    await screen.findByRole('heading', { name: '星轨防线' });
+    expect(screen.queryByRole('button', { name: '查看创作族谱' })).toBeNull();
+  });
+});
+
+describe('GameDetailPage 开始共创入口', () => {
+  it('已公开且授权开放时出现入口；唤起没被接手时降级给出可复制的作品 ID 与指引', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({ forkAuthorization: 'nonCommercial' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const entry = await screen.findByRole('button', { name: '开始共创' });
+    // 未展开前不露出获取方式。
+    expect(screen.queryByText(/从平台作品开始创作/u)).toBeNull();
+
+    // 进入唤起流程后再切假定时器：先让详情页的异步加载在真实定时器下完成。
+    vi.useFakeTimers();
+    fireEvent.click(entry);
+    // 主路径是唤起客户端，而不是先给手动方式。
+    expect(openForkProtocolMock).toHaveBeenCalledWith('game-1');
+    expect(screen.getByText('正在唤起陶泥儿客户端…')).toBeTruthy();
+    expect(screen.queryByText(/从平台作品开始创作/u)).toBeNull();
+
+    // 页面没有失焦 → 没有客户端接手 → 经过降级窗口后给手动路径。
+    await act(async () => {
+      vi.advanceTimersByTime(FORK_LAUNCH_FALLBACK_DELAY_MS + 10);
+    });
+    expect(screen.getByText(/没有检测到陶泥儿客户端/u)).toBeTruthy();
+    expect(
+      screen.getByText(
+        '在陶泥儿客户端里打开「从平台作品开始创作」，粘贴下面的作品 ID 或作品链接。',
+      ),
+    ).toBeTruthy();
+    expect(screen.getByText('game-1')).toBeTruthy();
+    expect(screen.getByText(/\/games\/detail\?id=game-1$/u)).toBeTruthy();
+    // 冻结口径：开始共创 = 复制整个工程继续改造；只保留一句话告知（对他人可见 + 不可撤销）。
+    expect(
+      screen.getByText(/整个工程（含素材与文档）复制到你的项目里继续改造/u),
+    ).toBeTruthy();
+    expect(screen.getByText(/复制后对他人可见，且不可撤销/u)).toBeTruthy();
+
+    fireEvent.click(screen.getByRole('button', { name: '复制作品 ID' }));
+    await act(async () => {});
+    expect(copyTextToClipboardMock).toHaveBeenCalledWith('game-1');
+    expect(screen.getByRole('button', { name: '作品 ID 已复制' })).toBeTruthy();
+
+    fireEvent.click(screen.getByRole('button', { name: '复制作品链接' }));
+    await act(async () => {});
+    expect(copyTextToClipboardMock).toHaveBeenCalledWith(
+      expect.stringContaining('/games/detail?id=game-1'),
+    );
+    expect(screen.getByRole('button', { name: '作品链接已复制' })).toBeTruthy();
+    vi.useRealTimers();
+  });
+
+  it('桌面端唤起后页面失焦即认为客户端接手：只给状态反馈，不出降级面板', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({ forkAuthorization: 'full' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const entry = await screen.findByRole('button', { name: '开始共创' });
+    vi.useFakeTimers();
+    fireEvent.click(entry);
+    expect(openForkProtocolMock).toHaveBeenCalledWith('game-1');
+
+    // 失焦 = 浏览器把焦点交给了外部协议处理器。
+    act(() => {
+      window.dispatchEvent(new Event('blur'));
+    });
+    await act(async () => {
+      vi.advanceTimersByTime(FORK_LAUNCH_FALLBACK_DELAY_MS + 10);
+    });
+
+    expect(screen.getByText(/已唤起陶泥儿客户端/u)).toBeTruthy();
+    // 已接手就不算降级：不出现手动获取的作品 ID 与复制按钮。
+    expect(screen.queryByText(/作品 ID：/u)).toBeNull();
+    expect(screen.queryByRole('button', { name: '复制作品 ID' })).toBeNull();
+    vi.useRealTimers();
+  });
+
+  it('移动端不尝试唤起，直接给手动路径', async () => {
+    setViewportWidth(375);
+    getGameMock.mockResolvedValueOnce(
+      createGame({ forkAuthorization: 'nonCommercial' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: '开始共创' }));
+
+    expect(openForkProtocolMock).not.toHaveBeenCalled();
+    expect(screen.getByText(/当前设备无法直接唤起客户端/u)).toBeTruthy();
+    expect(screen.getByText('game-1')).toBeTruthy();
+    expect(screen.getByRole('button', { name: '复制作品 ID' })).toBeTruthy();
+  });
+
+  it('授权为禁止共创时主操作仍在但置灰，点击给出原因', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({ forkAuthorization: 'forbidden' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const blocked = await screen.findByRole('button', {
+      name: '开始共创',
+    });
+    // 不静默隐藏：按钮在，但是 aria-disabled + 有原因（悬停 title）。
+    expect(blocked.getAttribute('aria-disabled')).toBe('true');
+    expect(blocked.getAttribute('title')).toContain('禁止共创');
+    // 点击给出可读原因（不发起唤起）。
+    fireEvent.click(blocked);
+    expect(
+      await screen.findByText(
+        /作者未开放共创授权（禁止共创），无法开始共创这部作品。/u,
+      ),
+    ).toBeTruthy();
+    expect(openForkProtocolMock).not.toHaveBeenCalled();
+  });
+
+  it('未公开作品不出现开始共创入口', async () => {
+    getMyGameMock.mockResolvedValueOnce({
+      ...createGame({ status: 'unpublished', forkAuthorization: 'full' }),
+      latestVersion: null,
+      versions: [],
+    } as GameDistributionMyGame);
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        ownerView
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+      />,
+    );
+
+    await screen.findByText('作品状态');
+    expect(screen.queryByRole('button', { name: '开始共创' })).toBeNull();
+    expect(screen.queryByRole('button', { name: '登录后开始共创' })).toBeNull();
+  });
+
+  it('未安装客户端：唤起后没被接管 → 打开同一个下载入口 + 给出人话提示', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({ id: 'game-1', forkAuthorization: 'full' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    // 先拿到按钮再开假定时器：findBy* 依赖真实定时器。
+    const entry = await screen.findByRole('button', { name: '开始共创' });
+    vi.useFakeTimers();
+    fireEvent.click(entry);
+    // 唤起已发出，但还没有任何「客户端接手」信号。
+    expect(openForkProtocolMock).toHaveBeenCalledWith('game-1');
+    expect(requestClientDownloadMock).not.toHaveBeenCalled();
+    expect(screen.getByText('正在唤起陶泥儿客户端…')).toBeTruthy();
+
+    await act(async () => {
+      vi.advanceTimersByTime(FORK_LAUNCH_FALLBACK_DELAY_MS + 50);
+    });
+
+    // 超时 = 没有客户端接手：打开与顶栏「下载客户端」**同一个**入口 + 保留手动复制路径。
+    expect(requestClientDownloadMock).toHaveBeenCalledTimes(1);
+    expect(
+      screen.getByText(/没有检测到陶泥儿客户端，已打开下载入口/u),
+    ).toBeTruthy();
+    expect(screen.getByRole('button', { name: '复制作品 ID' })).toBeTruthy();
+    vi.useRealTimers();
+  });
+
+  it('已安装客户端：失焦被接管 → 不打开下载入口', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({ id: 'game-1', forkAuthorization: 'full' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const entry = await screen.findByRole('button', { name: '开始共创' });
+    vi.useFakeTimers();
+    fireEvent.click(entry);
+    // 浏览器把焦点交给外部协议处理器 → 视为客户端接手。
+    act(() => {
+      window.dispatchEvent(new Event('blur'));
+    });
+    await act(async () => {
+      vi.advanceTimersByTime(FORK_LAUNCH_FALLBACK_DELAY_MS + 50);
+    });
+
+    expect(requestClientDownloadMock).not.toHaveBeenCalled();
+    expect(screen.getByText(/已唤起陶泥儿客户端/u)).toBeTruthy();
+    vi.useRealTimers();
+  });
+
+  it('移动端：不尝试唤起，直接给出下载入口与手动复制路径', async () => {
+    setViewportWidth(390);
+    getGameMock.mockResolvedValueOnce(
+      createGame({ id: 'game-1', forkAuthorization: 'full' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: '开始共创' }));
+
+    expect(openForkProtocolMock).not.toHaveBeenCalled();
+    expect(requestClientDownloadMock).toHaveBeenCalledTimes(1);
+    expect(screen.getByText(/当前设备无法直接唤起客户端/u)).toBeTruthy();
+  });
+
+  it('玩家侧（默认入口，未登录）入口是次要小按钮「登录后开始共创」，点击走仓库既有登录门禁而不是静默隐藏', async () => {
+    authUiMock.value.user = null;
+    authUiMock.value.canAccessProtectedData = false;
+    // 入口上下文 = 玩家侧：URL 上没有共创来源标记（默认深链也是玩家侧）。
+    window.history.replaceState(null, '', '/games/detail?id=game-1');
+    getGameMock.mockResolvedValueOnce(
+      createGame({ forkAuthorization: 'full' }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const gate = await screen.findByRole('button', {
+      name: '登录后开始共创',
+    });
+    // 文案如实：玩家侧（未登录）只有「登录后开始共创」，没有共创者侧那条主操作词。
+    expect(screen.queryByRole('button', { name: '开始共创' })).toBeNull();
+    expect(screen.queryByText(/从平台作品开始创作/u)).toBeNull();
+
+    fireEvent.click(gate);
+    expect(authUiMock.value.openLoginModal).toHaveBeenCalledTimes(1);
+    // 未登录既不唤起客户端，也不展开获取方式。
+    expect(openForkProtocolMock).not.toHaveBeenCalled();
+    expect(screen.queryByText(/从平台作品开始创作/u)).toBeNull();
+    // 入口上下文可观测：根节点带 `data-viewer-context`，按钮走「玩家侧」变体（不占重点色）。
+    expect(
+      document
+        .querySelector('.game-detail-page')
+        ?.getAttribute('data-viewer-context'),
+    ).toBe('player');
+    expect(gate.getAttribute('data-viewer-context')).toBe('player');
+    expect(gate.className).toContain('game-fork-remix-guest');
+    expect(gate.className).not.toContain('co-creation-fork-primary');
+  });
+
+  it('玩家侧变体的度量与配色：次要描边 + 32px/0.78rem，明显小于共创者侧的主操作（48px/0.94rem）', async () => {
+    // jsdom 不算几何：用 CSS 源码契约把「主次差异」钉死（真机几何由 smoke 记录）。
+    const css = readFileSync(
+      'src/components/game-distribution/gameDistribution.css',
+      'utf8',
+    );
+    expect(css).toMatch(
+      /\.game-fork-remix-link\.game-fork-remix-guest \{[\s\S]{0,400}?min-height: 2rem;/u,
+    );
+    expect(css).toMatch(
+      /\.game-fork-remix-link\.game-fork-remix-guest \{[\s\S]{0,400}?font-size: 0\.78rem;/u,
+    );
+    expect(css).toMatch(
+      /\.game-fork-remix-link\.game-fork-remix-guest \{[\s\S]{0,500}?background: var\(--platform-button-secondary-fill\);/u,
+    );
+    // 主操作（共创者那份）仍是实心强调 + lg 尺寸，两者不是同一套度量。
+    expect(css).toMatch(
+      /\.game-fork-remix-link\.co-creation-fork-primary \{[\s\S]{0,400}?min-height: 3rem;/u,
+    );
+    expect(css).toMatch(/background: var\(--platform-button-primary-solid\);/u);
+  });
+});
+
+describe('原版与二创对比入口', () => {
+  it('二创作品详情页给出「与原版对比」，带上原版与二创 id', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        lineage: {
+          generation: 1,
+          rootGameId: 'game-parent',
+          rootTitle: '原版作品',
+          parentGameId: 'game-parent',
+          parentTitle: '原版作品',
+          parentAuthorName: '原作者',
+        },
+      }),
+    );
+    const onOpenCompare = vi.fn();
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenCompare={onOpenCompare}
+      />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: '与原版对比' }));
+    expect(onOpenCompare).toHaveBeenCalledWith('game-parent', 'game-1');
+  });
+
+  it('母版（无父作品）不出现对比入口', async () => {
+    getGameMock.mockResolvedValueOnce(createGame());
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenCompare={vi.fn()}
+      />,
+    );
+
+    await screen.findByRole('heading', { name: '星轨防线' });
+    expect(screen.queryByRole('button', { name: '与原版对比' })).toBeNull();
+  });
+
+  it('树节点：显示游玩次数**子树合计**角标（▶ N），仍不渲染「与原版对比」', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: createLineageNode({
+        gameId: 'game-root',
+        title: '母版',
+        generation: 0,
+        parentGameId: null,
+        playCount: 1,
+      }),
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root',
+          title: '母版',
+          generation: 0,
+          parentGameId: null,
+          playCount: 1,
+        }),
+        createLineageNode({
+          gameId: 'game-leaf',
+          title: '叶节点',
+          generation: 1,
+          parentGameId: 'game-root',
+          playCount: 4,
+        }),
+        createLineageNode({
+          gameId: 'game-orphan',
+          title: '孤儿节点',
+          generation: 1,
+          parentGameId: 'game-missing',
+          playCount: 7,
+        }),
+      ],
+      truncated: false,
+    });
+    const onOpenCompare = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+        onOpenCompare={onOpenCompare}
+      />,
+    );
+
+    expect(await findTreeText('叶节点')).toBeTruthy();
+    // 口径变更（2026-10-07）：节点显示**子树合计**（`collectLineagePlayCountTotals().total`），
+    // 不是自身值；但**只显示一次** —— 卡面本体（广场卡）的「N 次游玩」就是它，
+    // 角标里那枚重复的 `▶ N` 已删除（截图反馈「▶N 同时出现在角标与 meta 行」）。
+    const rootCard = await cardOf('母版');
+    // 母版合计 = 自身 1 + 叶节点 4 = 5（孤儿节点挂在缺失的父下，不算它的后代）。
+    expect(rootCard.querySelector('.game-lineage-node__play-count')).toBeNull();
+    expect(
+      cardButtonOf(rootCard)?.querySelector('.game-card__play-count')
+        ?.textContent,
+    ).toBe('5 次游玩');
+    const leafCard = await cardOf('叶节点');
+    expect(leafCard.querySelector('.game-lineage-node__play-count')).toBeNull();
+    expect(
+      cardButtonOf(leafCard)?.querySelector('.game-card__play-count')
+        ?.textContent,
+    ).toBe('4 次游玩');
+    // 「含衍生」的口径说明挂在节点容器上（卡面那一行没法挂 title），悬停仍能看到分解。
+    expect(rootCard.getAttribute('title')).toContain('含衍生作品');
+    // 「与原版对比」仍然留在详情页，不在树里重复渲染。
+    expect(screen.queryByRole('button', { name: '与原版对比' })).toBeNull();
+    // 卡面**没有**动作按钮（整卡即入口）；游玩数由卡片自身承载（子树合计口径）。
+    expect(screen.queryByRole('button', { name: '打开作品' })).toBeNull();
+    expect(
+      screen.queryByRole('button', { name: '开始共创 叶节点' }),
+    ).toBeNull();
+    expect(within(await cardOf('叶节点')).getByText(/次游玩/u)).toBeTruthy();
+  });
+});
+
+describe('GameComparePage', () => {
+  it('左右并排渲染两侧作品并复用游玩页的同源 iframe', async () => {
+    getGameMock.mockImplementation((gameId: string) =>
+      Promise.resolve(
+        gameId === 'game-parent'
+          ? createGame({ id: 'game-parent', title: '原版作品' })
+          : createGame({
+              id: 'game-child',
+              title: '二创作品',
+              lineage: {
+                generation: 1,
+                rootGameId: 'game-parent',
+                rootTitle: '原版作品',
+                parentGameId: 'game-parent',
+                parentTitle: '原版作品',
+                parentAuthorName: '原作者',
+              },
+            }),
+      ),
+    );
+    render(
+      <GameComparePage
+        leftGameId="game-parent"
+        rightGameId="game-child"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText('原版作品')).toBeTruthy();
+    expect(screen.getByText('二创作品')).toBeTruthy();
+    expect(screen.getByText('母版')).toBeTruthy();
+    expect(screen.getByText('第 1 代')).toBeTruthy();
+
+    const frames = document.querySelectorAll('iframe.game-player-frame');
+    expect(frames).toHaveLength(2);
+    // 复用游玩页的嵌入属性：只允许脚本、不给同源、不带 referrer。
+    expect(frames[0]?.getAttribute('sandbox')).toBe('allow-scripts');
+    expect(frames[0]?.getAttribute('referrerpolicy')).toBe('no-referrer');
+    expect(frames[0]?.getAttribute('src')).toContain('/releases/version-1/');
+  });
+
+  it('任一侧不可读时只降级那一侧，另一侧照常渲染', async () => {
+    getGameMock.mockImplementation((gameId: string) =>
+      gameId === 'game-parent'
+        ? Promise.reject(new Error('作品不存在或未公开'))
+        : Promise.resolve(createGame({ id: 'game-child', title: '二创作品' })),
+    );
+    render(
+      <GameComparePage
+        leftGameId="game-parent"
+        rightGameId="game-child"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText('作品不存在或未公开')).toBeTruthy();
+    expect(screen.getByText('二创作品')).toBeTruthy();
+    // 降级那一侧不渲染 iframe，另一侧照常。
+    expect(document.querySelectorAll('iframe.game-player-frame')).toHaveLength(
+      1,
+    );
+  });
+});
+
+describe('GameThemesPage', () => {
+  it('渲染主题卡片（名称 / 角标 / 可见成员数）并可进入主题页', async () => {
+    listThemesMock.mockResolvedValue({
+      themes: [
+        {
+          themeId: 'theme-1',
+          name: '精选共创',
+          summary: '运营精选的共创主题',
+          badge: '精选',
+          memberCount: 2,
+        },
+      ],
+      nextCursor: null,
+    });
+    const onOpenTheme = vi.fn();
+    render(<GameThemesPage onBack={vi.fn()} onOpenTheme={onOpenTheme} />);
+
+    expect(await screen.findByText('精选共创')).toBeTruthy();
+    expect(screen.getByText('精选')).toBeTruthy();
+    expect(screen.getByText('2 棵作品树')).toBeTruthy();
+    // 末页 nextCursor 为 null：不渲染「加载更多」。
+    expect(screen.queryByRole('button', { name: '加载更多' })).toBeNull();
+
+    fireEvent.click(screen.getByRole('button', { name: /精选共创/u }));
+    expect(onOpenTheme).toHaveBeenCalledWith('theme-1');
+  });
+
+  it('有 nextCursor 时渲染「加载更多」并用游标追加下一页', async () => {
+    listThemesMock
+      .mockResolvedValueOnce({
+        themes: [
+          {
+            themeId: 'theme-1',
+            name: '第一页主题',
+            summary: '',
+            badge: '',
+            memberCount: 1,
+          },
+        ],
+        nextCursor: '100:theme-1',
+      })
+      .mockResolvedValueOnce({
+        themes: [
+          {
+            themeId: 'theme-2',
+            name: '第二页主题',
+            summary: '',
+            badge: '',
+            memberCount: 3,
+          },
+        ],
+        nextCursor: null,
+      });
+    render(<GameThemesPage onBack={vi.fn()} onOpenTheme={vi.fn()} />);
+
+    fireEvent.click(await screen.findByRole('button', { name: '加载更多' }));
+    await waitFor(() =>
+      expect(listThemesMock).toHaveBeenLastCalledWith('100:theme-1'),
+    );
+    expect(await screen.findByText('第二页主题')).toBeTruthy();
+    // 追加而不是替换。
+    expect(screen.getByText('第一页主题')).toBeTruthy();
+    expect(screen.queryByRole('button', { name: '加载更多' })).toBeNull();
+  });
+
+  it('没有主题时给出空态，失败时给出错误与重试', async () => {
+    listThemesMock.mockResolvedValueOnce({ themes: [], nextCursor: null });
+    render(<GameThemesPage onBack={vi.fn()} onOpenTheme={vi.fn()} />);
+    expect(
+      await screen.findByText('还没有已发布的共创主题，稍后再来看看。'),
+    ).toBeTruthy();
+
+    cleanup();
+    listThemesMock.mockRejectedValueOnce(new Error('网络错误'));
+    render(<GameThemesPage onBack={vi.fn()} onOpenTheme={vi.fn()} />);
+    expect(await screen.findByText('网络错误')).toBeTruthy();
+    expect(screen.getByRole('button', { name: '重试' })).toBeTruthy();
+  });
+});
+
+describe('GameThemePage', () => {
+  const rootGame = (id: string, title: string) =>
+    createGame({
+      id,
+      title,
+      lineage: {
+        generation: 0,
+        rootGameId: id,
+        rootTitle: title,
+        parentGameId: id,
+        parentTitle: title,
+        parentAuthorName: '原作者',
+      },
+    });
+
+  it('母版行的「N 次游玩」用子树合计（复用内嵌树那一次 /lineage，不多发请求）', async () => {
+    getThemeMock.mockResolvedValue({
+      themeId: 'theme-1',
+      name: '精选共创',
+      badge: null,
+      summary: null,
+      memberCount: 1,
+      roots: [
+        createGame({
+          id: 'game-root-1',
+          title: '根一',
+          playCount: 3,
+          lineage: { generation: 0 },
+        }),
+      ],
+    });
+    getGameLineageMock.mockResolvedValue({
+      rootGameId: 'game-root-1',
+      root: createLineageNode({
+        gameId: 'game-root-1',
+        title: '根一',
+        generation: 0,
+        parentGameId: null,
+        playCount: 3,
+      }),
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root-1',
+          title: '根一',
+          generation: 0,
+          parentGameId: null,
+          playCount: 3,
+        }),
+        createLineageNode({
+          gameId: 'game-child-1',
+          title: '衍生一',
+          generation: 1,
+          parentGameId: 'game-root-1',
+          playCount: 4,
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameThemePage
+        themeId="theme-1"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    // 合计 = 3 + 4 = 7（不是服务端的自身值 3），并给出分解。
+    const total = await screen.findByLabelText('游玩次数合计');
+    await waitFor(() =>
+      expect(total.textContent).toBe('7 次游玩（自身 3 + 衍生 4）'),
+    );
+    expect(screen.queryByText('3 次游玩')).toBeNull();
+    // 合计来自内嵌树那一次请求：主题页自己没有额外再拉一份 lineage。
+    expect(getGameLineageMock).toHaveBeenCalledTimes(1);
+    expect(getGameLineageMock).toHaveBeenCalledWith('game-root-1');
+  });
+
+  it('渲染主题头与逐根的内嵌作品树（复用族谱页）', async () => {
+    getThemeMock.mockResolvedValue({
+      themeId: 'theme-1',
+      name: '精选共创',
+      summary: '运营精选的共创主题',
+      badge: '精选',
+      memberCount: 2,
+      roots: [rootGame('game-root-1', '根一'), rootGame('game-root-2', '根二')],
+    });
+    getGameLineageMock.mockImplementation((rootGameId: string) =>
+      Promise.resolve({
+        rootGameId,
+        root: createLineageNode({
+          gameId: rootGameId,
+          title: `树 ${rootGameId}`,
+          generation: 0,
+          parentGameId: null,
+        }),
+        nodes: [
+          createLineageNode({
+            gameId: rootGameId,
+            title: `树 ${rootGameId}`,
+            generation: 0,
+            parentGameId: null,
+          }),
+        ],
+        truncated: false,
+      }),
+    );
+    const onOpenLineage = vi.fn();
+    render(
+      <GameThemePage
+        themeId="theme-1"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+        onOpenLineage={onOpenLineage}
+      />,
+    );
+
+    expect(await screen.findByText('精选共创')).toBeTruthy();
+    expect(screen.getByText('运营精选的共创主题')).toBeTruthy();
+    // 两个根各内嵌一棵树：树数据来自同一个 `/lineage` 查询。
+    expect(await screen.findByText('树 game-root-1')).toBeTruthy();
+    expect(screen.getByText('树 game-root-2')).toBeTruthy();
+    await waitFor(() => expect(getGameLineageMock).toHaveBeenCalledTimes(2));
+    expect(getGameLineageMock).toHaveBeenCalledWith('game-root-1');
+    expect(getGameLineageMock).toHaveBeenCalledWith('game-root-2');
+    // 内嵌模式不渲染族谱页外壳（页头/返回按钮），但保留「全屏查看」入口。
+    expect(
+      screen.getAllByRole('button', { name: '全屏查看族谱' }),
+    ).toHaveLength(2);
+    fireEvent.click(
+      screen.getAllByRole('button', { name: '全屏查看族谱' })[0]!,
+    );
+    expect(onOpenLineage).toHaveBeenCalledWith('game-root-1', 'game-root-1');
+  });
+
+  it('已发布但没有可见成员时给出空态而不是错误', async () => {
+    getThemeMock.mockResolvedValue({
+      themeId: 'theme-2',
+      name: '空主题',
+      summary: '',
+      badge: '',
+      memberCount: 0,
+      roots: [],
+    });
+    render(
+      <GameThemePage
+        themeId="theme-2"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByText('这个主题还没有可展示的作品树。'),
+    ).toBeTruthy();
+    expect(screen.queryByRole('button', { name: '重试' })).toBeNull();
+  });
+
+  it('主题不存在或未发布时走错误态（服务端 404 不返回空壳）', async () => {
+    getThemeMock.mockRejectedValueOnce(new Error('主题不存在'));
+    render(
+      <GameThemePage
+        themeId="theme-missing"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText('主题不存在')).toBeTruthy();
+    expect(screen.getByRole('button', { name: '重试' })).toBeTruthy();
+  });
+
+  it('roots 被截断时给出明确提示，且总数用 memberCount 而不是 roots 长度', async () => {
+    getThemeMock.mockResolvedValue({
+      themeId: 'theme-3',
+      name: '大主题',
+      summary: '',
+      badge: '',
+      memberCount: 120,
+      rootsTruncated: true,
+      roots: [rootGame('game-root-1', '根一')],
+    });
+    getGameLineageMock.mockResolvedValue({
+      rootGameId: 'game-root-1',
+      root: null,
+      nodes: [],
+      truncated: false,
+    });
+    render(
+      <GameThemePage
+        themeId="theme-3"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    // 总数是真实可见成员数（120），不是这一页拿到的 1 个。
+    expect(await screen.findByText('共 120 棵作品树')).toBeTruthy();
+    expect(screen.getByText(/这里只显示前 1 个，共 120 个/u)).toBeTruthy();
+    expect(screen.queryByText('共 1 棵作品树')).toBeNull();
+  });
+});
+
+describe('GameDetailPage 共创主题入口', () => {
+  it('渲染所属共创主题角标并可进入主题页', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        themes: [{ themeId: 'theme-1', name: '精选共创', badge: '精选' }],
+      }),
+    );
+    const onOpenTheme = vi.fn();
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenTheme={onOpenTheme}
+      />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: /精选共创/u }));
+    expect(onOpenTheme).toHaveBeenCalledWith('theme-1');
+  });
+
+  it('没有所属主题时不渲染主题容器（空数组不是缺键）', async () => {
+    getGameMock.mockResolvedValueOnce(createGame({ themes: [] }));
+    render(
+      <GameDetailPage
+        gameId="game-1"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenTheme={vi.fn()}
+      />,
+    );
+
+    await screen.findByRole('heading', { name: '星轨防线' });
+    expect(document.querySelector('.game-fork-theme-list')).toBeNull();
+  });
+});
+
+/** 4 节点、3 代的血缘链数据集（根 → 1 代 → 2 代 → 当前），供详情页血缘链用例共用。 */
+function buildChainDataset() {
+  return {
+    rootGameId: 'game-root',
+    root: null,
+    nodes: [
+      createLineageNode({
+        gameId: 'game-root',
+        title: '根原创',
+        authorName: '根作者',
+        generation: 0,
+        parentGameId: null,
+      }),
+      createLineageNode({
+        gameId: 'game-mid',
+        title: '一代作品',
+        authorName: '一代作者',
+        generation: 1,
+        parentGameId: 'game-root',
+      }),
+      createLineageNode({
+        gameId: 'game-current',
+        title: '当前作品',
+        authorName: '当前作者',
+        generation: 2,
+        parentGameId: 'game-mid',
+      }),
+    ],
+    truncated: false,
+  };
+}
+
+/**
+ * 父代 / 子代数据集：root → mid → current（锚点）→ child1/child2（直接子代），
+ * child1 → grandchild（孙代，不算「直接子代」）；root → uncle 是旁支。
+ */
+/** 演示树形状（`共创演示·A0`）：A0 → A1/A2/A3；A1 → A11/A12；A11 → A111；A2 → A21，全部 0 热度。 */
+const demoShapeTree = {
+  rootGameId: 'A0',
+  root: createLineageNode({
+    gameId: 'A0',
+    title: '母版甲',
+    generation: 0,
+    parentGameId: null,
+    playCount: 0,
+  }),
+  nodes: [
+    ['A0', '母版甲', 0, null],
+    ['A1', '一代甲', 1, 'A0'],
+    ['A2', '一代乙', 1, 'A0'],
+    ['A3', '一代丙', 1, 'A0'],
+    ['A11', '二代甲', 2, 'A1'],
+    ['A12', '二代乙', 2, 'A1'],
+    ['A21', '二代丙', 2, 'A2'],
+    ['A111', '三代甲', 3, 'A11'],
+  ].map(([gameId, title, generation, parentGameId]) =>
+    createLineageNode({
+      gameId: gameId as string,
+      title: title as string,
+      generation: generation as number,
+      parentGameId: parentGameId as string | null,
+      playCount: 0,
+    }),
+  ),
+  truncated: false,
+};
+
+const relationTree = {
+  rootGameId: 'game-root',
+  root: createLineageNode({
+    gameId: 'game-root',
+    title: '根原创',
+    generation: 0,
+    parentGameId: null,
+  }),
+  nodes: [
+    createLineageNode({
+      gameId: 'game-root',
+      title: '根原创',
+      generation: 0,
+      parentGameId: null,
+    }),
+    createLineageNode({
+      gameId: 'game-mid',
+      title: '中间代',
+      generation: 1,
+      parentGameId: 'game-root',
+    }),
+    createLineageNode({
+      gameId: 'game-uncle',
+      title: '旁支叔伯',
+      generation: 1,
+      parentGameId: 'game-root',
+    }),
+    createLineageNode({
+      gameId: 'game-current',
+      title: '当前作品',
+      generation: 2,
+      parentGameId: 'game-mid',
+    }),
+    createLineageNode({
+      gameId: 'game-child-1',
+      title: '子代甲',
+      generation: 3,
+      parentGameId: 'game-current',
+    }),
+    createLineageNode({
+      gameId: 'game-child-2',
+      title: '子代乙',
+      generation: 3,
+      parentGameId: 'game-current',
+    }),
+    createLineageNode({
+      gameId: 'game-grandchild',
+      title: '孙代作品',
+      generation: 4,
+      parentGameId: 'game-child-1',
+    }),
+  ],
+  truncated: false,
+};
+
+/** 节点卡片上的主行动作按钮（打开详情）与它的卡片容器：多个 describe 共用。 */
+/**
+ * 「树里的元素」判定：**图下方的父代/子代块**（`.lineage-relations`）不算树。
+ *
+ * 为什么不用「先拿容器再查」：容器（画布/大纲）是异步挂载的，基于容器的查询可能早于挂载而回退到
+ * body，于是撞上关系块里的同名文案。这里改成「全页查 + 过滤掉关系块」，既不用等容器也不会撞。
+ */
+/**
+ * 树里的元素判定：图下方的父代/子代清单不算树。
+ */
+const isInTree = (element: Element) =>
+  element.closest('.lineage-relations') === null;
+const treeTexts = async (text: string | RegExp) =>
+  (await screen.findAllByText(text)).filter(isInTree);
+
+/** 树里的节点卡（外层定位/状态 wrapper）。 */
+const treeNodeCards = () =>
+  [...document.querySelectorAll('.game-lineage-node')].filter(
+    (node) => !node.closest('.lineage-relations'),
+  );
+
+/** 卡内标题文本（卡现在就是广场卡组件：标题在 `.game-card__title-row > strong`）。 */
+const cardTitleOf = (node: Element) =>
+  (
+    node.querySelector('.game-card__title-row > strong')?.textContent ?? ''
+  ).trim();
+
+/** 按标题找树里的节点卡（wrapper）——等它渲染出来。 */
+const cardOf = async (title: string) =>
+  waitFor(() => {
+    const found = treeNodeCards().find((node) => cardTitleOf(node) === title);
+    if (!found) throw new Error(`树里还没有《${title}》`);
+    return found as HTMLElement;
+  });
+
+/**
+ * 节点卡**本身就是一个按钮**（广场卡的整体点击入口）——没有「打开作品」这类卡内按钮。
+ * 需要「点开详情」时点它即可。
+ */
+const cardButtonOf = (node: Element) =>
+  node.querySelector('.game-card') as HTMLElement | null;
+const openButton = (title: string) => {
+  const node = treeNodeCards().find((item) => cardTitleOf(item) === title);
+  const button = node ? cardButtonOf(node) : null;
+  if (!button) throw new Error(`树里找不到《${title}》卡片`);
+  return button;
+};
+/** 在树区域里按文本查找（等挂载 + 排除关系块）。 */
+const findTreeText = async (text: string) => {
+  const [element] = await waitFor(async () => {
+    const found = await treeTexts(text);
+    if (found.length === 0) throw new Error(`树里还没有「${text}」`);
+    return found;
+  });
+  return element;
+};
+
+describe('GameLineagePage 可视化与交互', () => {
+  const treeWithSibling = {
+    rootGameId: 'game-root',
+    root: createLineageNode({
+      gameId: 'game-root',
+      title: '母版',
+      generation: 0,
+      parentGameId: null,
+    }),
+    nodes: [
+      createLineageNode({
+        gameId: 'game-root',
+        title: '母版',
+        generation: 0,
+        parentGameId: null,
+      }),
+      createLineageNode({
+        gameId: 'game-mid',
+        title: '中间代',
+        generation: 1,
+        parentGameId: 'game-root',
+      }),
+      createLineageNode({
+        gameId: 'game-leaf',
+        title: '叶节点',
+        generation: 2,
+        parentGameId: 'game-mid',
+      }),
+      createLineageNode({
+        gameId: 'game-other',
+        title: '旁支',
+        generation: 1,
+        parentGameId: 'game-root',
+      }),
+    ],
+    truncated: false,
+  };
+
+  it('画布节点卡片显示作者名（与血缘链/大纲同信息密度）', async () => {
+    getGameLineageMock.mockResolvedValueOnce(buildChainDataset());
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await cardOf('根原创');
+    // 画布（stacked）卡片必须有作者行：抽出 LineageNodeContent 时作者行一度只留在 inline
+    // 布局，族谱树页面因此丢了作者名（并被 check-game-distribution-lineage-e2e 抓到）。
+    const canvas = document.querySelector(
+      '.game-lineage-canvas',
+    ) as HTMLElement;
+    expect(
+      Array.from(canvas.querySelectorAll('.game-card__meta'))
+        .map((element) => element.textContent)
+        .sort(),
+    ).toEqual(['一代作者', '当前作者', '根作者']);
+  });
+
+  /** 画布上所有节点卡片的标题（排序后比较，避免依赖布局顺序）。 */
+  const canvasTitles = (canvas: HTMLElement) =>
+    [...canvas.querySelectorAll('.game-lineage-node')]
+      .map(
+        (card) =>
+          card.querySelector('.game-card__title-row > strong')?.textContent ??
+          '',
+      )
+      .sort();
+
+  it('区分父代 / 子代 / 自己 / 旁支：data-relation + 可读角标', async () => {
+    getGameLineageMock.mockResolvedValueOnce(relationTree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const currentCard = await cardOf('当前作品');
+    // 锚点 = 自己：不给「父代/子代」角标（它就是「当前作品」）。
+    expect(currentCard.getAttribute('data-relation')).toBe('self');
+    expect(
+      currentCard.querySelector('.game-lineage-node__relation'),
+    ).toBeNull();
+    // 祖先链 = 父代。
+    for (const title of ['根原创', '中间代']) {
+      const card = await cardOf(title);
+      expect(card.getAttribute('data-relation')).toBe('ancestor');
+      expect(
+        within(card).getByText('父代', {
+          selector: '.game-lineage-node__relation',
+        }),
+      ).toBeTruthy();
+    }
+    // 后代（含孙代）= 子代。
+    for (const title of ['子代甲', '子代乙', '孙代作品']) {
+      const card = await cardOf(title);
+      expect(card.getAttribute('data-relation')).toBe('descendant');
+      expect(
+        within(card).getByText('子代', {
+          selector: '.game-lineage-node__relation',
+        }),
+      ).toBeTruthy();
+    }
+    // 旁支不冒充直系。
+    const uncleCard = await cardOf('旁支叔伯');
+    expect(uncleCard.getAttribute('data-relation')).toBe('side');
+    expect(uncleCard.querySelector('.game-lineage-node__relation')).toBeNull();
+  });
+
+  it('「只看父代与子代」：只留祖先链 + 自己 + 直接子代，再点一次恢复整棵树', async () => {
+    getGameLineageMock.mockResolvedValueOnce(relationTree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const canvas = (await screen.findByLabelText('创作族谱树')) as HTMLElement;
+    // 默认关：整棵树（含旁支与孙代）。
+    expect(canvasTitles(canvas)).toEqual(
+      [
+        '当前作品',
+        '中间代',
+        '子代乙',
+        '子代甲',
+        '旁支叔伯',
+        '根原创',
+        '孙代作品',
+      ].sort(),
+    );
+    const toggle = screen.getByRole('button', { name: '只看父代与子代' });
+    expect(toggle.getAttribute('aria-pressed')).toBe('false');
+
+    fireEvent.click(toggle);
+    // 开：父代（祖先链）+ 自己 + **直接**子代——不多不少。
+    expect(canvasTitles(canvas)).toEqual(
+      ['当前作品', '根原创', '子代乙', '子代甲', '中间代'].sort(),
+    );
+    expect(canvasTitles(canvas)).not.toContain('孙代作品');
+    expect(canvasTitles(canvas)).not.toContain('旁支叔伯');
+    // 状态有明确的可视/可读反馈：按钮文案 + aria-pressed + 说明行。
+    expect(
+      screen
+        .getByRole('button', { name: '只看父代与子代（已开启）' })
+        .getAttribute('aria-pressed'),
+    ).toBe('true');
+    expect(
+      screen.getByText(
+        '只显示当前作品的父代（祖先链）与直接子代，再点一次恢复整棵树',
+      ),
+    ).toBeTruthy();
+
+    // 取消：回到整棵树。
+    fireEvent.click(
+      screen.getByRole('button', { name: '只看父代与子代（已开启）' }),
+    );
+    expect(canvasTitles(canvas)).toEqual(
+      [
+        '当前作品',
+        '中间代',
+        '子代乙',
+        '子代甲',
+        '旁支叔伯',
+        '根原创',
+        '孙代作品',
+      ].sort(),
+    );
+    expect(
+      screen
+        .getByRole('button', { name: '只看父代与子代' })
+        .getAttribute('aria-pressed'),
+    ).toBe('false');
+  });
+
+  it('子树高亮恒生效、开关已删除（不保留恒为 true 的控件）', async () => {
+    getGameLineageMock.mockResolvedValueOnce(relationTree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await cardOf('当前作品');
+    // ⑥ 复选框不存在（不是禁用、不是隐藏文案）。
+    expect(screen.queryByText('高亮整棵子树')).toBeNull();
+    expect(screen.queryByLabelText('高亮整棵子树')).toBeNull();
+    // 其他筛选控件还在，说明删的是这一个而不是整行。
+    expect(screen.getByLabelText('按热度排序')).toBeTruthy();
+
+    // 行为恒生效：hover 一个中间节点 → 它的**后代**（孙代）不降透明，旁支才降透明。
+    // 没有开关可关掉它，因为这段行为不再依赖任何状态。
+    const midCard = await cardOf('中间代');
+    fireEvent.mouseEnter(midCard);
+    expect((await cardOf('孙代作品')).className).not.toContain(
+      'game-lineage-node--dimmed',
+    );
+    expect((await cardOf('旁支叔伯')).className).toContain(
+      'game-lineage-node--dimmed',
+    );
+    // 子树里的节点带上「子树」强化类，与祖先路径（path）区分开。
+    expect((await cardOf('孙代作品')).className).toContain(
+      'game-lineage-node--subtree',
+    );
+    fireEvent.mouseLeave(midCard);
+    expect((await cardOf('旁支叔伯')).className).not.toContain(
+      'game-lineage-node--dimmed',
+    );
+  });
+
+  it('大纲行角标成组、绝不叠印（代际/主干/当前作品/关系同组，CSS 里不再有各自的绝对定位）', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(demoShapeTree);
+    render(
+      <GameLineagePage
+        rootGameId="A0"
+        highlightGameId="A111"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    const rows = [...outline.querySelectorAll('.lineage-outline__row')];
+    expect(rows.length).toBe(8);
+    for (const row of rows) {
+      const badges = row.querySelector('.game-lineage-node__badges');
+      expect(badges).toBeTruthy();
+      // 角标组的直接子元素 = 全部角标（没有任何角标被留在封面里各排各的）。
+      for (const chip of [...badges!.children]) {
+        expect(chip.parentElement).toBe(badges);
+      }
+      expect(
+        row.querySelector(
+          '.game-lineage-node__cover > .game-lineage-node__badge',
+        ),
+      ).toBeNull();
+      expect(
+        row.querySelector(
+          '.game-lineage-node__cover > .game-lineage-node__trunk',
+        ),
+      ).toBeNull();
+    }
+    // 主干在大纲里也出现（A0 / A1 / A11 / A111 是各自代的主干），且不再与代际角标各占各的绝对位置。
+    expect(
+      [...outline.querySelectorAll('.game-lineage-node__trunk')].length,
+    ).toBe(4);
+    // jsdom 不做布局（拿不到真实几何），所以这里钉的是**结构 + CSS 契约**：
+    // 角标组内一律静态定位，旧的「代际左上 / 主干右上」绝对定位必须已被删除。
+    const css = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    expect(css).toContain('.game-lineage-node__badges {');
+    expect(css).toMatch(
+      /\.game-lineage-node__badges \.game-lineage-node__badge,[\s\S]{0,600}?position: static;/u,
+    );
+    expect(css).not.toMatch(
+      /\.game-lineage-node__badge \{[^}]*?position: absolute/u,
+    );
+    expect(css).not.toMatch(
+      /\.game-lineage-node__trunk \{[^}]*?position: absolute/u,
+    );
+  });
+
+  it('大纲限宽居中、操作留在内容列右端；缩略图与画布统一 16:9', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(demoShapeTree);
+    render(
+      <GameLineagePage
+        rootGameId="A0"
+        highlightGameId="A111"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    const rows = [...outline.querySelectorAll('.lineage-outline__row')];
+    expect(rows.length).toBe(8);
+    // 操作是行的**最后一个子元素**（在行内 = 内容列右端），不会飘到屏幕最右。
+    for (const row of rows) {
+      expect(row.lastElementChild?.className).toContain(
+        'lineage-outline__actions',
+      );
+    }
+    // 内容列限宽 + 居中：宽屏不再整屏出血。
+    const css = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    expect(css).toMatch(/\.lineage-outline \{[\s\S]{0,500}?max-width: 54rem;/u);
+    expect(css).toMatch(/\.lineage-outline \{[\s\S]{0,500}?margin: 0 auto;/u);
+    // 缩略图 16:9（与画布同一比例），不再被角标撑成窄竖条。
+    expect(css).toMatch(
+      /\.game-lineage-node__content--inline \.game-lineage-node__cover \{[\s\S]{0,300}?aspect-ratio: 16 \/ 9;/u,
+    );
+    expect(LINEAGE_COVER_ASPECT).toBeCloseTo(16 / 9, 5);
+  });
+
+  it('初始适配：装得下就全览、装不下就停在可读下限（横向铺满）并明确提示', async () => {
+    // 情形 1：视口够大 → 宽高同时 fit，所有可见节点都在视口内、无提示。
+    const wideWidth = vi
+      .spyOn(Element.prototype, 'clientWidth', 'get')
+      .mockReturnValue(1600);
+    const wideHeight = vi
+      .spyOn(Element.prototype, 'clientHeight', 'get')
+      // 卡片改成信息区版式后整棵树更高（4 层 × ~400 + 间距 ≈ 1900），
+      // 要装下并在可读下限之上，视口就得足够高。
+      .mockReturnValue(1500);
+    try {
+      getGameLineageMock.mockResolvedValueOnce(demoShapeTree);
+      const first = render(
+        <GameLineagePage
+          rootGameId="A0"
+          highlightGameId="A111"
+          onBack={vi.fn()}
+          onOpenDetail={vi.fn()}
+        />,
+      );
+      const canvas = (await screen.findByLabelText(
+        '创作族谱树',
+      )) as HTMLElement;
+      await waitFor(() =>
+        expect(canvas.querySelectorAll('.game-lineage-node').length).toBe(8),
+      );
+      const view = readCanvasViewport(canvas);
+      expect(visibleCanvasCards(canvas, view).length).toBe(8);
+      expect(screen.queryByText(/其余代际在视口外/u)).toBeNull();
+      first.unmount();
+
+      // 情形 2：视口装不下全览（低于可读下限）→ 停在可读下限 + 明确提示，不静默丢代际。
+      wideWidth.mockReturnValue(420);
+      wideHeight.mockReturnValue(320);
+      getGameLineageMock.mockResolvedValueOnce(demoShapeTree);
+      render(
+        <GameLineagePage
+          rootGameId="A0"
+          highlightGameId="A111"
+          onBack={vi.fn()}
+          onOpenDetail={vi.fn()}
+        />,
+      );
+      const smallCanvas = (await screen.findByLabelText(
+        '创作族谱树',
+      )) as HTMLElement;
+      await waitFor(() =>
+        expect(smallCanvas.querySelectorAll('.game-lineage-node').length).toBe(
+          8,
+        ),
+      );
+      const smallView = readCanvasViewport(smallCanvas);
+      const visible = visibleCanvasCards(smallCanvas, smallView);
+      const floored = Math.abs(smallView.scale - 0.8) < 0.001;
+      // 二选一（都不允许「既没全览又没提示」）：要么全部可见，要么停在可读下限 + 提示出现。
+      expect(floored || visible.length === 8).toBe(true);
+      if (floored) {
+        expect(
+          screen.getByText(
+            '树较大：已按可读缩放显示（其余代际在视口外），拖拽平移查看，或点「总览」看全树。',
+          ),
+        ).toBeTruthy();
+        // 停在可读下限时仍然把当前作品放进视口（不是把它也丢出去）。
+        expect(visible).toContain(
+          smallCanvas.querySelector('.game-lineage-node--anchor'),
+        );
+      }
+    } finally {
+      wideWidth.mockRestore();
+      wideHeight.mockRestore();
+    }
+  });
+
+  it('停在可读下限时横向铺满视口：树又宽又高时不留左右大片空白', async () => {
+    // 宽而矮的视口：按宽度适配（>1）比按高度全览（<1）大得多 —— 旧口径会取 0.6 的可读下限，
+    // 于是内容只占视口宽度的一半（截图反馈「留白过多」）；新口径取「宽度适配」把横向铺满。
+    const widthSpy = vi
+      .spyOn(Element.prototype, 'clientWidth', 'get')
+      .mockReturnValue(1600);
+    const heightSpy = vi
+      .spyOn(Element.prototype, 'clientHeight', 'get')
+      .mockReturnValue(380);
+    try {
+      getGameLineageMock.mockResolvedValueOnce(demoShapeTree);
+      render(
+        <GameLineagePage
+          rootGameId="A0"
+          highlightGameId="A111"
+          onBack={vi.fn()}
+          onOpenDetail={vi.fn()}
+        />,
+      );
+      const canvas = (await screen.findByLabelText(
+        '创作族谱树',
+      )) as HTMLElement;
+      await waitFor(() =>
+        expect(canvas.querySelectorAll('.game-lineage-node').length).toBe(8),
+      );
+      const content = canvas.querySelector(
+        '.game-lineage-canvas__content',
+      ) as HTMLElement;
+      const layoutWidth = Number.parseFloat(content.style.width);
+      const view = readCanvasViewport(canvas);
+      // 可读下限之上的横向铺满 = 按宽度适配（FIT_PADDING=24 ⇒ 可用宽度 1600-48）。
+      const fitWidth = (1600 - 48) / layoutWidth;
+      expect(view.scale).toBeGreaterThan(0.8);
+      expect(view.scale).toBeCloseTo(fitWidth, 3);
+      // 内容宽度（含 FIT_PADDING 的一侧）铺到视口边缘附近：空白 ≤ 上下留白量级。
+      expect(layoutWidth * view.scale).toBeGreaterThan(1500);
+      expect(
+        screen.getByText(
+          '树较大：已按可读缩放显示（其余代际在视口外），拖拽平移查看，或点「总览」看全树。',
+        ),
+      ).toBeTruthy();
+    } finally {
+      widthSpy.mockRestore();
+      heightSpy.mockRestore();
+    }
+  });
+
+  it('画布卡片就是广场卡组件：角标走卡面 badge 槽、卡内没有动作按钮、整卡点击进详情', async () => {
+    getGameLineageMock.mockResolvedValueOnce(relationTree);
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    const card = await cardOf('当前作品');
+    const cardButton = cardButtonOf(card)!;
+    // ① 卡面 = 广场卡组件本身（同一个 `.game-card`），角标走它的 badge 槽。
+    expect(cardButton.className).toContain('game-card');
+    const badges = cardButton.querySelector(
+      '.game-card__badges',
+    ) as HTMLElement;
+    expect(badges).toBeTruthy();
+    expect(within(badges).getByText('当前作品')).toBeTruthy();
+    // ①' 角标**不再压在封面上**：角标槽排在封面之后、信息区之前（DOM 顺序即渲染顺序）。
+    const cover = cardButton.querySelector('.game-cover') as HTMLElement;
+    const body = cardButton.querySelector('.game-card__body') as HTMLElement;
+    expect(cover.compareDocumentPosition(badges)).toBe(
+      Node.DOCUMENT_POSITION_FOLLOWING,
+    );
+    expect(badges.compareDocumentPosition(body)).toBe(
+      Node.DOCUMENT_POSITION_FOLLOWING,
+    );
+    // ①'' 竖版画布有左侧代际轴 → 卡上不再重复「第 N 代」；玩数由卡面承载 → 角标里没有 ▶N。
+    expect(
+      cardButton.querySelector('.game-lineage-node__generation'),
+    ).toBeNull();
+    expect(
+      cardButton.querySelector('.game-lineage-node__play-count'),
+    ).toBeNull();
+    // ② 卡内**没有任何动作按钮**（打开作品 / 开始共创 都已从卡面移除）。
+    expect(within(cardButton).queryByRole('button')).toBeNull();
+    expect(within(cardButton).queryByText('打开作品')).toBeNull();
+    expect(within(cardButton).queryByText('开始共创')).toBeNull();
+    // ③ 作者走广场卡的 meta 行。
+    expect(cardButton.querySelector('.game-card__meta')?.textContent).toMatch(
+      /作者/u,
+    );
+    // ④ 整卡点击 = 进详情。
+    fireEvent.click(cardButton);
+    expect(onOpenDetail).toHaveBeenCalledWith('game-current');
+    // ⑤ 卡面适配与角标配色（沿用上一轮的变体色，未新增色值）。
+    const css = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    expect(css).toMatch(
+      /\.game-card--lineage \.game-cover \{[\s\S]{0,200}?aspect-ratio: 16 \/ 9;/u,
+    );
+    // 角标槽必须离开「卡内绝对定位浮层」（共享卡默认位置）→ 静态流式、排在封面下方。
+    expect(css).toMatch(
+      /\.game-card--lineage \.game-card__badges \{[\s\S]{0,300}?position: static;/u,
+    );
+    expect(css).toMatch(
+      /\.game-card--lineage \.game-card__badges > \* \{[\s\S]{0,300}?position: static;/u,
+    );
+    // 窄卡上标题独占一行、游玩数不再和标题抢行宽。
+    expect(css).toMatch(
+      /\.game-card--lineage \.game-card__title-row \{[\s\S]{0,200}?flex-direction: column;/u,
+    );
+    expect(css).toMatch(
+      /\.game-lineage-node__trunk \{[\s\S]{0,300}?--platform-warm-bg/u,
+    );
+    expect(css).toMatch(
+      /\.game-lineage-node__anchor \{[\s\S]{0,300}?background: var\(--platform-accent\)/u,
+    );
+    expect(css).toMatch(
+      /\.game-lineage-node__relation--ancestor \{[\s\S]{0,300}?--platform-cool-bg/u,
+    );
+    expect(css).toMatch(
+      /\.game-lineage-node__relation--descendant \{[\s\S]{0,300}?--platform-success-bg/u,
+    );
+  });
+  it('大纲行：按钮改名「打开作品 / 开始共创」，共创按钮用主要（填充）样式', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(relationTree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    const row = outline.querySelector('.lineage-outline__row')!;
+    const actions = row.querySelector('.lineage-outline__actions')!;
+    expect(actions.querySelectorAll('button')).toHaveLength(2);
+    expect(
+      within(actions as HTMLElement).getByRole('button', { name: /打开/u })
+        .textContent,
+    ).toBe('打开作品');
+    const coCreate = within(actions as HTMLElement).getByRole('button', {
+      name: /开始共创/u,
+    });
+    expect(coCreate.textContent).toBe('开始共创');
+    expect(coCreate.className).toContain('lineage-outline__action--co-create');
+    // 主要/次要的视觉区分同样落在大纲行（不只画布卡片）。
+    const outlineCss = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    expect(outlineCss).toMatch(
+      /\.lineage-outline__action--co-create \{[\s\S]{0,200}?--platform-button-primary-solid/u,
+    );
+    // 动作名用**精确**断言（不扫全页文本）：大纲行里恰好这两个可见名，且行内没有任何以 Fork
+    // 命名的可交互元素。
+    expect(
+      within(actions as HTMLElement)
+        .getAllByRole('button')
+        .map((button) => button.textContent),
+    ).toEqual(['打开作品', '开始共创']);
+    expect(
+      within(actions as HTMLElement).queryByRole('button', { name: /Fork/u }),
+    ).toBeNull();
+  });
+
+  it('滚轮 = 竖向平移（不缩放）；Ctrl/⌘+滚轮 = 缩放；Shift+滚轮 = 横向平移', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const canvas = (await screen.findByLabelText('创作族谱树')) as HTMLElement;
+    const content = canvas.querySelector(
+      '.game-lineage-canvas__content',
+    ) as HTMLElement;
+    const read = () => {
+      const m = /translate\(([-\d.]+)px, ([-\d.]+)px\) scale\(([\d.]+)\)/u.exec(
+        content.style.transform,
+      );
+      return {
+        x: Number(m?.[1]),
+        y: Number(m?.[2]),
+        scale: Number(m?.[3]),
+      };
+    };
+    const wheel = (init: Record<string, unknown>) =>
+      fireEvent.wheel(canvas, init); // 返回 false 表示事件被 preventDefault
+
+    // 先等初始适配稳定（jsdom 下退到可读缩放下限 80%），否则会把「适配后的首次写入」误当成滚轮的效果。
+    await waitFor(() =>
+      expect(document.querySelector('.game-lineage-zoom')?.textContent).toBe(
+        '80%',
+      ),
+    );
+    const start = read();
+    // 裸滚轮：**只竖向平移**，缩放不变，且事件被 preventDefault（页面不会滚）。
+    expect(wheel({ deltaY: 120 })).toBe(false); // 事件被 preventDefault（页面不会跟着滚）
+    const afterPlain = read();
+    expect(afterPlain.y).not.toBe(start.y);
+    expect(afterPlain.x).toBe(start.x);
+    expect(afterPlain.scale).toBe(start.scale);
+
+    // Ctrl + 滚轮：缩放（口径写明在报告与规范里）。
+    const beforeZoom = read();
+    wheel({ deltaY: -120, ctrlKey: true });
+    const afterZoom = read();
+    expect(afterZoom.scale).not.toBe(beforeZoom.scale);
+    // 缩放以视口中心为锚点（jsdom 视口为 0 时中心就是 0，位移会跟着变），所以这里只断言缩放变了。
+
+    // Shift + 滚轮：横向平移。
+    const beforeShift = read();
+    wheel({ deltaY: 120, shiftKey: true });
+    const afterShift = read();
+    expect(afterShift.x).not.toBe(beforeShift.x);
+    expect(afterShift.y).toBe(beforeShift.y);
+  });
+
+  it('滚轮监听仍是非 passive 且绑在画布元素上（不许退回 React onWheel / window）', async () => {
+    const source = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/GameLineagePage.tsx',
+        'utf8',
+      ),
+    );
+    // React 的 onWheel 是 passive 的（preventDefault 无效、页面照样滚）→ 画布上不能再用它。
+    expect(source).not.toContain('onWheel={handleWheel}');
+    expect(source).toContain("addEventListener('wheel'");
+    expect(source).toContain('{ passive: false }');
+    expect(source).toContain('viewportRef.current');
+    expect(source).not.toMatch(/window\.addEventListener\('wheel'/u);
+    // 平移必须过边界钳制，且**不再**是缩放。
+    expect(source).toContain('clampLineagePan');
+    expect(source).toMatch(/offsetY: clampLineagePan\(/u);
+  });
+
+  it('拖动平移：超过阈值才算拖动（禁选中/拖文本），未拖动时点击照常触发', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    const canvas = (await screen.findByLabelText('创作族谱树')) as HTMLElement;
+    const content = canvas.querySelector(
+      '.game-lineage-canvas__content',
+    ) as HTMLElement;
+    // 拖动前：不是 panning 态、全局也允许选择。
+    expect(canvas.className).not.toContain('game-lineage-canvas--panning');
+    expect(document.body.style.userSelect).toBe('');
+
+    // ① 只按下、不移动：不算拖动（不捕获、不拦），**节点按钮的 click 照常触发**。
+    fireEvent.pointerDown(canvas, { pointerId: 1, clientX: 100, clientY: 100 });
+    expect(canvas.className).not.toContain('game-lineage-canvas--panning');
+    expect(document.body.style.userSelect).toBe('');
+    const cardButton = cardButtonOf(await cardOf('叶节点'));
+    expect(cardButton).toBeTruthy();
+    fireEvent.click(cardButton as HTMLElement);
+    expect(onOpenDetail).toHaveBeenCalledTimes(1);
+    fireEvent.pointerUp(canvas, { pointerId: 1, clientX: 100, clientY: 100 });
+
+    // ② 移动超过阈值：进入拖动（panning 态 + 全局禁选 + transform 变化）。
+    const before = content.style.transform;
+    fireEvent.pointerDown(canvas, { pointerId: 2, clientX: 100, clientY: 100 });
+    fireEvent.pointerMove(canvas, { pointerId: 2, clientX: 160, clientY: 130 });
+    expect(canvas.className).toContain('game-lineage-canvas--panning');
+    expect(document.body.style.userSelect).toBe('none');
+    expect(content.style.transform).not.toBe(before);
+    // 拖动中的 selectstart / dragstart 被阻止（双保险）。
+    canvas.dispatchEvent(
+      new Event('selectstart', { bubbles: true, cancelable: true }),
+    );
+    canvas.dispatchEvent(
+      new Event('dragstart', { bubbles: true, cancelable: true }),
+    );
+
+    fireEvent.pointerUp(canvas, { pointerId: 2, clientX: 160, clientY: 130 });
+    expect(canvas.className).not.toContain('game-lineage-canvas--panning');
+    expect(document.body.style.userSelect).toBe('');
+  });
+
+  it('画布交互样式契约：禁选中/禁原生拖拽/滚轮到边界不外溢、图片不可拖', async () => {
+    const css = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    const canvasRule = css.slice(
+      css.indexOf('.game-lineage-canvas {'),
+      css.indexOf('.game-lineage-canvas {') + 1200,
+    );
+    expect(canvasRule).toContain('user-select: none');
+    expect(canvasRule).toContain('touch-action: none');
+    expect(canvasRule).toContain('overscroll-behavior: contain');
+    expect(css).toContain('.game-lineage-canvas--panning');
+    expect(css).toMatch(
+      /\.game-lineage-canvas img,[\s\S]{0,200}?-webkit-user-drag: none;/u,
+    );
+  });
+
+  it('节点是真实 DOM 卡片：主体点击=选中、标题/打开作品=进详情、当前作品有标记且父在上子在下', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-leaf"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    const leafCard = await cardOf('叶节点');
+    const rootCard = await cardOf('母版');
+    // 当前作品标记
+    expect(leafCard.getAttribute('aria-current')).toBe('true');
+    expect(rootCard.getAttribute('aria-current')).toBeNull();
+    expect(within(leafCard).getByText('当前作品')).toBeTruthy();
+    // 分层：子节点在父节点下方
+    expect(parseFloat(leafCard.style.top)).toBeGreaterThan(
+      parseFloat(rootCard.style.top),
+    );
+    // 正交 elbow 连线
+    const paths = document.querySelectorAll('path.game-lineage-edge');
+    expect(paths.length).toBeGreaterThan(0);
+    const firstEdgePath = paths[0]!.getAttribute('d') ?? '';
+    expect(firstEdgePath).toContain(' V ');
+    expect(firstEdgePath).not.toContain(' C ');
+
+    // 主行动作是**真实 button**：键盘（Tab + Enter）与点击都能打开详情。
+    const leafOpen = openButton('叶节点');
+    expect(leafOpen.tagName).toBe('BUTTON');
+    leafOpen.focus();
+    expect(document.activeElement).toBe(leafOpen);
+    fireEvent.click(leafOpen);
+    expect(onOpenDetail).toHaveBeenCalledWith('game-leaf');
+    // 卡面没有动作按钮：整卡（`.game-card`）点击就是「进详情」。
+    expect(
+      within(leafCard).queryByRole('button', { name: '打开作品' }),
+    ).toBeNull();
+    expect(
+      within(leafCard).queryByRole('button', { name: /开始共创/u }),
+    ).toBeNull();
+
+    // 整卡点击 = 进详情（选中/高亮改由悬停或键盘聚焦驱动）。
+    fireEvent.click(cardButtonOf(leafCard) as HTMLElement);
+    expect(onOpenDetail).toHaveBeenCalledTimes(2);
+    // 选中/高亮是 hover 语义：移入出现、移开消失（点击不再兼做选中）。
+    fireEvent.mouseEnter(leafCard);
+    expect(leafCard.className).toContain('game-lineage-node--pinned');
+    fireEvent.mouseLeave(leafCard);
+    expect(leafCard.className).not.toContain('game-lineage-node--pinned');
+  });
+
+  it('hover 一个节点高亮祖先路径与子树，其余节点降透明；移开后恢复', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const midCard = await cardOf('中间代');
+    const rootCard = await cardOf('母版');
+    const leafCard = await cardOf('叶节点');
+    const otherCard = await cardOf('旁支');
+
+    fireEvent.mouseEnter(midCard);
+    // 祖先（母版）+ 自身 + 子树（叶节点）都不降透明，旁支降透明。
+    expect(rootCard.className).not.toContain('game-lineage-node--dimmed');
+    expect(midCard.className).not.toContain('game-lineage-node--dimmed');
+    expect(leafCard.className).not.toContain('game-lineage-node--dimmed');
+    expect(otherCard.className).toContain('game-lineage-node--dimmed');
+    // 连线同样有活跃/降透明区分。
+    expect(
+      document.querySelectorAll('path.game-lineage-edge--active').length,
+    ).toBeGreaterThan(0);
+    expect(
+      document.querySelectorAll('path.game-lineage-edge--dimmed').length,
+    ).toBeGreaterThan(0);
+
+    fireEvent.mouseLeave(midCard);
+    expect(otherCard.className).not.toContain('game-lineage-node--dimmed');
+    expect(
+      document.querySelectorAll('path.game-lineage-edge--dimmed').length,
+    ).toBe(0);
+  });
+
+  it('初次进入满足宽高两个维度并带可读下限；总览按钮给全览', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await cardOf('母版');
+    // 初次适配在 effect 里落地：先等它生效（jsdom 无布局尺寸 → min(scaleX, scaleY) 远小于 1，
+    // 因此命中可读下限 80%）。
+    await waitFor(() =>
+      expect(document.querySelector('.game-lineage-zoom')?.textContent).toBe(
+        '80%',
+      ),
+    );
+    expect(screen.getByText(/已按可读缩放显示/u)).toBeTruthy();
+    // 主动点「总览」才做真正的全览（不受可读下限约束），提示随之收起。
+    fireEvent.click(screen.getByRole('button', { name: '总览' }));
+    expect(document.querySelector('.game-lineage-zoom')?.textContent).toBe(
+      '35%',
+    );
+    expect(screen.queryByText(/已按可读缩放显示/u)).toBeNull();
+  });
+
+  it('代际轴在固定层上（不随内容层缩放平移），放大后仍在画布左侧', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await cardOf('母版');
+    const axisLayer = document.querySelector('.game-lineage-canvas__axis');
+    expect(axisLayer).not.toBeNull();
+    expect(axisLayer?.querySelectorAll('.game-lineage-axis').length).toBe(3);
+    // 轴不在内容层里：不会跟着 transform 缩放/平移。
+    expect(
+      document.querySelector(
+        '.game-lineage-canvas__content .game-lineage-axis',
+      ),
+    ).toBeNull();
+    expect(axisLayer?.textContent).toContain('母版');
+
+    fireEvent.click(screen.getByRole('button', { name: '放大' }));
+    expect(document.querySelector('.game-lineage-canvas__axis')).not.toBeNull();
+    expect(axisLayer?.querySelectorAll('.game-lineage-axis').length).toBe(3);
+  });
+
+  it('节点封面：有 coverObjectKey 时用 GameCover 渲染缩略图，没有时不渲染封面块', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: null,
+      nodes: [
+        {
+          ...createLineageNode({
+            gameId: 'game-with-cover',
+            title: '有封面',
+            generation: 0,
+            parentGameId: null,
+          }),
+          coverObjectKey: 'game-distribution/cover/one.png',
+        },
+        createLineageNode({
+          gameId: 'game-without-cover',
+          title: '没封面',
+          generation: 1,
+          parentGameId: 'game-with-cover',
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await screen.findByText('有封面');
+    // 封面是卡片主视觉：**每个节点都有封面位**；没有 coverObjectKey 的节点走 GameCover
+    // 自带的「底色 + 图标」降级，所以只有带 key 的那个节点出现真实图片。
+    expect(
+      document.querySelectorAll('.game-lineage-node .game-cover'),
+    ).toHaveLength(2);
+    expect(document.querySelectorAll('img.game-cover__image')).toHaveLength(1);
+    const withoutCover = await cardOf('没封面');
+    expect(withoutCover.querySelector('.game-cover')).not.toBeNull();
+    expect(withoutCover.querySelector('img.game-cover__image')).toBeNull();
+  });
+
+  it('选中路径后祖先链持续强化并给出面包屑；取消选中后复原', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const leafCard = await cardOf('叶节点');
+    // 选中/高亮由悬停或键盘聚焦驱动（点击现在是「进详情」）。
+    fireEvent.mouseEnter(leafCard);
+
+    // 面包屑：母版 → 中间代 → 叶节点，祖先移出视口也能读。
+    const breadcrumb = screen.getByLabelText('已选中的路径');
+    expect(breadcrumb.textContent).toContain('母版');
+    expect(breadcrumb.textContent).toContain('中间代');
+    expect(breadcrumb.textContent).toContain('叶节点');
+    // 祖先链与目标持续强化（不依赖 hover），旁支仍是被压暗的一方。
+    expect((await cardOf('母版')).className).toContain(
+      'game-lineage-node--path',
+    );
+    expect((await cardOf('中间代')).className).toContain(
+      'game-lineage-node--path',
+    );
+    expect(leafCard.className).toContain('game-lineage-node--pinned');
+    expect((await cardOf('旁支')).className).toContain(
+      'game-lineage-node--dimmed',
+    );
+    // 祖先链的连线也进入强化态（这正是「共创路径」的可视表达）。
+    expect(
+      document.querySelectorAll('path.game-lineage-edge--active').length,
+    ).toBeGreaterThan(0);
+
+    fireEvent.mouseLeave(leafCard);
+    expect(screen.queryByLabelText('已选中的路径')).toBeNull();
+    expect((await cardOf('旁支')).className).not.toContain(
+      'game-lineage-node--dimmed',
+    );
+  });
+
+  it('缩放按钮改变百分比，「总览」重新适配', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await cardOf('母版');
+    const zoomLabel = () =>
+      document.querySelector('.game-lineage-zoom')?.textContent ?? '';
+    // 初次适配是 effect 里跑的：先等它落定（jsdom 无布局尺寸 → 命中可读下限 80%）。
+    await waitFor(() => expect(zoomLabel()).toBe('80%'));
+    fireEvent.click(screen.getByRole('button', { name: '放大' }));
+    expect(zoomLabel()).toBe('96%');
+    fireEvent.click(screen.getByRole('button', { name: '缩小' }));
+    expect(zoomLabel()).toBe('80%');
+    // 总览（强制全览）在 jsdom 下退到最小缩放下限。
+    fireEvent.click(screen.getByRole('button', { name: '总览' }));
+    expect(zoomLabel()).toBe('35%');
+  });
+
+  it('图谱卡不再打印动作：卡内没有「打开作品 / 开始共创」，整卡点击只进详情', async () => {
+    getGameLineageMock.mockResolvedValueOnce(treeWithSibling);
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    const leafCard = await cardOf('叶节点');
+    const cardButton = cardButtonOf(leafCard)!;
+    expect(within(cardButton).queryByRole('button')).toBeNull();
+    expect(within(cardButton).queryByText('开始共创')).toBeNull();
+    expect(within(cardButton).queryByText('打开作品')).toBeNull();
+    // 整卡点击 = 进详情（唤起客户端的主入口在详情页主操作行 / 大纲行）。
+    fireEvent.click(cardButton);
+    expect(onOpenDetail).toHaveBeenCalledWith('game-leaf');
+    expect(openForkProtocolMock).not.toHaveBeenCalled();
+  });
+  it('不可用父节点：可聚焦、不可点进详情，且不出现被删作品的标题与作者名', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: null,
+      nodes: [
+        createLineageNode({
+          gameId: 'game-leaf',
+          title: '叶节点',
+          generation: 1,
+          parentGameId: 'game-deleted',
+        }),
+      ],
+      truncated: false,
+    });
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    const stubTitle = await screen.findByText('原作品已不可用');
+    const stubCard = stubTitle.closest('.game-lineage-node') as HTMLElement;
+    expect(stubCard.getAttribute('tabindex')).toBe('0');
+    expect(stubCard.getAttribute('role')).toBeNull();
+    expect(stubCard.getAttribute('aria-disabled')).toBe('true');
+    // 被删作品只以「不可用」形式出现：没有标题、没有作者名、也没有开始共创/对比动作。
+    expect(document.querySelector('.game-lineage-node--stub')).toBeTruthy();
+    expect(screen.queryByText(/作者 game-deleted/u)).toBeNull();
+    // 占位节点渲染的仍是广场卡（本身是 button），但点击不导航。
+    fireEvent.click(cardButtonOf(stubCard) as HTMLElement);
+    expect(onOpenDetail).not.toHaveBeenCalled();
+  });
+});
+
+describe('GameLineagePage 筛选器 / 主干线 / 信息面板（文档对齐）', () => {
+  const tree = {
+    rootGameId: 'game-root',
+    root: createLineageNode({
+      gameId: 'game-root',
+      title: '根原创',
+      generation: 0,
+      parentGameId: null,
+      playCount: 5,
+    }),
+    nodes: [
+      createLineageNode({
+        gameId: 'game-root',
+        title: '根原创',
+        generation: 0,
+        parentGameId: null,
+        playCount: 5,
+      }),
+      createLineageNode({
+        gameId: 'hot',
+        title: '热门二创',
+        generation: 1,
+        parentGameId: 'game-root',
+        playCount: 999,
+      }),
+      createLineageNode({
+        gameId: 'cold',
+        title: '冷门二创',
+        generation: 1,
+        parentGameId: 'game-root',
+        playCount: 1,
+      }),
+      createLineageNode({
+        gameId: 'deep',
+        title: '深代作品',
+        generation: 2,
+        parentGameId: 'hot',
+        playCount: 3,
+      }),
+    ],
+    truncated: false,
+  };
+
+  it('顶部筛选器：世代筛选只留该代及祖先，改动类型禁用并说明原因', async () => {
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await screen.findByText('深代作品');
+    const changeType = screen.getByLabelText('按改动类型筛选');
+    expect((changeType as HTMLSelectElement).disabled).toBe(true);
+    expect(screen.getByText('改动说明是自由文本，暂无可筛选分类')).toBeTruthy();
+
+    fireEvent.change(screen.getByLabelText('按世代筛选'), {
+      target: { value: '1' },
+    });
+    // 保留第 0、1 代（树不断链），第 2 代被筛掉。
+    expect(screen.queryByText('深代作品')).toBeNull();
+    expect(await cardOf('热门二创')).toBeTruthy();
+    expect(await cardOf('根原创')).toBeTruthy();
+  });
+
+  it('按热度排序：同代内 playCount 高的排在前面', async () => {
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await findTreeText('热门二创');
+    fireEvent.click(screen.getByRole('checkbox', { name: '按热度排序' }));
+
+    const coldCard = await cardOf('冷门二创');
+    const hotCard = await cardOf('热门二创');
+    expect(parseFloat(hotCard.style.left)).toBeLessThan(
+      parseFloat(coldCard.style.left),
+    );
+  });
+
+  it('热度排序判据 = 自身 playCount（子树合计更高的兄弟排后面）', async () => {
+    // self-hot：自身 100、无子代（合计 100）。deep-hot：自身 5、但子代 200（合计 205）。
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'game-root',
+      root: createLineageNode({
+        gameId: 'game-root',
+        title: '母版',
+        generation: 0,
+        parentGameId: null,
+        playCount: 1,
+      }),
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root',
+          title: '母版',
+          generation: 0,
+          parentGameId: null,
+          playCount: 1,
+        }),
+        createLineageNode({
+          gameId: 'self-hot',
+          title: '自身热',
+          generation: 1,
+          parentGameId: 'game-root',
+          playCount: 100,
+        }),
+        createLineageNode({
+          gameId: 'deep-hot',
+          title: '后代热',
+          generation: 1,
+          parentGameId: 'game-root',
+          playCount: 5,
+        }),
+        createLineageNode({
+          gameId: 'deep-child',
+          title: '爆款孙代',
+          generation: 2,
+          parentGameId: 'deep-hot',
+          playCount: 200,
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await findTreeText('自身热');
+    fireEvent.click(screen.getByRole('checkbox', { name: '按热度排序' }));
+    // 判据是自身：自身热（100）排在 后代热（自身 5 / 合计 205）**前面**。
+    expect(parseFloat((await cardOf('自身热')).style.left)).toBeLessThan(
+      parseFloat((await cardOf('后代热')).style.left),
+    );
+    // 主干线同理，仍然选「自身热」。
+    expect(
+      (await cardOf('自身热')).querySelector('.game-lineage-node__trunk'),
+    ).not.toBeNull();
+    expect(
+      (await cardOf('后代热')).querySelector('.game-lineage-node__trunk'),
+    ).toBeNull();
+  });
+
+  it('主干线：每代热度最高的节点带「主干」角标，主干边单独标记', async () => {
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await findTreeText('热门二创');
+    // 第 1 代主干 = 热门二创（999 > 1）；冷门二创不是主干。
+    expect(
+      (await cardOf('热门二创')).querySelector('.game-lineage-node__trunk'),
+    ).not.toBeNull();
+    expect(
+      (await cardOf('冷门二创')).querySelector('.game-lineage-node__trunk'),
+    ).toBeNull();
+    // 主干线：root→hot 与 hot→deep 两条。
+    expect(
+      document.querySelectorAll('path.game-lineage-edge--trunk').length,
+    ).toBe(2);
+  });
+
+  it('选中节点后右侧信息面板给出简介/授权与「前往体验 / 开始共创此版本」', async () => {
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        summary: '这是一个二创作品的简介',
+        forkAuthorization: 'nonCommercial',
+        currentVersion: {
+          id: 'v1',
+          versionNumber: 1,
+          changeSummary: '把跳台改成三段，并重画全部背景',
+        },
+      }),
+    );
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    const hotCard = await cardOf('热门二创');
+    // 面板只在选中后出现。
+    expect(screen.queryByLabelText('选中作品信息')).toBeNull();
+    fireEvent.mouseEnter(hotCard);
+
+    const panel = await screen.findByLabelText('选中作品信息');
+    expect(
+      await within(panel).findByText('这是一个二创作品的简介'),
+    ).toBeTruthy();
+    expect(within(panel).getByText(/允许非商用共创/u)).toBeTruthy();
+    // 「核心改动说明」字段还没上：不渲染这一行（不假装有数据）。
+    // 核心改动说明来自版本摘要层（selectedGame.currentVersion.changeSummary）。
+    expect(
+      within(panel).getByText(/核心改动说明：把跳台改成三段/u),
+    ).toBeTruthy();
+
+    fireEvent.click(within(panel).getByRole('button', { name: '前往体验' }));
+    expect(onOpenDetail).toHaveBeenCalledWith('hot');
+
+    expect(
+      within(panel).getByRole('button', { name: '开始共创此版本' }),
+    ).toBeTruthy();
+    // 动作名精确到**按钮**（不扫全页文本）：面板里没有任何以 Fork 命名的可交互元素，
+    // 可见名就是上面钉住的那一个。
+    expect(within(panel).queryByRole('button', { name: /Fork/u })).toBeNull();
+    fireEvent.click(
+      within(panel).getByRole('button', { name: '开始共创此版本' }),
+    );
+    expect(openForkProtocolMock).toHaveBeenCalledWith('hot');
+  });
+
+  it('窄屏默认大纲模式：缩进层级、顺序、主干导线、无横向溢出', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    // 移动端默认不再用画布。
+    expect(document.querySelector('.game-lineage-canvas')).toBeNull();
+    // 顺序：根（0 代）→ 1 代 → 1 代 → 2 代。
+    const rows = [...outline.querySelectorAll('.lineage-outline__row')];
+    expect(rows.map((row) => row.getAttribute('data-generation'))).toEqual([
+      '0',
+      '1',
+      '1',
+      '2',
+    ]);
+    const indentOf = (index: number) =>
+      parseFloat((rows[index] as HTMLElement).style.paddingLeft);
+    expect(indentOf(0)).toBe(0);
+    expect(indentOf(1)).toBeGreaterThan(indentOf(0));
+    expect(indentOf(3)).toBeGreaterThan(indentOf(1));
+    // 主干导线标记存在（热门二创是该代热度最高者）。
+    expect(
+      outline.querySelectorAll('.lineage-outline__guide--trunk').length,
+    ).toBeGreaterThan(0);
+    // 无横向溢出：大纲是全宽行 + 左缩进，绝不横向滚。
+    expect(outline.scrollWidth <= outline.clientWidth).toBe(true);
+  });
+
+  it('大纲行：点击行是选中（不导航），行内「打开」才导航，键盘可达', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    getGameMock.mockResolvedValueOnce(createGame({ summary: '选中后的简介' }));
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    const rowButton = (await within(outline).findByRole('button', {
+      name: /第 1 代《热门二创》/u,
+    })) as HTMLElement;
+    expect(rowButton.tagName).toBe('BUTTON');
+    rowButton.focus();
+    expect(document.activeElement).toBe(rowButton);
+
+    fireEvent.click(rowButton);
+    // 点击行 = 选中，不导航。
+    expect(onOpenDetail).not.toHaveBeenCalled();
+    expect(await screen.findByLabelText('选中作品信息')).toBeTruthy();
+
+    fireEvent.click(
+      within(outline).getByRole('button', { name: '打开《热门二创》详情' }),
+    );
+    expect(onOpenDetail).toHaveBeenCalledWith('hot');
+  });
+
+  it('窄屏选中节点后用 bottom sheet 展示简介/授权/改动说明与两个操作', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        summary: '这是一个二创作品的简介',
+        forkAuthorization: 'nonCommercial',
+        currentVersion: {
+          id: 'v1',
+          versionNumber: 1,
+          changeSummary: '把跳台改成三段，并重画全部背景',
+        },
+      }),
+    );
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    fireEvent.click(
+      await within(outline).findByRole('button', {
+        name: /第 1 代《热门二创》/u,
+      }),
+    );
+
+    const sheet = await screen.findByLabelText('选中作品信息');
+    expect(sheet.className).toContain('game-lineage-panel--sheet');
+    expect(within(sheet).getByText('这是一个二创作品的简介')).toBeTruthy();
+    expect(within(sheet).getByText(/允许非商用共创/u)).toBeTruthy();
+    expect(
+      within(sheet).getByText(/核心改动说明：把跳台改成三段/u),
+    ).toBeTruthy();
+    expect(
+      within(sheet).getByRole('button', { name: '前往体验' }),
+    ).toBeTruthy();
+    expect(
+      within(sheet).getByRole('button', { name: '开始共创此版本' }),
+    ).toBeTruthy();
+    // 窄屏 bottom sheet 与桌面浮层同一组件：动作名同样精确到按钮（不扫全页文本）。
+    expect(within(sheet).queryByRole('button', { name: /Fork/u })).toBeNull();
+    // 遮罩点击关闭。
+    fireEvent.click(screen.getByLabelText('关闭信息面板'));
+    await waitFor(() =>
+      expect(screen.queryByLabelText('选中作品信息')).toBeNull(),
+    );
+  });
+
+  it('面包屑在选中后出现，当前项在链尾（横向滚动容器里常驻可见）', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    getGameMock.mockResolvedValueOnce(createGame({ summary: '简介' }));
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    fireEvent.click(
+      await within(outline).findByRole('button', {
+        name: /第 2 代《深代作品》/u,
+      }),
+    );
+
+    const breadcrumb = await screen.findByLabelText('已选中的路径');
+    const crumbs = [
+      ...breadcrumb.querySelectorAll('.game-lineage-breadcrumb__crumb'),
+    ];
+    expect(crumbs.map((crumb) => crumb.textContent)).toEqual([
+      '母版《根原创》',
+      '第 1 代《热门二创》',
+      '第 2 代《深代作品》',
+    ]);
+    expect(crumbs[crumbs.length - 1]?.textContent).toContain('深代作品');
+  });
+
+  it('视图形态是分段控件：当前形态与 aria-pressed 一一对应（不再「画面是画布、按钮却是大纲已按下」）', async () => {
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const canvasButton = await screen.findByRole('button', {
+      name: '图谱视图',
+    });
+    const outlineButton = screen.getByRole('button', { name: '大纲视图' });
+    // 桌面默认画布 → 「图谱视图」按下、「大纲视图」未按下，且两个选项常驻（不是一个翻转按钮）。
+    expect(document.querySelector('.game-lineage-canvas')).not.toBeNull();
+    expect(canvasButton.getAttribute('aria-pressed')).toBe('true');
+    expect(outlineButton.getAttribute('aria-pressed')).toBe('false');
+    expect(
+      document
+        .querySelector('.game-lineage-filter__group')
+        ?.getAttribute('aria-label'),
+    ).toBe('视图形态');
+
+    fireEvent.click(outlineButton);
+    expect(await screen.findByLabelText('创作族谱大纲')).toBeTruthy();
+    expect(
+      screen
+        .getByRole('button', { name: '大纲视图' })
+        .getAttribute('aria-pressed'),
+    ).toBe('true');
+    expect(
+      screen
+        .getByRole('button', { name: '图谱视图' })
+        .getAttribute('aria-pressed'),
+    ).toBe('false');
+  });
+
+  it('画布控件栏：缩小 / 读数 / 放大 / 总览 / 刷新 五件齐全，且没有会被读成「搜索」的放大镜图标', async () => {
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const controls = await screen.findByLabelText('画布控件');
+    const names = [...controls.querySelectorAll('button')].map((button) =>
+      button.getAttribute('aria-label'),
+    );
+    expect(names).toEqual(['缩小', '放大', '总览', '刷新']);
+    expect(controls.querySelector('.game-lineage-zoom')?.textContent).toMatch(
+      /^\d+%$/u,
+    );
+    // 图标是「−/+」：放大镜（lucide ZoomIn/ZoomOut）在控件栏里会被读成「搜索」，
+    // 而这里根本没有搜索按钮 —— 用图标名钉住不许退回。
+    const source = readFileSync(
+      'src/components/game-distribution/GameLineagePage.tsx',
+      'utf8',
+    );
+    expect(source).toContain('<Minus aria-hidden="true" />');
+    expect(source).toContain('<Plus aria-hidden="true" />');
+    expect(source).not.toContain('ZoomIn');
+    expect(source).not.toContain('ZoomOut');
+    // 「总览」的动作是**收拢**回全览，图标必须是向内收的 `Minimize`；
+    // `Expand`（四角向外）与行为相反，钉住不许回来。
+    expect(source).toContain('<Minimize aria-hidden="true" />');
+    expect(source).not.toContain('<Expand aria-hidden="true" />');
+  });
+
+  it('图谱视图开关：移动端可切到画布（形态 B）并仍能选中节点', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    getGameMock.mockResolvedValueOnce(createGame({ summary: '简介' }));
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    await screen.findByLabelText('创作族谱大纲');
+    fireEvent.click(screen.getByRole('button', { name: '图谱视图' }));
+
+    await waitFor(() =>
+      expect(document.querySelector('.game-lineage-canvas')).not.toBeNull(),
+    );
+    expect(screen.queryByLabelText('创作族谱大纲')).toBeNull();
+    expect(screen.getByLabelText('画布控件')).toBeTruthy();
+    fireEvent.mouseEnter(await cardOf('热门二创'));
+    expect(await screen.findByLabelText('选中作品信息')).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: '大纲视图' }));
+    expect(await screen.findByLabelText('创作族谱大纲')).toBeTruthy();
+  });
+
+  it('图谱视图初次进入即适配并定位当前作品（不是 zoom 100% 的空屏）', async () => {
+    setViewportWidth(390);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    // jsdom 不做布局：给画布一个「真机尺寸」，适配与定位才有可断言的数值。
+    const widthSpy = vi
+      .spyOn(Element.prototype, 'clientWidth', 'get')
+      .mockReturnValue(390);
+    const heightSpy = vi
+      .spyOn(Element.prototype, 'clientHeight', 'get')
+      .mockReturnValue(667);
+    try {
+      render(
+        <GameLineagePage
+          rootGameId="game-root"
+          onBack={vi.fn()}
+          onOpenDetail={vi.fn()}
+        />,
+      );
+
+      await screen.findByLabelText('创作族谱大纲');
+      fireEvent.click(screen.getByRole('button', { name: '图谱视图' }));
+
+      const canvas = (await screen.findByLabelText(
+        '创作族谱树',
+      )) as HTMLElement;
+      const view = readCanvasViewport(canvas);
+      // 窄屏图谱视图是**横版**：代际沿 x 推进（同代同 left、兄弟靠 top 分开），
+      // 且不再渲染左侧代际轴（角标承担代际信息 —— 因此卡上**保留**世代角标）。
+      expect(canvas.querySelector('.game-lineage-canvas__axis')).toBeNull();
+      expect(
+        canvas.querySelector('.game-lineage-node__generation')?.textContent,
+      ).toBe('母版');
+      const cards = [...canvas.querySelectorAll('.game-lineage-node')].map(
+        (card) => card as HTMLElement,
+      );
+      const generationOne = cards.filter(
+        (card) => card.getAttribute('data-generation') === '1',
+      );
+      expect(generationOne.length).toBeGreaterThanOrEqual(2);
+      expect(new Set(generationOne.map((card) => card.style.left)).size).toBe(
+        1,
+      );
+      expect(new Set(generationOne.map((card) => card.style.top)).size).toBe(
+        generationOne.length,
+      );
+      expect(Math.round(view.scale * 100)).not.toBe(100);
+      expect(canvas.querySelector('.game-lineage-zoom')?.textContent).toBe(
+        `${Math.round(view.scale * 100)}%`,
+      );
+
+      const visible = visibleCanvasCards(canvas, view);
+      // 「一个节点都看不到」是最初的回归：这里至少要看到 3 个，且当前作品在视口内。
+      expect(visible.length).toBeGreaterThanOrEqual(3);
+      expect(visible).toContain(
+        canvas.querySelector('.game-lineage-node--anchor'),
+      );
+      expect(
+        visible.some((card) => card.getAttribute('data-generation') === '0'),
+      ).toBe(true);
+      // 移动端紧凑卡片按既有设计**省掉作者行**（CSS `.game-lineage-node--compact`：卡片更小、
+      // 字段更少）。作者名在桌面画布、大纲行与详情页都有；这条断言把这个差异固定下来，
+      // 避免它再次变成「实现与断言不同步」。
+      expect(
+        canvas.querySelectorAll('.game-lineage-node--compact').length,
+      ).toBe(cards.length);
+      // 卡就是广场卡：紧凑态也显示作者行（不再省行）。
+      expect(canvas.querySelectorAll('.game-card__meta').length).toBe(
+        cards.length,
+      );
+    } finally {
+      widthSpy.mockRestore();
+      heightSpy.mockRestore();
+    }
+  });
+
+  it('图谱视图缩放触底时把当前作品滚进视口（保上下文，不只剩空屏）', async () => {
+    setViewportWidth(320);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    const widthSpy = vi
+      .spyOn(Element.prototype, 'clientWidth', 'get')
+      .mockReturnValue(200);
+    const heightSpy = vi
+      .spyOn(Element.prototype, 'clientHeight', 'get')
+      .mockReturnValue(420);
+    try {
+      render(
+        <GameLineagePage
+          rootGameId="game-root"
+          // 锚点是**最右代**：树比视口宽、缩放已触底，必须靠位移把它拉进来。
+          highlightGameId="deep"
+          onBack={vi.fn()}
+          onOpenDetail={vi.fn()}
+        />,
+      );
+
+      await screen.findByLabelText('创作族谱大纲');
+      fireEvent.click(screen.getByRole('button', { name: '图谱视图' }));
+
+      const canvas = (await screen.findByLabelText(
+        '创作族谱树',
+      )) as HTMLElement;
+      const view = readCanvasViewport(canvas);
+      expect(view.scale).toBeGreaterThan(0);
+      expect(Math.round(view.scale * 100)).not.toBe(100);
+
+      const visible = visibleCanvasCards(canvas, view);
+      expect(visible).toContain(
+        canvas.querySelector('.game-lineage-node--anchor'),
+      );
+      // 当前作品进来了，但不是「只剩它」：父代仍在视口里，用户看得到上下文。
+      expect(visible.length).toBeGreaterThanOrEqual(2);
+      expect(
+        visible.some((card) => card.getAttribute('data-generation') === '1'),
+      ).toBe(true);
+    } finally {
+      widthSpy.mockRestore();
+      heightSpy.mockRestore();
+    }
+  });
+
+  it('移动端：「只看父代与子代」开关可用，大纲行也标出父代 / 子代', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(relationTree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    // 默认关：整棵树（7 个节点）。
+    expect(outline.querySelectorAll('.lineage-outline__row').length).toBe(7);
+    fireEvent.click(screen.getByRole('button', { name: '只看父代与子代' }));
+
+    const rows = [...outline.querySelectorAll('.lineage-outline__row')];
+    // 开：父代链（根原创 / 中间代）+ 自己 + 直接子代（子代甲 / 子代乙）——不多不少。
+    expect(rows.length).toBe(5);
+    expect(rows.map((row) => row.getAttribute('data-relation')).sort()).toEqual(
+      ['ancestor', 'ancestor', 'descendant', 'descendant', 'self'],
+    );
+    // 大纲行里同样是**可读角标**（不是只靠描边颜色）。
+    expect(
+      [...outline.querySelectorAll('.game-lineage-node__relation')]
+        .map((element) => element.textContent)
+        .sort(),
+    ).toEqual(['子代', '子代', '父代', '父代']);
+    // 取消：回到整棵树。
+    fireEvent.click(
+      screen.getByRole('button', { name: '只看父代与子代（已开启）' }),
+    );
+    expect(outline.querySelectorAll('.lineage-outline__row').length).toBe(7);
+  });
+
+  it('大纲行显示游玩次数**子树合计**（▶ N），与角标同行、不进文字块、不额外占行', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    const first = render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    const rowOf = (title: string) =>
+      [...outline.querySelectorAll('.lineage-outline__row')].find((row) =>
+        row.textContent?.includes(title),
+      ) as HTMLElement;
+    const chipOf = (title: string) =>
+      rowOf(title).querySelector(
+        '.game-lineage-node__badges > .game-lineage-node__play-count',
+      ) as HTMLElement;
+
+    // 显示的是**合计**（自身 + 全部后代），不是自身值：
+    // 热门二创自身 999、子代 深代作品 3 → ▶ 1002；冷门二创自身 1 → ▶ 1；母版 5+1002+1 → ▶ 1008。
+    expect(chipOf('热门二创').textContent).toBe('▶ 1002');
+    expect(chipOf('冷门二创').textContent).toBe('▶ 1');
+    expect(chipOf('根原创').textContent).toBe('▶ 1008');
+    expect(chipOf('深代作品').textContent).toBe('▶ 3');
+    // 角标说明含衍生（读屏 + 悬停都能看到口径）。
+    expect(chipOf('热门二创').getAttribute('title')).toContain('含衍生作品');
+    expect(chipOf('热门二创').getAttribute('aria-label')).toBe(
+      '游玩次数（含衍生作品）1002',
+    );
+    // 与角标同一组（同一行），**不在**文字块里 → 不会给它单开一行。
+    expect(
+      rowOf('热门二创').querySelector(
+        '.game-lineage-node__text .game-lineage-node__play-count',
+      ),
+    ).toBeNull();
+
+    // 全 0 也显示（列稳定、不会一会儿有一会儿没有），并且同样只在角标组里。
+    first.unmount();
+    getGameLineageMock.mockResolvedValueOnce(demoShapeTree);
+    const zero = render(
+      <GameLineagePage
+        rootGameId="A0"
+        highlightGameId="A111"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+    const zeroOutline = await zero.findByLabelText('创作族谱大纲');
+    const zeroChips = [
+      ...zeroOutline.querySelectorAll(
+        '.lineage-outline__row .game-lineage-node__badges > .game-lineage-node__play-count',
+      ),
+    ];
+    expect(zeroChips.length).toBe(8);
+    for (const chip of zeroChips) {
+      expect(chip.textContent).toBe('▶ 0');
+    }
+    zero.unmount();
+  });
+
+  it('窄屏仍能点进详情页与查看完整族谱入口（大纲模式不丢入口）', async () => {
+    setViewportWidth(375);
+    getGameLineageMock.mockResolvedValueOnce(tree);
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    const outline = await screen.findByLabelText('创作族谱大纲');
+    expect(
+      within(outline).getByRole('button', { name: '打开《根原创》详情' }),
+    ).toBeTruthy();
+    expect(
+      within(outline).getByRole('button', { name: '开始共创 根原创' }),
+    ).toBeTruthy();
+  });
+});
+
+/** 读画布视口状态：内容层的 `transform: translate(...) scale(...)`。 */
+function readCanvasViewport(canvas: HTMLElement) {
+  const content = canvas.querySelector(
+    '.game-lineage-canvas__content',
+  ) as HTMLElement;
+  const match = /translate\(([-\d.]+)px, ([-\d.]+)px\) scale\(([\d.]+)\)/u.exec(
+    content.style.transform,
+  );
+  if (!match) {
+    throw new Error(`无法解析画布 transform: ${content.style.transform}`);
+  }
+  return {
+    offsetX: Number.parseFloat(match[1]!),
+    offsetY: Number.parseFloat(match[2]!),
+    scale: Number.parseFloat(match[3]!),
+  };
+}
+
+/** 视口内可见的节点卡片：把内容层的 transform 应用到卡片矩形，再与画布矩形求交。 */
+function visibleCanvasCards(
+  canvas: HTMLElement,
+  view: { offsetX: number; offsetY: number; scale: number },
+) {
+  return [...canvas.querySelectorAll('.game-lineage-node')].filter((node) => {
+    const card = node as HTMLElement;
+    const left = view.offsetX + Number.parseFloat(card.style.left) * view.scale;
+    const top = view.offsetY + Number.parseFloat(card.style.top) * view.scale;
+    const width = Number.parseFloat(card.style.width) * view.scale;
+    const height = Number.parseFloat(card.style.minHeight) * view.scale;
+    return (
+      left + width > 0 &&
+      top + height > 0 &&
+      left < canvas.clientWidth &&
+      top < canvas.clientHeight
+    );
+  });
+}
+
+describe('GameDetailPage 共创模块（文档对齐）', () => {
+  it('世代/授权标签按文档口径渲染，并显示累计衍生作品数', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        forkAuthorization: 'nonCommercial',
+        forkCount: 3,
+        lineage: {
+          generation: 2,
+          rootGameId: 'game-root',
+          rootTitle: '根原创',
+          parentGameId: 'game-parent',
+          parentTitle: '原初之光',
+          parentAuthorName: '原作者',
+        },
+      }),
+    );
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('2 代三创')).toBeTruthy();
+    expect(screen.getByText('允许非商用共创')).toBeTruthy();
+    expect(screen.getByText('累计衍生作品 3')).toBeTruthy();
+    expect(screen.getByText('2 代三创 · 改编自父代《原初之光》')).toBeTruthy();
+    // 主操作按文档叫「开始共创」（2026-10-07 起与玩家侧同一词表）。
+    expect(screen.getByRole('button', { name: '开始共创' })).toBeTruthy();
+  });
+
+  it('累计创作世代数字段缺失时不渲染该概览项（不拿别的数字凑数）', async () => {
+    getGameMock.mockResolvedValueOnce(createGame({ forkCount: 2 }));
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    expect(await screen.findByText('累计衍生作品 2')).toBeTruthy();
+    expect(screen.queryByText(/累计创作世代数/u)).toBeNull();
+  });
+
+  it('血缘图搬到正文之后的整宽区块：侧栏共创卡里不再有图', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        id: 'game-current',
+        lineage: {
+          rootGameId: 'game-root',
+          parentGameId: 'game-mid',
+          parentTitle: '一代作品',
+          parentAuthorName: '一代作者',
+          generation: 2,
+        },
+      }),
+    );
+    getGameLineageMock.mockResolvedValue(buildChainDataset());
+    render(
+      <GameDetailPage
+        gameId="game-current"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenGameDetail={vi.fn()}
+        onOpenLineage={vi.fn()}
+      />,
+    );
+
+    const block = (await screen.findByLabelText('创作血缘')).closest(
+      '.game-lineage-block',
+    ) as HTMLElement;
+    // ① 图不在侧栏：共创卡里没有任何树渲染（画布 / 节点卡片 / 大纲都没有）。
+    const card = document.querySelector(
+      '.game-detail-side .game-detail-info-card .game-fork-card',
+    ) as HTMLElement;
+    expect(card).toBeTruthy();
+    expect(card.querySelector('.game-lineage-canvas')).toBeNull();
+    expect(card.querySelector('.game-lineage-node')).toBeNull();
+    expect(card.querySelector('.lineage-outline')).toBeNull();
+    // 侧栏卡保留：世代 / 授权标签、概览数据、四个入口。
+    expect(within(card).getByText('2 代三创')).toBeTruthy();
+    expect(
+      within(card).getByRole('button', { name: '查看创作族谱' }),
+    ).toBeTruthy();
+    // 2026-10-07：主操作「开始共创」已搬到**主操作行**，共创卡内不再重复出现。
+    expect(within(card).queryByRole('button', { name: '开始共创' })).toBeNull();
+    const actionsRow = card.closest('.game-detail-display') as HTMLElement;
+    expect(
+      within(actionsRow).getByRole('button', { name: '开始共创' }),
+    ).toBeTruthy();
+    // ② 图在**正文之后**：`.game-detail-page` 的直接子级，且排在正文容器之后。
+    const page = document.querySelector('.game-detail-page') as HTMLElement;
+    const children = [...page.children];
+    expect(children.indexOf(block)).toBeGreaterThan(
+      children.findIndex((element) =>
+        element.classList.contains('game-detail-display'),
+      ),
+    );
+    // 内嵌族谱页自己拉一次 /lineage：等树真的渲染出来再断言归属。
+    const blockCanvas = (await within(block).findByLabelText(
+      '创作族谱树',
+    )) as HTMLElement;
+    expect(blockCanvas.querySelectorAll('.game-lineage-node').length).toBe(3);
+    expect(
+      within(block).getByRole('heading', { name: '这部作品的血缘图' }),
+    ).toBeTruthy();
+    expect(
+      within(block).getByRole('button', { name: '全屏查看族谱' }),
+    ).toBeTruthy();
+  });
+
+  it('入口上下文（同一登录态、同一份数据）：玩家侧看不到血缘图/族谱入口/共创标签，共创者侧完全保留', async () => {
+    const gameWithLineage = () =>
+      createGame({
+        id: 'game-current',
+        forkAuthorization: 'nonCommercial',
+        forkCount: 3,
+        themes: [{ themeId: 'theme-1', name: '精选共创', badge: '精选' }],
+        lineage: {
+          generation: 2,
+          rootGameId: 'game-root',
+          rootTitle: '根原创',
+          parentGameId: 'game-mid',
+          parentTitle: '原初之光',
+          parentAuthorName: '原作者',
+        },
+      });
+    const renderDetail = () =>
+      render(
+        <GameDetailPage
+          gameId="game-current"
+          onBack={vi.fn()}
+          onPlay={vi.fn()}
+          onOpenGameDetail={vi.fn()}
+          onOpenLineage={vi.fn()}
+          onOpenCompare={vi.fn()}
+          onOpenTheme={vi.fn()}
+        />,
+      );
+
+    // ① 玩家侧（**已登录**，默认入口 URL）：血缘相关内容与共创标签一律不渲染，
+    //    但公开数据与主题入口保留。→ 这条同时证明「差异来自入口，不来自登录态」。
+    authUiMock.value.user = { id: 'author-1' };
+    authUiMock.value.canAccessProtectedData = true;
+    window.history.replaceState(null, '', '/games/detail?id=game-current');
+    getGameMock.mockResolvedValueOnce(gameWithLineage());
+    getGameLineageMock.mockResolvedValueOnce(buildChainDataset());
+    const player = renderDetail();
+    await screen.findByText('累计衍生作品 3');
+    expect(screen.queryByLabelText('创作血缘')).toBeNull();
+    expect(screen.queryByRole('button', { name: '全屏查看族谱' })).toBeNull();
+    expect(screen.queryByRole('button', { name: '查看创作族谱' })).toBeNull();
+    expect(screen.queryByRole('button', { name: '与原版对比' })).toBeNull();
+    expect(screen.queryByText('2 代三创')).toBeNull();
+    expect(screen.queryByText('允许非商用共创')).toBeNull();
+    expect(screen.queryByText(/改编自父代/u)).toBeNull();
+    expect(document.querySelector('.game-fork-lineage__author')).toBeNull();
+    // 公开数据与主题（浏览入口，不是血缘结构）仍在。
+    expect(screen.getByText('累计衍生作品 3')).toBeTruthy();
+    expect(screen.getByRole('button', { name: /精选共创/u })).toBeTruthy();
+    expect(
+      document
+        .querySelector('.game-detail-page')
+        ?.getAttribute('data-viewer-context'),
+    ).toBe('player');
+    // 玩家侧的「开始共创」是次要小按钮：登录后与共创者侧同一词表、只是样式更轻。
+    expect(
+      screen.getByRole('button', { name: '开始共创' }).className,
+    ).toContain('game-fork-remix-guest');
+    // 图谱页自己的「图下方父代/子代清单」也不会出现（整块不渲染）。
+    expect(document.querySelector('.lineage-relation__grid')).toBeNull();
+    player.unmount();
+
+    // ② 共创者侧（**同一登录态**，只把入口来源换成共创侧）：与改动前一致 —— 图、入口、标签都在。
+    window.history.replaceState(
+      null,
+      '',
+      '/games/detail?id=game-current&from=co-creation',
+    );
+    getGameMock.mockResolvedValueOnce(gameWithLineage());
+    getGameLineageMock.mockResolvedValueOnce(buildChainDataset());
+    renderDetail();
+    expect(await screen.findByLabelText('创作血缘')).toBeTruthy();
+    expect(screen.getByText('2 代三创')).toBeTruthy();
+    expect(screen.getByText('允许非商用共创')).toBeTruthy();
+    expect(screen.getByText('2 代三创 · 改编自父代《原初之光》')).toBeTruthy();
+    expect(screen.getByText('父代作者 原作者')).toBeTruthy();
+    expect(screen.getByRole('button', { name: '查看创作族谱' })).toBeTruthy();
+    expect(screen.getByRole('button', { name: '与原版对比' })).toBeTruthy();
+    expect(
+      document
+        .querySelector('.game-detail-page')
+        ?.getAttribute('data-viewer-context'),
+    ).toBe('co-creator');
+    expect(
+      screen.getByRole('button', { name: '开始共创' }).className,
+    ).toContain('co-creation-fork-primary');
+  });
+
+  it('「全屏查看族谱」= 真·全屏 overlay（portal 到 body / Esc 与关闭按钮 / 焦点与滚动恢复）', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        id: 'game-current',
+        lineage: { rootGameId: 'game-root', parentGameId: 'game-mid' },
+      }),
+    );
+    getGameLineageMock.mockResolvedValue(buildChainDataset());
+    render(
+      <GameDetailPage
+        gameId="game-current"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenGameDetail={vi.fn()}
+      />,
+    );
+
+    const trigger = await screen.findByRole('button', {
+      name: '全屏查看族谱',
+    });
+    expect(document.body.style.overflow).toBe('');
+    trigger.focus();
+    fireEvent.click(trigger);
+
+    const dialog = await screen.findByRole('dialog', {
+      name: '创作族谱（全屏）',
+    });
+    // portal 到 `document.body`（不在详情页/平台容器的 DOM 里）⇒ 不受容器宽度与 overflow 约束。
+    expect(dialog.parentElement).toBe(document.body);
+    expect(dialog.getAttribute('aria-modal')).toBe('true');
+    expect(dialog.className).toContain('lineage-fullscreen');
+    // 打开：锁 body 滚动 + 焦点移入 overlay。
+    expect(document.body.style.overflow).toBe('hidden');
+    expect(document.activeElement?.getAttribute('aria-label')).toBe(
+      '关闭全屏族谱',
+    );
+    // overlay 里就是同一套画布（不是第二套实现），且内嵌那棵树已卸载（DOM 里只剩一个画布）。
+    expect(within(dialog).getByLabelText('创作族谱树')).toBeTruthy();
+    expect(document.querySelectorAll('.game-lineage-canvas')).toHaveLength(1);
+
+    // Esc 关闭：overlay 消失、滚动锁恢复、焦点回到触发按钮、内嵌树回来。
+    fireEvent.keyDown(document, { key: 'Escape' });
+    await waitFor(() =>
+      expect(
+        screen.queryByRole('dialog', { name: '创作族谱（全屏）' }),
+      ).toBeNull(),
+    );
+    expect(document.body.style.overflow).toBe('');
+    expect(document.activeElement).toBe(trigger);
+    expect(document.querySelectorAll('.game-lineage-canvas')).toHaveLength(1);
+
+    // 关闭按钮同样能关。
+    fireEvent.click(screen.getByRole('button', { name: '全屏查看族谱' }));
+    fireEvent.click(
+      await screen.findByRole('button', { name: '关闭全屏族谱' }),
+    );
+    await waitFor(() =>
+      expect(
+        screen.queryByRole('dialog', { name: '创作族谱（全屏）' }),
+      ).toBeNull(),
+    );
+  });
+
+  it('封面契约：容器强制 16:9 且不被拉伸，图片 100%×100% + object-fit: cover（三处同一套）', async () => {
+    const css = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    // 同一规则里必须同时具备 16:9 + 不被 flex 拉伸 + 裁切（历史上有多条同名片段，
+    // 所以用「同一规则内」的前瞻断言，不去猜是哪一条）。
+    expect(css).toMatch(
+      /\.game-lineage-node__cover \{(?=[^}]*aspect-ratio: 16 \/ 9)(?=[^}]*flex: 0 0 auto)(?=[^}]*overflow: hidden)[^}]*\}/u,
+    );
+    expect(css).toMatch(
+      /\.game-lineage-node__cover \.game-cover,[\s\S]{0,240}?height: 100%;/u,
+    );
+    expect(css).toMatch(
+      /\.game-lineage-node__cover img \{[\s\S]{0,120}?object-fit: cover;/u,
+    );
+  });
+
+  it('主操作行不再内联状态文本：行内不换行/不被挤扁，面板改 portal 浮层', async () => {
+    // 窄屏：唤起直接进入「手动获取作品 ID」的降级面板（无需等失焦超时）。
+    setViewportWidth(390);
+    getGameMock.mockResolvedValueOnce(
+      createGame({ id: 'game-current', forkAuthorization: 'full' }),
+    );
+    render(
+      <GameDetailPage
+        gameId="game-current"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenGameDetail={vi.fn()}
+      />,
+    );
+
+    const playButton = await screen.findByRole('button', { name: /开始游戏/u });
+    const actionsRow = playButton.closest(
+      '.game-detail-hero__actions',
+    ) as HTMLElement;
+    expect(actionsRow).toBeTruthy();
+
+    // 结构契约：行内**没有**任何内联状态/提示节点（历史类名都不该再出现在行里）。
+    expect(actionsRow.querySelector('.game-collection-notice')).toBeNull();
+    expect(actionsRow.querySelector('.game-fork-remix-status')).toBeNull();
+    // 警告节点仍在（`aria-describedby` 关联要它），但视觉隐藏、不占行内空间。
+    for (const warning of actionsRow.querySelectorAll('.game-device-warning')) {
+      expect(warning.className).toContain('game-device-warning--sr');
+    }
+
+    // 触发唤起 → 面板必须是 portal 到 body 的浮层（不参与行布局），且可关。
+    fireEvent.click(screen.getByRole('button', { name: '开始共创' }));
+    const panel = await screen.findByRole('dialog', { name: '手动开始共创' });
+    expect(panel.parentElement).toBe(document.body);
+    expect(panel.className).toContain('game-fork-remix-panel--portal');
+    expect(
+      within(panel).getByRole('button', { name: '复制作品 ID' }),
+    ).toBeTruthy();
+
+    // CSS 契约：行内子项不收缩、不折行（无论旁边再加什么元素都不会把按钮压成两行）。
+    const css = await import('node:fs').then((fs) =>
+      fs.readFileSync(
+        'src/components/game-distribution/gameDistribution.css',
+        'utf8',
+      ),
+    );
+    expect(css).toMatch(
+      /\.game-detail-hero__actions > \* \{[^}]*flex: 0 0 auto;[^}]*white-space: nowrap;/u,
+    );
+    expect(css).toMatch(
+      /\.game-fork-remix-panel--portal \{[^}]*position: fixed;/u,
+    );
+  });
+
+  it('区块默认以根为作用域，并把当前作品定位进视口', async () => {
+    // jsdom 不做布局：给画布一个真机尺寸，初始适配与定位才有可断言的数值。
+    const widthSpy = vi
+      .spyOn(Element.prototype, 'clientWidth', 'get')
+      .mockReturnValue(1280);
+    const heightSpy = vi
+      .spyOn(Element.prototype, 'clientHeight', 'get')
+      .mockReturnValue(720);
+    try {
+      getGameMock.mockResolvedValueOnce(
+        createGame({
+          id: 'game-current',
+          lineage: { rootGameId: 'game-root', parentGameId: 'game-mid' },
+        }),
+      );
+      getGameLineageMock.mockResolvedValue(buildChainDataset());
+      render(
+        <GameDetailPage
+          gameId="game-current"
+          onBack={vi.fn()}
+          onPlay={vi.fn()}
+          onOpenGameDetail={vi.fn()}
+        />,
+      );
+
+      const block = (await screen.findByLabelText('创作血缘')) as HTMLElement;
+      const canvas = (await within(block).findByLabelText(
+        '创作族谱树',
+      )) as HTMLElement;
+      await within(
+        block.querySelector('.game-lineage-canvas') as HTMLElement,
+      ).findByText('根原创');
+      // 作用域是**根**：母版节点就在树里（不是以当前作品为顶的局部树）。
+      expect(canvas.textContent).toContain('根原创');
+      const view = readCanvasViewport(canvas);
+      expect(Math.round(view.scale * 100)).not.toBe(100);
+      const visible = visibleCanvasCards(canvas, view);
+      expect(visible).toContain(
+        canvas.querySelector('.game-lineage-node--anchor'),
+      );
+      expect(visible.length).toBeGreaterThanOrEqual(2);
+    } finally {
+      widthSpy.mockRestore();
+      heightSpy.mockRestore();
+    }
+  });
+
+  it('窄断点：正文区块走大纲形态且不横向溢出', async () => {
+    setViewportWidth(390);
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        id: 'game-current',
+        lineage: { rootGameId: 'game-root', parentGameId: 'game-mid' },
+      }),
+    );
+    getGameLineageMock.mockResolvedValue(buildChainDataset());
+    render(
+      <GameDetailPage
+        gameId="game-current"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenGameDetail={vi.fn()}
+      />,
+    );
+
+    const block = (await screen.findByLabelText('创作血缘')) as HTMLElement;
+    const outline = await within(block).findByLabelText('创作族谱大纲');
+    expect(block.querySelector('.game-lineage-canvas')).toBeNull();
+    // 大纲是全宽行 + 左缩进：绝不横向滚。
+    expect(outline.scrollWidth <= outline.clientWidth).toBe(true);
+    // 图仍然只有一套渲染：大纲行里的节点内容复用同一个组件。
+    expect(
+      outline.querySelectorAll('.game-lineage-node__content--inline').length,
+    ).toBeGreaterThan(0);
+  });
+
+  /**
+   * 游玩次数合计的数据集：root(10) → mid(20) → current(7) → child(5) → grandchild(3)。
+   * 「当前作品」的合计 = 7 + 5 + 3 = 15（自身 7 + 衍生 8）。
+   */
+  const playCountTree = {
+    rootGameId: 'game-root',
+    root: null,
+    nodes: [
+      createLineageNode({
+        gameId: 'game-root',
+        title: '根原创',
+        generation: 0,
+        parentGameId: null,
+        playCount: 10,
+      }),
+      createLineageNode({
+        gameId: 'game-mid',
+        title: '中间代',
+        generation: 1,
+        parentGameId: 'game-root',
+        playCount: 20,
+      }),
+      createLineageNode({
+        gameId: 'game-current',
+        title: '当前作品',
+        generation: 2,
+        parentGameId: 'game-mid',
+        playCount: 7,
+      }),
+      createLineageNode({
+        gameId: 'game-child',
+        title: '子代',
+        generation: 3,
+        parentGameId: 'game-current',
+        playCount: 5,
+      }),
+      createLineageNode({
+        gameId: 'game-grandchild',
+        title: '孙代',
+        generation: 4,
+        parentGameId: 'game-child',
+        playCount: 3,
+      }),
+    ],
+    truncated: false,
+  };
+
+  it('游玩次数按「子代叠加到父代」显示：卡里给合计 + 分解，hero 同口径', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({
+        id: 'game-current',
+        playCount: 7,
+        forkCount: 3,
+        lineage: {
+          rootGameId: 'game-root',
+          parentGameId: 'game-mid',
+          parentTitle: '中间代',
+          parentAuthorName: '原作者',
+          generation: 2,
+        },
+      }),
+    );
+    getGameLineageMock.mockResolvedValue(playCountTree);
+    render(
+      <GameDetailPage
+        gameId="game-current"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenGameDetail={vi.fn()}
+      />,
+    );
+
+    // 卡里的概览：合计 + 分解（不是只给一个会让人误解的数字）。
+    const breakdown = await screen.findByLabelText('游玩次数合计');
+    expect(breakdown.textContent).toBe('游玩 15 次（自身 7 + 衍生 8）');
+    // 自身值只出现在分解里，不再单独显示成「7 次游玩」。
+    expect(screen.queryByText('7 次游玩')).toBeNull();
+    // hero 也是同一口径（子树合计），与卡里一致。
+    const hero = document.querySelector('.game-detail-hero') as HTMLElement;
+    expect(await within(hero).findByText('15 次游玩')).toBeTruthy();
+    expect(screen.getByText('累计衍生作品 3')).toBeTruthy();
+  });
+
+  it('共创卡只留标签 + 数据 + 入口：不再渲染派生作品卡列表（热门衍生栏已并入图谱）', async () => {
+    getGameMock.mockResolvedValueOnce(
+      createGame({ id: 'game-current', forkCount: 3, lineage: null }),
+    );
+    getGameLineageMock.mockResolvedValue(buildChainDataset());
+    getDerivedGamesMock.mockResolvedValueOnce({
+      gameId: 'game-current',
+      nodes: [
+        createLineageNode({
+          gameId: 'child-1',
+          title: '被改编出来的作品',
+          playCount: 12,
+          generation: 1,
+          parentGameId: 'game-current',
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameDetailPage
+        gameId="game-current"
+        onBack={vi.fn()}
+        onPlay={vi.fn()}
+        onOpenGameDetail={vi.fn()}
+        onOpenLineage={vi.fn()}
+      />,
+    );
+
+    const card = (await screen.findByText('累计衍生作品 3')).closest(
+      '.game-fork-card',
+    ) as HTMLElement;
+    // 卡里保留：世代/授权标签、数据概览、查看创作族谱、主题 tag（若有）。
+    expect(within(card).getByText('累计衍生作品 3')).toBeTruthy();
+    expect(
+      within(card).getByRole('button', { name: '查看创作族谱' }),
+    ).toBeTruthy();
+    // 卡里**不再有**派生作品卡列表：`CoCreationHotDerived` 组件与它的 `.co-creation-hot*` 样式
+    // 已于 2026-10-07 删除（零引用），这里钉住「它不会再回来」。
+    expect(card.querySelector('.co-creation-hot')).toBeNull();
+    expect(screen.queryByLabelText('热门衍生作品')).toBeNull();
+    expect(within(card).queryByText('被改编出来的作品')).toBeNull();
+  });
+
+  it('图谱页：图下方给出「父代」「子代」两块清单，子代按热度降序、点击可进详情', async () => {
+    getGameLineageMock.mockResolvedValue({
+      rootGameId: 'game-root',
+      root: null,
+      nodes: [
+        createLineageNode({
+          gameId: 'game-root',
+          title: '母版',
+          generation: 0,
+          parentGameId: null,
+          playCount: 1,
+        }),
+        createLineageNode({
+          gameId: 'game-mid',
+          title: '中间代',
+          generation: 1,
+          parentGameId: 'game-root',
+          playCount: 2,
+        }),
+        createLineageNode({
+          gameId: 'game-current',
+          title: '当前作品',
+          generation: 2,
+          parentGameId: 'game-mid',
+          playCount: 3,
+        }),
+        createLineageNode({
+          gameId: 'child-cold',
+          title: '冷门子代',
+          generation: 3,
+          parentGameId: 'game-current',
+          playCount: 1,
+        }),
+        createLineageNode({
+          gameId: 'child-hot',
+          title: '热门子代',
+          generation: 3,
+          parentGameId: 'game-current',
+          playCount: 99,
+        }),
+        createLineageNode({
+          gameId: 'grandchild',
+          title: '孙代作品',
+          generation: 4,
+          parentGameId: 'child-hot',
+          playCount: 5,
+        }),
+      ],
+      truncated: false,
+    });
+    const onOpenDetail = vi.fn();
+    render(
+      <GameLineagePage
+        rootGameId="game-root"
+        highlightGameId="game-current"
+        onBack={vi.fn()}
+        onOpenDetail={onOpenDetail}
+      />,
+    );
+
+    // 父代 = 祖先链（根 → 直接父），不含当前作品。
+    const ancestors = await screen.findByRole('region', { name: '父代' });
+    const ancestorNames = [
+      ...ancestors.querySelectorAll('.game-card__title-row > strong'),
+    ].map((element) => element.textContent);
+    expect(ancestorNames).toEqual(['母版', '中间代']);
+    // 子代 = **直接子代**（不含孙代），按热度（自身 playCount）降序。
+    const children = screen.getByRole('region', { name: '子代' });
+    expect(
+      [...children.querySelectorAll('.game-card__title-row > strong')].map(
+        (element) => element.textContent,
+      ),
+    ).toEqual(['热门子代', '冷门子代']);
+    expect(within(children).queryByText('孙代作品')).toBeNull();
+    // 点击进详情（清单里也是广场卡：整卡就是按钮）。
+    fireEvent.click(
+      children.querySelector(
+        '.lineage-relation__item .game-card',
+      ) as HTMLElement,
+    );
+    expect(onOpenDetail).toHaveBeenCalledWith('child-hot');
+  });
+
+  it('图谱页：没有父代/子代时两块给空态说明（不空白）', async () => {
+    getGameLineageMock.mockResolvedValueOnce({
+      rootGameId: 'solo',
+      root: null,
+      nodes: [
+        createLineageNode({
+          gameId: 'solo',
+          title: '孤作品',
+          generation: 0,
+          parentGameId: null,
+          playCount: 0,
+        }),
+      ],
+      truncated: false,
+    });
+    render(
+      <GameLineagePage
+        rootGameId="solo"
+        onBack={vi.fn()}
+        onOpenDetail={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByText(
+        '这部作品是母版，没有父代（它的后代都在上面的树里）。',
+      ),
+    ).toBeTruthy();
+    expect(screen.getByText('这部作品还没有直接子代。')).toBeTruthy();
+  });
+
+  it('可判定为已收藏时显示「已收藏」，点击取消收藏', async () => {
+    getGameMock.mockResolvedValueOnce(createGame({ collected: true }));
+    setGameCollectionMock.mockResolvedValueOnce({ collected: false });
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const button = await screen.findByRole('button', { name: '已收藏' });
+    fireEvent.click(button);
+
+    await waitFor(() =>
+      expect(setGameCollectionMock).toHaveBeenCalledWith(
+        'game-1',
+        false,
+        expect.stringContaining('game-1'),
+      ),
+    );
+    // 以服务端返回为准：取消后回到「收藏」。
+    expect(await screen.findByRole('button', { name: '收藏' })).toBeTruthy();
+  });
+
+  it('可判定为未收藏时显示「收藏」，点击收藏并乐观切到已收藏', async () => {
+    getGameMock.mockResolvedValueOnce(createGame({ collected: false }));
+    setGameCollectionMock.mockResolvedValueOnce({ collected: true });
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const button = await screen.findByRole('button', { name: '收藏' });
+    fireEvent.click(button);
+
+    await waitFor(() =>
+      expect(setGameCollectionMock).toHaveBeenCalledWith(
+        'game-1',
+        true,
+        expect.stringContaining('game-1'),
+      ),
+    );
+    expect(await screen.findByRole('button', { name: '已收藏' })).toBeTruthy();
+  });
+
+  it('缺 collected 字段（匿名按不返回该键）时不渲染成未收藏，点击走登录门禁', async () => {
+    authUiMock.value.user = null;
+    authUiMock.value.canAccessProtectedData = false;
+    // 匿名响应完全没有 collected 键——不能当 false 渲染。
+    getGameMock.mockResolvedValueOnce(createGame());
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    const button = await screen.findByRole('button', { name: '收藏' });
+    expect(screen.queryByRole('button', { name: '已收藏' })).toBeNull();
+    expect(button.getAttribute('title')).toBe('登录后可收藏');
+
+    fireEvent.click(button);
+    expect(authUiMock.value.openLoginModal).toHaveBeenCalledTimes(1);
+    // 未登录不发收藏请求，也不伪造已收藏态。
+    expect(setGameCollectionMock).not.toHaveBeenCalled();
+    expect(screen.queryByRole('button', { name: '已收藏' })).toBeNull();
+  });
+
+  it('收藏失败时回滚乐观态并提示服务端文案', async () => {
+    getGameMock.mockResolvedValueOnce(createGame({ collected: false }));
+    setGameCollectionMock.mockRejectedValueOnce(new Error('作品未公开'));
+    render(
+      <GameDetailPage gameId="game-1" onBack={vi.fn()} onPlay={vi.fn()} />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: '收藏' }));
+
+    expect(await screen.findByText('作品未公开')).toBeTruthy();
+    // 回滚：不能停在乐观的「已收藏」。
+    expect(screen.getByRole('button', { name: '收藏' })).toBeTruthy();
+    expect(screen.queryByRole('button', { name: '已收藏' })).toBeNull();
+  });
+});
+
+describe('PlatformToastHost（轻提示宿主）', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('portal 到 body、`role=status` + `aria-live=polite`，可手动关闭', async () => {
+    render(<PlatformToastHost />);
+    expect(screen.queryByTestId('platform-toast-host')).toBeNull();
+
+    act(() => {
+      showPlatformToast({ text: '作品 ID 已复制' });
+    });
+
+    const host = await screen.findByTestId('platform-toast-host');
+    // portal 到 body：不在渲染它的容器里，因此不参与任何页面布局。
+    expect(host.parentElement).toBe(document.body);
+    const toast = within(host).getByRole('status');
+    expect(toast.getAttribute('aria-live')).toBe('polite');
+    expect(toast.textContent).toContain('作品 ID 已复制');
+
+    // 键盘可达的关闭按钮。
+    fireEvent.click(
+      screen.getByRole('button', { name: '关闭提示：作品 ID 已复制' }),
+    );
+    expect(screen.queryByTestId('platform-toast-host')).toBeNull();
+  });
+
+  it('错误级用 `role=alert` + `aria-live=assertive`，且默认不自动消失', async () => {
+    vi.useFakeTimers();
+    render(<PlatformToastHost />);
+    act(() => {
+      showPlatformToast({ text: '开始共创失败', tone: 'error' });
+    });
+    const host = screen.getByTestId('platform-toast-host');
+    expect(within(host).getByRole('alert').getAttribute('aria-live')).toBe(
+      'assertive',
+    );
+    act(() => {
+      vi.advanceTimersByTime(PLATFORM_TOAST_DEFAULT_DURATION_MS * 4);
+    });
+    // 错误不会自己消失，必须用户关闭。
+    expect(screen.getByTestId('platform-toast-host')).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: /关闭提示/ }));
+    expect(screen.queryByTestId('platform-toast-host')).toBeNull();
+  });
+
+  it('普通提示自动消失（默认 5s），多条可堆叠', async () => {
+    vi.useFakeTimers();
+    render(<PlatformToastHost />);
+    act(() => {
+      showPlatformToast({ text: '第一条' });
+      showPlatformToast({ text: '第二条' });
+    });
+    const host = screen.getByTestId('platform-toast-host');
+    expect(within(host).getAllByRole('status')).toHaveLength(2);
+    act(() => {
+      vi.advanceTimersByTime(PLATFORM_TOAST_DEFAULT_DURATION_MS + 50);
+    });
+    // 两条都到点 → 宿主整块收起。
+    expect(screen.queryByTestId('platform-toast-host')).toBeNull();
+    void host;
+  });
+
+  it('normalizePlatformToast：默认 tone 与时长规则稳定', () => {
+    expect(normalizePlatformToast({ text: 'a' })).toEqual({
+      text: 'a',
+      tone: 'info',
+      durationMs: PLATFORM_TOAST_DEFAULT_DURATION_MS,
+    });
+    expect(
+      normalizePlatformToast({ text: 'a', tone: 'warning' }).durationMs,
+    ).toBe(null);
+    expect(
+      normalizePlatformToast({ text: 'a', tone: 'error', durationMs: 800 })
+        .durationMs,
+    ).toBe(800);
+  });
+});
diff --git a/src/components/game-distribution/GameGalleryPage.tsx b/src/components/game-distribution/GameGalleryPage.tsx
index 3f222d484..ec2987700 100644
--- a/src/components/game-distribution/GameGalleryPage.tsx
+++ b/src/components/game-distribution/GameGalleryPage.tsx
@@ -5,6 +5,7 @@ import { GameCard } from '@genarrative/shared/components';
 import { Gamepad2, Monitor, Search, Smartphone, Sparkles } from 'lucide-react';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
+import { resolveGameForkAuthorization } from '../../../packages/shared/src/contracts/gameDistribution';
 import {
   type GameCategory,
   type GameDistributionGame,
@@ -35,14 +36,49 @@ type GameGalleryPageProps = {
   onOpenDetail: (gameId: string) => void;
   onOpenMyGames?: () => void;
   onOpenPublish?: () => void;
+  /**
+   * 页签作用域：`all` = 游戏广场（全部公开作品，默认）；`forkable` = **共创页**
+   * （只列**支持共创**的作品，请求带 `forkable=1`）。
+   *
+   * 2026-10-07：`forkable` 从「游戏页里的子页签」升级为**侧边栏顶层入口**
+   * （`/games/co-creation`，侧边栏「共创」），页面内的「游戏 / 共创」子页签已删除。
+   */
+  scope?: 'all' | 'forkable';
 };
 
+/** 页签作用域 → 只保留了「支持共创」这一条口径的过滤（与 `forkable=1` 同义）。 */
+function isForkable(game: GameDistributionGame) {
+  return resolveGameForkAuthorization(game.forkAuthorization) !== 'forbidden';
+}
+
+/**
+ * 卡片指标位上的「共创次数」（模块私有：只在共创页的卡片上消费）。
+ *
+ * 字段口径（2026-10-07）：
+ * - 优先读服务端公开目录的 `coCreationCount`（**整棵子树里公开可见的全部后代数、不含自己**）；
+ * - 缺省时回退**已有**的 `forkCount`（契约里写明是「被改编次数 = 直接子代数量」——
+ *   栈里还是旧模块时走这条，不报错）；
+ * - 两者都缺省 / 非法 → 返回 `null`（调用方回退「N 次游玩」，**不伪造 0**）；
+ * - 真实值 `0` **要显示**（「被共创 0 次」= 还没人接着做，是信息不是噪声）。
+ *
+ * 只在 `scope === 'forkable'` 时使用，广场 / 游戏页卡片不受影响。
+ */
+function resolveCoCreationCount(
+  game: Pick<GameDistributionGame, 'coCreationCount' | 'forkCount'>,
+): number | null {
+  const raw = game.coCreationCount ?? game.forkCount;
+  if (typeof raw !== 'number' || !Number.isFinite(raw) || raw < 0) return null;
+  return Math.floor(raw);
+}
+
 export function GameGalleryPage({
   searchKeyword = '',
   onOpenDetail,
   onOpenMyGames,
   onOpenPublish,
+  scope = 'all',
 }: GameGalleryPageProps) {
+  const forkableOnly = scope === 'forkable';
   const initialFiltersRef = useRef<GameGalleryFilters | null>(null);
   if (initialFiltersRef.current === null) {
     const queryFilters =
@@ -64,8 +100,12 @@ export function GameGalleryPage({
   const [keywordInput, setKeywordInput] = useState(initialFilters.keyword);
   const [activeKeyword, setActiveKeyword] = useState(initialFilters.keyword);
   const [games, setGames] = useState<GameDistributionGame[]>([]);
+  /** 下一页游标：非空才渲染「加载更多」（末页服务端给 null）。 */
+  const [nextCursor, setNextCursor] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(true);
+  const [isLoadingMore, setIsLoadingMore] = useState(false);
   const [error, setError] = useState('');
+  const [loadMoreError, setLoadMoreError] = useState('');
   const requestSerialRef = useRef(0);
   const scrollContainerRef = useRef<HTMLElement | null>(null);
   const gameListRef = useRef<HTMLDivElement | null>(null);
@@ -92,7 +132,8 @@ export function GameGalleryPage({
   }, []);
 
   /**
-   * 首屏「立即试玩」只把列表滚进视野，不替用户选定某一款游戏。
+   * 首屏「浏览作品」只把列表滚进视野，不替用户选定某一款游戏，也**不启动**任何作品
+   * —— 所以文案是「浏览作品」（描述滚动/查看列表），不是「开始游戏」（会让人以为会启动）。
    *
    * 滚动容器是平台页签面板而不是窗口，所以按容器相对位置计算，缺少
    * `scrollTo` 时退化成直接赋值，保证无动画环境也能生效。
@@ -120,10 +161,17 @@ export function GameGalleryPage({
     const requestSerial = ++requestSerialRef.current;
     setIsLoading(true);
     setError('');
-    void listGames({ keyword: activeKeyword, category })
-      .then((nextGames) => {
+    setLoadMoreError('');
+    void listGames({
+      keyword: activeKeyword,
+      category,
+      // 「共创」页签只列支持共创的作品；服务端口径未上线期间下面还有一层同义兜底过滤。
+      ...(forkableOnly ? { forkable: true } : {}),
+    })
+      .then((page) => {
         if (requestSerial !== requestSerialRef.current) return;
-        setGames(nextGames);
+        setGames(page.games);
+        setNextCursor(page.nextCursor);
       })
       .catch((loadError: unknown) => {
         if (requestSerial !== requestSerialRef.current) return;
@@ -134,7 +182,44 @@ export function GameGalleryPage({
       .finally(() => {
         if (requestSerial === requestSerialRef.current) setIsLoading(false);
       });
-  }, [activeKeyword, category]);
+  }, [activeKeyword, category, forkableOnly]);
+
+  /**
+   * 「加载更多」：用服务端给的 `nextCursor` 取下一页并**按 gameId 去重后追加**。
+   *
+   * 不静默截断、也不重置：失败时**保留已加载的内容**并给可读提示（用户能继续看已有的、可重试）。
+   * 游标对客户端不透明，这里绝不自己拼。
+   */
+  const loadMoreGames = useCallback(() => {
+    if (!nextCursor || isLoadingMore) return;
+    const requestSerial = requestSerialRef.current;
+    setIsLoadingMore(true);
+    setLoadMoreError('');
+    void listGames({
+      keyword: activeKeyword,
+      category,
+      cursor: nextCursor,
+      ...(forkableOnly ? { forkable: true } : {}),
+    })
+      .then((page) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setGames((current) => {
+          const seen = new Set(current.map((game) => game.id));
+          const appended = page.games.filter((game) => !seen.has(game.id));
+          return appended.length === 0 ? current : [...current, ...appended];
+        });
+        setNextCursor(page.nextCursor);
+      })
+      .catch((loadError: unknown) => {
+        if (requestSerial !== requestSerialRef.current) return;
+        setLoadMoreError(
+          loadError instanceof Error ? loadError.message : '加载下一页失败',
+        );
+      })
+      .finally(() => {
+        if (requestSerial === requestSerialRef.current) setIsLoadingMore(false);
+      });
+  }, [activeKeyword, category, forkableOnly, isLoadingMore, nextCursor]);
 
   useEffect(() => {
     if (lastPropKeywordRef.current === searchKeyword) return;
@@ -177,8 +262,11 @@ export function GameGalleryPage({
   }, [scrollKey]);
 
   const visibleGames = useMemo(
-    () => games.filter((game) => matchesGameDeviceFilter(game, device)),
-    [device, games],
+    () =>
+      games
+        .filter((game) => (forkableOnly ? isForkable(game) : true))
+        .filter((game) => matchesGameDeviceFilter(game, device)),
+    [device, forkableOnly, games],
   );
   const hasActiveFilters =
     activeKeyword.trim().length > 0 || category !== '全部' || device !== '全部';
@@ -228,24 +316,41 @@ export function GameGalleryPage({
       <section className="game-hero">
         <div className="game-hero__copy">
           <span className="game-eyebrow">
-            <Sparkles aria-hidden="true" /> 陶泥儿游戏分发
+            <Sparkles aria-hidden="true" />{' '}
+            {forkableOnly ? '陶泥儿共创' : '陶泥儿游戏分发'}
           </span>
-          <h1>
-            把灵感做成游戏，
-            <br />
-            <em>现在就开始玩。</em>
-          </h1>
-          <p>
-            来自 AGC
-            创作者的轻量游戏集合。打开网页即可游玩，每一次尝试都值得被看见。
-          </p>
+          {forkableOnly ? (
+            <>
+              <h1>
+                这些作品欢迎你
+                <br />
+                <em>接着做下去。</em>
+              </h1>
+              <p>
+                这里只列出已开放共创的作品。点开作品详情里的「开始共创」，
+                就能把整个工程复制到你的项目里继续改造。
+              </p>
+            </>
+          ) : (
+            <>
+              <h1>
+                把灵感做成游戏，
+                <br />
+                <em>现在就开始玩。</em>
+              </h1>
+              <p>
+                来自 AGC
+                创作者的轻量游戏集合。打开网页即可游玩，每一次尝试都值得被看见。
+              </p>
+            </>
+          )}
           <div className="game-hero__actions">
             <PlatformActionButton
               size="md"
               shape="pill"
               onClick={scrollToGameList}
             >
-              <Gamepad2 aria-hidden="true" /> 立即试玩
+              <Gamepad2 aria-hidden="true" /> 浏览作品
             </PlatformActionButton>
             <span className="game-hero__hint">支持桌面端与移动端</span>
           </div>
@@ -257,8 +362,10 @@ export function GameGalleryPage({
 
       <div className="game-toolbar" ref={gameListRef}>
         <div className="game-toolbar__title">
-          <span className="game-eyebrow">发现好玩的</span>
-          <h2>游戏广场</h2>
+          <span className="game-eyebrow">
+            {forkableOnly ? '可以共创的作品' : '发现好玩的'}
+          </span>
+          <h2>{forkableOnly ? '共创广场' : '游戏广场'}</h2>
         </div>
         <div className="game-toolbar__actions">
           <label className="game-search">
@@ -340,12 +447,18 @@ export function GameGalleryPage({
       ) : null}
       {!isLoading && !error && visibleGames.length === 0 ? (
         <PlatformEmptyState surface="subpanel" size="panel">
-          <strong>还没有找到对应游戏</strong>
+          <strong>
+            {forkableOnly && !hasActiveFilters
+              ? '暂时没有开放共创的作品'
+              : '还没有找到对应游戏'}
+          </strong>
           <br />
           <span>
             {hasActiveFilters
               ? '换个关键词、分类或设备条件再试试。'
-              : '新的游戏正在路上，稍后再来看看。'}
+              : forkableOnly
+                ? '作者把作品开放共创授权后，它会出现在这里。'
+                : '新的游戏正在路上，稍后再来看看。'}
           </span>
           {hasActiveFilters ? (
             <div className="game-empty-actions">
@@ -363,14 +476,63 @@ export function GameGalleryPage({
       ) : null}
       {!isLoading && !error && visibleGames.length > 0 ? (
         <div className="game-grid">
-          {visibleGames.map((game) => (
-            <GameCard
-              cover={<GameCover game={game} />}
-              key={game.id}
-              game={game}
-              onOpen={() => openDetail(game.id)}
-            />
-          ))}
+          {visibleGames.map((game) => {
+            /**
+             * **共创次数顶掉游玩数**（只在共创页生效）：卡片标题行右侧那个指标位，
+             * 在共创广场上要回答的是「这个作品被多少人接着做了」——2026-10-07 用户口径
+             * 「并非游玩次数，而是共创次数」。角标（封面上的那枚）已删除，同一张卡上
+             * 计数只留这一处。
+             *
+             * 取不到任何计数（作者侧 / 旧响应都没有 `coCreationCount` 与 `forkCount`）时
+             * **不传 `metric`**，卡片回到默认的「N 次游玩」而不是渲染一个假 0。
+             */
+            const coCreationCount = forkableOnly
+              ? resolveCoCreationCount(game)
+              : null;
+            return (
+              <GameCard
+                cover={<GameCover game={game} />}
+                key={game.id}
+                game={game}
+                metric={
+                  coCreationCount === null ? undefined : (
+                    <span
+                      className="game-card__co-creation-count"
+                      aria-label={`被共创 ${coCreationCount} 次`}
+                    >
+                      <Sparkles aria-hidden="true" />
+                      被共创 {coCreationCount} 次
+                    </span>
+                  )
+                }
+                onOpen={() => openDetail(game.id)}
+              />
+            );
+          })}
+        </div>
+      ) : null}
+      {/*
+        游标分页的「加载更多」：只要有下一页游标就露出（哪怕当前设备筛选暂时没有可见条目，
+        否则用户会卡在「空态 + 再也点不到下一页」）。失败**不清空**已加载内容，只给提示 + 重试。
+      */}
+      {!isLoading && !error && (nextCursor || loadMoreError) ? (
+        <div className="game-empty-actions">
+          {loadMoreError ? (
+            <span className="game-gallery-more__error" role="status">
+              {loadMoreError}
+            </span>
+          ) : null}
+          {nextCursor ? (
+            <PlatformActionButton
+              tone="secondary"
+              size="sm"
+              shape="pill"
+              disabled={isLoadingMore}
+              onClick={() => void loadMoreGames()}
+            >
+              {isLoadingMore ? '正在加载…' : '加载更多'}
+            </PlatformActionButton>
+          ) : null}
         </div>
       ) : null}
     </div>
diff --git a/src/components/game-distribution/GameLineagePage.tsx b/src/components/game-distribution/GameLineagePage.tsx
new file mode 100644
index 000000000..c5a78ddc6
--- /dev/null
+++ b/src/components/game-distribution/GameLineagePage.tsx
@@ -0,0 +1,1469 @@
+import './gameDistribution.css';
+
+import { GameCard } from '@genarrative/shared/components';
+import { ArrowLeft, Minimize, Minus, Plus, RefreshCcw } from 'lucide-react';
+import {
+  type CSSProperties,
+  type PointerEvent as ReactPointerEvent,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+import {
+  type GameDistributionGame,
+  type GameDistributionLineageResponse,
+  getGame,
+  getGameLineage,
+} from '../../services/gameDistributionClient';
+import { CopyFeedbackButton } from '../common/CopyFeedbackButton';
+import { PlatformEmptyState } from '../common/PlatformEmptyState';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import { useCopyFeedback } from '../common/useCopyFeedback';
+import { GameCover } from './GameCover';
+import { useIsMobileViewport } from './gameDistributionGuards';
+import {
+  FORK_LAUNCH_FALLBACK_DELAY_MS,
+  openForkProtocol,
+} from './gameForkProtocol';
+import { LineageInfoPanel } from './LineageInfoPanel';
+import { LineageOutlineList } from './LineageOutlineList';
+import { LineageRelationLists } from './LineageRelationLists';
+import {
+  buildLineageTreeLayout,
+  clampLineagePan,
+  collectLineageAncestorChain,
+  collectLineageHighlight,
+  collectLineageImmediateScope,
+  collectLineagePlayCountTotals,
+  collectLineageRelationRoles,
+  estimateLineageCardHeight,
+  generationAxisLabel,
+  LINEAGE_CARD_BASE_HEIGHT,
+  LINEAGE_CARD_WIDTH,
+  LINEAGE_COMPACT_CARD_BASE_HEIGHT,
+  LINEAGE_COMPACT_NODE_WIDTH,
+  LINEAGE_NODE_PADDING_X,
+  LINEAGE_NODE_PADDING_Y,
+  type LineageLayoutNode,
+  type LineagePlayCountBreakdown,
+  type LineageRelationRole,
+} from './lineageTreeLayout';
+
+type GameLineagePageProps = {
+  /** 路由 `?id=` 里的根作品 ID；为空时给出明确的无效编号提示，不发请求。 */
+  rootGameId: string | null;
+  /**
+   * 用户是从作品详情页的哪个节点进来的，用来标记「当前作品」。
+   * 缺失时退回标记根节点（直接打开族谱链接的场景）。
+   */
+  highlightGameId?: string | null;
+  onBack?: () => void;
+  onOpenDetail: (gameId: string) => void;
+  /**
+   * 内嵌模式：隐藏页面外壳（返回按钮 / 页头 / 脚注），只渲染可视化树本身。
+   * 供主题页逐根渲染多棵树复用同一份树查询与渲染（不新建第二套树逻辑）。
+   */
+  embedded?: boolean;
+  /**
+   * 树加载完成后把「每个节点的游玩次数分解（子树合计）」回传给宿主，供宿主页面显示合计
+   * ——宿主用**同一次** `/lineage` 请求的结果算，不需要自己再发一次（主题页的母版行就用它）。
+   * 回调在内部用 ref 保存，宿主不必包 `useCallback`。
+   */
+  onPlayCountTotals?: (
+    totals: ReadonlyMap<string, LineagePlayCountBreakdown>,
+  ) => void;
+};
+
+/** 拖动阈值（像素）：超过它才算「拖动」，否则一律当作点击，交给浏览器原生 click。 */
+const DRAG_START_THRESHOLD_PX = 4;
+
+const MIN_SCALE = 0.35;
+const MAX_SCALE = 1.8;
+const FIT_PADDING = 24;
+/**
+ * 可读下限：把整棵树硬塞进窗口会把字缩到看不清（尤其窄屏），
+ * 所以初次进入若全览缩放低于它，就按可读缩放 + 可平移呈现，由用户点「总览」主动全览。
+ *
+ * 取值依据（2026-10-07 真机实测，截图反馈「60% 可读缩放下卡片信息过密/过小」）：
+ * 卡面是 240 宽的广场卡 —— 标题 `1rem`、游玩数 `0.66rem`、作者 `0.7rem`，
+ * 60% 时分别是 9.6 / 6.3 / 6.7px，明显读不清；0.8 时是 12.8 / 8.4 / 9px，
+ * 配合角标下移与「标题独占一行」的版式，首屏可读。
+ */
+const READABLE_MIN_SCALE = 0.8;
+
+type ViewportState = { scale: number; offsetX: number; offsetY: number };
+
+/**
+ * 一个树节点：真实 HTML 卡片（可聚焦、可点击、有可访问名称），不是 SVG 矩形。
+ *
+ * 交互分工：主点击（含键盘 Enter/Space）进作品详情；次要动作「开始共创」放在卡片内部的独立
+ * `<button>` 里并 `stopPropagation`，所以两者不会互相抢事件。
+ */
+function LineageTreeNodeCard({
+  layoutNode,
+  isAnchor,
+  isDimmed,
+  isOnPath,
+  isPinned,
+  compact,
+  showGenerationBadge,
+  relation,
+  playCount,
+  onOpenDetail,
+  onActivate,
+  onDeactivate,
+}: {
+  layoutNode: LineageLayoutNode;
+  isAnchor: boolean;
+  isDimmed: boolean;
+  /** 该节点在「锁定/高亮目标」的祖先链上（含目标自身）。 */
+  isOnPath: boolean;
+  isPinned: boolean;
+  /** 窄屏紧凑模式：少一行信息、卡片更小。 */
+  compact: boolean;
+  /** 是否渲染世代角标（仅在**没有**左侧代际轴的横版画布上为 true，避免与轴重复）。 */
+  showGenerationBadge: boolean;
+  /** 相对「当前作品」的角色：父代 / 子代 / 自己 / 旁支（打 `data-relation` + 角标）。 */
+  relation: LineageRelationRole;
+  /** 游玩次数**子树合计**（显示口径）：卡面本体的「N 次游玩」用它，角标里不再重复。 */
+  playCount: LineagePlayCountBreakdown | null;
+  onOpenDetail: (gameId: string) => void;
+  onActivate: (gameId: string) => void;
+  onDeactivate: () => void;
+}) {
+  const { gameId, title, authorName, generation, isStub } = layoutNode;
+  const displayTitle = isStub ? '原作品已不可用' : (title ?? '未命名作品');
+  const authorLabel = isStub
+    ? '标题与作者名不对外展示'
+    : (authorName ?? '').trim() || '未署名作者';
+  // 父作品不可用的占位节点只能聚焦（不可点进详情，也没有「开始共创」动作）。
+
+  /**
+   * `GameCover` 需要一份最小作品投影：族谱节点只有公开投影（标题/作者/游玩数/封面对象键），
+   * 其余字段仅为满足类型，不参与渲染（卡面数据由 `GameCard` 的 props 传真实值）。
+   */
+  const coverGame = {
+    id: gameId,
+    title: displayTitle,
+    coverColor: '#d77a51',
+    icon: '✦',
+    coverObjectKey: layoutNode.coverObjectKey ?? null,
+    playCount: playCount?.total ?? layoutNode.node?.playCount ?? 0,
+    author: { id: 'lineage', name: authorLabel || '未署名作者' },
+  } as unknown as GameDistributionGame;
+  /**
+   * 卡面角标槽（不承载动作按钮）：世代 / 主干 / 当前作品 / 父代-子代。
+   *
+   * 两处**去重**（截图反馈里「角标压在封面上导致遮挡与信息重复」）：
+   * - 游玩次数不再进角标：卡面本体（广场卡）的标题行已经写着同一个合计「N 次游玩」，
+   *   角标里再来一个 `▶ N` 是同一数字的第二处（口径见 `collectLineagePlayCountTotals`）。
+   *   大纲行没有广场卡本体，那边的 `▶ N` 保留（`LineageNodeContent` 里的那份）。
+   * - 世代角标只在**没有代际轴**时渲染（窄屏横版画布）：竖版画布左侧的代际轴已经逐行写着
+   *   「母版 / 第 1 代 / …」，每张卡再带一枚「第 N 代」是同一信息的第二处。
+   */
+  const badges = (
+    <>
+      {showGenerationBadge ? (
+        <span className="game-lineage-node__generation">
+          {generationAxisLabel(generation)}
+        </span>
+      ) : null}
+      {layoutNode.isTrunk ? (
+        <span className="game-lineage-node__trunk" title="该代热度最高的版本">
+          主干
+        </span>
+      ) : null}
+      {isAnchor ? (
+        <span className="game-lineage-node__anchor">当前作品</span>
+      ) : null}
+      {relation === 'ancestor' || relation === 'descendant' ? (
+        <span
+          className={`game-lineage-node__relation game-lineage-node__relation--${relation}`}
+          data-relation={relation}
+        >
+          {relation === 'ancestor' ? '父代' : '子代'}
+        </span>
+      ) : null}
+    </>
+  );
+
+  return (
+    <div
+      className={[
+        'game-lineage-node',
+        isAnchor ? 'game-lineage-node--anchor' : '',
+        isStub ? 'game-lineage-node--stub' : '',
+        isDimmed ? 'game-lineage-node--dimmed' : '',
+        // 路径上的节点（祖先链 + 目标）与「仅子树」的节点给不同强度的强化，
+        // 这样「整棵子树」在默认全览下也有明显差异，而不是只把别人变淡。
+        !isDimmed && isOnPath ? 'game-lineage-node--path' : '',
+        !isDimmed && !isOnPath ? 'game-lineage-node--subtree' : '',
+        isPinned ? 'game-lineage-node--pinned' : '',
+        compact ? 'game-lineage-node--compact' : '',
+      ]
+        .filter(Boolean)
+        .join(' ')}
+      style={{
+        left: layoutNode.x,
+        top: layoutNode.y,
+        width: layoutNode.width,
+        minHeight: layoutNode.height,
+        // 默认态就按「顶级分支」着色：不必等 hover 也能看出哪几颗属于同一个共创分支。
+        ['--lineage-branch' as string]: `var(--lineage-branch-${layoutNode.branchIndex % 6})`,
+      }}
+      data-generation={generation}
+      data-branch={layoutNode.branchIndex}
+      data-relation={relation}
+      /*
+        游玩次数的**含衍生**说明：卡面本体的「N 次游玩」是广场卡给的一行文本，没法挂 title，
+        所以把口径挂在节点容器上（悬停卡片空白处仍能看到），角标里那枚重复的 `▶ N` 因此可以去掉。
+        拿不到树（`playCount` 为 null）时不给说明——不暗示含衍生。
+      */
+      title={
+        playCount
+          ? `游玩次数（含衍生作品）：自身 ${playCount.own} + 衍生 ${playCount.inherited}`
+          : undefined
+      }
+      // 占位节点只能聚焦（不进详情）；当前作品在无障碍层也标出来。
+      tabIndex={isStub ? 0 : undefined}
+      aria-disabled={isStub ? 'true' : undefined}
+      aria-current={isAnchor ? 'true' : undefined}
+      // 悬停/聚焦仍然驱动「高亮祖先链 + 右侧信息面板」（不抢点击）。
+      onMouseEnter={() => onActivate(gameId)}
+      onMouseLeave={onDeactivate}
+      onFocus={() => onActivate(gameId)}
+      onBlur={onDeactivate}
+    >
+      {/*
+        卡面 = **广场作品卡的同一个组件**（`@genarrative/shared/components` 的 `GameCard`）：
+        整卡就是入口（点击 → 进详情），卡上不再放「打开作品 / 开始共创」按钮
+        —— 用户口径：看封面决定不了共创，必须点进去看。
+        占位节点（父作品不可用）点击不导航，只作为可聚焦的降级说明。
+      */}
+      <GameCard
+        className="game-card--lineage"
+        game={{
+          title: displayTitle,
+          // 显示口径：游玩次数 = 该节点的**子树合计**（与卡片自身的「N 次游玩」一致）。
+          playCount: playCount?.total ?? layoutNode.node?.playCount ?? 0,
+          author: !isStub && authorLabel ? { name: authorLabel } : undefined,
+        }}
+        cover={
+          <GameCover game={coverGame} objectKey={layoutNode.coverObjectKey} />
+        }
+        badges={badges}
+        onOpen={() => {
+          if (isStub) return;
+          onOpenDetail(gameId);
+        }}
+      />
+    </div>
+  );
+}
+
+/**
+ * 创作族谱页：把 `/games/{id}/lineage` 的树画成**节点-连线**可视化。
+ *
+ * 分工：连线与缩放/平移靠一个 `<svg>` + 一层 CSS transform 的内容层；节点是**真实 HTML 卡片**
+ * （可点击、可聚焦、有可访问名称），因此交互、读屏与选中态都是 DOM 语义，而不是 SVG 伪元素。
+ * 布局计算全在 `lineageTreeLayout`（纯函数，useMemo 缓存），hover 只改变高亮集合、不触发重排。
+ */
+export function GameLineagePage({
+  rootGameId,
+  highlightGameId = null,
+  onBack,
+  onOpenDetail,
+  embedded = false,
+  onPlayCountTotals,
+}: GameLineagePageProps) {
+  const normalizedRootId = rootGameId?.trim() ?? '';
+  const [lineage, setLineage] =
+    useState<GameDistributionLineageResponse | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState('');
+  const [activeGameId, setActiveGameId] = useState('');
+  const [pinnedGameId, setPinnedGameId] = useState('');
+  const [generationFilter, setGenerationFilter] = useState<number | null>(null);
+  const [sortByHeat, setSortByHeat] = useState(false);
+  const [selectedGame, setSelectedGame] = useState<GameDistributionGame | null>(
+    null,
+  );
+  const isMobileViewport = useIsMobileViewport();
+  /**
+   * 形态：移动端默认**大纲式缩进树**（无横向滚动、触控友好），可用「图谱视图」切回画布；
+   * 桌面默认画布。`null` = 跟随当前断点的默认值。
+   */
+  const [viewMode, setViewMode] = useState<'outline' | 'canvas' | null>(null);
+  const [viewport, setViewport] = useState<ViewportState>({
+    scale: 1,
+    offsetX: 0,
+    offsetY: 0,
+  });
+  const [forkNotice, setForkNotice] = useState('');
+  const [fitHint, setFitHint] = useState('');
+  const [forkFallbackGameId, setForkFallbackGameId] = useState('');
+  // 复制反馈保留更久（默认 1.4s 在真实浏览器里太短：用户/验收脚本都可能错过那一瞬），
+  // 并且旁边常驻一条 role=status 的说明，标签复位后仍然能看到「刚才复制成功了」。
+  const { copyState: forkCopyState, copyText: copyForkId } = useCopyFeedback({
+    resetDelayMs: 5000,
+  });
+  const viewportRef = useRef<HTMLDivElement>(null);
+  const currentCrumbRef = useRef<HTMLButtonElement>(null);
+  const forkTimerRef = useRef<number | null>(null);
+  const forkHandlersRef = useRef<(() => void) | null>(null);
+  /** 拖动中：驱动 CSS（user-select: none / touch-action: none / 光标）。 */
+  const [isPanning, setIsPanning] = useState(false);
+  const dragRef = useRef<{
+    x: number;
+    y: number;
+    offsetX: number;
+    offsetY: number;
+    pointerId: number;
+    /** 是否已经越过拖动阈值（越过才捕获指针、才拦默认行为）。 */
+    started: boolean;
+  } | null>(null);
+
+  const loadLineage = useCallback(async () => {
+    if (!normalizedRootId) {
+      setLineage(null);
+      setError('');
+      return;
+    }
+    setIsLoading(true);
+    setError('');
+    try {
+      const result = await getGameLineage(normalizedRootId);
+      if (!result) {
+        setError('游戏编号无效');
+        return;
+      }
+      setLineage(result);
+    } catch (loadError) {
+      setError(
+        loadError instanceof Error ? loadError.message : '读取创作族谱失败',
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, [normalizedRootId]);
+
+  useEffect(() => {
+    void loadLineage();
+  }, [loadLineage]);
+
+  const nodes = useMemo(() => lineage?.nodes ?? [], [lineage]);
+  /**
+   * 游玩次数**显示**口径 = 该节点的**子树合计**（父代展示自己 + 全部后代，见 §3.6.3）。
+   * 同一棵树只算一次：既给节点角标（`▶ N`），也回传给宿主（主题页母版行）。
+   * **注意**：主干线与「按热度排序」的判据仍是**自身** `playCount`（服务端字段原值），
+   * 与这里的显示口径**不同**——两处注释互相指认，别改错。
+   */
+  const playCountTotals = useMemo(
+    () => collectLineagePlayCountTotals(nodes),
+    [nodes],
+  );
+  /**
+   * 树一变就把「每个节点的游玩次数分解」交给宿主（主题页的母版行要显示子树合计）。
+   * 回调存在 ref 里，所以宿主不必包 `useCallback`，也不会因为回调换身份而反复触发。
+   */
+  const playCountTotalsCallbackRef = useRef(onPlayCountTotals);
+  playCountTotalsCallbackRef.current = onPlayCountTotals;
+  useEffect(() => {
+    const callback = playCountTotalsCallbackRef.current;
+    if (!callback || !lineage) return;
+    callback(playCountTotals);
+  }, [lineage, playCountTotals]);
+  // 高亮锚点（= 「当前作品」，也是「父代 / 子代」的基准）必须早于筛选链路声明。
+  const anchorId = highlightGameId?.trim() || normalizedRootId;
+  /**
+   * 每个节点相对当前作品的角色：`self` / `ancestor`（父代）/ `descendant`（子代）/ `side`（旁支）。
+   * 用**未筛选**的整棵树算，所以世代筛选、只看父子、排序都不会改口径。
+   */
+  /** 祖先链（根 → 直接父）：与信息面板面包屑同一份顺序函数。 */
+  const ancestorChain = useMemo(() => {
+    const chain = collectLineageAncestorChain(nodes, anchorId);
+    // 去掉自己：这是「父代」清单。
+    return chain.filter((node) => node.gameId !== anchorId);
+  }, [anchorId, nodes]);
+  /**
+   * **直接子代**（按热度降序；同热度按服务端顺序 = 创建时间序稳定兜底）。
+   * 选「直接子代」而不是整棵子树：与 `forkCount`/「被改编 N」同口径，且再深的层级交给上面的树。
+   */
+  const directChildren = useMemo(() => {
+    const children = nodes.filter(
+      (node) => (node.parentGameId ?? null) === anchorId,
+    );
+    return children
+      .map((node, index) => ({ node, index }))
+      .sort(
+        (left, right) =>
+          right.node.playCount - left.node.playCount ||
+          left.index - right.index,
+      )
+      .map((item) => item.node);
+  }, [anchorId, nodes]);
+  const relationRoles = useMemo(
+    () => collectLineageRelationRoles(nodes, anchorId),
+    [anchorId, nodes],
+  );
+  /** 「只看父代与子代」的保留集合：祖先链 + 自己 + 直接子代。 */
+  const relatedScope = useMemo(
+    () => collectLineageImmediateScope(nodes, anchorId),
+    [anchorId, nodes],
+  );
+  /** 开关：默认关（显示以根为作用域的整棵树），打开后只看父代与直接子代，再点一次取消。 */
+  const [onlyRelated, setOnlyRelated] = useState(false);
+  /**
+   * 顶部筛选器：按世代筛选（保留该代及其祖先，树不断链）与按热度排序
+   * （同代内 `playCount` 倒序；关闭时保持服务端顺序 = 创建时间序）。
+   *
+   * 注意排序判据是**自身** `playCount`（服务端字段原值），与主干线同裁定：热度表达的是
+   * 「这一版自己有多热」，不是子树合计（显示口径见 §3.6.3）。别改成 `...Totals`。
+   */
+  const filteredNodes = useMemo(() => {
+    const kept =
+      generationFilter === null
+        ? [...nodes]
+        : nodes.filter((node) => node.generation <= generationFilter);
+    // 「只看父代与子代」：作用域里没有锚点（例如锚点不在可见集合里）时不筛选，
+    // 免得渲染出一张空图。
+    const scoped = onlyRelated
+      ? kept.filter((node) => relatedScope.has(node.gameId))
+      : kept;
+    const useScoped =
+      onlyRelated && scoped.some((node) => node.gameId === anchorId);
+    const result = useScoped ? scoped : kept;
+    if (!sortByHeat) return result;
+    return result
+      .map((node, index) => ({ node, index }))
+      .sort(
+        (left, right) =>
+          left.node.generation - right.node.generation ||
+          right.node.playCount - left.node.playCount ||
+          left.index - right.index,
+      )
+      .map((item) => item.node);
+  }, [
+    anchorId,
+    generationFilter,
+    nodes,
+    onlyRelated,
+    relatedScope,
+    sortByHeat,
+  ]);
+  const generationsPresent = useMemo(
+    () =>
+      [...new Set(nodes.map((node) => node.generation))].sort((a, b) => a - b),
+    [nodes],
+  );
+  // 窄屏用紧凑布局（更小的卡片与间距 + 更大的相对字号），避免「桌面画布缩小 + 字太小」。
+  const compactTree = isMobileViewport;
+  /** 窄屏图谱视图用横版画布：代际信息交给节点角标，因此不渲染左侧代际轴层。 */
+  const horizontalCanvas = compactTree;
+  const layout = useMemo(() => {
+    // 卡片高度估算（纯函数、确定性）：层高 = 该层最高卡片 + rowGap，据此排下一层 ——
+    // 同层里出现一张「2 行标题」的高卡也不会被下一层压住。渲染后不再测量 DOM。
+    const cardHeights = new Map(
+      filteredNodes.map((node) => [
+        node.gameId,
+        estimateLineageCardHeight({
+          title: node.title,
+          baseHeight: compactTree
+            ? LINEAGE_COMPACT_CARD_BASE_HEIGHT
+            : LINEAGE_CARD_BASE_HEIGHT,
+        }),
+      ]),
+    );
+    return buildLineageTreeLayout(
+      filteredNodes,
+      compactTree
+        ? {
+            // 紧凑态：窄屏横版画布专用的较小卡宽（`LINEAGE_COMPACT_CARD_WIDTH`）。
+            // 注意**清单卡不跟它降级**：2026-10-07 用户拍板「宽 + 不截断」优先，清单一律用
+            // `LINEAGE_CARD_WIDTH`（224），390 窄屏因此是 1 列而不是 2 列小卡。
+            nodeWidth: LINEAGE_COMPACT_NODE_WIDTH,
+            nodeHeight: LINEAGE_COMPACT_CARD_BASE_HEIGHT,
+            columnGap: 22,
+            rowGap: 88,
+            axisWidth: 72,
+            // 窄屏图谱视图用横版（根在左、代际向右、兄弟沿纵向排开）：窄屏上比顶→下更省横向空间，
+            // 纵向溢出交给滑动。代际信息由节点自带角标承担，所以横版不渲染代际轴（见下面的轴层）。
+            orientation: 'horizontal',
+            cardHeights,
+          }
+        : { cardHeights },
+    );
+  }, [compactTree, filteredNodes]);
+  // 高亮目标：锁定（点击「锁定路径」）优先于 hover/聚焦；锁定后即使祖先移出视口，路径仍由面包屑兜底。
+  const highlightTargetId = pinnedGameId || activeGameId;
+  const highlighted = useMemo(
+    () =>
+      highlightTargetId
+        ? // 子树高亮**恒定开启**（2026-10-06 口径：原来那个「高亮整棵子树」复选框没有意义，
+          // 已删除，也不再保留一个恒为 true 的开关状态到处传）。
+          collectLineageHighlight(layout.nodes, highlightTargetId)
+        : null,
+    [highlightTargetId, layout.nodes],
+  );
+  const pathIds = useMemo(
+    () =>
+      highlightTargetId
+        ? collectLineageHighlight(layout.nodes, highlightTargetId, {
+            includeSubtree: false,
+          })
+        : null,
+    [highlightTargetId, layout.nodes],
+  );
+  /** 锁定路径的面包屑：从母版到锁定节点，按代际升序。 */
+  const pinnedChain = useMemo(() => {
+    if (!pinnedGameId || !pathIds) return [];
+    return layout.nodes
+      .filter((item) => pathIds.has(item.gameId))
+      .sort((left, right) => left.generation - right.generation)
+      .map((item) => ({
+        gameId: item.gameId,
+        label: item.isStub ? '原作品已不可用' : (item.title ?? '未命名作品'),
+        generation: item.generation,
+      }));
+  }, [layout.nodes, pathIds, pinnedGameId]);
+  const effectiveViewMode =
+    viewMode ?? (isMobileViewport ? 'outline' : 'canvas');
+  const trunkGameIds = useMemo(
+    () =>
+      new Set(
+        layout.nodes.filter((item) => item.isTrunk).map((item) => item.gameId),
+      ),
+    [layout.nodes],
+  );
+  const derivedCount = nodes.filter((node) => node.generation > 0).length;
+  const nodeCountLabel =
+    layout.nodes.length > 0
+      ? `${layout.nodes.length} 个节点${lineage?.truncated ? '（已截断）' : ''}`
+      : '';
+
+  /** 总览：宽高**两个维度同时**满足（取更小的那个比例），并居中。 */
+  const fitToView = useCallback(
+    (forceFullView = false) => {
+      const viewportElement = viewportRef.current;
+      if (!viewportElement || layout.nodes.length === 0) return;
+      const availableWidth = Math.max(
+        1,
+        viewportElement.clientWidth - FIT_PADDING * 2,
+      );
+      const availableHeight = Math.max(
+        1,
+        viewportElement.clientHeight - FIT_PADDING * 2,
+      );
+      const fullFit = Math.min(
+        availableWidth / Math.max(layout.width, 1),
+        availableHeight / Math.max(layout.height, 1),
+      );
+      // 全览会缩到低于可读下限时（初次进入），改用可读缩放：信息先看得清，全览交给按钮。
+      const floored = !forceFullView && fullFit < READABLE_MIN_SCALE;
+      const scale = Math.min(
+        MAX_SCALE,
+        Math.max(MIN_SCALE, floored ? READABLE_MIN_SCALE : fullFit),
+      );
+      setFitHint(
+        floored
+          ? '树较大，已按可读缩放显示：拖拽平移查看，或点「总览」看全树。'
+          : '',
+      );
+      setViewport({
+        scale,
+        // 水平居中：内容宽度已含左侧代际轴，避免右侧留一大片空白。
+        offsetX: Math.max(
+          FIT_PADDING,
+          (viewportElement.clientWidth - layout.width * scale) / 2,
+        ),
+        offsetY: FIT_PADDING,
+      });
+    },
+    [layout.height, layout.nodes.length, layout.width],
+  );
+
+  /**
+   * 初次进入的定位：`mode='both'`（桌面：宽高同时满足并居中）/ `mode='width'`（窄屏图谱视图：
+   * 整棵树横向看完）。两者都会把**当前作品**用最小位移拉进视口——详情页内嵌的整宽血缘区块
+   * 与独立族谱页都用它，进入时就能看到「我这一支」，不必自己找。
+   *
+   * 为什么按形态分开：窄屏默认是大纲形态，画布**根本没挂载**（`viewportRef.current` 为 null），
+   * 桌面那条自动适配其实什么都没做；用户切到图谱视图时画布是新挂载的，会停在
+   * `scale 1 / offset 0`——实测一个节点都看不到。所以窄屏在「进入图谱视图」时再定位一次。
+   */
+  const fitToInitialView = useCallback(
+    (mode: 'both' | 'width') => {
+      const viewportElement = viewportRef.current;
+      if (!viewportElement || layout.nodes.length === 0) return;
+      const width = viewportElement.clientWidth;
+      const height = viewportElement.clientHeight;
+      const availableWidth = Math.max(1, width - FIT_PADDING * 2);
+      const availableHeight = Math.max(1, height - FIT_PADDING * 2);
+      const fitWidth = availableWidth / Math.max(layout.width, 1);
+      const fitBoth = Math.min(
+        fitWidth,
+        availableHeight / Math.max(layout.height, 1),
+      );
+      const fitTarget = mode === 'width' ? fitWidth : fitBoth;
+      // 低于可读下限时不强行全览：改用可读缩放 + 平移，并把「还有代际在视口外」写进提示
+      //（不静默把最深的代际丢在视口外）。
+      const floored = mode === 'both' && fitTarget < READABLE_MIN_SCALE;
+      /*
+       * 可读缩放下**横向铺满**：宽度适配比下限更大时就用宽度适配，左右不留大片空白
+       *（截图反馈「留白过多」）；树比视口还宽时退回下限，多出来的横向由拖拽承担。
+       * 纵向不铺满：树比视口高就上下平移，这是「可读优先、全览交给按钮」的既定口径。
+       */
+      const target = floored
+        ? Math.max(READABLE_MIN_SCALE, Math.min(fitWidth, MAX_SCALE))
+        : fitTarget;
+      const scale = Math.min(MAX_SCALE, Math.max(MIN_SCALE, target));
+      setFitHint(
+        floored
+          ? '树较大：已按可读缩放显示（其余代际在视口外），拖拽平移查看，或点「总览」看全树。'
+          : scale > target + 0.001
+            ? '树较宽，已按最小缩放显示：拖拽平移查看。'
+            : '',
+      );
+      // 水平与垂直都按内容居中（内容比视口小时不会把空白全堆在下边/右边）。
+      let offsetX = Math.max(FIT_PADDING, (width - layout.width * scale) / 2);
+      let offsetY = Math.max(FIT_PADDING, (height - layout.height * scale) / 2);
+      const anchorNode = layout.nodes.find((item) => item.gameId === anchorId);
+      if (anchorNode && width > 0 && height > 0) {
+        const left = offsetX + anchorNode.x * scale;
+        const right = left + anchorNode.width * scale;
+        const top = offsetY + anchorNode.y * scale;
+        const bottom = top + anchorNode.height * scale;
+        // 只做**最小位移**把当前作品拉进视口（贴到最近的边），不做粗暴对中——
+        // 这样父代 / 子代 / 兄弟仍在视口里，用户一眼能看到上下文。
+        if (left < FIT_PADDING) offsetX += FIT_PADDING - left;
+        else if (right > width - FIT_PADDING) {
+          offsetX -= right - (width - FIT_PADDING);
+        }
+        if (top < FIT_PADDING) offsetY += FIT_PADDING - top;
+        else if (bottom > height - FIT_PADDING) {
+          offsetY -= bottom - (height - FIT_PADDING);
+        }
+      }
+      setViewport({ scale, offsetX, offsetY });
+    },
+    [anchorId, layout.height, layout.nodes, layout.width],
+  );
+
+  // 初次进入（或换了根作品 / 锚点 / 可见节点）自动适配一次；之后交给用户自己缩放/平移，不抢视野。
+  const fittedForRef = useRef('');
+  useEffect(() => {
+    if (layout.nodes.length === 0) return;
+    const key = `${normalizedRootId}:${layout.nodes.length}:${layout.width}:${anchorId}`;
+    if (fittedForRef.current === key) return;
+    fittedForRef.current = key;
+    fitToInitialView('both');
+  }, [
+    anchorId,
+    fitToInitialView,
+    layout.nodes.length,
+    layout.width,
+    normalizedRootId,
+  ]);
+
+  // 窄屏「进入图谱视图」时按宽度适配并定位一次；筛选、缩放、平移不抢视野。
+  const mobileFocusedForRef = useRef('');
+  useEffect(() => {
+    if (effectiveViewMode !== 'canvas' || !isMobileViewport) return;
+    if (layout.nodes.length === 0) return;
+    const key = `${normalizedRootId}:${layout.nodes.length}:${layout.width}:${anchorId}`;
+    if (mobileFocusedForRef.current === key) return;
+    mobileFocusedForRef.current = key;
+    fitToInitialView('width');
+  }, [
+    anchorId,
+    effectiveViewMode,
+    fitToInitialView,
+    isMobileViewport,
+    layout.nodes.length,
+    layout.width,
+    normalizedRootId,
+  ]);
+
+  useEffect(
+    () => () => {
+      if (forkTimerRef.current !== null) {
+        window.clearTimeout(forkTimerRef.current);
+      }
+      const handOff = forkHandlersRef.current;
+      if (handOff) {
+        window.removeEventListener('blur', handOff);
+        document.removeEventListener('visibilitychange', handOff);
+      }
+    },
+    [],
+  );
+
+  /**
+   * 右侧信息面板的数据：只为**选中的那一个节点**请求一次公开详情（简介 / 授权类型）。
+   * 「核心改动说明」等后端字段，缺失就不渲染这一行。
+   */
+  useEffect(() => {
+    if (!pinnedGameId) {
+      setSelectedGame(null);
+      return;
+    }
+    let alive = true;
+    void (async () => {
+      try {
+        const detail = await getGame(pinnedGameId);
+        if (alive) setSelectedGame(detail ?? null);
+      } catch {
+        if (alive) setSelectedGame(null);
+      }
+    })();
+    return () => {
+      alive = false;
+    };
+  }, [pinnedGameId]);
+  const selectedLayoutNode = pinnedGameId
+    ? (layout.nodes.find((item) => item.gameId === pinnedGameId) ?? null)
+    : null;
+  // 面包屑在移动端横向滚动：当前项常驻可见（jsdom 里 scrollIntoView 可能不存在，故用可选调用）。
+  useEffect(() => {
+    currentCrumbRef.current?.scrollIntoView?.({
+      inline: 'nearest',
+      block: 'nearest',
+    });
+  }, [pinnedGameId]);
+
+  const zoomBy = useCallback((factor: number) => {
+    setViewport((current) => {
+      const scale = Math.min(
+        MAX_SCALE,
+        Math.max(MIN_SCALE, current.scale * factor),
+      );
+      const viewportElement = viewportRef.current;
+      const centerX = (viewportElement?.clientWidth ?? 0) / 2;
+      const centerY = (viewportElement?.clientHeight ?? 0) / 2;
+      // 以画布中心为锚点缩放，避免「越缩越偏」。
+      const ratio = scale / current.scale;
+      return {
+        scale,
+        offsetX: centerX - (centerX - current.offsetX) * ratio,
+        offsetY: centerY - (centerY - current.offsetY) * ratio,
+      };
+    });
+  }, []);
+
+  /**
+   * 画布是否真的挂载了内容：树是**异步加载**的，首帧 `viewportRef.current` 还是 null，
+   * 所以原生监听必须依赖「画布有内容」这个信号重新绑定，否则会一次都没挂上。
+   */
+  const canvasHasContent =
+    effectiveViewMode === 'canvas' && layout.nodes.length > 0;
+  /**
+   * 滚轮：**只缩放画布，不滚动外部页面**。
+   *
+   * 为什么用原生监听而不是 React 的 `onWheel`：React 17+ 把 `wheel` 挂在根容器上且**是 passive 的**
+   * （`preventDefault` 会被忽略，页面照样滚）——这正是「滚轮同时缩放 + 滚页面」的根因。
+   * 这里绑在**画布元素本身**（不是 `window`），显式 `{ passive: false }`，滚轮就不会外溢。
+   */
+  useEffect(() => {
+    const element = viewportRef.current;
+    if (!element) return;
+    const onWheel = (event: WheelEvent) => {
+      // 无论做什么，先阻止页面滚动（含浏览器「捏合缩放整页」）——这是上一轮修好的口径，不许退回去。
+      event.preventDefault();
+      // deltaMode=1 是「按行」滚动（部分浏览器/鼠标驱动），折算成像素量级，避免一格跳很远。
+      const delta = event.deltaMode === 1 ? event.deltaY * 16 : event.deltaY;
+      if (delta === 0) return;
+      // **Ctrl / ⌘ + 滚轮 = 缩放**（画布类应用的通用手势，也保住「键盘/触控板也能放大」的能力）；
+      // 裸滚轮 = **竖向平移**（2026-10-07 用户口径：「滚动滚轮改成上下滚动吧，而不是现在的缩放」）。
+      if (event.ctrlKey || event.metaKey) {
+        zoomBy(delta < 0 ? 1.08 : 1 / 1.08);
+        return;
+      }
+      const viewportElement = viewportRef.current;
+      // **Shift + 滚轮 = 横向平移**（内容超宽时用得上；纵向仍是默认）。
+      const horizontal = event.shiftKey;
+      setViewport((current) => {
+        const width = viewportElement?.clientWidth ?? 0;
+        const height = viewportElement?.clientHeight ?? 0;
+        const contentWidth = layout.width * current.scale;
+        const contentHeight = layout.height * current.scale;
+        if (horizontal) {
+          return {
+            ...current,
+            offsetX: clampLineagePan(
+              current.offsetX - delta,
+              width,
+              contentWidth,
+            ),
+          };
+        }
+        return {
+          ...current,
+          offsetY: clampLineagePan(
+            current.offsetY - delta,
+            height,
+            contentHeight,
+          ),
+        };
+      });
+    };
+    element.addEventListener('wheel', onWheel, { passive: false });
+    return () => element.removeEventListener('wheel', onWheel);
+  }, [canvasHasContent, layout.height, layout.width, zoomBy]);
+
+  /**
+   * 拖动平移期间禁止文本选择 / 原生拖拽（否则按住划一下就把文字选走、再拖变成拖文本）。
+   * `selectstart` / `dragstart` 不是 React 合成事件，所以在画布上挂原生监听一次。
+   */
+  useEffect(() => {
+    const element = viewportRef.current;
+    if (!element) return;
+    const block = (event: Event) => {
+      if (!dragRef.current?.started) return;
+      event.preventDefault();
+    };
+    const blockDragStart = (event: Event) => event.preventDefault();
+    element.addEventListener('selectstart', block);
+    element.addEventListener('dragstart', blockDragStart);
+    return () => {
+      element.removeEventListener('selectstart', block);
+      element.removeEventListener('dragstart', blockDragStart);
+    };
+  }, [canvasHasContent]);
+
+  /**
+   * 拖动期间把 `user-select` 压到 body 上。
+   *
+   * 为什么不止靠画布容器的 CSS：指针可能划到画布外（尤其配合 pointer capture），
+   * 而选择行为发生在 document 级别；拖动期间全局禁选最稳，松手即恢复。
+   */
+  useEffect(() => {
+    if (!isPanning) return;
+    const previous = document.body.style.userSelect;
+    document.body.style.userSelect = 'none';
+    return () => {
+      document.body.style.userSelect = previous;
+    };
+  }, [isPanning]);
+
+  /**
+   * 按下：只记起点，**不**捕获指针、**不** preventDefault。
+   *
+   * 为什么不在按下时就 `setPointerCapture`：一旦在**容器**上捕获，后续 `pointerup` 会被重定向到容器，
+   * 于是 `click` 的 target 变成画布而**不是节点卡片里的按钮** ⇒ 「图谱里的东西点不动」
+   * （Chromium 的经典坑）。这里改成「移动超过阈值才算拖动」，纯点击完全走浏览器原生 click。
+   */
+  const handlePointerDown = (event: ReactPointerEvent<HTMLDivElement>) => {
+    // 只响应主键 / 触摸 / 笔；中键与右键留给浏览器（新标签页打开、右键菜单）。
+    if (event.pointerType === 'mouse' && event.button !== 0) return;
+    dragRef.current = {
+      x: event.clientX,
+      y: event.clientY,
+      offsetX: viewport.offsetX,
+      offsetY: viewport.offsetY,
+      pointerId: event.pointerId,
+      started: false,
+    };
+  };
+
+  const handlePointerMove = (event: ReactPointerEvent<HTMLDivElement>) => {
+    const drag = dragRef.current;
+    if (!drag) return;
+    if (!drag.started) {
+      const moved = Math.hypot(event.clientX - drag.x, event.clientY - drag.y);
+      // 还没超过阈值：不当作拖动 —— 不动画布、不拦事件，让 click / 文本选择走原生路径。
+      if (moved < DRAG_START_THRESHOLD_PX) return;
+      drag.started = true;
+      setIsPanning(true);
+      // 真正开始拖动才捕获指针：移出画布/越界后仍然跟手。
+      event.currentTarget.setPointerCapture?.(drag.pointerId);
+    }
+    event.preventDefault();
+    const viewportElement = viewportRef.current;
+    setViewport((current) => {
+      const width = viewportElement?.clientWidth ?? 0;
+      const height = viewportElement?.clientHeight ?? 0;
+      const contentWidth = layout.width * current.scale;
+      const contentHeight = layout.height * current.scale;
+      return {
+        ...current,
+        offsetX: clampLineagePan(
+          drag.offsetX + (event.clientX - drag.x),
+          width,
+          contentWidth,
+        ),
+        offsetY: clampLineagePan(
+          drag.offsetY + (event.clientY - drag.y),
+          height,
+          contentHeight,
+        ),
+      };
+    });
+  };
+
+  const endDrag = (event?: ReactPointerEvent<HTMLDivElement>) => {
+    const drag = dragRef.current;
+    dragRef.current = null;
+    setIsPanning(false);
+    // 只有真的捕获过才释放（没拖动过就完全没碰过指针）。
+    if (
+      drag?.started &&
+      event?.currentTarget?.hasPointerCapture?.(event.pointerId)
+    ) {
+      event.currentTarget.releasePointerCapture(event.pointerId);
+    }
+  };
+
+  /** 节点上的「开始共创」次要动作：复用详情页同一条唤起 + 降级链路（协议模块 + 复制回退）。 */
+  const launchForkFromNode = useCallback((gameId: string) => {
+    if (forkTimerRef.current !== null) {
+      window.clearTimeout(forkTimerRef.current);
+      forkTimerRef.current = null;
+    }
+    const previousHandOff = forkHandlersRef.current;
+    if (previousHandOff) {
+      window.removeEventListener('blur', previousHandOff);
+      document.removeEventListener('visibilitychange', previousHandOff);
+      forkHandlersRef.current = null;
+    }
+    setForkFallbackGameId('');
+    setForkNotice('正在唤起陶泥儿客户端…');
+    const handOffToClient = () => {
+      if (forkTimerRef.current !== null) {
+        window.clearTimeout(forkTimerRef.current);
+        forkTimerRef.current = null;
+      }
+      window.removeEventListener('blur', handOffToClient);
+      document.removeEventListener('visibilitychange', handOffToClient);
+      forkHandlersRef.current = null;
+      setForkNotice(
+        '已唤起陶泥儿客户端。若没有自动打开，请用作品 ID 手动开始共创。',
+      );
+      setForkFallbackGameId(gameId);
+    };
+    forkHandlersRef.current = handOffToClient;
+    window.addEventListener('blur', handOffToClient, { once: true });
+    document.addEventListener('visibilitychange', handOffToClient, {
+      once: true,
+    });
+    openForkProtocol(gameId);
+    forkTimerRef.current = window.setTimeout(() => {
+      forkTimerRef.current = null;
+      window.removeEventListener('blur', handOffToClient);
+      document.removeEventListener('visibilitychange', handOffToClient);
+      forkHandlersRef.current = null;
+      setForkNotice(
+        '没有检测到陶泥儿客户端，已切换为手动方式：复制作品 ID 到客户端开始共创。',
+      );
+      setForkFallbackGameId(gameId);
+    }, FORK_LAUNCH_FALLBACK_DELAY_MS);
+  }, []);
+
+  return (
+    <div
+      className={`game-page game-lineage-page${embedded ? ' game-lineage-page--embedded' : ''}`}
+      /*
+        卡宽与节点内边距的**唯一来源**是布局常量（`lineageTreeLayout.ts`）：这里把它们下发给 CSS，
+        `.game-lineage-node`（宽由布局的行内 style 给）与 `.lineage-relation__grid`（轨道 = 卡宽）
+        都只读这几个变量，因此「画布节点卡」与「父代/子代清单卡」永远同宽、也不会各自写死一套数。
+      */
+      style={
+        {
+          '--lineage-card-width': `${LINEAGE_CARD_WIDTH}px`,
+          '--lineage-node-pad-y': `${LINEAGE_NODE_PADDING_Y}px`,
+          '--lineage-node-pad-x': `${LINEAGE_NODE_PADDING_X}px`,
+        } as CSSProperties
+      }
+    >
+      {embedded ? null : (
+        <button type="button" className="game-back-button" onClick={onBack}>
+          <ArrowLeft /> 返回
+        </button>
+      )}
+      {embedded ? null : (
+        <div className="game-toolbar">
+          <div className="game-toolbar__title">
+            <span className="game-eyebrow">创作族谱</span>
+            <h2>{lineage?.root?.title?.trim() || '创作族谱'}</h2>
+          </div>
+          {nodeCountLabel ? (
+            <span className="game-lineage-summary" role="status">
+              {nodeCountLabel}
+            </span>
+          ) : null}
+        </div>
+      )}
+
+      {!normalizedRootId ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          游戏编号无效
+        </PlatformStatusMessage>
+      ) : null}
+      {isLoading ? (
+        <div className="game-loading-panel">正在加载创作族谱…</div>
+      ) : null}
+      {!isLoading && error ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          <span>{error}</span>
+          <button
+            type="button"
+            className="game-lineage-retry"
+            onClick={() => void loadLineage()}
+          >
+            重试
+          </button>
+        </PlatformStatusMessage>
+      ) : null}
+
+      {!isLoading && !error && lineage ? (
+        <>
+          {lineage.truncated ? (
+            <p className="game-lineage-notice" role="status">
+              这部作品衍生较多，这里只展示前 {nodes.length} 个节点。
+            </p>
+          ) : null}
+          {lineage.root ? null : (
+            <p
+              className="game-lineage-notice game-lineage-notice--muted"
+              role="status"
+            >
+              母版已不可用，下面按代际关系展示仍可阅读的衍生作品。
+            </p>
+          )}
+          {fitHint && !embedded ? (
+            <p className="game-lineage-notice" role="status">
+              {fitHint}
+            </p>
+          ) : null}
+          {nodes.length === 0 ? (
+            <PlatformEmptyState surface="subpanel" size="panel">
+              <span>这部作品还没有可展示的族谱节点。</span>
+            </PlatformEmptyState>
+          ) : (
+            <>
+              <div className="game-lineage-filters">
+                <label className="game-lineage-filter">
+                  <span>世代</span>
+                  <select
+                    aria-label="按世代筛选"
+                    value={
+                      generationFilter === null
+                        ? 'all'
+                        : String(generationFilter)
+                    }
+                    onChange={(event) => {
+                      const value = event.target.value;
+                      setGenerationFilter(
+                        value === 'all' ? null : Number(value),
+                      );
+                    }}
+                  >
+                    <option value="all">全部</option>
+                    {generationsPresent.map((generation) => (
+                      <option key={generation} value={generation}>
+                        {generationAxisLabel(generation)}
+                      </option>
+                    ))}
+                  </select>
+                </label>
+                <label className="game-lineage-filter game-lineage-toggle">
+                  <input
+                    type="checkbox"
+                    checked={sortByHeat}
+                    onChange={(event) => setSortByHeat(event.target.checked)}
+                  />
+                  按热度排序
+                </label>
+                {/*
+                  形态切换：移动端默认大纲、桌面默认图谱（画布）。
+                  用**两个按钮的分段控件**而不是一个来回翻转的开关：原来那个单按钮的文案是
+                  「目标形态」（图谱态显示「大纲视图」）而 `aria-pressed` 却指「当前是画布」，
+                  于是屏幕上明明画着画布、按钮却是「大纲视图 + 已按下」（截图反馈里的状态不一致）。
+                  现在两个选项常驻，`aria-pressed` 与文案一一对应，当前形态一眼可读。
+                */}
+                <span
+                  className="game-lineage-filter__group"
+                  role="group"
+                  aria-label="视图形态"
+                >
+                  <button
+                    type="button"
+                    className="game-lineage-filter__switch"
+                    aria-pressed={effectiveViewMode === 'canvas'}
+                    onClick={() => setViewMode('canvas')}
+                  >
+                    图谱视图
+                  </button>
+                  <button
+                    type="button"
+                    className="game-lineage-filter__switch"
+                    aria-pressed={effectiveViewMode === 'outline'}
+                    onClick={() => setViewMode('outline')}
+                  >
+                    大纲视图
+                  </button>
+                </span>
+                {/*
+                  「只看父代与子代」：默认关（整棵树）。打开后只留当前作品的祖先链（父代）
+                  与**直接**子代；再点一次取消。作用是「聚焦一支」——树大了以后不必在旁支里找。
+                */}
+                <button
+                  type="button"
+                  className="game-lineage-filter__switch game-lineage-filter__switch--relation"
+                  aria-pressed={onlyRelated}
+                  onClick={() => setOnlyRelated((current) => !current)}
+                >
+                  {onlyRelated ? '只看父代与子代（已开启）' : '只看父代与子代'}
+                </button>
+                {onlyRelated ? (
+                  <span className="game-lineage-filter__note" role="status">
+                    只显示当前作品的父代（祖先链）与直接子代，再点一次恢复整棵树
+                  </span>
+                ) : null}
+                {/*
+                  改动类型筛选：`changeSummary` 字段已上线，但它是**自由文本**（服务端没有分类枚举），
+                  因此仍然**禁用 + 说明**，不编造筛选值域；等后端给出可枚举的改动类型再接。
+                */}
+                <label className="game-lineage-filter game-lineage-filter--disabled">
+                  <span>改动类型</span>
+                  <select aria-label="按改动类型筛选" disabled>
+                    <option>暂不可用</option>
+                  </select>
+                  <span className="game-lineage-filter__note">
+                    改动说明是自由文本，暂无可筛选分类
+                  </span>
+                </label>
+              </div>
+              <div className="game-lineage-viewport-controls">
+                {/*
+                  这里原来有个「高亮整棵子树」复选框：它恒为真、没有任何用户可见意义（2026-10-06
+                  口径——删除并**默认开启**）。子树高亮现在是唯一行为，不再有开关状态。
+                */}
+                {fitHint && embedded ? (
+                  <span className="game-lineage-fork-notice" role="status">
+                    {fitHint}
+                  </span>
+                ) : null}
+                {forkNotice ? (
+                  <span className="game-lineage-fork-notice" role="status">
+                    {forkNotice}
+                  </span>
+                ) : null}
+                {forkCopyState === 'copied' ? (
+                  <span className="game-lineage-fork-notice" role="status">
+                    作品 ID 已复制，可在客户端「从平台作品开始创作」里粘贴。
+                  </span>
+                ) : null}
+                {forkCopyState === 'failed' ? (
+                  <span className="game-lineage-fork-notice" role="status">
+                    复制失败：请手动选中作品 ID 文本。
+                  </span>
+                ) : null}
+                {forkFallbackGameId ? (
+                  <CopyFeedbackButton
+                    state={forkCopyState}
+                    idleLabel={`复制 ${forkFallbackGameId} 去开始共创`}
+                    copiedLabel="作品 ID 已复制"
+                    failedLabel="复制失败"
+                    className="game-lineage-fork-copy"
+                    onClick={() => void copyForkId(forkFallbackGameId)}
+                  />
+                ) : null}
+              </div>
+              {pinnedChain.length > 0 ? (
+                <div
+                  className="game-lineage-breadcrumb"
+                  aria-label="已选中的路径"
+                >
+                  {pinnedChain.map((crumb, index) => (
+                    <span
+                      key={crumb.gameId}
+                      className="game-lineage-breadcrumb__item"
+                    >
+                      {index > 0 ? <span aria-hidden="true">→</span> : null}
+                      <button
+                        type="button"
+                        className="game-lineage-breadcrumb__crumb"
+                        ref={
+                          crumb.gameId === pinnedGameId
+                            ? currentCrumbRef
+                            : undefined
+                        }
+                        onClick={() => setPinnedGameId(crumb.gameId)}
+                      >
+                        {`${generationAxisLabel(crumb.generation)}《${crumb.label}》`}
+                      </button>
+                    </span>
+                  ))}
+                  <button
+                    type="button"
+                    className="game-lineage-breadcrumb__clear"
+                    onClick={() => setPinnedGameId('')}
+                  >
+                    取消锁定
+                  </button>
+                </div>
+              ) : null}
+              {effectiveViewMode === 'outline' ? (
+                <LineageOutlineList
+                  nodes={layout.nodes}
+                  currentGameId={anchorId}
+                  trunkGameIds={trunkGameIds}
+                  selectedGameId={pinnedGameId}
+                  relationByGameId={relationRoles}
+                  playCountByGameId={playCountTotals}
+                  onSelect={(gameId) =>
+                    setPinnedGameId((current) =>
+                      current === gameId ? '' : gameId,
+                    )
+                  }
+                  onOpenDetail={onOpenDetail}
+                  onOpenFork={launchForkFromNode}
+                />
+              ) : (
+                <div
+                  className={`game-lineage-canvas${isPanning ? ' game-lineage-canvas--panning' : ''}`}
+                  ref={viewportRef}
+                  onPointerDown={handlePointerDown}
+                  onPointerMove={handlePointerMove}
+                  onPointerUp={endDrag}
+                  onPointerCancel={endDrag}
+                  onLostPointerCapture={endDrag}
+                  aria-label="创作族谱树"
+                >
+                  <div
+                    className="game-lineage-canvas__content"
+                    style={{
+                      width: layout.width,
+                      height: layout.height,
+                      transform: `translate(${viewport.offsetX}px, ${viewport.offsetY}px) scale(${viewport.scale})`,
+                    }}
+                  >
+                    <svg
+                      className="game-lineage-canvas__edges"
+                      width={layout.width}
+                      height={layout.height}
+                      aria-hidden="true"
+                    >
+                      {layout.edges.map((edge) => (
+                        <path
+                          key={edge.id}
+                          d={edge.path}
+                          // 默认态按顶级分支着色；高亮态由 class 覆盖成强调色。
+                          style={{
+                            ['--lineage-branch' as string]: `var(--lineage-branch-${edge.branchIndex % 6})`,
+                          }}
+                          className={
+                            (edge.isTrunk ? 'game-lineage-edge--trunk ' : '') +
+                            (highlighted &&
+                            highlighted.has(edge.parentGameId) &&
+                            highlighted.has(edge.childGameId)
+                              ? 'game-lineage-edge game-lineage-edge--active'
+                              : highlighted
+                                ? 'game-lineage-edge game-lineage-edge--dimmed'
+                                : 'game-lineage-edge')
+                          }
+                        />
+                      ))}
+                    </svg>
+                    {layout.nodes.map((layoutNode) => (
+                      <LineageTreeNodeCard
+                        key={layoutNode.gameId}
+                        layoutNode={layoutNode}
+                        isAnchor={layoutNode.gameId === anchorId}
+                        isDimmed={Boolean(
+                          highlighted && !highlighted.has(layoutNode.gameId),
+                        )}
+                        isOnPath={Boolean(pathIds?.has(layoutNode.gameId))}
+                        isPinned={pinnedGameId === layoutNode.gameId}
+                        compact={compactTree}
+                        // 竖版画布有左侧代际轴，卡上不再重复「第 N 代」；横版（窄屏图谱）没有轴，保留。
+                        showGenerationBadge={horizontalCanvas}
+                        relation={
+                          relationRoles.get(layoutNode.gameId) ?? 'side'
+                        }
+                        playCount={
+                          playCountTotals.get(layoutNode.gameId) ?? null
+                        }
+                        onOpenDetail={onOpenDetail}
+                        onActivate={(gameId: string) => {
+                          setActiveGameId(gameId);
+                          setPinnedGameId(gameId);
+                        }}
+                        onDeactivate={() => {
+                          setActiveGameId('');
+                          setPinnedGameId('');
+                        }}
+                      />
+                    ))}
+                  </div>
+                  {/*
+                  代际轴是**固定层**：在 transform 之外，位置按视口换算，字号不随缩放变小，
+                  因此放大或平移后轴标签始终在画布左侧可读，而不会被内容层带出去裁掉。
+                  横版（窄屏图谱视图）不渲染它：代际沿横向推进，节点自带的角标已承担代际信息。
+                */}
+                  {horizontalCanvas ? null : (
+                    <div
+                      className="game-lineage-canvas__axis"
+                      aria-hidden="true"
+                    >
+                      {layout.axis.map((entry, index) => (
+                        <span
+                          key={entry.generation}
+                          className="game-lineage-axis"
+                          style={{
+                            top: viewport.offsetY + entry.y * viewport.scale,
+                            // 行高跟着缩放走，且取**该层层高**（层高按最高卡算）：
+                            // 轴上的行与画布里的行始终对齐。
+                            height: entry.height * viewport.scale,
+                            borderTopWidth: index === 0 ? 0 : 1,
+                          }}
+                        >
+                          <span className="game-lineage-axis__label">
+                            {entry.label}
+                          </span>
+                          <span className="game-lineage-axis__count">
+                            {entry.count}
+                          </span>
+                        </span>
+                      ))}
+                    </div>
+                  )}
+                  {/*
+                  画布内悬浮控件：放在**右下角**——左侧是代际轴、顶部是路径面包屑，
+                  右下角是地图/画布类应用的习惯位置，也最不容易遮住根节点与主干。
+                */}
+                  <div
+                    className="game-lineage-controls"
+                    role="group"
+                    aria-label="画布控件"
+                    // 悬浮控件不是画布内容：按下时不要触发画布平移。
+                    onPointerDown={(event) => event.stopPropagation()}
+                  >
+                    <button
+                      type="button"
+                      className="game-lineage-controls__button"
+                      aria-label="缩小"
+                      title="缩小"
+                      disabled={viewport.scale <= MIN_SCALE + 0.001}
+                      onClick={() => zoomBy(1 / 1.2)}
+                    >
+                      {/*
+                        用「−/+」而不是放大镜图标：放大镜在控件栏里会被读成「搜索」
+                        （截图反馈里就有人问「搜索为什么放在图谱控件栏」），
+                        而这里其实**没有**搜索按钮 —— 读数和 ± 才是地图/画布控件的通用语。
+                      */}
+                      <Minus aria-hidden="true" />
+                    </button>
+                    <span className="game-lineage-zoom" role="status">
+                      {Math.round(viewport.scale * 100)}%
+                    </span>
+                    <button
+                      type="button"
+                      className="game-lineage-controls__button"
+                      aria-label="放大"
+                      title="放大"
+                      disabled={viewport.scale >= MAX_SCALE - 0.001}
+                      onClick={() => zoomBy(1.2)}
+                    >
+                      <Plus aria-hidden="true" />
+                    </button>
+                    <span
+                      className="game-lineage-controls__divider"
+                      aria-hidden="true"
+                    />
+                    <button
+                      type="button"
+                      className="game-lineage-controls__button game-lineage-controls__button--wide"
+                      aria-label="总览"
+                      title="总览"
+                      onClick={() => fitToView(true)}
+                    >
+                      {/*
+                        「总览」的动作是**把视图收拢回全览**（缩放到装得下整棵树），
+                        所以图标用 `Minimize`（箭头指向中间）——它与 `Expand` 是 lucide 里
+                        同一对反向图标，语义正好对上「收拢/适配」；原先用 `Expand`（四角向外）
+                        与行为相反（用户截图口径：「改成向中间的箭头，因为现在这个就是起到这个作用的」）。
+                      */}
+                      <Minimize aria-hidden="true" />
+                      <span className="game-lineage-controls__label">总览</span>
+                    </button>
+                    <button
+                      type="button"
+                      className="game-lineage-controls__button game-lineage-controls__button--wide"
+                      aria-label="刷新"
+                      title="刷新"
+                      disabled={isLoading}
+                      onClick={() => void loadLineage()}
+                    >
+                      <RefreshCcw aria-hidden="true" />
+                      <span className="game-lineage-controls__label">刷新</span>
+                    </button>
+                  </div>
+                  {/*
+                  右侧信息面板：只在**选中节点**时出现，浮动叠加（不推挤画布）。
+                  简介 / 授权类型只为选中的这一个节点请求一次公开详情；
+                  「核心改动说明」是后端待补字段，缺失时整行不渲染。
+                */}
+                  {selectedLayoutNode ? (
+                    <LineageInfoPanel
+                      node={selectedLayoutNode}
+                      game={selectedGame}
+                      isSheet={false}
+                      onClose={() => setPinnedGameId('')}
+                      onOpenDetail={onOpenDetail}
+                      onOpenFork={launchForkFromNode}
+                    />
+                  ) : null}
+                </div>
+              )}
+              {/* 大纲模式下的 bottom sheet（桌面形态的面板在画布内，见上一分支）。 */}
+              {effectiveViewMode === 'outline' && selectedLayoutNode ? (
+                <LineageInfoPanel
+                  node={selectedLayoutNode}
+                  game={selectedGame}
+                  isSheet={isMobileViewport}
+                  onClose={() => setPinnedGameId('')}
+                  onOpenDetail={onOpenDetail}
+                  onOpenFork={launchForkFromNode}
+                />
+              ) : null}
+              {derivedCount === 0 ? (
+                <PlatformEmptyState surface="subpanel" size="panel">
+                  <span>这部作品还没有衍生作品，欢迎从它开始共创。</span>
+                </PlatformEmptyState>
+              ) : null}
+              {/*
+                图**下方**的「父代 / 子代」两块清单（2026-10-07 用户口径）：
+                详情页共创卡不再堆派生作品卡，改为在图谱里一次看清「从哪来、下一步是谁」。
+                数据全部来自**同一次** `/lineage`（零额外请求）：
+                - 父代 = 祖先链（根 → 直接父），顺序与面包屑同一份；
+                - 子代 = **直接子代**，按**热度（自身 playCount）降序**、同热度按服务端顺序稳定兜底。
+                  选「直接子代」的理由：① 与平台既有 `forkCount`/「被改编 N」同口径，块里的卡片数
+                  与数字对得上；② 与画布上「只看父代与子代」开关同义；③ 再往下的层级由上面的树
+                  表达，这里只做「一步关系」的快速跳转。
+              */}
+              <LineageRelationLists
+                ancestors={ancestorChain}
+                children={directChildren}
+                playCountTotals={playCountTotals}
+                onOpenDetail={onOpenDetail}
+              />
+            </>
+          )}
+        </>
+      ) : null}
+
+      {embedded ? null : (
+        <p className="game-detail-footnote">
+          拖拽平移、滚轮或按钮缩放；悬停或键盘聚焦一个节点会高亮它的祖先路径。已删除或未公开的
+          来源作品只显示「原作品已不可用」。
+        </p>
+      )}
+    </div>
+  );
+}
+
+export default GameLineagePage;
diff --git a/src/components/game-distribution/GamePlayFrame.tsx b/src/components/game-distribution/GamePlayFrame.tsx
new file mode 100644
index 000000000..ddd71c4ed
--- /dev/null
+++ b/src/components/game-distribution/GamePlayFrame.tsx
@@ -0,0 +1,38 @@
+import type { Ref } from 'react';
+
+/**
+ * 平台游戏的同源 iframe 嵌入：游玩页与「原版与二创对比」页共用同一份构建方式。
+ *
+ * 抽出来是为了不出现第二套嵌入逻辑——`sandbox` / `allow` / `referrerPolicy` 三项一旦
+ * 在别处复刻就会漂移，而它们是这个嵌入的安全边界（只允许脚本、不给同源、不带 referrer）。
+ * 入口地址仍由调用方用 `normalizeGameEntryUrl` 归一：平台同源路径 `/games/<gameId>/`，
+ * 历史数据里的绝对地址也按同一口径收敛。
+ */
+export function GamePlayFrame({
+  entryUrl,
+  title,
+  ready,
+  frameRef,
+  onLoad,
+}: {
+  entryUrl: string;
+  /** 无障碍标题，形如「<作品名> 在线游玩」。 */
+  title: string;
+  /** 是否已加载完成：`.game-player-frame--ready` 控制就绪后的可见态。 */
+  ready: boolean;
+  frameRef?: Ref<HTMLIFrameElement>;
+  onLoad?: () => void;
+}) {
+  return (
+    <iframe
+      ref={frameRef}
+      title={title}
+      src={entryUrl}
+      className={`game-player-frame ${ready ? 'game-player-frame--ready' : ''}`}
+      sandbox="allow-scripts"
+      allow="fullscreen"
+      referrerPolicy="no-referrer"
+      onLoad={onLoad}
+    />
+  );
+}
diff --git a/src/components/game-distribution/GamePlayPage.tsx b/src/components/game-distribution/GamePlayPage.tsx
index 9fd013558..de24db013 100644
--- a/src/components/game-distribution/GamePlayPage.tsx
+++ b/src/components/game-distribution/GamePlayPage.tsx
@@ -29,6 +29,7 @@ import {
   useIsMobileViewport,
   useIsPortraitViewport,
 } from './gameDistributionGuards';
+import { GamePlayFrame } from './GamePlayFrame';
 
 type GamePlayPageProps = { gameId: string | null; onBack: () => void };
 
@@ -323,15 +324,12 @@ export function GamePlayPage({ gameId, onBack }: GamePlayPageProps) {
           </PlatformStatusMessage>
         ) : null}
         {hasStarted && playUrl ? (
-          <iframe
-            ref={frameRef}
+          <GamePlayFrame
+            frameRef={frameRef}
             key={`${game.currentVersion?.id ?? game.id}:${frameRunId}`}
             title={`${game.title} 在线游玩`}
-            src={playUrl}
-            className={`game-player-frame ${startupState === 'ready' ? 'game-player-frame--ready' : ''}`}
-            sandbox="allow-scripts"
-            allow="fullscreen"
-            referrerPolicy="no-referrer"
+            entryUrl={playUrl}
+            ready={startupState === 'ready'}
             onLoad={() => setStartupState('ready')}
           />
         ) : null}
diff --git a/src/components/game-distribution/GamePublishPage.test.tsx b/src/components/game-distribution/GamePublishPage.test.tsx
index e5ea9632f..22fe41ab9 100644
--- a/src/components/game-distribution/GamePublishPage.test.tsx
+++ b/src/components/game-distribution/GamePublishPage.test.tsx
@@ -357,9 +357,7 @@ test('买断制发布把价格随版本请求提交，免费模式提交 0', asy
 
   await waitFor(() => expect(submitGameVersion).toHaveBeenCalledTimes(1));
   const payload = vi.mocked(publishGameVersion).mock.calls[0]?.[0];
-  expect(payload).toEqual(
-    expect.objectContaining({ priceMudPoints: 120 }),
-  );
+  expect(payload).toEqual(expect.objectContaining({ priceMudPoints: 120 }));
   expect(payload).toEqual(
     expect.objectContaining({
       gameMetadata: expect.objectContaining({ title: '付费游戏' }),
@@ -802,9 +800,7 @@ test('线上封面没有冻结快照时沿用游戏行封面对象键', async ()
   });
   fireEvent.click(screen.getByRole('button', { name: '提交新版本审核' }));
 
-  await waitFor(() =>
-    expect(publishGameVersion).toHaveBeenCalledTimes(1),
-  );
+  await waitFor(() => expect(publishGameVersion).toHaveBeenCalledTimes(1));
   expect(vi.mocked(publishGameVersion).mock.calls[0]?.[0]).toEqual(
     expect.objectContaining({
       gameMetadata: expect.objectContaining({
@@ -814,6 +810,174 @@ test('线上封面没有冻结快照时沿用游戏行封面对象键', async ()
   );
 });
 
+test('衍生作品发布新版本必须填「本次核心改动说明」', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    {
+      id: 'game-1',
+      title: '星轨防线',
+      summary: '守住轨道城',
+      description: '旧版资料',
+      category: '动作',
+      tags: ['塔防'],
+      publicationRevision: 4,
+      // 有血缘 → 衍生作品：核心改动说明必填。
+      lineage: {
+        generation: 1,
+        rootGameId: 'game-root',
+        rootTitle: '根原创',
+        parentGameId: 'game-root',
+        parentTitle: '根原创',
+        parentAuthorName: '原作者',
+      },
+      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',
+      priceMudPoints: 0,
+      frozenMetadata: {
+        coverObjectKey: 'game-distribution/cover/old.png',
+        screenshots: ['game-distribution/screenshot/old.png'],
+      },
+    },
+  } as never);
+  mockPublishVersionResult({
+    versionId: 'gamever-3',
+    versionNumber: 3,
+    publicationRevision: 4,
+  });
+
+  renderPublishPage(createAuthValue(), 'game-1');
+  await screen.findByLabelText('游戏名称');
+
+  const field = await screen.findByLabelText('本次核心改动说明');
+  expect(field).toBeTruthy();
+
+  const file = await buildZipFile();
+  fireEvent.change(screen.getByLabelText(/发行包 ZIP/u), {
+    target: { files: [file] },
+  });
+  // 空着提交：前端同等校验拦截（服务端同样会以 FORK_CHANGE_SUMMARY_REQUIRED 失败关闭）。
+  fireEvent.click(screen.getByRole('button', { name: '提交新版本审核' }));
+  expect(
+    await screen.findByText(/衍生作品必须填写「本次核心改动说明」/u),
+  ).toBeTruthy();
+  expect(publishGameVersion).not.toHaveBeenCalled();
+
+  const summaryText =
+    '把跳台改成三段，并重画全部背景与音效，同时调整了整体节奏';
+  fireEvent.change(field, { target: { value: summaryText } });
+  fireEvent.click(screen.getByRole('button', { name: '提交新版本审核' }));
+
+  await waitFor(() => expect(publishGameVersion).toHaveBeenCalledTimes(1));
+  expect(vi.mocked(publishGameVersion).mock.calls[0]?.[0]).toEqual(
+    expect.objectContaining({ changeSummary: summaryText }),
+  );
+});
+
+test('母版发布新版本不渲染改动说明字段，请求体也不带它', 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',
+      priceMudPoints: 0,
+      frozenMetadata: {
+        coverObjectKey: 'game-distribution/cover/old.png',
+        screenshots: ['game-distribution/screenshot/old.png'],
+      },
+    },
+  } as never);
+  mockPublishVersionResult({
+    versionId: 'gamever-3',
+    versionNumber: 3,
+    publicationRevision: 4,
+  });
+  vi.mocked(uploadGamePackage).mockResolvedValue({
+    versionId: 'gamever-3',
+    status: 'uploaded',
+  });
+  vi.mocked(submitGameVersion).mockResolvedValue({
+    version: { status: 'pending_review' },
+  });
+
+  renderPublishPage(createAuthValue(), 'game-1');
+  await screen.findByLabelText('游戏名称');
+  expect(screen.queryByLabelText('本次核心改动说明')).toBeNull();
+
+  const file = await buildZipFile();
+  fireEvent.change(screen.getByLabelText(/发行包 ZIP/u), {
+    target: { files: [file] },
+  });
+  fireEvent.click(screen.getByRole('button', { name: '提交新版本审核' }));
+
+  await waitFor(() => expect(publishGameVersion).toHaveBeenCalledTimes(1));
+  expect(vi.mocked(publishGameVersion).mock.calls[0]?.[0]).not.toHaveProperty(
+    'changeSummary',
+  );
+});
+
 test('更新模式读不到归属游戏时失败关闭且不提交', async () => {
   vi.mocked(listMyGames).mockResolvedValue([]);
 
diff --git a/src/components/game-distribution/GamePublishPage.tsx b/src/components/game-distribution/GamePublishPage.tsx
index 4031c0824..91cfff2c9 100644
--- a/src/components/game-distribution/GamePublishPage.tsx
+++ b/src/components/game-distribution/GamePublishPage.tsx
@@ -3,11 +3,12 @@ import './gameDistribution.css';
 import { ArrowLeft, Upload } from 'lucide-react';
 import { useEffect, useRef, useState } from 'react';
 
-import type {
-  GameDistributionCategory,
-  GameDistributionDeviceSupport,
-  GameDistributionOrientation,
-  GameDistributionVersionDetail,
+import {
+  GAME_DISTRIBUTION_DEFAULT_FORK_AUTHORIZATION,
+  type GameDistributionCategory,
+  type GameDistributionDeviceSupport,
+  type GameDistributionOrientation,
+  type GameDistributionVersionDetail,
 } from '../../../packages/shared/src/contracts/gameDistribution';
 import { loadFrontendRuntimeConfig } from '../../services/frontendRuntimeConfigService';
 import {
@@ -66,6 +67,8 @@ type GameUpdateContext = {
   gameId: string;
   versionNumber: number;
   title: string;
+  /** 衍生作品（有父作品血缘）：发布新版本时必须填「本次核心改动说明」。 */
+  isDerivative: boolean;
 };
 
 /**
@@ -81,6 +84,28 @@ const submitGamePublish = createGamePublishSubmission({
   clearPublishDraft,
 });
 
+/**
+ * 「本次核心改动说明」的字数口径，与 Rust 侧
+ * `module-game-distribution/src/domain.rs` 的 `GAME_DISTRIBUTION_CHANGE_SUMMARY_MIN_CHARS = 20` /
+ * `GAME_DISTRIBUTION_CHANGE_SUMMARY_MAX_CHARS = 500` 一致（按字符计，CJK 友好）；服务端的失败码是
+ * `FORK_CHANGE_SUMMARY_REQUIRED` / `FORK_CHANGE_SUMMARY_INVALID`。
+ */
+const CHANGE_SUMMARY_MIN_CHARS = 20;
+const CHANGE_SUMMARY_MAX_CHARS = 500;
+
+let publishKeySeed = 0;
+// 保留 origin/master 的每会话幂等键生成器：统一发布链路已改用 versionId 派生键，
+// 这里暂不引用，待确认不再需要后由后续变更删除。
+// eslint-disable-next-line unused-imports/no-unused-vars -- origin/master 特性暂挂
+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,
@@ -93,6 +118,7 @@ export function GamePublishPage({
   const [description, setDescription] = useState('');
   const [category, setCategory] = useState<GameDistributionCategory>('休闲');
   const [tagsInput, setTagsInput] = useState('');
+  const [changeSummary, setChangeSummary] = useState('');
   const [deviceSupport, setDeviceSupport] =
     useState<GameDistributionDeviceSupport>({
       desktop: true,
@@ -202,6 +228,8 @@ export function GamePublishPage({
           gameId: game.id,
           versionNumber: detail.version.versionNumber,
           title: detail.game.title,
+          // 血缘行存在（generation > 0）就是衍生作品；母版没有父作品。
+          isDerivative: (game.lineage?.generation ?? 0) > 0,
         });
         void applyVersionMediaDefaults(detail, {
           getCover: () => coverImageRef.current,
@@ -342,6 +370,9 @@ export function GamePublishPage({
       deviceSupport,
       inputModes: resolveGameInputModes(deviceSupport),
       orientation,
+      // 网页发布面板只发布作者自己的作品（母版）：共创授权用最保守默认值。
+      // 衍生作品声明只来自 AGC 项目内的 `.agent/fork-source.json`，网页路径不提交。
+      forkAuthorization: GAME_DISTRIBUTION_DEFAULT_FORK_AUTHORIZATION,
     };
   }
 
@@ -416,6 +447,11 @@ export function GamePublishPage({
     target: GamePublishSubmissionTarget;
     versionNumber: number;
     priceMudPoints: number;
+    /**
+     * 衍生作品的「本次核心改动说明」；母版不传。服务端按衍生判定做必填与长度校验，
+     * 页面只负责采集与本地同口径提示。
+     */
+    changeSummary?: string;
   }): Promise<GamePublishSubmissionSuccess> {
     const prepared = await prepareGamePackage(packageFile as File);
     const submission = buildGamePublishMediaSubmission(
@@ -435,6 +471,7 @@ export function GamePublishPage({
       packageEntryPath: 'index.html',
       priceMudPoints: input.priceMudPoints,
       gameMetadata,
+      changeSummary: input.changeSummary,
       packageBody: new Blob([prepared.bytes as unknown as BlobPart], {
         type: 'application/zip',
       }),
@@ -468,6 +505,27 @@ export function GamePublishPage({
       setError(metadataError);
       return;
     }
+    // 衍生作品必须填「本次核心改动说明」：前端做同等校验并给可读提示（服务端同样失败关闭，
+    // 码为 FORK_CHANGE_SUMMARY_REQUIRED / FORK_CHANGE_SUMMARY_INVALID）。
+    const normalizedChangeSummary = changeSummary.trim();
+    if (updateContext.isDerivative) {
+      const charCount = [...normalizedChangeSummary].length;
+      if (charCount === 0) {
+        setError(
+          `衍生作品必须填写「本次核心改动说明」（不少于 ${CHANGE_SUMMARY_MIN_CHARS} 个字）。`,
+        );
+        return;
+      }
+      if (
+        charCount < CHANGE_SUMMARY_MIN_CHARS ||
+        charCount > CHANGE_SUMMARY_MAX_CHARS
+      ) {
+        setError(
+          `「本次核心改动说明」需要 ${CHANGE_SUMMARY_MIN_CHARS}~${CHANGE_SUMMARY_MAX_CHARS} 个字（当前 ${charCount} 个字）。`,
+        );
+        return;
+      }
+    }
     if (!packageFile) {
       setError('请选择发行包 ZIP');
       return;
@@ -482,12 +540,11 @@ export function GamePublishPage({
         target: { mode: 'update', gameId: updateContext.gameId },
         versionNumber: updateContext.versionNumber + 1,
         priceMudPoints: price.priceMudPoints,
+        changeSummary: normalizedChangeSummary,
       });
       setPublishedGameId(updateContext.gameId);
       setUpdateContext((current) =>
-        current
-          ? { ...current, versionNumber: result.versionNumber }
-          : current,
+        current ? { ...current, versionNumber: result.versionNumber } : current,
       );
     } catch (updateError: unknown) {
       setError(
@@ -787,6 +844,34 @@ export function GamePublishPage({
               onChange={(e) => setTagsInput(e.target.value)}
             />
           </label>
+          {/*
+            「本次核心改动说明」：**衍生作品必填**（服务端 `FORK_CHANGE_SUMMARY_REQUIRED`），
+            母版可空（服务端忽略）。校验口径与 Rust 侧
+            `module-game-distribution/src/domain.rs` 的 MIN/MAX 常量一致（按字符计，CJK 友好）。
+          */}
+          {updateContext?.isDerivative ? (
+            <label className="game-publish-field">
+              本次核心改动说明（必填）
+              <textarea
+                value={changeSummary}
+                placeholder={`说明这一版相对来源作品改了什么（${CHANGE_SUMMARY_MIN_CHARS}~${CHANGE_SUMMARY_MAX_CHARS} 个字）`}
+                disabled={isResumingDraft}
+                aria-label="本次核心改动说明"
+                onChange={(e) => setChangeSummary(e.target.value)}
+              />
+              <span
+                className="game-publish-field__hint"
+                role="status"
+                aria-live="polite"
+              >
+                {[...changeSummary.trim()].length}/{CHANGE_SUMMARY_MAX_CHARS}
+                {[...changeSummary.trim()].length > 0 &&
+                [...changeSummary.trim()].length < CHANGE_SUMMARY_MIN_CHARS
+                  ? `（至少 ${CHANGE_SUMMARY_MIN_CHARS} 个字）`
+                  : ''}
+              </span>
+            </label>
+          ) : null}
           <label className="game-publish-field">
             画面方向
             <select
diff --git a/src/components/game-distribution/GameThemePage.tsx b/src/components/game-distribution/GameThemePage.tsx
new file mode 100644
index 000000000..245b6c75c
--- /dev/null
+++ b/src/components/game-distribution/GameThemePage.tsx
@@ -0,0 +1,262 @@
+import './gameDistribution.css';
+
+import { ArrowLeft, RefreshCcw } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+
+import {
+  type GameDistributionThemeDetail,
+  getTheme,
+} from '../../services/gameDistributionClient';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformEmptyState } from '../common/PlatformEmptyState';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import { GameLineagePage } from './GameLineagePage';
+import type { LineagePlayCountBreakdown } from './lineageTreeLayout';
+import { useGameAuthorDisplayName } from './useGameAuthorName';
+
+type GameThemePageProps = {
+  themeId: string | null;
+  onBack: () => void;
+  onOpenDetail: (gameId: string) => void;
+  /** 直接进族谱页（树的全屏版本）；主题页内已内嵌渲染同一棵树。 */
+  onOpenLineage?: (rootGameId: string, fromGameId?: string) => void;
+};
+
+/** 成员根卡片：作品摘要 + 「查看作品 / 查看作品族谱」两个入口。 */
+function ThemeRootCard({
+  root,
+  playCountBreakdown,
+  onOpenDetail,
+  onOpenLineage,
+}: {
+  root: {
+    id: string;
+    title: string;
+    author: { id: string; name: string };
+    playCount: number;
+    lineage?: { generation: number } | null;
+  };
+  /**
+   * 游玩次数分解（子树合计）。**显示口径 2026-10-06**：父代展示「自己 + 全部后代的合计」。
+   * 拿不到树时为 `null` → 回退服务端的**自身值**，且不说「含衍生」。
+   */
+  playCountBreakdown?: LineagePlayCountBreakdown | null;
+  onOpenDetail: (gameId: string) => void;
+  onOpenLineage?: (rootGameId: string, fromGameId?: string) => void;
+}) {
+  const authorName = useGameAuthorDisplayName(root.author);
+  const generation = root.lineage?.generation ?? 0;
+  return (
+    <header className="game-theme-root__head">
+      <span className="game-theme-root__generation">
+        {generation === 0 ? '母版' : `第 ${generation} 代`}
+      </span>
+      <h3 className="game-theme-root__title">{root.title}</h3>
+      <p className="game-theme-root__meta">
+        <span>{authorName?.trim() || '未署名作者'}</span>
+        <span aria-hidden="true">·</span>
+        <span aria-label="游玩次数合计">
+          {(playCountBreakdown?.total ?? root.playCount).toLocaleString()}{' '}
+          次游玩
+          {playCountBreakdown && playCountBreakdown.inherited > 0
+            ? `（自身 ${playCountBreakdown.own} + 衍生 ${playCountBreakdown.inherited}）`
+            : ''}
+        </span>
+      </p>
+      <div className="game-theme-root__actions">
+        <PlatformActionButton
+          tone="secondary"
+          size="sm"
+          shape="pill"
+          onClick={() => onOpenDetail(root.id)}
+        >
+          查看作品
+        </PlatformActionButton>
+        {onOpenLineage ? (
+          <PlatformActionButton
+            tone="secondary"
+            size="sm"
+            shape="pill"
+            onClick={() => onOpenLineage(root.id, root.id)}
+          >
+            全屏查看族谱
+          </PlatformActionButton>
+        ) : null}
+      </div>
+    </header>
+  );
+}
+
+/**
+ * 主题页：标题 / 简介 / 角标 + 成员根清单，**逐根内嵌渲染作品树**。
+ *
+ * 树不在这里重建：内嵌的就是族谱页组件（`GameLineagePage embedded`），因此树查询、可见性过滤、
+ * 排序与截断全部复用 M3 那一份实现，主题页不引入第二套树规则。代价是每个根一次 `/lineage`
+ * 请求（技术方案 §3.10.4 已接受的 N+1 取舍）。
+ *
+ * 已发布但可见成员为空 → 明确空态（不是错误）；主题不存在 / 未发布 → 服务端 404，这里走错误态。
+ */
+export function GameThemePage({
+  themeId,
+  onBack,
+  onOpenDetail,
+  onOpenLineage,
+}: GameThemePageProps) {
+  const normalizedThemeId = themeId?.trim() ?? '';
+  const [theme, setTheme] = useState<GameDistributionThemeDetail | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState('');
+
+  const loadTheme = useCallback(async () => {
+    if (!normalizedThemeId) {
+      setTheme(null);
+      setError('主题编号无效');
+      return;
+    }
+    setIsLoading(true);
+    setError('');
+    try {
+      const detail = await getTheme(normalizedThemeId);
+      if (!detail) {
+        setError('主题不存在或尚未发布');
+        return;
+      }
+      setTheme(detail);
+    } catch (loadError: unknown) {
+      setError(
+        loadError instanceof Error ? loadError.message : '主题不存在或尚未发布',
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, [normalizedThemeId]);
+
+  useEffect(() => {
+    void loadTheme();
+  }, [loadTheme]);
+
+  const [rootPlayCounts, setRootPlayCounts] = useState<ReadonlyMap<
+    string,
+    LineagePlayCountBreakdown
+  > | null>(null);
+  /**
+   * 各根树的「游玩次数分解」由内嵌的族谱页用**它自己那次** `/lineage` 请求回传（不额外请求）。
+   * 节点 id 全局唯一，所以多棵树的结果直接合并。
+   */
+  const handlePlayCountTotals = useCallback(
+    (totals: ReadonlyMap<string, LineagePlayCountBreakdown>) => {
+      setRootPlayCounts((current) => new Map([...(current ?? []), ...totals]));
+    },
+    [],
+  );
+
+  return (
+    <div className="game-page game-theme-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>{theme?.name?.trim() || '共创主题'}</h2>
+        </div>
+        <PlatformActionButton
+          tone="secondary"
+          size="sm"
+          shape="pill"
+          disabled={isLoading}
+          onClick={() => void loadTheme()}
+        >
+          <RefreshCcw aria-hidden="true" /> 刷新
+        </PlatformActionButton>
+      </div>
+
+      {theme?.badge || theme?.summary ? (
+        <div className="game-theme-summary">
+          {theme.badge ? (
+            <span className="game-theme-summary__badge">{theme.badge}</span>
+          ) : null}
+          {theme.summary ? (
+            <p className="game-theme-summary__text">{theme.summary}</p>
+          ) : null}
+        </div>
+      ) : null}
+
+      {theme ? (
+        <p className="game-theme-summary__meta">
+          共 {theme.memberCount} 棵作品树
+        </p>
+      ) : null}
+      {theme?.rootsTruncated ? (
+        /*
+          总数一律用 `memberCount`（真实可见成员数，不截断）；`roots.length` 只是这一页拿到几个。
+          两者不再保证相等，所以这里显式区分「显示前 N 个」与「共 M 个」。
+        */
+        <p className="game-lineage-notice" role="status">
+          这个主题的根较多：这里只显示前 {theme.roots.length} 个，共{' '}
+          {theme.memberCount} 个。
+        </p>
+      ) : null}
+
+      {isLoading && !theme ? (
+        <div className="game-loading-panel">正在加载共创主题…</div>
+      ) : null}
+      {!isLoading && error ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          <span>{error}</span>
+          {normalizedThemeId ? (
+            <button
+              type="button"
+              className="game-lineage-retry"
+              onClick={() => void loadTheme()}
+            >
+              重试
+            </button>
+          ) : null}
+        </PlatformStatusMessage>
+      ) : null}
+      {!isLoading && !error && theme && theme.roots.length === 0 ? (
+        <PlatformEmptyState surface="subpanel" size="panel">
+          <span>这个主题还没有可展示的作品树。</span>
+        </PlatformEmptyState>
+      ) : null}
+      {!error && theme && theme.roots.length > 0 ? (
+        <div className="game-theme-trees">
+          {theme.roots.map((root) => (
+            <section
+              key={root.id}
+              className="game-theme-root"
+              aria-label={`${root.title} 的作品树`}
+            >
+              <ThemeRootCard
+                root={root}
+                playCountBreakdown={rootPlayCounts?.get(root.id) ?? null}
+                onOpenDetail={onOpenDetail}
+                onOpenLineage={onOpenLineage}
+              />
+              {/*
+                内嵌族谱页：树查询与渲染完全复用 M3 实现（embedded 只隐藏页面外壳：
+                返回按钮 / 页头 / 脚注），不在主题侧重建第二套树。
+                `onPlayCountTotals` 把同一棵树的游玩次数分解回传给上面那张母版行。
+              */}
+              <GameLineagePage
+                embedded
+                rootGameId={root.id}
+                highlightGameId={root.id}
+                onBack={onBack}
+                onOpenDetail={onOpenDetail}
+                onPlayCountTotals={handlePlayCountTotals}
+              />
+            </section>
+          ))}
+        </div>
+      ) : null}
+
+      <p className="game-detail-footnote">
+        树只展示已公开的作品；成员作品下架或删除后会从主题里消失，重新公开后自动回来。
+      </p>
+    </div>
+  );
+}
+
+export default GameThemePage;
diff --git a/src/components/game-distribution/GameThemesPage.tsx b/src/components/game-distribution/GameThemesPage.tsx
new file mode 100644
index 000000000..c5d9e129a
--- /dev/null
+++ b/src/components/game-distribution/GameThemesPage.tsx
@@ -0,0 +1,148 @@
+import './gameDistribution.css';
+
+import { ArrowLeft, RefreshCcw } from 'lucide-react';
+import { useCallback, useEffect, useState } from 'react';
+
+import {
+  type GameDistributionThemeSummary,
+  listThemes,
+} from '../../services/gameDistributionClient';
+import { PlatformActionButton } from '../common/PlatformActionButton';
+import { PlatformEmptyState } from '../common/PlatformEmptyState';
+import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+
+type GameThemesPageProps = {
+  onBack: () => void;
+  onOpenTheme: (themeId: string) => void;
+};
+
+/**
+ * 共创主题列表（`/games/themes`）。
+ *
+ * 匿名可读；分页沿用服务端游标惯例（默认 20 / 上限 50 / 末页 nextCursor 为 null）：
+ * 只有 `nextCursor` 非空才渲染「加载更多」，点击时把已加载的页追加在后面。
+ *
+ * 2026-10-07：「游戏 / 共创」子页签已删除（共创升为侧边栏顶层入口、指向作品列表，
+ * 不再指向主题列表）。本页保留路由与「返回」，入口来自作品详情的「所属主题」或直接 URL。
+ */
+export function GameThemesPage({ onBack, onOpenTheme }: GameThemesPageProps) {
+  const [themes, setThemes] = useState<GameDistributionThemeSummary[]>([]);
+  const [nextCursor, setNextCursor] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState('');
+
+  const loadThemes = useCallback(async (cursor?: string) => {
+    setIsLoading(true);
+    setError('');
+    try {
+      const page = await listThemes(cursor);
+      setThemes((current) =>
+        cursor ? [...current, ...page.themes] : page.themes,
+      );
+      setNextCursor(page.nextCursor);
+    } catch (loadError: unknown) {
+      setError(
+        loadError instanceof Error ? loadError.message : '读取共创主题失败',
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void loadThemes();
+  }, [loadThemes]);
+
+  return (
+    <div className="game-page game-themes-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>
+        <PlatformActionButton
+          tone="secondary"
+          size="sm"
+          shape="pill"
+          disabled={isLoading}
+          onClick={() => void loadThemes()}
+        >
+          <RefreshCcw aria-hidden="true" /> 刷新
+        </PlatformActionButton>
+      </div>
+
+      {error ? (
+        <PlatformStatusMessage tone="error" surface="platform">
+          <span>{error}</span>
+          <button
+            type="button"
+            className="game-lineage-retry"
+            onClick={() => void loadThemes()}
+          >
+            重试
+          </button>
+        </PlatformStatusMessage>
+      ) : null}
+      {isLoading && themes.length === 0 ? (
+        <div className="game-loading-panel">正在加载共创主题…</div>
+      ) : null}
+      {!isLoading && !error && themes.length === 0 ? (
+        <PlatformEmptyState surface="subpanel" size="panel">
+          <span>还没有已发布的共创主题，稍后再来看看。</span>
+        </PlatformEmptyState>
+      ) : null}
+      {themes.length > 0 ? (
+        <>
+          <ul className="game-theme-list">
+            {themes.map((theme) => (
+              <li key={theme.themeId}>
+                <button
+                  type="button"
+                  className="game-theme-card"
+                  onClick={() => onOpenTheme(theme.themeId)}
+                >
+                  {theme.badge ? (
+                    <span className="game-theme-card__badge">
+                      {theme.badge}
+                    </span>
+                  ) : null}
+                  <span className="game-theme-card__name">{theme.name}</span>
+                  {theme.summary ? (
+                    <span className="game-theme-card__summary">
+                      {theme.summary}
+                    </span>
+                  ) : null}
+                  <span className="game-theme-card__meta">
+                    {theme.memberCount} 棵作品树
+                  </span>
+                </button>
+              </li>
+            ))}
+          </ul>
+          {nextCursor ? (
+            <div className="game-empty-actions">
+              <PlatformActionButton
+                tone="secondary"
+                size="sm"
+                shape="pill"
+                disabled={isLoading}
+                onClick={() => void loadThemes(nextCursor)}
+              >
+                加载更多
+              </PlatformActionButton>
+            </div>
+          ) : null}
+        </>
+      ) : null}
+
+      <p className="game-detail-footnote">
+        共创主题由平台命名，一个主题可以包含多棵作品树；作品之间仍各自独立展示。
+      </p>
+    </div>
+  );
+}
+
+export default GameThemesPage;
diff --git a/src/components/game-distribution/LineageFullscreenOverlay.tsx b/src/components/game-distribution/LineageFullscreenOverlay.tsx
new file mode 100644
index 000000000..3ab6b5928
--- /dev/null
+++ b/src/components/game-distribution/LineageFullscreenOverlay.tsx
@@ -0,0 +1,93 @@
+import { useEffect, useRef } from 'react';
+import { createPortal } from 'react-dom';
+
+import { GameLineagePage } from './GameLineagePage';
+
+/**
+ * 「全屏查看族谱」的**真·全屏 overlay**（2026-10-07 用户口径：「你这个全屏查看族谱压根就不是全屏」）。
+ *
+ * 之前的实现其实是**路由跳转**到 `/games/lineage`：页面仍然活在平台 tab 面板里（左侧有导航栏、
+ * 四周有内边距），所以「全屏」名不副实。这里改成：
+ *
+ * - **`createPortal` 挂到 `document.body`** + `position: fixed; inset: 0` ⇒ 完全不受详情页/平台
+ *   容器的宽度、`max-width`、`overflow` 约束；
+ * - 关闭路径齐备：右上「关闭」按钮 + `Esc`；
+ * - 无障碍：`role="dialog"` + `aria-modal="true"`，打开时焦点移入 overlay（关闭按钮），关闭后
+ *   焦点回到触发按钮；
+ * - 打开时锁 `body` 滚动，关闭时**恢复原滚动位置**；
+ * - 移动端同样整屏，留 `env(safe-area-inset-*)`，不被刘海/底部条压住；
+ * - 里面的图谱**就是** `GameLineagePage`（`embedded`）——与内嵌区共用同一套画布实现
+ *   （点选 / 拖拽 / 滚轮竖向平移 / 封面 16:9 全都同一份代码，不存在第二套画布）。
+ */
+export function LineageFullscreenOverlay({
+  rootGameId,
+  currentGameId,
+  onOpenGameDetail,
+  onClose,
+  triggerRef,
+}: {
+  rootGameId: string;
+  currentGameId: string | null;
+  onOpenGameDetail: (gameId: string) => void;
+  onClose: () => void;
+  /** 触发按钮：关闭后把焦点还给它。 */
+  triggerRef: React.RefObject<HTMLButtonElement | null>;
+}) {
+  const closeButtonRef = useRef<HTMLButtonElement>(null);
+
+  useEffect(() => {
+    const previousOverflow = document.body.style.overflow;
+    const previousScrollY = window.scrollY;
+    // 关闭时要还原焦点：在 effect 里取一次触发按钮的引用（cleanup 里直接读 ref.current 会被 lint 拦，
+    // 而且那时元素可能已经换了）。
+    const trigger = triggerRef.current;
+    document.body.style.overflow = 'hidden';
+    closeButtonRef.current?.focus();
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key !== 'Escape') return;
+      event.stopPropagation();
+      onClose();
+    };
+    document.addEventListener('keydown', onKeyDown);
+    return () => {
+      document.removeEventListener('keydown', onKeyDown);
+      document.body.style.overflow = previousOverflow;
+      // 关闭后回到打开前的位置（锁定滚动期间不会累积位移，这里只是兜底）。
+      window.scrollTo(0, previousScrollY);
+      trigger?.focus();
+    };
+  }, [onClose, triggerRef]);
+
+  return createPortal(
+    <div
+      className="lineage-fullscreen"
+      role="dialog"
+      aria-modal="true"
+      aria-label="创作族谱（全屏）"
+    >
+      <header className="lineage-fullscreen__bar">
+        <h2 className="lineage-fullscreen__title">创作族谱</h2>
+        <button
+          ref={closeButtonRef}
+          type="button"
+          className="lineage-fullscreen__close"
+          aria-label="关闭全屏族谱"
+          onClick={onClose}
+        >
+          关闭
+        </button>
+      </header>
+      <div className="lineage-fullscreen__body">
+        <GameLineagePage
+          embedded
+          rootGameId={rootGameId}
+          highlightGameId={currentGameId}
+          onOpenDetail={onOpenGameDetail}
+        />
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+export default LineageFullscreenOverlay;
diff --git a/src/components/game-distribution/LineageInfoPanel.tsx b/src/components/game-distribution/LineageInfoPanel.tsx
new file mode 100644
index 000000000..3a58f84f2
--- /dev/null
+++ b/src/components/game-distribution/LineageInfoPanel.tsx
@@ -0,0 +1,115 @@
+import {
+  GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS,
+  resolveGameForkAuthorization,
+} from '../../../packages/shared/src/contracts/gameDistribution';
+import type { GameDistributionGame } from '../../services/gameDistributionClient';
+import type { LineageLayoutNode } from './lineageTreeLayout';
+import { generationAxisLabel } from './lineageTreeLayout';
+
+/**
+ * 选中节点的信息面板：**桌面用右侧浮层、移动端用 bottom sheet**（同一个组件，只换形态）。
+ *
+ * 分成两种形态是为了不写两套：内容（简介 / 授权类型 / 核心改动说明 / 两个操作）完全一致，
+ * 差别只在 CSS 类与容器位置——桌面挂在画布右上，移动端从底部升起（带遮罩与关闭按钮）。
+ * 简介与授权只对**选中的这一个节点**请求一次公开详情（不发 N 次请求）。
+ */
+export function LineageInfoPanel({
+  node,
+  game,
+  isSheet,
+  onClose,
+  onOpenDetail,
+  onOpenFork,
+}: {
+  node: LineageLayoutNode;
+  /** 选中节点的公开详情（简介 / 授权 / 版本摘要层的改动说明）；读取中为 null。 */
+  game: GameDistributionGame | null;
+  isSheet: boolean;
+  onClose: () => void;
+  onOpenDetail: (gameId: string) => void;
+  onOpenFork: (gameId: string) => void;
+}) {
+  const authorizationLabel = game
+    ? GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS[
+        resolveGameForkAuthorization(game.forkAuthorization)
+      ]
+    : null;
+  /** 核心改动说明在**版本摘要层**（`currentVersion.changeSummary`），缺失就不渲染这一行。 */
+  const coreChangeNote = game?.currentVersion?.changeSummary?.trim() ?? '';
+
+  return (
+    <>
+      {isSheet ? (
+        <button
+          type="button"
+          className="game-lineage-sheet-backdrop"
+          aria-label="关闭信息面板"
+          onClick={onClose}
+        />
+      ) : null}
+      <aside
+        className={`game-lineage-panel${
+          isSheet ? ' game-lineage-panel--sheet' : ''
+        }`}
+        aria-label="选中作品信息"
+      >
+        {isSheet ? (
+          <button
+            type="button"
+            className="game-lineage-panel__close"
+            aria-label="关闭"
+            onClick={onClose}
+          >
+            关闭
+          </button>
+        ) : null}
+        <h3 className="game-lineage-panel__title">
+          {node.isStub ? '原作品已不可用' : (node.title ?? '未命名作品')}
+        </h3>
+        <p className="game-lineage-panel__meta">
+          {generationAxisLabel(node.generation)} ·{' '}
+          {node.isStub
+            ? '标题与作者名不对外展示'
+            : (node.authorName ?? '').trim() || '未署名作者'}
+        </p>
+        {node.isStub ? (
+          <p className="game-lineage-panel__note">
+            来源作品已删除或未公开，只保留代际位置。
+          </p>
+        ) : (
+          <>
+            <p className="game-lineage-panel__summary">
+              {game?.summary?.trim() || '暂无简介'}
+            </p>
+            <p className="game-lineage-panel__meta">
+              授权：{authorizationLabel ?? '读取中…'}
+            </p>
+            {coreChangeNote ? (
+              <p className="game-lineage-panel__note">
+                核心改动说明：{coreChangeNote}
+              </p>
+            ) : null}
+            <span className="game-lineage-panel__actions">
+              <button
+                type="button"
+                className="game-lineage-panel__button"
+                onClick={() => onOpenDetail(node.gameId)}
+              >
+                前往体验
+              </button>
+              <button
+                type="button"
+                className="game-lineage-panel__button game-lineage-panel__button--primary"
+                onClick={() => onOpenFork(node.gameId)}
+              >
+                开始共创此版本
+              </button>
+            </span>
+          </>
+        )}
+      </aside>
+    </>
+  );
+}
+
+export default LineageInfoPanel;
diff --git a/src/components/game-distribution/LineageNodeContent.tsx b/src/components/game-distribution/LineageNodeContent.tsx
new file mode 100644
index 000000000..b8aeece23
--- /dev/null
+++ b/src/components/game-distribution/LineageNodeContent.tsx
@@ -0,0 +1,141 @@
+import type { GameDistributionGame } from '../../services/gameDistributionClient';
+import { GameCover } from './GameCover';
+import type {
+  LineagePlayCountBreakdown,
+  LineageRelationRole,
+} from './lineageTreeLayout';
+import { generationAxisLabel } from './lineageTreeLayout';
+
+/**
+ * 族谱节点卡片的**内容**（封面 + 代际角标 + 标题 + 作者），族谱画布与详情页血缘链共用。
+ *
+ * 抽出来是为了只有一套「封面色块 / 角标 / 省略规则」：详情页的血缘链曾经自己写过一份窄卡片，
+ * 结果在 ~230px 的右栏里把标题挤成逐字换行。现在两处都用这里的规则：
+ * - 标题容器 `min-width: 0`（flex 子项默认不收缩的经典坑）+ 2 行 line-clamp + ellipsis；
+ * - `layout="stacked"`：画布卡片，封面在上、信息条在下；
+ * - `layout="inline"`：血缘链节点，封面在左、文字在右，**矮而宽**，绝不允许逐字换行。
+ */
+export function LineageNodeContent({
+  title,
+  authorName,
+  generation,
+  coverObjectKey,
+  layout,
+  isAnchor = false,
+  isStub = false,
+  isTrunk = false,
+  compact = false,
+  relation = 'side',
+  playCount = null,
+}: {
+  title: string | null;
+  authorName: string | null;
+  generation: number;
+  coverObjectKey?: string | null;
+  layout: 'stacked' | 'inline';
+  isAnchor?: boolean;
+  isStub?: boolean;
+  isTrunk?: boolean;
+  /** 画布卡片的紧凑态（窄屏图谱）：省掉作者行；大纲/血缘链行始终保留作者名。 */
+  compact?: boolean;
+  /**
+   * 相对「当前作品」的角色：父代（祖先链）/ 子代（后代）/ 自己 / 旁支。
+   * 只给**父代 / 子代**渲染角标（自己是「当前作品」角标、旁支不标注），
+   * 是可读文本而不是只靠颜色，因此可断言。
+   */
+  relation?: LineageRelationRole;
+  /**
+   * 该节点的游玩次数**子树合计**（`collectLineagePlayCountTotals` 的结果）。
+   * 传了就显示紧凑角标 `▶ N`（`title` 说明含衍生）；`null` / 不传则不显示（拿不到树时）。
+   */
+  playCount?: LineagePlayCountBreakdown | null;
+}) {
+  const displayTitle = isStub ? '原作品已不可用' : (title ?? '未命名作品');
+  const authorLabel = isStub
+    ? '标题与作者名不对外展示'
+    : (authorName ?? '').trim() || '未署名作者';
+  /** `GameCover` 只读 title / coverColor / icon / coverObjectKey；族谱节点没有完整游戏行。 */
+  const coverGame = {
+    title: displayTitle,
+    coverColor: '#F3E4D0',
+    icon: '🎮',
+    coverObjectKey,
+  } as unknown as GameDistributionGame;
+
+  /**
+   * 角标组：代际 / 主干 / 当前作品 / 父代-子代 **一律**放在同一个 flex 容器里。
+   *
+   * 之前这几枚角标各自 `position: absolute`（代际左上、主干右上、当前作品在流内），
+   * 在窄卡里会**互相叠印**（大纲行里 `第 1 代` 与 `主干` 叠成乱码字形）。改成「同一组、
+   * 有 gap 的 flex 行」后，重叠在结构上不可能发生，画布与大纲共用同一组角标。
+   */
+  const badges = (
+    <span className="game-lineage-node__badges">
+      <span className="game-lineage-node__badge">
+        {generationAxisLabel(generation)}
+      </span>
+      {isTrunk ? (
+        <span className="game-lineage-node__trunk" title="该代热度最高的版本">
+          主干
+        </span>
+      ) : null}
+      {isAnchor ? (
+        <span className="game-lineage-node__anchor">当前作品</span>
+      ) : null}
+      {relation === 'ancestor' || relation === 'descendant' ? (
+        // 「父代 / 子代」是可读文本角标（不是只靠描边颜色），所以能被断言、也能被读屏。
+        <span
+          className={`game-lineage-node__relation game-lineage-node__relation--${relation}`}
+          data-relation={relation}
+        >
+          {relation === 'ancestor' ? '父代' : '子代'}
+        </span>
+      ) : null}
+      {playCount ? (
+        /*
+          游玩次数 = **该节点的子树合计**（`collectLineagePlayCountTotals().total`，口径见 §3.6.3）。
+          紧凑呈现：与角标同行的小 pill（▶ 数字），`title`/`aria-label` 说明它**含衍生作品**，
+          避免把「父代显示自己 + 全部后代」误解成「这一个作品自己有多少人玩」。
+          全 0 也显示（列稳定，不会一会儿有一个字一会儿没有）。
+          注意：**主干线 / 热度排序的判据仍是自身 playCount**，与这里的显示口径不同。
+        */
+        <span
+          className="game-lineage-node__play-count"
+          title={`游玩次数（含衍生作品）：自身 ${playCount.own} + 衍生 ${playCount.inherited}`}
+          aria-label={`游玩次数（含衍生作品）${playCount.total}`}
+        >
+          ▶ {playCount.total}
+        </span>
+      ) : null}
+    </span>
+  );
+
+  return (
+    <span
+      className={`game-lineage-node__content game-lineage-node__content--${layout}`}
+    >
+      <span className="game-lineage-node__cover">
+        <GameCover game={coverGame} objectKey={coverObjectKey} />
+      </span>
+      {/*
+        角标组在封面**下方**（卡片信息区第一行）：不再压封面、不再用深色药丸浮在图上。
+        画布卡片与大纲行都用同一组（角标语义 / 配色 / 顺序完全一致），组内 flex + gap + 可换行。
+      */}
+      {badges}
+      <span className="game-lineage-node__text">
+        <span className="game-lineage-node__title">{displayTitle}</span>
+        {/*
+          作者名在两种形态都渲染（画布卡片曾因重构一度漏掉，导致节点少了作者信息、
+          也踩到了 e2e 的作者名断言）：只有窄屏图谱的紧凑卡片才省掉它。
+        */}
+        {layout === 'stacked' && compact ? null : (
+          <span className="game-lineage-node__meta">
+            <span className="game-lineage-node__author">{authorLabel}</span>
+          </span>
+        )}
+      </span>
+    </span>
+  );
+}
+
+export default LineageNodeContent;
diff --git a/src/components/game-distribution/LineageOutlineList.tsx b/src/components/game-distribution/LineageOutlineList.tsx
new file mode 100644
index 000000000..686b346f6
--- /dev/null
+++ b/src/components/game-distribution/LineageOutlineList.tsx
@@ -0,0 +1,130 @@
+import { LineageNodeContent } from './LineageNodeContent';
+import type {
+  LineagePlayCountBreakdown,
+  LineageRelationRole,
+} from './lineageTreeLayout';
+
+/**
+ * 移动端**大纲式缩进树**（默认形态）：全宽行 + 左缩进 + 肘形导线。
+ *
+ * 为什么移动端默认不用画布：窄屏上把画布缩小只会让字更小、还得缩放平移；大纲模式
+ * 宽度自适应、**无横向滚动**、每行都是 44px 以上的触控目标，读起来最省力。
+ * 节点内容复用与画布/血缘链同一个 `LineageNodeContent`（只有一套封面色块与省略规则）。
+ *
+ * 语义与画布一致：点击行 = **选中**（高亮祖先链 + 面包屑），行内「打开」= 进详情，
+ * 「开始共创」= 唤起/降级链路；主干链的导线加粗并用主题色。
+ */
+export function LineageOutlineList({
+  nodes,
+  currentGameId,
+  trunkGameIds,
+  selectedGameId,
+  relationByGameId,
+  playCountByGameId,
+  onSelect,
+  onOpenDetail,
+  onOpenFork,
+}: {
+  /** 已按代际升序排好的节点（含占位父节点）。 */
+  nodes: readonly {
+    gameId: string;
+    generation: number;
+    isStub: boolean;
+    title: string | null;
+    authorName: string | null;
+    coverObjectKey?: string | null;
+  }[];
+  currentGameId: string;
+  trunkGameIds: ReadonlySet<string>;
+  selectedGameId: string;
+  /** 每个节点相对「当前作品」的角色（父代 / 子代 / 自己 / 旁支）：与画布同一份口径。 */
+  relationByGameId: ReadonlyMap<string, LineageRelationRole>;
+  /** 每个节点的游玩次数**子树合计**（显示口径，与画布同一份数据）：紧凑角标 `▶ N`。 */
+  playCountByGameId: ReadonlyMap<string, LineagePlayCountBreakdown>;
+  onSelect: (gameId: string) => void;
+  onOpenDetail: (gameId: string) => void;
+  onOpenFork: (gameId: string) => void;
+}) {
+  return (
+    <ul className="lineage-outline" aria-label="创作族谱大纲">
+      {nodes.map((node) => {
+        const isCurrent = node.gameId === currentGameId;
+        const isSelected = node.gameId === selectedGameId;
+        const relation = relationByGameId.get(node.gameId) ?? 'side';
+        return (
+          <li
+            key={node.gameId}
+            className={`lineage-outline__row${
+              isSelected ? ' lineage-outline__row--selected' : ''
+            }`}
+            data-generation={node.generation}
+            data-relation={relation}
+            // 层级用左缩进表达：每代 1.1rem，最多缩进 6 代避免窄屏被挤没。
+            style={{ paddingLeft: `${Math.min(node.generation, 6) * 1.1}rem` }}
+          >
+            <span
+              className={`lineage-outline__guide${
+                trunkGameIds.has(node.gameId)
+                  ? ' lineage-outline__guide--trunk'
+                  : ''
+              }`}
+              aria-hidden="true"
+            >
+              {node.generation === 0 ? '' : '└─'}
+            </span>
+            <button
+              type="button"
+              className={`lineage-outline__main${
+                isCurrent ? ' lineage-outline__main--current' : ''
+              }`}
+              aria-current={isCurrent ? 'true' : undefined}
+              aria-label={`第 ${node.generation} 代《${node.isStub ? '原作品已不可用' : node.title}》· ${
+                node.isStub
+                  ? '标题与作者名不对外展示'
+                  : node.authorName?.trim() || '未署名作者'
+              }· 游玩次数（含衍生作品）${
+                playCountByGameId.get(node.gameId)?.total ?? 0
+              }`}
+              onClick={() => onSelect(node.gameId)}
+            >
+              <LineageNodeContent
+                layout="inline"
+                title={node.title}
+                authorName={node.authorName}
+                generation={node.generation}
+                coverObjectKey={node.coverObjectKey}
+                isAnchor={isCurrent}
+                isStub={node.isStub}
+                isTrunk={trunkGameIds.has(node.gameId)}
+                relation={relation}
+                playCount={playCountByGameId.get(node.gameId) ?? null}
+              />
+            </button>
+            {node.isStub ? null : (
+              <span className="lineage-outline__actions">
+                <button
+                  type="button"
+                  className="lineage-outline__action"
+                  aria-label={`打开《${node.title}》详情`}
+                  onClick={() => onOpenDetail(node.gameId)}
+                >
+                  打开作品
+                </button>
+                <button
+                  type="button"
+                  className="lineage-outline__action lineage-outline__action--co-create"
+                  aria-label={`开始共创 ${node.title}`}
+                  onClick={() => onOpenFork(node.gameId)}
+                >
+                  开始共创
+                </button>
+              </span>
+            )}
+          </li>
+        );
+      })}
+    </ul>
+  );
+}
+
+export default LineageOutlineList;
diff --git a/src/components/game-distribution/LineageRelationLists.tsx b/src/components/game-distribution/LineageRelationLists.tsx
new file mode 100644
index 000000000..971b73970
--- /dev/null
+++ b/src/components/game-distribution/LineageRelationLists.tsx
@@ -0,0 +1,135 @@
+import { GameCard } from '@genarrative/shared/components';
+
+import type { GameDistributionLineageNode } from '../../services/gameDistributionClient';
+import type { GameDistributionGame } from '../../services/gameDistributionClient';
+import { GameCover } from './GameCover';
+import type {
+  LineagePlayCountBreakdown,
+  LineageRelationRole,
+} from './lineageTreeLayout';
+
+/**
+ * 图谱**下方**的「父代 / 子代」两块清单（2026-10-07 用户口径）。
+ *
+ * 为什么放在这里而不是详情页共创卡里：用户要的是「所有父代子代都放到图谱下面，卡片只留数据和 tag」。
+ * 数据全部来自**同一次** `/lineage`（零额外请求），卡片复用族谱的 `LineageNodeContent`（与画布/大纲
+ * 同一套封面色块与省略规则），因此不会出现「第三套卡片」。
+ *
+ * 排序口径：
+ * - 父代 = 祖先链（根 → 直接父），与面包屑同一份顺序（由调用方算好）；
+ * - 子代 = **直接子代**、按**热度（自身 `playCount`）降序**，同热度保持服务端顺序（创建时间序）。
+ *   选直接子代：与 `forkCount`/「被改编 N」同口径；再深的层级由上面的树表达。
+ */
+export function LineageRelationLists({
+  ancestors,
+  children,
+  playCountTotals,
+  onOpenDetail,
+}: {
+  /** 祖先链（根 → 直接父），**不含**当前作品。 */
+  ancestors: readonly GameDistributionLineageNode[];
+  /** 直接子代（调用方已按热度降序排好）。 */
+  children: readonly GameDistributionLineageNode[];
+  playCountTotals: ReadonlyMap<string, LineagePlayCountBreakdown>;
+  onOpenDetail: (gameId: string) => void;
+}) {
+  /**
+   * 单个节点 → **广场作品卡的同一个组件**（`GameCard`）。
+   * 整卡可点 → 进详情；卡面不再放动作按钮（用户口径：看封面决定不了共创，必须点进去看）。
+   * 世代 / 父代-子代 / ▶子树合计 通过卡片的 `badges` 槽承载。
+   */
+  const renderCard = (
+    node: GameDistributionLineageNode,
+    role: LineageRelationRole,
+  ) => {
+    const breakdown = playCountTotals.get(node.gameId) ?? null;
+    const author = (node.authorName ?? '').trim() || '未署名作者';
+    return (
+      <li className="lineage-relation__item" key={node.gameId}>
+        <GameCard
+          className="game-card--lineage"
+          game={{
+            title: node.title,
+            playCount: breakdown?.total ?? node.playCount,
+            author: { name: author },
+          }}
+          cover={
+            <GameCover
+              game={
+                {
+                  id: node.gameId,
+                  title: node.title,
+                  coverColor: '#d77a51',
+                  icon: '✦',
+                  coverObjectKey: node.coverObjectKey ?? null,
+                  playCount: breakdown?.total ?? node.playCount,
+                  author: { id: 'lineage', name: author },
+                } as unknown as GameDistributionGame
+              }
+              objectKey={node.coverObjectKey ?? null}
+            />
+          }
+          badges={
+            <>
+              <span className="game-lineage-node__generation">
+                第 {node.generation} 代
+              </span>
+              <span
+                className={`game-lineage-node__relation game-lineage-node__relation--${role}`}
+                data-relation={role}
+              >
+                {role === 'ancestor' ? '父代' : '子代'}
+              </span>
+              {breakdown ? (
+                <span
+                  className="game-lineage-node__play-count"
+                  title={`游玩次数（含衍生作品）：自身 ${breakdown.own} + 衍生 ${breakdown.inherited}`}
+                  aria-label={`游玩次数（含衍生作品）${breakdown.total}`}
+                >
+                  ▶ {breakdown.total}
+                </span>
+              ) : null}
+            </>
+          }
+          onOpen={() => onOpenDetail(node.gameId)}
+        />
+      </li>
+    );
+  };
+
+  return (
+    <div className="lineage-relations">
+      <section className="lineage-relation" aria-label="父代">
+        <h3 className="lineage-relation__title">
+          父代
+          <span className="lineage-relation__count">{ancestors.length}</span>
+        </h3>
+        {ancestors.length === 0 ? (
+          <p className="lineage-relation__empty">
+            这部作品是母版，没有父代（它的后代都在上面的树里）。
+          </p>
+        ) : (
+          <ul className="lineage-relation__grid">
+            {ancestors.map((node) => renderCard(node, 'ancestor'))}
+          </ul>
+        )}
+      </section>
+      <section className="lineage-relation" aria-label="子代">
+        <h3 className="lineage-relation__title">
+          子代
+          <span className="lineage-relation__count">{children.length}</span>
+          <span className="lineage-relation__hint">直接子代 · 按热度</span>
+        </h3>
+        {children.length === 0 ? (
+          <p className="lineage-relation__empty">这部作品还没有直接子代。</p>
+        ) : (
+          <ul className="lineage-relation__grid">
+            {children.map((node) => renderCard(node, 'descendant'))}
+          </ul>
+        )}
+      </section>
+    </div>
+  );
+}
+
+export default LineageRelationLists;
diff --git a/src/components/game-distribution/MyGamesPage.test.tsx b/src/components/game-distribution/MyGamesPage.test.tsx
index e4669ea4a..611d416d9 100644
--- a/src/components/game-distribution/MyGamesPage.test.tsx
+++ b/src/components/game-distribution/MyGamesPage.test.tsx
@@ -9,13 +9,16 @@ import {
   cancelGameVersion,
   deleteMyGame,
   type GameDistributionMyGame,
+  getDerivedGames,
   getGameDistributionMediaReadUrl,
   getGameVersion,
   getOwnerGameDistributionMediaReadUrl,
+  listMyCollections,
   listMyGames,
   loadVersionRecoveryActions,
   submitGameVersion,
   unpublishGame,
+  updateGameForkAuthorization,
   updateMyGame,
 } from '../../services/gameDistributionClient';
 import { AuthUiContext } from '../auth/AuthUiContext';
@@ -24,14 +27,17 @@ import { MyGamesPage } from './MyGamesPage';
 vi.mock('../../services/gameDistributionClient', () => ({
   cancelGameVersion: vi.fn(),
   deleteMyGame: vi.fn(),
+  getDerivedGames: vi.fn(),
   getGameDistributionMediaReadUrl: vi.fn().mockResolvedValue(''),
-  getOwnerGameDistributionMediaReadUrl: vi.fn().mockResolvedValue(''),
   getGameVersion: vi.fn(),
+  getOwnerGameDistributionMediaReadUrl: vi.fn().mockResolvedValue(''),
+  listMyCollections: vi.fn(),
   listMyGames: vi.fn(),
   loadVersionRecoveryActions: vi.fn(),
   submitGameVersion: vi.fn(),
   unpublishGame: vi.fn(),
   updateMyGame: vi.fn(),
+  updateGameForkAuthorization: vi.fn(),
 }));
 
 type AuthValue = NonNullable<ContextType<typeof AuthUiContext>>;
@@ -125,14 +131,21 @@ beforeEach(() => {
   stubMemoryLocalStorage();
   vi.mocked(cancelGameVersion).mockReset();
   vi.mocked(deleteMyGame).mockReset();
+  vi.mocked(getDerivedGames).mockReset();
   vi.mocked(getGameVersion).mockReset();
   vi.mocked(getOwnerGameDistributionMediaReadUrl).mockReset();
   vi.mocked(getOwnerGameDistributionMediaReadUrl).mockResolvedValue('');
   vi.mocked(listMyGames).mockReset();
+  vi.mocked(listMyCollections).mockReset();
+  vi.mocked(listMyCollections).mockResolvedValue({
+    games: [],
+    nextCursor: null,
+  });
   vi.mocked(loadVersionRecoveryActions).mockReset();
   vi.mocked(submitGameVersion).mockReset();
   vi.mocked(unpublishGame).mockReset();
   vi.mocked(updateMyGame).mockReset();
+  vi.mocked(updateGameForkAuthorization).mockReset();
   vi.mocked(listMyGames).mockResolvedValue([]);
   vi.mocked(loadVersionRecoveryActions).mockResolvedValue({});
   // 默认没有冻结素材：编辑弹窗打开时按“线上封面不可复用”处理，用例按需覆盖。
@@ -142,6 +155,19 @@ beforeEach(() => {
   } as never);
 });
 
+test('作者中心列表（拿不到树）仍显示服务端自身游玩数，不暗示含衍生', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ status: 'published', playCount: 3 }),
+  ]);
+  renderPage(createAuthValue());
+
+  // 「我的作品」没有作品树可算（也不该为此发 /lineage 请求），所以显示服务端的**自身值**。
+  expect(await screen.findByText(/3 次游玩/u)).toBeTruthy();
+  // 不出现「合计 / 含衍生」这类只有拿到树才成立的说法。
+  expect(document.body.textContent).not.toContain('含衍生');
+  expect(document.body.textContent).not.toContain('游玩次数合计');
+});
+
 test('未登录时提示登录且不请求作者接口', () => {
   renderPage(null);
   expect(
@@ -630,3 +656,305 @@ test('删除作品需二次确认并带上当前修订号', async () => {
   expect(String(idempotencyKey)).toContain('game-delete');
   await waitFor(() => expect(listMyGames).toHaveBeenCalledTimes(2));
 });
+
+test('把共创授权从禁止提升为非商用会携带期望档位并重新加载列表', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ forkAuthorization: 'forbidden' }),
+  ]);
+  vi.mocked(updateGameForkAuthorization).mockResolvedValue({
+    ok: true,
+    game: { id: 'game-1', forkAuthorization: 'nonCommercial' },
+  });
+
+  renderPage(createAuthValue());
+
+  expect(await screen.findByText(/共创：禁止共创/)).toBeTruthy();
+  fireEvent.click(screen.getByRole('button', { name: '共创授权' }));
+
+  const nonCommercialOption = screen.getByRole('button', { name: '非商用' });
+  expect((nonCommercialOption as HTMLButtonElement).disabled).toBe(false);
+  fireEvent.click(nonCommercialOption);
+
+  // 首次点击只进入确认态，不发送请求。
+  expect(updateGameForkAuthorization).not.toHaveBeenCalled();
+  fireEvent.click(screen.getByRole('button', { name: '确认提升' }));
+
+  await waitFor(() =>
+    expect(updateGameForkAuthorization).toHaveBeenCalledTimes(1),
+  );
+  const [gameId, target, expected, idempotencyKey] =
+    vi.mocked(updateGameForkAuthorization).mock.calls[0] ?? [];
+  expect(gameId).toBe('game-1');
+  expect(target).toBe('nonCommercial');
+  expect(expected).toBe('forbidden');
+  expect(String(idempotencyKey)).toContain('game-1');
+  await waitFor(() => expect(listMyGames).toHaveBeenCalledTimes(2));
+  expect(screen.getByText(/共创授权已更新为「允许非商用共创」/)).toBeTruthy();
+});
+
+test('共创授权当前档位与更低档位不可点', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ forkAuthorization: 'nonCommercial' }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  expect(await screen.findByText(/共创：允许非商用共创/)).toBeTruthy();
+  fireEvent.click(screen.getByRole('button', { name: '共创授权' }));
+
+  expect(
+    (screen.getByRole('button', { name: '禁止' }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  expect(
+    (screen.getByRole('button', { name: '非商用' }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(true);
+  expect(
+    (screen.getByRole('button', { name: '全开放' }) as HTMLButtonElement)
+      .disabled,
+  ).toBe(false);
+});
+
+test('共创授权已达全开放时入口变为只读展示', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ forkAuthorization: 'full' }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  expect(await screen.findByText('共创授权已达上限')).toBeTruthy();
+  expect(screen.queryByRole('button', { name: '共创授权' })).toBeNull();
+});
+
+test('「被改编 N」入口按需拉取并列出直接子代，点击可进入详情', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ status: 'published', forkCount: 1 }),
+  ]);
+  vi.mocked(getDerivedGames).mockResolvedValue({
+    gameId: 'game-1',
+    nodes: [
+      {
+        gameId: 'game-child',
+        title: '衍生作品',
+        authorName: '改编者',
+        generation: 1,
+        parentGameId: 'game-1',
+        playCount: 5,
+        status: 'published',
+      },
+    ],
+    truncated: false,
+  });
+  const onOpenDetail = vi.fn();
+
+  render(
+    <AuthUiContext.Provider value={createAuthValue()}>
+      <MyGamesPage onBack={vi.fn()} onOpenDetail={onOpenDetail} />
+    </AuthUiContext.Provider>,
+  );
+
+  const toggle = await screen.findByRole('button', { name: /被改编 1/ });
+  // 展开前不请求衍生列表。
+  expect(getDerivedGames).not.toHaveBeenCalled();
+  fireEvent.click(toggle);
+
+  await waitFor(() => expect(getDerivedGames).toHaveBeenCalledWith('game-1'));
+  expect(await screen.findByText('衍生作品')).toBeTruthy();
+  expect(screen.getByText(/改编者 · 第 1 代 · 已公开/)).toBeTruthy();
+
+  fireEvent.click(screen.getByRole('button', { name: '衍生作品' }));
+  expect(onOpenDetail).toHaveBeenCalledWith('game-child');
+});
+
+test('没有衍生作品时展开给出空态', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ status: 'published', forkCount: 0 }),
+  ]);
+  vi.mocked(getDerivedGames).mockResolvedValue({
+    gameId: 'game-1',
+    nodes: [],
+    truncated: false,
+  });
+
+  renderPage(createAuthValue());
+
+  fireEvent.click(await screen.findByRole('button', { name: /被改编 0/ }));
+  expect(await screen.findByText('还没有衍生作品。')).toBeTruthy();
+});
+
+test('衍生列表读取失败时行内给出错误与重试', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ status: 'published', forkCount: 2 }),
+  ]);
+  vi.mocked(getDerivedGames)
+    .mockRejectedValueOnce(new Error('网络错误'))
+    .mockResolvedValueOnce({
+      gameId: 'game-1',
+      nodes: [
+        {
+          gameId: 'game-child',
+          title: '衍生作品',
+          authorName: '改编者',
+          generation: 1,
+          parentGameId: 'game-1',
+          playCount: 5,
+          status: 'published',
+        },
+      ],
+      truncated: true,
+    });
+
+  renderPage(createAuthValue());
+
+  fireEvent.click(await screen.findByRole('button', { name: /被改编 2/ }));
+  expect(await screen.findByText('网络错误')).toBeTruthy();
+  fireEvent.click(screen.getByRole('button', { name: '重试' }));
+  expect(await screen.findByText('衍生作品')).toBeTruthy();
+  expect(screen.getByText('衍生作品较多，仅展示前 1 部。')).toBeTruthy();
+});
+
+test('衍生作品的授权入口改为只读展示（授权继承父作品，不可单独提升）', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'g-fork',
+      title: '共创乙',
+      status: 'published',
+      forkAuthorization: 'nonCommercial',
+      lineage: {
+        generation: 1,
+        rootGameId: 'g-original',
+        rootTitle: '母版甲',
+        parentGameId: 'g-original',
+        parentTitle: '母版甲',
+        parentAuthorName: '原作者',
+      },
+    }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  expect(
+    await screen.findByText(/共创授权继承自父作品（允许非商用共创）/u),
+  ).toBeTruthy();
+  // 提升入口不再出现：服务端会拒绝对衍生作品的授权 PUT。
+  expect(screen.queryByRole('button', { name: '共创授权' })).toBeNull();
+});
+
+test('分类标签按文档口径过滤，并给出总作品数 / 累计被共创次数 / 世代数', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({
+      id: 'g-original',
+      title: '母版甲',
+      status: 'published',
+      forkCount: 2,
+    }),
+    createGame({
+      id: 'g-fork',
+      title: '共创乙',
+      status: 'published',
+      forkCount: 1,
+      lineage: {
+        generation: 1,
+        rootGameId: 'g-original',
+        rootTitle: '母版甲',
+        parentGameId: 'g-original',
+        parentTitle: '母版甲',
+        parentAuthorName: '原作者',
+      },
+    }),
+    createGame({
+      id: 'g-draft',
+      title: '草稿丙',
+      status: 'unpublished',
+      forkCount: 0,
+    }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  // 数据概览：总作品数 + 累计被共创次数（世代数字段缺失 → 该项不渲染）。
+  expect(await screen.findByText('总作品数 3')).toBeTruthy();
+  expect(screen.getByText('累计被共创次数 3')).toBeTruthy();
+  expect(screen.queryByText(/累计衍生世代数/u)).toBeNull();
+
+  // 卡片上的世代数与子衍生作品数量。
+  expect(screen.getByText('子衍生作品 2')).toBeTruthy();
+  expect(screen.getByText('子衍生作品 1')).toBeTruthy();
+
+  // 分类：原创作品只看无父作品的；我发布的共创只看有父且已公开的；草稿只看非公开的。
+  fireEvent.click(screen.getByRole('tab', { name: '原创作品' }));
+  expect(screen.getByText('母版甲')).toBeTruthy();
+  expect(screen.queryByText('共创乙')).toBeNull();
+  expect(screen.queryByText('草稿丙')).toBeNull();
+
+  fireEvent.click(screen.getByRole('tab', { name: '我发布的共创' }));
+  expect(screen.getByText('共创乙')).toBeTruthy();
+  expect(screen.queryByText('母版甲')).toBeNull();
+  expect(screen.queryByText('草稿丙')).toBeNull();
+
+  fireEvent.click(screen.getByRole('tab', { name: '我的草稿' }));
+  expect(screen.getByText('草稿丙')).toBeTruthy();
+  expect(screen.queryByText('母版甲')).toBeNull();
+
+  fireEvent.click(screen.getByRole('tab', { name: '全部作品' }));
+  expect(screen.getByText('母版甲')).toBeTruthy();
+  expect(screen.getByText('共创乙')).toBeTruthy();
+  expect(screen.getByText('草稿丙')).toBeTruthy();
+});
+
+test('未公开作品不渲染「被改编 N」入口', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([
+    createGame({ status: 'unpublished', forkCount: 0 }),
+  ]);
+
+  renderPage(createAuthValue());
+
+  expect(await screen.findByText('我的游戏')).toBeTruthy();
+  expect(screen.queryByRole('button', { name: /被改编/ })).toBeNull();
+  expect(getDerivedGames).not.toHaveBeenCalled();
+});
+
+test('「我的收藏」页签空收藏时给出空态，且只在切过去时拉取', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([]);
+  vi.mocked(listMyCollections).mockResolvedValue({
+    games: [],
+    nextCursor: null,
+  });
+
+  renderPage(createAuthValue());
+  await screen.findByText('我的游戏');
+  // 默认在「我的作品」页签，不同时打收藏接口。
+  expect(listMyCollections).not.toHaveBeenCalled();
+
+  fireEvent.click(screen.getByRole('tab', { name: '我的收藏' }));
+
+  expect(
+    await screen.findByText(
+      '还没有收藏任何作品。在作品详情页点「收藏」，就会出现在这里。',
+    ),
+  ).toBeTruthy();
+  await waitFor(() => expect(listMyCollections).toHaveBeenCalledTimes(1));
+});
+
+test('「我的收藏」页签渲染收藏作品并可点进详情', async () => {
+  vi.mocked(listMyGames).mockResolvedValue([]);
+  vi.mocked(listMyCollections).mockResolvedValue({
+    games: [createGame({ id: 'game-c1', title: '被收藏的作品' })],
+    nextCursor: null,
+  });
+  const onOpenDetail = vi.fn();
+
+  render(
+    <AuthUiContext.Provider value={createAuthValue()}>
+      <MyGamesPage onBack={vi.fn()} onOpenDetail={onOpenDetail} />
+    </AuthUiContext.Provider>,
+  );
+  fireEvent.click(screen.getByRole('tab', { name: '我的收藏' }));
+
+  const title = await screen.findByText('被收藏的作品');
+  fireEvent.click(title);
+  expect(onOpenDetail).toHaveBeenCalledWith('game-c1');
+  // 服务端当前 nextCursor 恒为 null：不渲染「加载更多」。
+  expect(screen.queryByRole('button', { name: '加载更多' })).toBeNull();
+});
diff --git a/src/components/game-distribution/MyGamesPage.tsx b/src/components/game-distribution/MyGamesPage.tsx
index ef8511829..29e9d2718 100644
--- a/src/components/game-distribution/MyGamesPage.tsx
+++ b/src/components/game-distribution/MyGamesPage.tsx
@@ -1,25 +1,40 @@
 import './gameDistribution.css';
 
+import { GameCard } from '@genarrative/shared/components';
 import { ArrowLeft, RefreshCcw } from 'lucide-react';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
 import type { GameDistributionRecoveryAction } from '../../../packages/shared/src/contracts/gameDistribution';
+import {
+  canUpgradeGameForkAuthorization,
+  GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS,
+  GAME_DISTRIBUTION_FORK_AUTHORIZATION_SHORT_LABELS,
+  GAME_DISTRIBUTION_FORK_AUTHORIZATIONS,
+  type GameDistributionForkAuthorization,
+  resolveGameForkAuthorization,
+} from '../../../packages/shared/src/contracts/gameDistribution';
 import {
   cancelGameVersion,
   deleteMyGame,
+  type GameDistributionGame,
+  type GameDistributionLineageNode,
   type GameDistributionMyGame,
   type GameDistributionUpdateMyGameResponse,
   type GameDistributionVersionStatusEntry,
+  getDerivedGames,
+  listMyCollections,
   listMyGames,
   loadVersionRecoveryActions,
   submitGameVersion,
   unpublishGame,
+  updateGameForkAuthorization,
 } from '../../services/gameDistributionClient';
 import { useAuthUi } from '../auth/AuthUiContext';
 import { PlatformActionButton } from '../common/PlatformActionButton';
 import { PlatformDangerConfirmDialog } from '../common/PlatformDangerConfirmDialog';
 import { PlatformEmptyState } from '../common/PlatformEmptyState';
 import { PlatformStatusMessage } from '../common/PlatformStatusMessage';
+import { coCreationGenerationShortLabel } from './coCreationCopy';
 import { GameCover } from './GameCover';
 import {
   type GamePublishDraft,
@@ -83,6 +98,12 @@ function createDeleteKey(gameId: string) {
   return `game-delete-${gameId}-${Date.now()}-${deleteKeySeed}`;
 }
 
+let forkAuthorizationKeySeed = 0;
+function createForkAuthorizationKey(gameId: string) {
+  forkAuthorizationKeySeed += 1;
+  return `game-fork-authorization-${gameId}-${Date.now()}-${forkAuthorizationKeySeed}`;
+}
+
 export type MyGameStatusFilter =
   | 'all'
   | 'published'
@@ -126,6 +147,12 @@ const VERSION_FILTER_STATUSES: Record<
   closed: { cancelled: true, revoked: true },
 };
 
+/** 行内授权设置的目标档位；两段式确认后才会发出请求。 */
+type ForkAuthorizationDraft = {
+  gameId: string;
+  target: GameDistributionForkAuthorization;
+};
+
 function resolveVersionStatus(game: GameDistributionMyGame) {
   const latest = game.latestVersion;
   if (!latest) return null;
@@ -169,8 +196,47 @@ export function MyGamesPage({
   const [statusFilter, setStatusFilter] = useState<MyGameStatusFilter>('all');
   const [versionFilter, setVersionFilter] =
     useState<MyGameVersionFilter>('all');
+  const [forkAuthorizationEditorGameId, setForkAuthorizationEditorGameId] =
+    useState('');
+  const [pendingForkAuthorization, setPendingForkAuthorization] =
+    useState<ForkAuthorizationDraft | null>(null);
+  const [savingForkAuthorizationGameId, setSavingForkAuthorizationGameId] =
+    useState('');
+  /** 「被改编 N」行内展开：展开的是哪个作品，以及按作品缓存的直接子代。 */
+  const [expandedDerivedGameId, setExpandedDerivedGameId] = useState('');
+  const [derivedByGameId, setDerivedByGameId] = useState<
+    Record<string, { nodes: GameDistributionLineageNode[]; truncated: boolean }>
+  >({});
+  const [loadingDerivedGameId, setLoadingDerivedGameId] = useState('');
+  const [derivedErrorByGameId, setDerivedErrorByGameId] = useState<
+    Record<string, string>
+  >({});
   const [notice, setNotice] = useState('');
   const [error, setError] = useState('');
+  /**
+   * 页签：作品管理（原有内容）与「我的收藏」。
+   *
+   * 放在 `/games/mine` 而不是「我的」个人页：两者都是「登录后属于我自己的东西」，
+   * 且这一页已经是登录门禁后的作者中心，收藏列表不需要新路由（也就不会牵动
+   * 路由表 / nginx / Pingora 那一组必须同批登记的清单）。收藏是玩家级动作，
+   * 不要求作者身份，门禁只要求登录，与这一页的既有门禁一致。
+   */
+  const [tab, setTab] = useState<'works' | 'collections'>('works');
+  /**
+   * 「我的作品」下的分类标签（文档：全部作品 / 原创作品 / 我发布的共创 / 我的草稿）。
+   *
+   * 口径说明：原创 = 没有父作品（`lineage` 缺省或 generation 0）；我发布的共创 = 有父作品
+   * 且已公开；我的草稿 = 状态非 `published`（与卡片上的状态标签同一口径）。
+   */
+  const [workCategory, setWorkCategory] = useState<
+    'all' | 'original' | 'coCreated' | 'draft'
+  >('all');
+  const [collections, setCollections] = useState<GameDistributionGame[]>([]);
+  const [isLoadingCollections, setIsLoadingCollections] = useState(false);
+  const [collectionsError, setCollectionsError] = useState('');
+  const [collectionsNextCursor, setCollectionsNextCursor] = useState<
+    string | null
+  >(null);
   const canLoad = Boolean(authUi?.user && authUi.canAccessProtectedData);
   const currentUserId = authUi?.user?.id ?? '';
   /**
@@ -195,6 +261,10 @@ export function MyGamesPage({
     try {
       const entries = await listMyGames();
       setGames(entries);
+      // 列表刷新后「被改编 N」计数也刷新了，行内展开的旧子代列表一并作废，避免展示陈旧数据。
+      setExpandedDerivedGameId('');
+      setDerivedByGameId({});
+      setDerivedErrorByGameId({});
       // 列表投影不带 recoveryAction，只为还需要作者动作的最新版本补一次版本回读；
       // 单个回读失败只丢失该版本的下一步提示，不影响列表。
       const pendingVersionIds = entries
@@ -222,6 +292,40 @@ export function MyGamesPage({
     void loadGames();
   }, [loadGames]);
 
+  /**
+   * 「我的收藏」：只在切到该页签时按需拉取，避免每次进我的作品都多打一次接口。
+   * 游标形态按「将来会有 cursor」写：传 cursor 时追加，否则替换；服务端当前恒为 null，
+   * 所以现在不会出现「加载更多」，但接口形状已经兼容。
+   */
+  const loadCollections = useCallback(
+    async (cursor?: string) => {
+      if (!canLoad) {
+        setCollections([]);
+        return;
+      }
+      setIsLoadingCollections(true);
+      setCollectionsError('');
+      try {
+        const page = await listMyCollections();
+        setCollections((current) =>
+          cursor ? [...current, ...page.games] : page.games,
+        );
+        setCollectionsNextCursor(page.nextCursor);
+      } catch (loadError: unknown) {
+        setCollectionsError(
+          loadError instanceof Error ? loadError.message : '读取我的收藏失败',
+        );
+      } finally {
+        setIsLoadingCollections(false);
+      }
+    },
+    [canLoad],
+  );
+
+  useEffect(() => {
+    if (tab === 'collections') void loadCollections();
+  }, [loadCollections, tab]);
+
   const visibleGames = useMemo(
     () =>
       games.filter((game) => {
@@ -236,7 +340,40 @@ export function MyGamesPage({
       }),
     [games, statusFilter, versionFilter],
   );
-  const hasActiveFilter = statusFilter !== 'all' || versionFilter !== 'all';
+  /** 分类标签（文档口径）：原创 = 无父作品；我发布的共创 = 有父作品且已公开；草稿 = 非公开。 */
+  const categoryGames = useMemo(() => {
+    if (workCategory === 'all') return visibleGames;
+    return visibleGames.filter((game) => {
+      const isCoCreated = (game.lineage?.generation ?? 0) > 0;
+      // 三个分类互斥：草稿优先（非公开），其余按是否二创分原创 / 共创。
+      if (workCategory === 'draft') return game.status !== 'published';
+      if (game.status !== 'published') return false;
+      return workCategory === 'original' ? !isCoCreated : isCoCreated;
+    });
+  }, [visibleGames, workCategory]);
+  const totalForkCount = useMemo(
+    () => games.reduce((sum, game) => sum + (game.forkCount ?? 0), 0),
+    [games],
+  );
+  /**
+   * 累计衍生世代数：`my-games` 目前没有这个字段（后端待补），因此**有才渲染**，
+   * 缺失时概览少一项而不是拿别的数字凑。
+   */
+  const totalDerivedGenerations = useMemo(() => {
+    const values = games
+      .map((game) =>
+        'descendantGenerationCount' in game &&
+        typeof game.descendantGenerationCount === 'number'
+          ? game.descendantGenerationCount
+          : null,
+      )
+      .filter((value): value is number => value !== null);
+    return values.length > 0
+      ? values.reduce((sum, value) => sum + value, 0)
+      : null;
+  }, [games]);
+  const hasActiveFilter =
+    statusFilter !== 'all' || versionFilter !== 'all' || workCategory !== 'all';
 
   function resolveLatestRecoveryAction(game: GameDistributionMyGame) {
     const latest = game.latestVersion;
@@ -264,6 +401,41 @@ export function MyGamesPage({
     );
   }
 
+  async function loadDerivedNodes(game: GameDistributionMyGame) {
+    setLoadingDerivedGameId(game.id);
+    setDerivedErrorByGameId((current) => ({ ...current, [game.id]: '' }));
+    try {
+      const result = await getDerivedGames(game.id);
+      if (!result) {
+        setDerivedErrorByGameId((current) => ({
+          ...current,
+          [game.id]: '读取衍生作品失败',
+        }));
+        return;
+      }
+      setDerivedByGameId((current) => ({
+        ...current,
+        [game.id]: { nodes: result.nodes, truncated: result.truncated },
+      }));
+    } catch (loadError: unknown) {
+      setDerivedErrorByGameId((current) => ({
+        ...current,
+        [game.id]:
+          loadError instanceof Error ? loadError.message : '读取衍生作品失败',
+      }));
+    } finally {
+      setLoadingDerivedGameId('');
+    }
+  }
+
+  function handleToggleDerived(game: GameDistributionMyGame) {
+    const isOpen = expandedDerivedGameId === game.id;
+    setExpandedDerivedGameId(isOpen ? '' : game.id);
+    if (!isOpen && !derivedByGameId[game.id]) {
+      void loadDerivedNodes(game);
+    }
+  }
+
   async function handleCancelVersion(
     game: GameDistributionMyGame,
     version: GameDistributionVersionStatusEntry,
@@ -312,6 +484,36 @@ export function MyGamesPage({
     }
   }
 
+  async function handleUpdateForkAuthorization(
+    game: GameDistributionMyGame,
+    target: GameDistributionForkAuthorization,
+    expected: GameDistributionForkAuthorization,
+  ) {
+    setSavingForkAuthorizationGameId(game.id);
+    setForkAuthorizationEditorGameId('');
+    setPendingForkAuthorization(null);
+    setError('');
+    setNotice('');
+    try {
+      await updateGameForkAuthorization(
+        game.id,
+        target,
+        expected,
+        createForkAuthorizationKey(game.id),
+      );
+      setNotice(
+        `《${game.title}》的共创授权已更新为「${GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS[target]}」。`,
+      );
+      await loadGames();
+    } catch (updateError: unknown) {
+      setError(
+        updateError instanceof Error ? updateError.message : '设置共创授权失败',
+      );
+    } finally {
+      setSavingForkAuthorizationGameId('');
+    }
+  }
+
   async function handleUnpublish(game: GameDistributionMyGame) {
     setBusyGameId(game.id);
     setError('');
@@ -392,297 +594,669 @@ export function MyGamesPage({
         ) : null}
       </div>
 
-      {error ? (
-        <PlatformStatusMessage tone="error" surface="platform">
-          {error}
-        </PlatformStatusMessage>
-      ) : null}
+      <div className="game-tabs" role="tablist" aria-label="我的内容">
+        <button
+          type="button"
+          role="tab"
+          aria-selected={tab === 'works'}
+          className="game-tabs__button"
+          onClick={() => setTab('works')}
+        >
+          我的作品
+        </button>
+        <button
+          type="button"
+          role="tab"
+          aria-selected={tab === 'collections'}
+          className="game-tabs__button"
+          onClick={() => setTab('collections')}
+        >
+          我的收藏
+        </button>
+      </div>
 
-      {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-filters">
-          <label className="game-publish-field">
-            作品状态
-            <select
-              value={statusFilter}
-              onChange={(event) =>
-                setStatusFilter(event.target.value as MyGameStatusFilter)
-              }
-            >
-              <option value="all">全部</option>
-              <option value="published">已公开</option>
-              <option value="unpublished">未公开</option>
-              <option value="suspended">已被封禁</option>
-            </select>
-          </label>
-          <label className="game-publish-field">
-            版本状态
-            <select
-              value={versionFilter}
-              onChange={(event) =>
-                setVersionFilter(event.target.value as MyGameVersionFilter)
-              }
-            >
-              {VERSION_FILTER_OPTIONS.map((item) => (
-                <option key={item.value} value={item.value}>
-                  {item.label}
-                </option>
-              ))}
-            </select>
-          </label>
-          {hasActiveFilter ? (
-            <PlatformActionButton
-              tone="secondary"
-              size="sm"
-              shape="pill"
-              onClick={() => {
-                setStatusFilter('all');
-                setVersionFilter('all');
-              }}
-            >
-              重置筛选
-            </PlatformActionButton>
+      {tab === 'collections' ? (
+        <>
+          {collectionsError ? (
+            <PlatformStatusMessage tone="error" surface="platform">
+              <span>{collectionsError}</span>
+              <button
+                type="button"
+                className="game-lineage-retry"
+                onClick={() => void loadCollections()}
+              >
+                重试
+              </button>
+            </PlatformStatusMessage>
           ) : null}
-        </div>
+          {!canLoad ? (
+            <PlatformEmptyState surface="subpanel" size="panel">
+              <span>登录后可以查看收藏的作品。</span>
+              <PlatformActionButton
+                size="sm"
+                shape="pill"
+                onClick={() =>
+                  authUi?.openLoginModal(() => void loadCollections())
+                }
+              >
+                登录
+              </PlatformActionButton>
+            </PlatformEmptyState>
+          ) : null}
+          {canLoad && isLoadingCollections ? (
+            <div className="game-loading-panel">正在加载我的收藏…</div>
+          ) : null}
+          {canLoad &&
+          !isLoadingCollections &&
+          !collectionsError &&
+          collections.length === 0 ? (
+            <PlatformEmptyState surface="subpanel" size="panel">
+              <span>
+                还没有收藏任何作品。在作品详情页点「收藏」，就会出现在这里。
+              </span>
+            </PlatformEmptyState>
+          ) : null}
+          {canLoad && collections.length > 0 ? (
+            <>
+              <div className="game-grid">
+                {collections.map((game) => (
+                  <GameCard
+                    key={game.id}
+                    cover={<GameCover game={game} />}
+                    game={game}
+                    onOpen={() => onOpenDetail(game.id)}
+                  />
+                ))}
+              </div>
+              {collectionsNextCursor ? (
+                <div className="game-empty-actions">
+                  <PlatformActionButton
+                    tone="secondary"
+                    size="sm"
+                    shape="pill"
+                    disabled={isLoadingCollections}
+                    onClick={() => void loadCollections(collectionsNextCursor)}
+                  >
+                    加载更多
+                  </PlatformActionButton>
+                </div>
+              ) : null}
+            </>
+          ) : null}
+        </>
       ) : null}
 
-      {canLoad &&
-      games.length > 0 &&
-      visibleGames.length === 0 &&
-      !isLoading ? (
-        <PlatformEmptyState surface="subpanel" size="panel">
-          <span>没有符合当前筛选条件的作品。</span>
-        </PlatformEmptyState>
-      ) : null}
+      {tab === 'works' ? (
+        <>
+          {/*
+        分类标签 + 数据概览（文档「个人二创作品管理页」）。
+        概览里的「累计衍生世代数」等后端字段存在时才渲染，缺失不拿别的数字凑。
+      */}
+          <div className="game-tabs" role="tablist" aria-label="我的作品分类">
+            {(
+              [
+                ['all', '全部作品'],
+                ['original', '原创作品'],
+                ['coCreated', '我发布的共创'],
+                ['draft', '我的草稿'],
+              ] as const
+            ).map(([key, label]) => (
+              <button
+                key={key}
+                type="button"
+                role="tab"
+                aria-selected={workCategory === key}
+                className="game-tabs__button"
+                onClick={() => setWorkCategory(key)}
+              >
+                {label}
+              </button>
+            ))}
+          </div>
+          <div className="co-creation-overview" aria-label="创作数据概览">
+            <span className="co-creation-stat">总作品数 {games.length}</span>
+            <span className="co-creation-stat">
+              累计被共创次数 {totalForkCount}
+            </span>
+            {totalDerivedGenerations === null ? null : (
+              <span className="co-creation-stat">
+                累计衍生世代数 {totalDerivedGenerations}
+              </span>
+            )}
+          </div>
+          {error ? (
+            <PlatformStatusMessage tone="error" surface="platform">
+              {error}
+            </PlatformStatusMessage>
+          ) : null}
 
-      {canLoad && visibleGames.length > 0 ? (
-        <div className="my-game-list">
-          {visibleGames.map((game) => {
-            const version = resolveVersionStatus(game);
-            const latestVersion = game.latestVersion;
-            const actionCopy = resolveLatestActionCopy(game);
-            const resumeLabel = resolveDraftResumeLabel(game);
-            const versions = game.versions;
-            const isHistoryOpen = expandedGameId === game.id;
-            return (
-              <article key={game.id} className="my-game-card">
-                <GameCover game={game} compact owner />
-                <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}`}
-                    >
-                      {GAME_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 ? (
-                      <>
+          {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-filters">
+              <label className="game-publish-field">
+                作品状态
+                <select
+                  value={statusFilter}
+                  onChange={(event) =>
+                    setStatusFilter(event.target.value as MyGameStatusFilter)
+                  }
+                >
+                  <option value="all">全部</option>
+                  <option value="published">已公开</option>
+                  <option value="unpublished">未公开</option>
+                  <option value="suspended">已被封禁</option>
+                </select>
+              </label>
+              <label className="game-publish-field">
+                版本状态
+                <select
+                  value={versionFilter}
+                  onChange={(event) =>
+                    setVersionFilter(event.target.value as MyGameVersionFilter)
+                  }
+                >
+                  {VERSION_FILTER_OPTIONS.map((item) => (
+                    <option key={item.value} value={item.value}>
+                      {item.label}
+                    </option>
+                  ))}
+                </select>
+              </label>
+              {hasActiveFilter ? (
+                <PlatformActionButton
+                  tone="secondary"
+                  size="sm"
+                  shape="pill"
+                  onClick={() => {
+                    setStatusFilter('all');
+                    setVersionFilter('all');
+                  }}
+                >
+                  重置筛选
+                </PlatformActionButton>
+              ) : null}
+            </div>
+          ) : null}
+
+          {canLoad &&
+          games.length > 0 &&
+          categoryGames.length === 0 &&
+          !isLoading ? (
+            <PlatformEmptyState surface="subpanel" size="panel">
+              <span>没有符合当前筛选条件的作品。</span>
+            </PlatformEmptyState>
+          ) : null}
+
+          {canLoad && categoryGames.length > 0 ? (
+            <div className="my-game-list">
+              {categoryGames.map((game) => {
+                const version = resolveVersionStatus(game);
+                const latestVersion = game.latestVersion;
+                const actionCopy = resolveLatestActionCopy(game);
+                const resumeLabel = resolveDraftResumeLabel(game);
+                const versions = game.versions;
+                const isHistoryOpen = expandedGameId === game.id;
+                const forkAuthorization = resolveGameForkAuthorization(
+                  game.forkAuthorization,
+                );
+                const forkCount = game.forkCount ?? 0;
+                const isDerivedOpen = expandedDerivedGameId === game.id;
+                const derivedEntry = derivedByGameId[game.id] ?? null;
+                const derivedError = derivedErrorByGameId[game.id] ?? '';
+                const isDerivedLoading = loadingDerivedGameId === game.id;
+                const forkAuthorizationLabel =
+                  GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS[
+                    forkAuthorization
+                  ];
+                const isForkAuthorizationEditing =
+                  forkAuthorizationEditorGameId === game.id;
+                const forkAuthorizationTarget =
+                  pendingForkAuthorization?.gameId === game.id
+                    ? pendingForkAuthorization.target
+                    : null;
+                const isSavingForkAuthorization =
+                  savingForkAuthorizationGameId === game.id;
+                const forkAuthorizationTargetLabel = forkAuthorizationTarget
+                  ? GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS[
+                      forkAuthorizationTarget
+                    ]
+                  : '';
+                const forkAuthorizationOptions =
+                  GAME_DISTRIBUTION_FORK_AUTHORIZATIONS.map((option) => ({
+                    option,
+                    label:
+                      GAME_DISTRIBUTION_FORK_AUTHORIZATION_SHORT_LABELS[option],
+                    fullLabel:
+                      GAME_DISTRIBUTION_FORK_AUTHORIZATION_LABELS[option],
+                    canUpgrade: canUpgradeGameForkAuthorization(
+                      forkAuthorization,
+                      option,
+                    ),
+                  }));
+                return (
+                  <article key={game.id} className="my-game-card">
+                    <GameCover game={game} compact owner />
+                    <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}`}
+                        >
+                          {GAME_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}
+                        <span>·</span>
+                        <span>共创：{forkAuthorizationLabel}</span>
+                        {/* 文档要求卡片显示世代数与子衍生作品数量（世代取血缘 generation）。 */}
                         <span>·</span>
                         <span>
-                          版本 v{version.versionNumber} · {version.label}
+                          {coCreationGenerationShortLabel(
+                            game.lineage?.generation ?? 0,
+                          )}
                         </span>
-                      </>
-                    ) : null}
-                  </div>
-                  {version?.reviewReason ? (
-                    <p className="my-game-card__reason">
-                      驳回理由：{version.reviewReason}
-                    </p>
-                  ) : null}
-                  {actionCopy ? (
-                    <p className="my-game-card__next-step">
-                      下一步：{actionCopy}
-                    </p>
-                  ) : null}
-                  {versions.length > 0 ? (
-                    <button
-                      type="button"
-                      className="my-game-card__history-toggle"
-                      aria-expanded={isHistoryOpen}
-                      aria-controls={`game-version-history-${game.id}`}
-                      onClick={() =>
-                        setExpandedGameId((current) =>
-                          current === game.id ? '' : game.id,
-                        )
-                      }
-                    >
-                      版本历史（{versions.length}）
-                      {isHistoryOpen ? '收起' : '展开'}
-                    </button>
-                  ) : null}
-                  {isHistoryOpen ? (
-                    <GameVersionHistory
-                      id={`game-version-history-${game.id}`}
-                      versions={versions}
-                      recoveryActions={recoveryActions}
-                    />
-                  ) : 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}
-                    {publishEnabled ? (
-                      <PlatformActionButton
-                        tone="secondary"
-                        size="sm"
-                        shape="pill"
-                        disabled={busyGameId === game.id}
-                        onClick={() => setEditingGame(game)}
-                      >
-                        编辑资料
-                      </PlatformActionButton>
-                    ) : null}
-                    {resumeLabel ? (
-                      <PlatformActionButton
-                        tone="secondary"
-                        size="sm"
-                        shape="pill"
-                        onClick={() => onResumePublish?.()}
-                      >
-                        {resumeLabel}
-                      </PlatformActionButton>
-                    ) : null}
-                    {resolveLatestRecoveryAction(game) === 'submit' &&
-                    latestVersion &&
-                    !resumeLabel ? (
-                      <PlatformActionButton
-                        tone="secondary"
-                        size="sm"
-                        shape="pill"
-                        disabled={
-                          submittingVersionId === latestVersion.versionId
-                        }
-                        onClick={() => void handleSubmitVersion(game)}
-                      >
-                        提交审核
-                      </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 ? (
+                        <span>·</span>
+                        <span>子衍生作品 {forkCount}</span>
+                      </div>
+                      {version?.reviewReason ? (
+                        <p className="my-game-card__reason">
+                          驳回理由：{version.reviewReason}
+                        </p>
+                      ) : null}
+                      {actionCopy ? (
+                        <p className="my-game-card__next-step">
+                          下一步：{actionCopy}
+                        </p>
+                      ) : null}
+                      {versions.length > 0 ? (
+                        <button
+                          type="button"
+                          className="my-game-card__history-toggle"
+                          aria-expanded={isHistoryOpen}
+                          aria-controls={`game-version-history-${game.id}`}
+                          onClick={() =>
+                            setExpandedGameId((current) =>
+                              current === game.id ? '' : game.id,
+                            )
+                          }
+                        >
+                          版本历史（{versions.length}）
+                          {isHistoryOpen ? '收起' : '展开'}
+                        </button>
+                      ) : null}
+                      {/*
+                    「被改编 N」与版本历史同属作品关系的展开信息，放在同一节奏里，
+                    不占用下方动作行的位置；点开后才按需拉取直接子代。
+                    只在已公开作品上渲染：衍生接口要求锚点公开可读，未公开/草稿作品点进去必然 404。
+                  */}
+                      {game.status === 'published' ? (
                         <>
+                          <button
+                            type="button"
+                            className="my-game-card__derived-toggle"
+                            aria-expanded={isDerivedOpen}
+                            aria-controls={`game-derived-${game.id}`}
+                            onClick={() => handleToggleDerived(game)}
+                          >
+                            被改编 {forkCount}
+                            {isDerivedOpen ? '收起' : '展开'}
+                          </button>
+                          {isDerivedOpen ? (
+                            <div
+                              className="my-game-card__derived"
+                              id={`game-derived-${game.id}`}
+                            >
+                              {isDerivedLoading ? (
+                                <p className="my-game-card__derived-empty">
+                                  正在加载衍生作品…
+                                </p>
+                              ) : null}
+                              {!isDerivedLoading && derivedError ? (
+                                <p className="my-game-card__derived-error">
+                                  {derivedError}
+                                  <button
+                                    type="button"
+                                    className="game-lineage-retry"
+                                    onClick={() => void loadDerivedNodes(game)}
+                                  >
+                                    重试
+                                  </button>
+                                </p>
+                              ) : null}
+                              {!isDerivedLoading &&
+                              !derivedError &&
+                              derivedEntry
+                                ? derivedEntry.nodes.map((node) => (
+                                    <div
+                                      key={node.gameId}
+                                      className="my-game-card__derived-item"
+                                    >
+                                      <button
+                                        type="button"
+                                        className="my-game-card__derived-title"
+                                        onClick={() =>
+                                          onOpenDetail(node.gameId)
+                                        }
+                                      >
+                                        {node.title.trim() || '未命名作品'}
+                                      </button>
+                                      <span className="my-game-card__derived-meta">
+                                        {node.authorName?.trim() ||
+                                          '未署名作者'}{' '}
+                                        · 第 {node.generation} 代 ·{' '}
+                                        {GAME_STATUS_LABEL[node.status] ??
+                                          node.status}
+                                      </span>
+                                    </div>
+                                  ))
+                                : null}
+                              {!isDerivedLoading &&
+                              !derivedError &&
+                              derivedEntry &&
+                              derivedEntry.nodes.length === 0 ? (
+                                <p className="my-game-card__derived-empty">
+                                  还没有衍生作品。
+                                </p>
+                              ) : null}
+                              {!isDerivedLoading &&
+                              !derivedError &&
+                              derivedEntry?.truncated ? (
+                                <p className="my-game-card__derived-truncated">
+                                  衍生作品较多，仅展示前{' '}
+                                  {derivedEntry.nodes.length} 部。
+                                </p>
+                              ) : null}
+                            </div>
+                          ) : null}
+                        </>
+                      ) : null}
+                      {isHistoryOpen ? (
+                        <GameVersionHistory
+                          id={`game-version-history-${game.id}`}
+                          versions={versions}
+                          recoveryActions={recoveryActions}
+                        />
+                      ) : null}
+                      <div className="my-game-card__actions">
+                        <PlatformActionButton
+                          tone="secondary"
+                          size="sm"
+                          shape="pill"
+                          onClick={() => onOpenDetail(game.id)}
+                        >
+                          查看详情
+                        </PlatformActionButton>
+                        {onPublishVersion ? (
                           <PlatformActionButton
-                            tone="danger"
+                            tone="primary"
                             size="sm"
                             shape="pill"
-                            disabled={
-                              cancellingVersionId === latestVersion.versionId
-                            }
-                            onClick={() =>
-                              void handleCancelVersion(game, latestVersion)
-                            }
+                            onClick={() => onPublishVersion(game.id)}
                           >
-                            确认撤回
+                            发布新版本
                           </PlatformActionButton>
+                        ) : null}
+                        {publishEnabled ? (
+                          <PlatformActionButton
+                            tone="secondary"
+                            size="sm"
+                            shape="pill"
+                            disabled={busyGameId === game.id}
+                            onClick={() => setEditingGame(game)}
+                          >
+                            编辑资料
+                          </PlatformActionButton>
+                        ) : null}
+                        {resumeLabel ? (
+                          <PlatformActionButton
+                            tone="secondary"
+                            size="sm"
+                            shape="pill"
+                            onClick={() => onResumePublish?.()}
+                          >
+                            {resumeLabel}
+                          </PlatformActionButton>
+                        ) : null}
+                        {resolveLatestRecoveryAction(game) === 'submit' &&
+                        latestVersion &&
+                        !resumeLabel ? (
                           <PlatformActionButton
                             tone="secondary"
                             size="sm"
                             shape="pill"
                             disabled={
-                              cancellingVersionId === latestVersion.versionId
+                              submittingVersionId === latestVersion.versionId
                             }
-                            onClick={() => setConfirmingVersionId('')}
+                            onClick={() => void handleSubmitVersion(game)}
                           >
-                            取消
+                            提交审核
                           </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}
+                        {/*
+                      授权提升入口**只给母版**：服务端现在会拒绝对衍生作品的授权 PUT
+                      （衍生作品授权继承父作品，不可单独提升），所以衍生作品这里只做只读展示。
+                    */}
+                        {(game.lineage?.generation ?? 0) > 0 ? (
+                          <span className="my-game-status my-game-status--fork-inherited">
+                            共创授权继承自父作品（{forkAuthorizationLabel}）
+                          </span>
+                        ) : forkAuthorization === 'full' ? (
+                          <span className="my-game-status my-game-status--fork-full">
+                            共创授权已达上限
+                          </span>
+                        ) : isForkAuthorizationEditing ? (
+                          forkAuthorizationTarget ? (
+                            <>
+                              <span className="my-game-card__fork-confirm">
+                                确认提升为「{forkAuthorizationTargetLabel}」？
+                                提升后不可撤销。
+                              </span>
+                              <PlatformActionButton
+                                tone="danger"
+                                size="sm"
+                                shape="pill"
+                                disabled={isSavingForkAuthorization}
+                                onClick={() =>
+                                  void handleUpdateForkAuthorization(
+                                    game,
+                                    forkAuthorizationTarget,
+                                    forkAuthorization,
+                                  )
+                                }
+                              >
+                                确认提升
+                              </PlatformActionButton>
+                              <PlatformActionButton
+                                tone="secondary"
+                                size="sm"
+                                shape="pill"
+                                disabled={isSavingForkAuthorization}
+                                onClick={() =>
+                                  setPendingForkAuthorization(null)
+                                }
+                              >
+                                取消
+                              </PlatformActionButton>
+                            </>
+                          ) : (
+                            <>
+                              {forkAuthorizationOptions.map(
+                                ({ option, label, canUpgrade, fullLabel }) => (
+                                  <PlatformActionButton
+                                    key={option}
+                                    tone={
+                                      option === forkAuthorization
+                                        ? 'primary'
+                                        : 'secondary'
+                                    }
+                                    size="sm"
+                                    shape="pill"
+                                    disabled={
+                                      isSavingForkAuthorization || !canUpgrade
+                                    }
+                                    title={
+                                      canUpgrade
+                                        ? `提升为「${fullLabel}」`
+                                        : '共创授权只能提升，不能降级'
+                                    }
+                                    onClick={() =>
+                                      setPendingForkAuthorization({
+                                        gameId: game.id,
+                                        target: option,
+                                      })
+                                    }
+                                  >
+                                    {label}
+                                  </PlatformActionButton>
+                                ),
+                              )}
+                              <PlatformActionButton
+                                tone="secondary"
+                                size="sm"
+                                shape="pill"
+                                onClick={() =>
+                                  setForkAuthorizationEditorGameId('')
+                                }
+                              >
+                                取消
+                              </PlatformActionButton>
+                            </>
+                          )
+                        ) : (
+                          <PlatformActionButton
+                            tone="secondary"
+                            size="sm"
+                            shape="pill"
+                            disabled={isSavingForkAuthorization}
+                            onClick={() => {
+                              setPendingForkAuthorization(null);
+                              setForkAuthorizationEditorGameId(game.id);
+                            }}
+                          >
+                            共创授权
+                          </PlatformActionButton>
+                        )}
                         <PlatformActionButton
-                          tone="secondary"
+                          tone="danger"
                           size="sm"
                           shape="pill"
-                          disabled={
-                            cancellingVersionId === latestVersion.versionId
-                          }
-                          onClick={() =>
-                            setConfirmingVersionId(latestVersion.versionId)
-                          }
+                          disabled={busyGameId === game.id}
+                          onClick={() => setDeletingGame(game)}
                         >
-                          撤回审核
+                          删除作品
                         </PlatformActionButton>
-                      )
-                    ) : null}
-                    <PlatformActionButton
-                      tone="danger"
-                      size="sm"
-                      shape="pill"
-                      disabled={busyGameId === game.id}
-                      onClick={() => setDeletingGame(game)}
-                    >
-                      删除作品
-                    </PlatformActionButton>
-                  </div>
-                </div>
-              </article>
-            );
-          })}
-        </div>
+                      </div>
+                    </div>
+                  </article>
+                );
+              })}
+            </div>
+          ) : null}
+        </>
       ) : null}
 
       {editingGame ? (
diff --git a/src/components/game-distribution/coCreationCopy.ts b/src/components/game-distribution/coCreationCopy.ts
new file mode 100644
index 000000000..abaa4d3c8
--- /dev/null
+++ b/src/components/game-distribution/coCreationCopy.ts
@@ -0,0 +1,23 @@
+/**
+ * 共创模块的用户可见文案口径（需求文档「功能交互 · 前台用户端」）。
+ *
+ * 世代表述按文档给的三档命名：`0 代原创 / 1 代二创 / 2 代三创 / N 代迭代`。
+ * 树与溯源条上用短标签（`0 代` / `N 代`），详情页标签行用全称。
+ */
+export function coCreationGenerationTagLabel(generation: number) {
+  if (generation <= 0) return '0 代原创';
+  if (generation === 1) return '1 代二创';
+  if (generation === 2) return '2 代三创';
+  return `${generation} 代迭代`;
+}
+
+/** 短标签：溯源条 / 图谱节点上的角标。 */
+export function coCreationGenerationShortLabel(generation: number) {
+  return generation <= 0 ? '0 代' : `${generation} 代`;
+}
+
+/** 作者头像降级：链路节点目前没有头像字段，用「姓名首字」圆形字标代替（不伪造头像图）。 */
+export function coCreationAvatarInitial(authorName: string | null | undefined) {
+  const trimmed = (authorName ?? '').trim();
+  return trimmed ? [...trimmed][0]! : '?';
+}
diff --git a/src/components/game-distribution/gameDistribution.css b/src/components/game-distribution/gameDistribution.css
index 92b3bdda9..33c71ceb7 100644
--- a/src/components/game-distribution/gameDistribution.css
+++ b/src/components/game-distribution/gameDistribution.css
@@ -317,6 +317,1186 @@
   font-weight: 800;
   letter-spacing: 0.16em;
 }
+/*
+ * 共创资料卡：详情页通过共享展示组件的 `infoCards` 槽位渲染，卡片外壳
+ * （`.game-detail-info-card`）与内联 flex 的 value 包裹层都由共享组件提供。
+ * 这里把卡内布局改成纵向栅格，免得授权徽章、代际与改编次数挤在一行里被侧栏裁掉；
+ * 选择器前缀沿用共享组件的类名，保证优先级高于共享样式的 `.game-detail-info-card span`。
+ */
+.game-detail-info-card .game-fork-card {
+  display: grid;
+  justify-items: start;
+  gap: 0.3rem;
+  white-space: normal;
+}
+.game-detail-info-card .game-fork-badge {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.2rem 0.6rem;
+  background: var(--platform-surface-fill);
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  font-weight: 800;
+}
+.game-detail-info-card .game-fork-badge--nonCommercial {
+  background: var(--platform-success-bg);
+  color: var(--platform-success-text);
+}
+.game-detail-info-card .game-fork-badge--full {
+  background: rgba(199, 101, 61, 0.14);
+  color: var(--platform-accent-strong);
+}
+.game-detail-info-card .game-fork-lineage {
+  color: var(--platform-text-base);
+  font-weight: 700;
+}
+.game-detail-info-card .game-fork-lineage__author,
+.game-detail-info-card .game-fork-derived {
+  color: var(--platform-text-soft);
+}
+/* 族谱入口：与卡内文字同节奏的次级按钮，窄屏也靠网格换行收在侧栏里。 */
+.game-fork-lineage-link {
+  justify-self: start;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.22rem 0.7rem;
+  background: transparent;
+  color: var(--platform-accent-strong);
+  font: inherit;
+  font-size: 0.76rem;
+  font-weight: 700;
+  cursor: pointer;
+}
+.game-fork-lineage-link:hover {
+  background: rgba(199, 101, 61, 0.12);
+}
+/*
+ * 「改造这个作品」：入口 + 展开后的获取方式面板。都在共创信息卡内，
+ * 窄屏靠网格换行与 `overflow-wrap: anywhere` 收在侧栏里，不产生横向溢出。
+ */
+.game-fork-remix-link {
+  justify-self: start;
+  border: 1px solid var(--platform-accent-strong);
+  border-radius: 999px;
+  padding: 0.22rem 0.75rem;
+  background: rgba(199, 101, 61, 0.12);
+  color: var(--platform-accent-strong);
+  font: inherit;
+  font-size: 0.76rem;
+  font-weight: 700;
+  cursor: pointer;
+}
+.game-fork-remix-link:hover {
+  background: rgba(199, 101, 61, 0.2);
+}
+.game-fork-remix-panel {
+  display: grid;
+  justify-items: start;
+  gap: 0.35rem;
+  width: 100%;
+  max-width: 100%;
+  box-sizing: border-box;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.6rem;
+  padding: 0.55rem 0.65rem;
+  background: var(--platform-surface-muted, rgba(0, 0, 0, 0.02));
+  font-size: 0.76rem;
+  line-height: 1.6;
+}
+.game-fork-remix-steps {
+  color: var(--platform-text-base);
+  overflow-wrap: anywhere;
+}
+.game-fork-remix-value {
+  min-width: 0;
+  color: var(--platform-text-soft);
+  overflow-wrap: anywhere;
+}
+.game-fork-remix-value code {
+  color: var(--platform-text-strong);
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.72rem;
+  overflow-wrap: anywhere;
+}
+.game-fork-remix-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+}
+.game-fork-remix-copy {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.2rem 0.7rem;
+  background: var(--platform-surface, #fff);
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.74rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.game-fork-remix-note {
+  color: var(--platform-text-soft);
+  overflow-wrap: anywhere;
+}
+.game-fork-remix-status {
+  color: var(--platform-text-soft);
+  font-size: 0.74rem;
+  overflow-wrap: anywhere;
+}
+/*
+ * 「原版与二创对比」：桌面端左右并排，窄屏改上下堆叠（不出现横向溢出）。
+ * iframe 复用游玩页的 `.game-player-frame`，这里只给两侧容器定尺寸与堆叠规则。
+ */
+.game-compare-page {
+  max-width: 90rem;
+  margin: 0 auto;
+  display: flex;
+  flex-direction: column;
+  gap: 0.9rem;
+}
+.game-compare-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.9rem;
+  align-items: start;
+}
+.game-compare-side {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  min-width: 0;
+}
+.game-compare-side__head {
+  display: flex;
+  flex-direction: column;
+  gap: 0.15rem;
+  min-width: 0;
+}
+.game-compare-side__role {
+  align-self: flex-start;
+  border-radius: 999px;
+  padding: 0.1rem 0.5rem;
+  background: var(--platform-surface-border);
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  font-weight: 700;
+}
+.game-compare-side__title {
+  margin: 0;
+  color: var(--platform-text-strong);
+  font-size: 0.95rem;
+  overflow-wrap: anywhere;
+}
+.game-compare-side__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  overflow-wrap: anywhere;
+}
+.game-compare-side__frame {
+  position: relative;
+  aspect-ratio: 4 / 3;
+  min-height: 18rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.75rem;
+  overflow: hidden;
+}
+@media (max-width: 900px) {
+  .game-compare-grid {
+    grid-template-columns: minmax(0, 1fr);
+  }
+  .game-compare-side__frame {
+    min-height: 15rem;
+  }
+}
+.game-detail-info-card .game-fork-compare-link {
+  justify-self: start;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.22rem 0.7rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.76rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.game-detail-info-card .game-fork-compare-link:hover {
+  color: var(--platform-text-strong);
+}
+/* 收藏失败/状态提示：与动作行同一行内换行，不撑破容器。 */
+.game-collection-notice {
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  overflow-wrap: anywhere;
+}
+/* 我的作品 / 我的收藏页签。 */
+.game-tabs {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.4rem;
+}
+.game-tabs__button {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.25rem 0.9rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.8rem;
+  font-weight: 700;
+  cursor: pointer;
+}
+.game-tabs__button[aria-selected='true'] {
+  border-color: var(--platform-accent-strong);
+  background: rgba(199, 101, 61, 0.12);
+  color: var(--platform-accent-strong);
+}
+.game-lineage-node__compare {
+  align-self: flex-start;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.18rem 0.65rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.74rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+/* 共创主题：列表卡片与主题页（成员根 + 内嵌作品树）。 */
+.game-theme-list {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(min(18rem, 100%), 1fr));
+  gap: 0.7rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.game-theme-card {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.25rem;
+  width: 100%;
+  box-sizing: border-box;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.75rem;
+  padding: 0.8rem 0.9rem;
+  background: var(--platform-surface, #fff);
+  color: var(--platform-text-base);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+.game-theme-card:hover {
+  border-color: var(--platform-accent-strong);
+}
+.game-theme-card__badge {
+  border-radius: 999px;
+  padding: 0.1rem 0.5rem;
+  background: rgba(199, 101, 61, 0.14);
+  color: var(--platform-accent-strong);
+  font-size: 0.7rem;
+  font-weight: 700;
+}
+.game-theme-card__name {
+  color: var(--platform-text-strong);
+  font-size: 0.95rem;
+  font-weight: 700;
+  overflow-wrap: anywhere;
+}
+.game-theme-card__summary,
+.game-theme-card__meta {
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  overflow-wrap: anywhere;
+}
+.game-theme-summary {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.4rem;
+}
+.game-theme-summary__badge {
+  border-radius: 999px;
+  padding: 0.12rem 0.6rem;
+  background: rgba(199, 101, 61, 0.14);
+  color: var(--platform-accent-strong);
+  font-size: 0.74rem;
+  font-weight: 700;
+}
+.game-theme-summary__text {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.8rem;
+  line-height: 1.6;
+  overflow-wrap: anywhere;
+}
+.game-theme-summary__meta {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.8rem;
+  overflow-wrap: anywhere;
+}
+.game-theme-trees {
+  display: flex;
+  flex-direction: column;
+  gap: 1.1rem;
+}
+.game-theme-root {
+  display: flex;
+  flex-direction: column;
+  gap: 0.55rem;
+  min-width: 0;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.85rem;
+  padding: 0.8rem 0.9rem;
+}
+.game-theme-root__head {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.4rem;
+}
+.game-theme-root__generation {
+  border-radius: 999px;
+  padding: 0.1rem 0.5rem;
+  background: var(--platform-surface-border);
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+  font-weight: 700;
+}
+.game-theme-root__title {
+  margin: 0;
+  color: var(--platform-text-strong);
+  font-size: 0.95rem;
+  overflow-wrap: anywhere;
+}
+.game-theme-root__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  overflow-wrap: anywhere;
+}
+.game-theme-root__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+}
+/* 内嵌的族谱页：去掉页面级留白，避免主题页里出现两层「页面」盒。 */
+.game-lineage-page--embedded {
+  max-width: none;
+  margin: 0;
+}
+
+/*
+ * 空态/列表底部的操作区（广场「加载更多」、主题页「加载更多」、我的收藏「加载更多」共用）。
+ * 之前只有类名没有样式，窄屏上按钮与提示可能横向挤成一排 —— 这里统一成可换行、居中、不溢出的行。
+ */
+.game-empty-actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  margin-top: 1rem;
+  min-width: 0;
+}
+.game-gallery-more__error {
+  color: var(--platform-text-soft);
+  font-size: 0.8rem;
+  overflow-wrap: anywhere;
+}
+
+/*
+ * 详情页**正文之后**的整宽血缘图区块（需求 2026-10-06：图可能很大，~230px 的侧栏塞不下）。
+ * 区块内嵌族谱页组件（embedded），所以这里只需要管「区块自己的标题 + 全屏入口」这一段。
+ */
+.game-lineage-block {
+  display: flex;
+  flex-direction: column;
+  gap: 0.6rem;
+  margin-top: 1.4rem;
+  min-width: 0;
+}
+.game-lineage-block__heading {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 0.5rem;
+}
+.game-lineage-block__title {
+  display: flex;
+  flex-direction: column;
+  gap: 0.15rem;
+  min-width: 0;
+}
+.game-lineage-block__title h2 {
+  margin: 0;
+  font-size: 1.05rem;
+}
+.game-detail-info-card .game-fork-theme-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  justify-items: start;
+}
+.game-detail-info-card .game-fork-theme-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.18rem 0.6rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.74rem;
+  font-weight: 600;
+  cursor: pointer;
+  overflow-wrap: anywhere;
+}
+.game-detail-info-card .game-fork-theme-link:hover {
+  color: var(--platform-text-strong);
+}
+.game-detail-info-card .game-fork-theme-badge {
+  color: var(--platform-accent-strong);
+  font-weight: 700;
+}
+/* 共创模块（详情页）：世代/授权标签、数据概览、血缘溯源条、热门衍生栏。 */
+.game-detail-info-card .co-creation-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  justify-items: start;
+}
+.game-detail-info-card .co-creation-tag {
+  border-radius: 999px;
+  padding: 0.12rem 0.6rem;
+  font-size: 0.72rem;
+  font-weight: 700;
+}
+.game-detail-info-card .co-creation-tag--generation {
+  background: rgba(199, 101, 61, 0.14);
+  color: var(--platform-accent-strong);
+}
+.game-detail-info-card .co-creation-stats {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  font-variant-numeric: tabular-nums;
+}
+.game-detail-info-card .co-creation-stat {
+  color: var(--platform-text-soft);
+  font-size: 0.76rem;
+}
+.co-creation-fork-primary {
+  align-self: stretch;
+  justify-content: center;
+  padding: 0.45rem 0.9rem;
+  border-color: var(--platform-accent-strong);
+  background: rgba(199, 101, 61, 0.14);
+  font-size: 0.86rem;
+}
+.co-creation-fork-primary--blocked {
+  border-color: var(--platform-surface-border);
+  background: var(--platform-surface-muted, rgba(0, 0, 0, 0.04));
+  color: var(--platform-text-soft);
+  cursor: not-allowed;
+}
+/* 画布内悬浮控件（右下角）：圆角胶囊、浅色底 + 毛玻璃、内边距统一、轻阴影。 */
+.game-lineage-controls {
+  position: absolute;
+  z-index: 3;
+  right: 0.6rem;
+  bottom: 0.6rem;
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.3rem 0.4rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  background: var(--platform-surface, #fff);
+  box-shadow: 0 8px 22px rgba(76, 41, 27, 0.16);
+  backdrop-filter: blur(10px);
+}
+.game-lineage-controls__button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.25rem;
+  width: 2rem;
+  height: 2rem;
+  border: 0;
+  border-radius: 999px;
+  background: transparent;
+  color: var(--platform-text-strong);
+  font: inherit;
+  cursor: pointer;
+}
+.game-lineage-controls__button:hover:not(:disabled) {
+  background: rgba(199, 101, 61, 0.14);
+}
+.game-lineage-controls__button:disabled {
+  opacity: 0.38;
+  cursor: not-allowed;
+}
+.game-lineage-controls__button--wide {
+  width: auto;
+  padding: 0 0.65rem;
+}
+.game-lineage-controls__label {
+  font-size: 0.76rem;
+  font-weight: 600;
+}
+.game-lineage-controls__divider {
+  width: 1px;
+  height: 1.2rem;
+  background: var(--platform-surface-border);
+}
+/* 缩放读数：与 ± 按钮视觉等重、等宽对齐（数字不跳动）。 */
+.game-lineage-zoom {
+  min-width: 3.1rem;
+  text-align: center;
+  color: var(--platform-text-strong);
+  font-size: 0.86rem;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+}
+.game-lineage-summary {
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  font-variant-numeric: tabular-nums;
+}
+@media (max-width: 820px) {
+  .game-lineage-controls__label {
+    display: none;
+  }
+  .game-lineage-controls__button--wide {
+    width: 2rem;
+    padding: 0;
+  }
+}
+
+/*
+ * 族谱树可视化：一个可平移/缩放的画布 + 内容层（CSS transform）。
+ * 连线在 SVG 里（坐标就是内容层坐标，随内容层一起缩放），节点是绝对定位的真实 HTML 卡片
+ * —— 因为节点要真的可点击 / 可聚焦 / 可读屏，不能画成 SVG 矩形。
+ */
+.game-lineage-viewport-controls {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.5rem;
+}
+.game-lineage-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+}
+.game-lineage-fork-notice {
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  overflow-wrap: anywhere;
+}
+.game-lineage-fork-copy {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.2rem 0.7rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.74rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.game-lineage-canvas {
+  position: relative;
+  height: clamp(22rem, 62vh, 46rem);
+  max-width: 100%;
+  overflow: hidden;
+  /* 默认态分支色板：同一顶级分支的节点与连线共用一种色系。 */
+  --lineage-branch-0: #8a6cb4;
+  --lineage-branch-1: #4e8f8a;
+  --lineage-branch-2: #b4763a;
+  --lineage-branch-3: #5d7fb0;
+  --lineage-branch-4: #a8556f;
+  --lineage-branch-5: #6b8f4e;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.85rem;
+  background: radial-gradient(
+      circle at 1px 1px,
+      var(--platform-surface-border) 1px,
+      transparent 0
+    )
+    0 0 / 22px 22px;
+  cursor: grab;
+  /* 拖动平移的交互硬化（2026-10-07）：
+   * - `touch-action: none`：拖拽不触发浏览器自身的滚动/缩放，触屏同手势也不打架；
+   * - `user-select: none`：按住拖动不选中文本（否则再拖会把文字拖走）；
+   * - `overscroll-behavior: contain`：滚轮到边界也不把滚动链交给外部页面。 */
+  touch-action: none;
+  user-select: none;
+  -webkit-user-select: none;
+  overscroll-behavior: contain;
+}
+.game-lineage-canvas--panning {
+  cursor: grabbing;
+}
+/* 画布里的图片不参与原生拖拽（否则会出现「把封面图拖走」）。 */
+.game-lineage-canvas img,
+.game-lineage-canvas .game-cover__image {
+  -webkit-user-drag: none;
+  user-drag: none;
+  pointer-events: none;
+}
+.game-lineage-canvas:active {
+  cursor: grabbing;
+}
+.game-lineage-canvas__content {
+  position: absolute;
+  top: 0;
+  left: 0;
+  transform-origin: 0 0;
+  transition: transform 180ms ease-out;
+  will-change: transform;
+}
+/* 顶部筛选器（文档「顶部操作栏」）：世代 / 热度排序 / 改动类型（待字段，禁用）。 */
+.game-lineage-filters {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.5rem;
+}
+.game-lineage-filter {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+}
+.game-lineage-filter select {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.5rem;
+  padding: 0.15rem 0.35rem;
+  background: var(--platform-surface, #fff);
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.78rem;
+}
+.game-lineage-filter--disabled {
+  opacity: 0.55;
+}
+.game-lineage-filter__note {
+  color: var(--platform-text-soft);
+  font-size: 0.7rem;
+}
+/* 主干线：文档要求「每代热度最高的版本用粗实线连接」。 */
+.game-lineage-edge--trunk {
+  stroke-width: 6;
+}
+/* 「主干」角标 = 暖色（强调）。定位/尺寸由角标组统一管。 */
+.game-lineage-node__trunk {
+  border: 1px solid var(--platform-warm-border);
+  background: var(--platform-warm-bg);
+  color: var(--platform-warm-text);
+  font-weight: 700;
+}
+/* 右侧信息面板：浮动叠加在画布右上（控件在右下，避免互相遮挡）。 */
+.game-lineage-panel {
+  position: absolute;
+  z-index: 4;
+  top: 0.6rem;
+  right: 0.6rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.3rem;
+  width: min(18rem, calc(100% - 1.2rem));
+  max-height: calc(100% - 4.5rem);
+  overflow-y: auto;
+  padding: 0.7rem 0.8rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.8rem;
+  background: var(--platform-surface, #fff);
+  box-shadow: 0 10px 26px rgba(76, 41, 27, 0.18);
+}
+.game-lineage-panel__title {
+  margin: 0;
+  color: var(--platform-text-strong);
+  font-size: 0.9rem;
+  overflow-wrap: anywhere;
+}
+.game-lineage-panel__meta,
+.game-lineage-panel__note,
+.game-lineage-panel__summary {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.76rem;
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}
+.game-lineage-panel__summary {
+  color: var(--platform-text-base);
+}
+.game-lineage-panel__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+  margin-top: 0.15rem;
+}
+.game-lineage-panel__button {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.2rem 0.7rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.76rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.game-lineage-panel__button--primary {
+  border-color: var(--platform-accent-strong);
+  background: rgba(199, 101, 61, 0.14);
+  color: var(--platform-accent-strong);
+}
+.game-lineage-canvas__edges {
+  position: absolute;
+  top: 0;
+  left: 0;
+  overflow: visible;
+  pointer-events: none;
+}
+.game-lineage-edge {
+  fill: none;
+  /* 默认态就按顶级分支着色（同一分支同色系），不必等 hover 也能读出「共创路径」。 */
+  stroke: var(--lineage-branch, var(--platform-text-base));
+  opacity: 0.9;
+  /* 缩到 35% 时线不能细到看不见：non-scaling-stroke 让线宽与屏幕像素绑定，不随缩放变化。 */
+  vector-effect: non-scaling-stroke;
+  stroke-width: 3;
+  transition:
+    stroke 160ms ease,
+    opacity 160ms ease;
+}
+.game-lineage-edge--active {
+  stroke: var(--platform-accent-strong);
+  stroke-width: 5.5;
+  opacity: 1;
+  filter: drop-shadow(0 0 4px rgba(199, 101, 61, 0.45));
+}
+.game-lineage-edge--dimmed {
+  opacity: 0.08;
+}
+/* 代际轴：画布左侧的固定层（在内容层的 transform 之外），放大/平移后仍然可读、不被裁。
+   背景用平台 surface 淡色调（**不是白色条**），每个代际行只画一条分隔线，
+   因此整体看起来是一条连续的轴，而不是一条条白条。 */
+.game-lineage-canvas__axis {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  width: 96px;
+  pointer-events: none;
+  border-right: 1px solid var(--platform-surface-border);
+  background: var(--platform-surface-muted, rgba(104, 54, 36, 0.055));
+}
+.game-lineage-axis {
+  position: absolute;
+  left: 0;
+  right: 0;
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  gap: 0.3rem;
+  padding-left: 0.55rem;
+  border-top: 1px solid var(--platform-surface-border);
+  color: var(--platform-text-strong);
+  font-size: 0.76rem;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+.game-lineage-axis__count {
+  border-radius: 999px;
+  padding: 0.05rem 0.45rem;
+  background: var(--platform-surface, #fff);
+  color: var(--platform-text-soft);
+  font-size: 0.68rem;
+  font-weight: 600;
+}
+.game-lineage-node {
+  position: absolute;
+  box-sizing: border-box;
+  cursor: pointer;
+  transition:
+    opacity 160ms ease,
+    box-shadow 160ms ease;
+}
+.game-lineage-node--dimmed {
+  opacity: 0.34;
+}
+/* 高亮分三档，差异要肉眼可见：路径节点（强调边 + 淡强调环）、仅子树节点（强调虚线边）、
+   目标节点（2px 强调边 + 更粗的环）。容器已透明，因此这些表达都落在**卡片**上；
+   环叠在卡片自身的轻阴影之前，所以高亮时不会把阴影吃掉。 */
+.game-lineage-node--path .game-card--lineage {
+  border-color: var(--platform-accent-strong);
+  box-shadow:
+    0 0 0 2px rgba(199, 101, 61, 0.28),
+    var(--lineage-card-shadow);
+}
+.game-lineage-node--subtree .game-card--lineage {
+  border-color: var(--platform-accent-strong);
+  border-style: dashed;
+}
+.game-lineage-node--pinned .game-card--lineage {
+  border-style: solid;
+  border-width: 2px;
+  box-shadow:
+    0 0 0 3px rgba(199, 101, 61, 0.22),
+    var(--lineage-card-shadow);
+}
+.game-lineage-breadcrumb {
+  position: absolute;
+  z-index: 2;
+  top: 0.4rem;
+  left: 0.5rem;
+  right: 0.5rem;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.25rem 0.4rem;
+  border-radius: 999px;
+  background: var(--platform-surface, #fff);
+  box-shadow: 0 1px 6px rgba(0, 0, 0, 0.12);
+  font-size: 0.72rem;
+}
+.game-lineage-breadcrumb__item {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  color: var(--platform-text-soft);
+}
+.game-lineage-breadcrumb__crumb,
+.game-lineage-breadcrumb__clear {
+  border: none;
+  padding: 0.1rem 0.3rem;
+  border-radius: 999px;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.72rem;
+  cursor: pointer;
+  overflow-wrap: anywhere;
+}
+.game-lineage-breadcrumb__crumb:hover,
+.game-lineage-breadcrumb__clear:hover {
+  color: var(--platform-text-strong);
+  background: rgba(199, 101, 61, 0.12);
+}
+/* 窄屏紧凑卡：卡片更小、标题字号相对更大、字段更少（作者行不渲染）；封面仍是 16:9。 */
+.game-lineage-node--compact .game-lineage-node__title {
+  font-size: 0.88rem;
+}
+.game-lineage-node--compact .game-lineage-node__badge {
+  font-size: 0.72rem;
+}
+.game-lineage-node__pin {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.14rem 0.6rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.72rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.game-lineage-node__pin[aria-pressed='true'] {
+  border-color: var(--platform-accent-strong);
+  color: var(--platform-accent-strong);
+}
+.game-lineage-node--stub {
+  cursor: default;
+}
+/* 占位节点（父作品不可用）的虚线边同样落在**卡片**上（容器已透明）。 */
+.game-lineage-node--stub .game-card--lineage {
+  border-style: dashed;
+}
+/* 焦点环也贴在**卡片**上（容器盒子比卡片大 12.8px，环画在容器上会离卡一圈空白）。 */
+.game-lineage-node:focus-visible {
+  outline: none;
+}
+.game-lineage-node:focus-visible .game-card--lineage {
+  outline: 2px solid var(--platform-accent-strong);
+  outline-offset: 2px;
+}
+.game-lineage-node__title {
+  color: var(--platform-text-strong);
+  font-size: 0.9rem;
+  font-weight: 700;
+  overflow-wrap: anywhere;
+}
+/* 链节点与画布卡片共用的内容布局（LineageNodeContent）。 */
+.game-lineage-node__content {
+  display: flex;
+  min-width: 0;
+}
+.game-lineage-node__content--stacked {
+  flex-direction: column;
+  gap: 0;
+  width: 100%;
+}
+.game-lineage-node__content--inline {
+  flex-direction: row;
+  align-items: center;
+  gap: 0.5rem;
+  width: 100%;
+  min-width: 0;
+  padding: 0.15rem 0;
+}
+
+/*
+ * 角标组：代际 / 主干 / 当前作品 / 父代-子代 的**唯一排版容器**（flex + gap + 可换行）。
+ *
+ * 为什么必须成组：这几枚角标以前各自 position: absolute（代际左上、主干右上、「当前作品」在流内），
+ * 在窄容器里会叠印成乱码字形（大纲行的「第 1 代」与「主干」就是这个问题）。
+ * 现在它们同组排布 —— 重叠在结构上不可能发生，画布与大纲共用同一组角标。
+ */
+.game-lineage-node__badges {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.25rem;
+  min-width: 0;
+}
+/*
+ * 角标配色表（每类语义一色，**全部取自平台既有 `--platform-*` 变量，不新增色值**）：
+ *   代际 = 中性  ｜ 主干 = 暖色（强调）  ｜ 当前作品 = 主色实心
+ *   父代 = cool  ｜ 子代 = success  ｜ ▶游玩数 = 中性
+ * 全部带 1px 边框（浅色卡片上也有边界）；组内静态定位 + flex + gap（永不重叠）。
+ */
+/* 组内角标一律静态定位（颜色 / 圆角仍由各自规则给）。 */
+.game-lineage-node__badges .game-lineage-node__badge,
+.game-lineage-node__badges .game-lineage-node__trunk,
+.game-lineage-node__badges .game-lineage-node__anchor,
+.game-lineage-node__badges .game-lineage-node__play-count,
+.game-lineage-node__badges .game-lineage-node__relation {
+  position: static;
+  top: auto;
+  right: auto;
+  bottom: auto;
+  left: auto;
+  margin: 0;
+  border-radius: 999px;
+  padding: 0.05rem 0.4rem;
+  font-size: 0.6rem;
+  line-height: 1.6;
+  white-space: nowrap;
+}
+/* 画布卡片：角标组在**封面下方**的信息区第一行（不再压封面、不再用深色药丸浮在图上）。 */
+.game-lineage-node__content--stacked .game-lineage-node__badges {
+  justify-content: flex-start;
+  padding: 0.35rem 0.5rem 0;
+}
+/* 大纲行：角标组在封面右侧、操作左侧，靠右对齐，标题占满剩余空间。 */
+.game-lineage-node__content--inline .game-lineage-node__badges {
+  flex: 0 1 auto;
+  justify-content: flex-end;
+}
+.game-lineage-node__text {
+  display: flex;
+  flex-direction: column;
+  gap: 0.15rem;
+  min-width: 0;
+  flex: 1 1 auto;
+}
+/* 防逐字换行：min-width:0 让 flex 子项可收缩，标题 2 行截断（line-clamp）+ 省略号。 */
+.game-lineage-node__title {
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  overflow-wrap: anywhere;
+  word-break: normal;
+}
+
+/*
+ * 画布卡片：标题按真实行数占高（1 行 = 1 行）。
+ * 「同层等高」现在由**布局**负责：`buildLineageTreeLayout` 给同层每个节点同一个 `height`
+ * （= 该层最高卡片的估算高度），卡片按 `min-height` 撑到它 —— 所以不再需要用
+ * `min-height` 把每一行标题都硬撑成 2 行（那会让所有卡片白高一行）。
+ */
+/* 作者行：独立一行、更小更淡（与标题拉开层级）。 */
+.game-lineage-node__meta {
+  display: flex;
+  min-width: 0;
+  gap: 0.3rem;
+  overflow: hidden;
+  color: var(--platform-text-muted);
+  font-size: 0.7rem;
+  font-weight: 500;
+}
+.game-lineage-node__author {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+/* 链节点：横版小缩略图（64×36），矮而宽，触控目标 ≥44px。 */
+.game-lineage-node__content--inline .game-lineage-node__cover {
+  flex: 0 0 auto;
+  width: 4.5rem;
+  height: auto;
+  /* 与画布统一的 16:9 横版缩略图（曾在大纲行里被角标撑成窄竖条）。 */
+  aspect-ratio: 16 / 9;
+  border-radius: 0.35rem;
+}
+.game-lineage-node__content--inline .game-lineage-node__badge,
+.game-lineage-node__content--inline .game-lineage-node__anchor {
+  font-size: 0.6rem;
+  padding: 0.05rem 0.35rem;
+}
+
+/* 卡片主体 = 选中；标题/封面 = 打开详情。封面做主视觉（大图 + 圆角 + 轻阴影）。
+   容器不裁切（`visible`）：卡片自身的阴影/高亮环不能被容器 `overflow: hidden` 切掉。 */
+.game-lineage-node {
+  overflow: visible;
+}
+.game-lineage-node__open {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  width: 100%;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+/*
+ * 游玩次数角标：**该节点的子树合计**（`collectLineagePlayCountTotals().total`，口径见 §3.6.3）。
+ * 紧凑 pill（▶ N）+ `title` 说明「含衍生作品」，与其它角标同行所以**不撑高卡片**；全 0 也显示。
+ * 注意：主干线 / 热度排序的判据是**自身** playCount，与这个显示口径不同。
+ */
+.game-lineage-node__play-count {
+  border: 1px solid var(--platform-neutral-border);
+  background: var(--platform-neutral-bg);
+  color: var(--platform-text-base);
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+}
+
+.game-lineage-node__cover {
+  position: relative;
+  display: block;
+  width: 100%;
+  /* 横版封面：比例由 LINEAGE_COVER_ASPECT 内联给出（16:9，与发布面板封面预览一致）。 */
+  overflow: hidden;
+  background: var(--platform-surface-border);
+}
+.game-lineage-node__cover img,
+.game-lineage-node__cover .game-cover__image {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+.game-lineage-node__cover .game-cover {
+  width: 100%;
+  height: 100%;
+  border-radius: 0;
+}
+/* 代际角标 = 中性。定位/尺寸由角标组统一管。 */
+.game-lineage-node__badge {
+  border: 1px solid var(--platform-neutral-border);
+  background: var(--platform-neutral-bg);
+  color: var(--platform-neutral-text);
+  font-weight: 700;
+}
+.game-lineage-node__strip {
+  display: flex;
+  flex-direction: column;
+  gap: 0.1rem;
+  min-width: 0;
+  padding: 0.4rem 0.55rem 0.45rem;
+}
+.game-lineage-node__stub-body {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  padding: 0.7rem 0.8rem;
+  min-width: 0;
+}
+/* 卡片底部操作行：两个**等权重**按钮并排（等宽、同高、同圆角），窄卡允许换行但不裁切。 */
+.game-lineage-node__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+  padding: 0.45rem 0.5rem 0.55rem;
+}
+.game-lineage-node__actions > button {
+  flex: 1 1 0;
+  min-width: 6.4rem;
+  min-height: 2rem;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 999px;
+  padding: 0 0.6rem;
+  font: inherit;
+  font-size: 0.74rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+/* 次要动作（描边）。 */
+.game-lineage-node__actions > .game-lineage-node__open-action {
+  border: 1px solid var(--platform-surface-border);
+  background: var(--platform-button-secondary-fill);
+  color: var(--platform-button-secondary-text);
+}
+/* 主要动作 = 开始共创（填充/着色）。 */
+.game-lineage-node__fork {
+  border: 1px solid var(--platform-button-primary-border);
+  background: var(--platform-button-primary-solid);
+  color: var(--platform-button-primary-text);
+  font: inherit;
+  cursor: pointer;
+}
+.game-lineage-node__fork:hover {
+  color: var(--platform-text-strong);
+}
+.game-lineage-zoom {
+  color: var(--platform-text-soft);
+  font-size: 0.76rem;
+  font-variant-numeric: tabular-nums;
+}
+/* 尊重「减少动效」偏好：只保留状态变化，不做过渡动画。 */
+@media (prefers-reduced-motion: reduce) {
+  .game-lineage-canvas__content,
+  .game-lineage-node,
+  .game-lineage-edge {
+    transition: none;
+  }
+}
+/* 窄屏：节点尺寸适合触摸，画布可横向平移（内容层平移而不是页面溢出）。 */
+@media (max-width: 820px) {
+  .game-lineage-canvas {
+    height: clamp(20rem, 56vh, 34rem);
+  }
+}
 .game-loading-panel {
   display: grid;
   min-height: 18rem;
@@ -652,6 +1832,7 @@
 .my-game-card__actions {
   display: flex;
   flex-wrap: wrap;
+  align-items: center;
   gap: 0.5rem;
   margin-top: auto;
   padding-top: 0.35rem;
@@ -673,6 +1854,16 @@
   background: var(--platform-button-danger-fill);
   color: var(--platform-button-danger-text);
 }
+.my-game-status--fork-full {
+  background: rgba(199, 101, 61, 0.14);
+  color: var(--platform-accent-strong);
+}
+.my-game-card__fork-confirm {
+  flex: 1 1 100%;
+  color: var(--platform-text-soft);
+  font-size: 0.72rem;
+  line-height: 1.5;
+}
 @media (max-width: 560px) {
   .my-game-card {
     flex-direction: column;
@@ -1052,3 +2243,874 @@
     width: clamp(7rem, 14vw, 12rem);
   }
 }
+
+/*
+ * 创作族谱页。树按代际分段，每段用自适应网格排节点卡片：窄屏单列、宽屏多列，
+ * 长标题与较大的游玩数都靠 `overflow-wrap: anywhere` + 网格换行收在容器内，
+ * 不产生横向溢出，也不需要桌面端才有的交互。
+ */
+.game-lineage-page {
+  max-width: 70rem;
+  margin: 0 auto;
+  display: flex;
+  flex-direction: column;
+  gap: 0.9rem;
+}
+.game-lineage-notice {
+  margin: 0;
+  padding: 0.6rem 0.8rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.6rem;
+  background: var(--platform-surface-muted, rgba(0, 0, 0, 0.02));
+  color: var(--platform-text-base);
+  font-size: 0.82rem;
+  line-height: 1.6;
+  overflow-wrap: anywhere;
+}
+.game-lineage-notice--muted {
+  color: var(--platform-text-soft);
+}
+.game-lineage-retry {
+  margin-left: 0.6rem;
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  padding: 0.2rem 0.7rem;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-size: 0.78rem;
+  cursor: pointer;
+}
+.game-lineage-node {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  min-width: 0;
+  /*
+   * 容器**完全透明**：页面上只应看到卡片本身。
+   * 用户口径（截图里卡片后面那块浅色圆角板）：「有个背景，应该只需要这张卡片，可以稍微做点阴影」
+   * —— 背景 / 边框 / 圆角 / 阴影全部搬到**卡片自身**（`.game-card--lineage`），
+   * 高亮也改成作用在卡片上（见下面的 `--path/--subtree/--pinned/--anchor` 那组）。
+   * 内边距只用于「卡宽 → 节点盒宽」的换算，与 `LINEAGE_NODE_PADDING_X/Y` 同源（页面下发变量）。
+   */
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  box-shadow: none;
+  padding: var(--lineage-node-pad-y, 11.2px) var(--lineage-node-pad-x, 12.8px);
+}
+/* 「当前作品」：强调描边 + 一圈淡强调环（环作用在**卡片**上，容器已透明）。 */
+.game-lineage-node--anchor .game-card--lineage {
+  border-color: var(--platform-accent-strong);
+  box-shadow:
+    0 0 0 2px rgba(199, 101, 61, 0.18),
+    var(--lineage-card-shadow);
+}
+.game-lineage-node__head {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.4rem;
+}
+.game-lineage-node__generation,
+.game-lineage-node__anchor {
+  border-radius: 999px;
+  padding: 0.1rem 0.5rem;
+  font-size: 0.7rem;
+  font-weight: 700;
+}
+.game-lineage-node__generation {
+  background: var(--platform-surface-border);
+  color: var(--platform-text-soft);
+}
+/* 「当前作品」= 主色实心（最强的一枚）。 */
+.game-lineage-node__anchor {
+  border: 1px solid var(--platform-accent);
+  background: var(--platform-accent);
+  color: var(--platform-button-primary-text);
+  font-weight: 700;
+}
+.game-lineage-node__title {
+  border: none;
+  padding: 0;
+  background: transparent;
+  color: var(--platform-text-strong);
+  font: inherit;
+  font-size: 0.95rem;
+  font-weight: 700;
+  text-align: left;
+  overflow-wrap: anywhere;
+  cursor: pointer;
+}
+.game-lineage-node__title:hover {
+  text-decoration: underline;
+}
+.game-lineage-node__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  overflow-wrap: anywhere;
+}
+.game-lineage-node__parent-unavailable {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.74rem;
+}
+
+/*
+ * 我的作品页「被改编 N」行内展开：与版本历史同一节奏，不挤占动作行的位置。
+ */
+.my-game-card__derived-toggle {
+  align-self: flex-start;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.2rem 0.7rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.76rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.my-game-card__derived-toggle:hover:not(:disabled) {
+  color: var(--platform-text-strong);
+}
+.my-game-card__derived {
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.6rem;
+  padding: 0.6rem 0.7rem;
+  background: var(--platform-surface-muted, rgba(0, 0, 0, 0.02));
+}
+.my-game-card__derived-empty,
+.my-game-card__derived-error,
+.my-game-card__derived-truncated {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  overflow-wrap: anywhere;
+}
+.my-game-card__derived-item {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.4rem;
+  min-width: 0;
+}
+.my-game-card__derived-title {
+  border: none;
+  padding: 0;
+  background: transparent;
+  color: var(--platform-text-strong);
+  font: inherit;
+  font-size: 0.85rem;
+  font-weight: 700;
+  text-align: left;
+  overflow-wrap: anywhere;
+  cursor: pointer;
+}
+.my-game-card__derived-title:hover {
+  text-decoration: underline;
+}
+.my-game-card__derived-meta {
+  color: var(--platform-text-soft);
+  font-size: 0.76rem;
+  overflow-wrap: anywhere;
+}
+/* 个人创作数据概览（我的作品页）：与详情页共创模块同一视觉语言。 */
+.co-creation-overview {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.8rem;
+  padding: 0.55rem 0.7rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 0.7rem;
+  background: var(--platform-surface-muted, rgba(104, 54, 36, 0.04));
+}
+.co-creation-overview .co-creation-stat {
+  color: var(--platform-text-soft);
+  font-size: 0.78rem;
+  font-variant-numeric: tabular-nums;
+}
+
+/*
+ * 移动端「大纲式缩进树」（默认形态）：全宽行 + 左缩进 + 肘形导线，**无横向滚动**。
+ * 每行 ≥44px 触控目标；点击行=选中，行内「打开 / 开始共创」是次要动作。
+ */
+.lineage-outline {
+  display: flex;
+  flex-direction: column;
+  gap: 0.15rem;
+  /* 内容列限宽 + 居中：大纲不再整屏出血（宽屏上曾是 1300px+ 横条，中间大片空白）。
+     操作按钮固定在行右端 = 内容列右端，不会飘到屏幕最右侧。 */
+  margin: 0 auto;
+  padding: 0;
+  list-style: none;
+  width: 100%;
+  max-width: 54rem;
+  overflow-x: hidden;
+}
+.lineage-outline__row {
+  display: flex;
+  align-items: center;
+  gap: 0.2rem;
+  min-width: 0;
+  max-width: 100%;
+  /* 统一基线：所有行同高（缩略图 16:9 + 标题最多 2 行），卡片高度不再参差。 */
+  min-height: 3.5rem;
+  box-sizing: border-box;
+}
+.lineage-outline__guide {
+  flex: 0 0 auto;
+  width: 1.1rem;
+  color: var(--platform-surface-border);
+  font-size: 0.8rem;
+  line-height: 1;
+  text-align: center;
+}
+/* 主干链的导线加粗并用主题色（与桌面「主干线粗实线」同语义）。 */
+.lineage-outline__guide--trunk {
+  color: var(--platform-accent-strong);
+  font-weight: 700;
+}
+.lineage-outline__main {
+  display: block;
+  flex: 1 1 auto;
+  min-width: 0;
+  min-height: 2.75rem;
+  border: 1px solid transparent;
+  border-radius: 0.6rem;
+  padding: 0.3rem 0.4rem;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+.lineage-outline__row--selected .lineage-outline__main,
+.lineage-outline__main--current {
+  border-color: var(--platform-accent-strong);
+  background: rgba(199, 101, 61, 0.12);
+}
+.lineage-outline__action {
+  flex: 0 0 auto;
+  min-height: 2.4rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0 0.7rem;
+  background: var(--platform-surface, #fff);
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.76rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+/* 大纲行的两个动作与画布卡片同一套主次：打开作品 = 描边（次要），开始共创 = 填充（主要）。 */
+.lineage-outline__action--co-create {
+  border-color: var(--platform-button-primary-border);
+  background: var(--platform-button-primary-solid);
+  color: var(--platform-button-primary-text);
+}
+.lineage-outline__actions {
+  display: flex;
+  flex: 0 0 auto;
+  gap: 0.25rem;
+  /* 与标题同一视觉组：贴文字右侧、行内右端，不跨出限宽内容列。 */
+  margin-left: 0.25rem;
+}
+/* 大纲行里的标题：单行省略（不逐字换行）。 */
+.lineage-outline .game-lineage-node__title {
+  -webkit-line-clamp: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.lineage-outline .game-lineage-node__meta {
+  font-size: 0.72rem;
+  color: var(--platform-text-soft);
+}
+.lineage-filter__switch,
+.game-lineage-filter__switch {
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.25rem 0.8rem;
+  background: var(--platform-surface, #fff);
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.78rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+/* 开关按下态：明确的可视反馈（不是只靠 aria-pressed 属性）。 */
+.game-lineage-filter__switch[aria-pressed='true'] {
+  border-color: var(--platform-accent-strong);
+  background: rgba(199, 101, 61, 0.12);
+  color: var(--platform-accent-strong);
+}
+/*
+ * 视图形态分段控件（图谱视图 / 大纲视图 两个常驻按钮）：
+ * 挨在一起、间距收紧，读起来是「一组里选一个」，而不是两个互不相干的开关。
+ */
+.game-lineage-filter__group {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+}
+
+/*
+ * 「父代 / 子代」角标：**可读文本**（不是只靠颜色深浅），所以可断言、读屏也能读到；
+ * 自己是「当前作品」角标、旁支不标注。颜色只是辅助表达。
+ */
+.game-lineage-node__relation {
+  align-self: flex-start;
+  padding: 0 0.35rem;
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  font-size: 0.62rem;
+  line-height: 1.6;
+  white-space: nowrap;
+}
+/* 父代 = cool 色系。 */
+.game-lineage-node__relation--ancestor {
+  border: 1px solid var(--platform-cool-border);
+  background: var(--platform-cool-bg);
+  color: var(--platform-cool-text);
+  font-weight: 700;
+}
+/* 子代 = success 色系。 */
+.game-lineage-node__relation--descendant {
+  border: 1px solid var(--platform-success-border);
+  background: var(--platform-success-bg);
+  color: var(--platform-success-text);
+  font-weight: 700;
+}
+/* 画布卡片按角色加描边（辅助：主表达仍是上面的角标与 data-relation）。 */
+.game-lineage-node[data-relation='ancestor'] {
+  border-color: var(--platform-accent-strong);
+}
+.lineage-outline__row[data-relation='ancestor'] .lineage-outline__main {
+  border-left: 3px solid var(--platform-accent-strong);
+}
+.lineage-outline__row[data-relation='descendant'] .lineage-outline__main {
+  border-left: 3px solid var(--platform-surface-border);
+}
+.game-lineage-filter__switch[aria-pressed='true'] {
+  border-color: var(--platform-accent-strong);
+  color: var(--platform-accent-strong);
+}
+/* 移动端信息面板 = bottom sheet：底部升起、可下拉关闭（遮罩点击关闭）。 */
+.game-lineage-sheet-backdrop {
+  position: absolute;
+  inset: 0;
+  z-index: 3;
+  border: 0;
+  padding: 0;
+  background: rgba(0, 0, 0, 0.32);
+  cursor: pointer;
+}
+.game-lineage-panel--sheet {
+  /* bottom sheet 用 fixed：不依赖页面里有没有定位祖先。 */
+  position: fixed;
+  top: auto;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  width: 100%;
+  max-height: 70%;
+  border-radius: 1rem 1rem 0 0;
+  /* 底部安全区：iPhone 手势条不被内容压住。 */
+  padding-bottom: calc(0.9rem + env(safe-area-inset-bottom, 0px));
+  box-shadow: 0 -8px 24px rgba(0, 0, 0, 0.22);
+}
+.game-lineage-panel__close {
+  align-self: flex-end;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  padding: 0.15rem 0.7rem;
+  background: transparent;
+  color: var(--platform-text-base);
+  font: inherit;
+  font-size: 0.76rem;
+  cursor: pointer;
+}
+/* 面包屑：移动端横向可滚动，当前项常驻可见（组件里用 scrollIntoView 保证）。 */
+.game-lineage-breadcrumb {
+  overflow-x: auto;
+  overflow-y: hidden;
+  flex-wrap: nowrap;
+}
+.game-lineage-breadcrumb__item {
+  flex: 0 0 auto;
+}
+/* 移动端：画布高度更紧凑，悬浮控件只留图标（已有规则），并给底部安全区留白。 */
+@media (max-width: 820px) {
+  .game-lineage-canvas {
+    height: clamp(18rem, 52vh, 30rem);
+  }
+  .game-lineage-page {
+    padding-bottom: env(safe-area-inset-bottom, 0px);
+  }
+}
+
+/*
+ * 图谱下方的「父代 / 子代」两块清单（2026-10-07）：与大纲同一套行样式（复用 LineageNodeContent），
+ * 只把列表收窄到内容列宽并居中，避免又变成整屏出血的横条。
+ */
+.lineage-relations {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  margin-top: 1.25rem;
+}
+.lineage-relation {
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+}
+.lineage-relation__title {
+  display: flex;
+  align-items: baseline;
+  gap: 0.4rem;
+  margin: 0;
+  font-size: 0.95rem;
+  font-weight: 700;
+}
+.lineage-relation__count {
+  border: 1px solid var(--platform-neutral-border);
+  border-radius: 999px;
+  padding: 0 0.4rem;
+  background: var(--platform-neutral-bg);
+  color: var(--platform-neutral-text);
+  font-size: 0.7rem;
+  font-weight: 600;
+}
+.lineage-relation__hint {
+  color: var(--platform-text-muted);
+  font-size: 0.72rem;
+  font-weight: 500;
+}
+.lineage-relation__empty {
+  margin: 0;
+  color: var(--platform-text-soft);
+  font-size: 0.8rem;
+}
+
+/*
+ * 「开始共创」在主操作行里：**必须与「开始游戏」同一套视觉权重**。
+ *
+ * 为什么需要这段：按钮原先住在 `.game-detail-info-card` 里，样式被卡内作用域套着
+ * （`.game-detail-info-card .game-fork-remix-link` / `.co-creation-fork-primary`）；
+ * 搬到 `actions` 主操作行后**选择器不再命中**，按钮退回浏览器默认样式（细边框 + 无内边距），
+ * 于是与「开始游戏」不是一个量级。这里把它按平台主操作按钮的度量固定下来（实心强调、lg 高度）。
+ */
+.game-fork-remix-link.co-creation-fork-primary {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  align-self: center;
+  gap: 0.35rem;
+  /* 与主操作行里的「开始游戏」逐项对齐（实测：高 48 / 圆角 16 / 内边距 0 16 / 字号 15）。 */
+  min-height: 3rem;
+  padding: 0 1rem;
+  border: 1px solid var(--platform-button-primary-border);
+  border-radius: 1rem;
+  background: var(--platform-button-primary-solid);
+  color: var(--platform-button-primary-text);
+  font: inherit;
+  font-size: 0.94rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.game-fork-remix-link.co-creation-fork-primary:hover {
+  background: var(--platform-accent-strong, var(--platform-accent));
+}
+/*
+ * 游客（只玩游戏）的「开始共创」入口：**不占重点色**、缩成次要小按钮。
+ *
+ * 为什么：产品口径里普通用户是「玩游戏的」，共创是共创者（开发游戏的人）的主操作，
+ * 游客不该被一个实心强调的大按钮抢走注意力。但它**仍然可点**（点击走登录门禁），
+ * 所以这不是 disabled 样式 —— 用平台既有的次要按钮变量（描边 + 次要底色），
+ * 尺寸降到 32px 高 / 0.78rem（共创者那份主操作是 48px / 0.94rem），差异可量。
+ */
+.game-fork-remix-link.game-fork-remix-guest {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  align-self: center;
+  /* 与主操作行里的「收藏」(sm) 同量级，明显小于「开始游戏」(lg)。 */
+  min-height: 2rem;
+  padding: 0 0.75rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  background: var(--platform-button-secondary-fill);
+  color: var(--platform-button-secondary-text);
+  font: inherit;
+  font-size: 0.78rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.game-fork-remix-link.game-fork-remix-guest:hover {
+  border-color: var(--platform-surface-hover-border);
+  background: var(--platform-surface-muted, rgba(0, 0, 0, 0.04));
+}
+/* 禁止共创：置灰但可点（点了给原因），与平台 disabled 观感一致。 */
+.co-creation-fork-primary--blocked,
+.game-fork-remix-link.co-creation-fork-primary--blocked {
+  border-color: var(--platform-surface-border);
+  background: var(--platform-surface-muted, rgba(0, 0, 0, 0.04));
+  color: var(--platform-text-soft);
+  cursor: not-allowed;
+}
+/* 「全屏查看族谱」= 次级动作（描边），别和主操作抢焦点。 */
+.game-fork-lineage-link {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  align-self: center;
+  min-height: 2rem;
+  padding: 0 0.85rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  background: var(--platform-button-secondary-fill);
+  color: var(--platform-button-secondary-text);
+  font: inherit;
+  font-size: 0.82rem;
+  font-weight: 600;
+  cursor: pointer;
+  white-space: nowrap;
+}
+.game-fork-lineage-link:hover {
+  border-color: var(--platform-surface-hover-border);
+}
+
+/*
+ * 「全屏查看族谱」的真·全屏 overlay：portal 到 body + position:fixed inset:0，
+ * 因此不受详情页/平台 tab 面板的宽度、max-width、overflow 约束（之前是路由跳转，名不副实）。
+ * 移动端同样整屏，并给刘海/底部条留安全区。
+ */
+.lineage-fullscreen {
+  position: fixed;
+  inset: 0;
+  z-index: 90;
+  display: flex;
+  flex-direction: column;
+  background: var(--platform-body-fill, #fff);
+  padding-top: env(safe-area-inset-top);
+  padding-right: env(safe-area-inset-right);
+  padding-bottom: env(safe-area-inset-bottom);
+  padding-left: env(safe-area-inset-left);
+}
+.lineage-fullscreen__bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+  padding: 0.55rem 1rem;
+  border-bottom: 1px solid var(--platform-surface-border);
+  background: var(--platform-surface, #fff);
+}
+.lineage-fullscreen__title {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 700;
+}
+.lineage-fullscreen__close {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 2.25rem;
+  padding: 0 1rem;
+  border: 1px solid var(--platform-surface-border);
+  border-radius: 999px;
+  background: var(--platform-button-secondary-fill);
+  color: var(--platform-button-secondary-text);
+  font: inherit;
+  font-size: 0.85rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+.lineage-fullscreen__body {
+  flex: 1 1 auto;
+  min-height: 0;
+  /* overlay 自己滚：画布先占满一屏，父代/子代清单接在下面（不挤压画布）。
+     两条滚动条（overlay + 画布）都保留，各自负责各的内容。 */
+  overflow: auto;
+  padding: 0.5rem 1rem 1rem;
+}
+/*
+ * 全屏模式下画布**吃满一屏**：高度 = 视口 − 头部栏 − 筛选/控件两行（`--lineage-overlay-chrome`）。
+ * 内嵌在详情页时仍走 `.game-lineage-canvas` 的可读高度上限（clamp(22rem, 62vh, 46rem)），
+ * 两种模式分开取值、互不影响。
+ */
+.lineage-fullscreen {
+  --lineage-overlay-chrome: 6.5rem;
+}
+.lineage-fullscreen__body .game-lineage-canvas {
+  height: calc(100dvh - var(--lineage-overlay-chrome));
+  max-height: calc(100dvh - var(--lineage-overlay-chrome));
+  min-height: 18rem;
+}
+
+/*
+ * 封面固定 **16:9 且必须铺满**（2026-10-07 用户口径：「封面固定 16：9，并且图片一定要铺满，不要留空白」）。
+ * 之前画布卡片的封面 `aspect-ratio` 是 `auto`、且作为纵向 flex 子项被拉伸，图片只占上半截 → 下半截是空白；
+ * 大纲/关系行的封面虽然 16:9，但内部图片被撑到 192px 高、只露出一条 → 也不是「铺满」。
+ * 这里把三处统一：容器强制 16:9（`flex: 0 0 auto` 防止被 flex 拉伸）、
+ * 内层 wrapper 与 img 100%×100% + `object-fit: cover`。无封面时的占位仍由 `GameCover` 自己给（保留兜底）。
+ */
+.game-lineage-node__cover {
+  position: relative;
+  display: block;
+  width: 100%;
+  aspect-ratio: 16 / 9;
+  flex: 0 0 auto;
+  overflow: hidden;
+}
+.game-lineage-node__cover .game-cover,
+.game-lineage-node__cover .game-cover__image,
+.game-lineage-node__cover img {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+/*
+ * 收敛共享样式：`.game-cover` 自带 `min-height: 12rem`（紧凑态 7rem），在族谱封面里会把内层盒子
+ * 撑到 192px —— `height: 100%` 因此永远不生效，img 盒虚高到 192px、只靠 `overflow: hidden` 裁。
+ * 这里把 min-height 归零，让内层盒真正等于封面盒（16:9），不需要任何裁切兜底。
+ */
+.game-lineage-node__cover .game-cover {
+  min-height: 0;
+}
+.game-lineage-node__cover img {
+  object-fit: cover;
+  object-position: center;
+}
+
+/*
+ * 主操作行「任何状态都不换行、不被挤扁」（2026-10-07 用户口径：提示显示成 toast，别挤占元素空间）。
+ * 行内状态文本已经全部改走 toast / portal 浮层；这里再钉一层样式保险：
+ * 子项不收缩、文字不折行 —— 无论旁边以后再加什么，都不会把「开始游戏 / 收藏 / 开始共创」压成两行。
+ */
+.game-detail-hero__actions > * {
+  flex: 0 0 auto;
+  white-space: nowrap;
+}
+/* 读屏专用：保留 id（`aria-describedby` 还指着它）但不占布局空间。 */
+.game-device-warning--sr {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
+/*
+ * 「手动开始共创」面板：portal 到 `body` 的浮层（底部居中），
+ * 不再作为主操作行的子项参与布局 —— 打开面板不会把同行按钮挤走。
+ */
+.game-fork-remix-panel--portal {
+  position: fixed;
+  left: 50%;
+  bottom: calc(1rem + env(safe-area-inset-bottom));
+  transform: translateX(-50%);
+  z-index: 110;
+  max-width: min(34rem, calc(100vw - 2rem));
+  box-shadow: 0 18px 48px rgba(48, 32, 22, 0.22);
+}
+/* 轻提示宿主：固定右下角堆叠，`pointer-events: none` 让空白区域不挡点击。 */
+.platform-toast-host {
+  position: fixed;
+  right: 1rem;
+  bottom: calc(1rem + env(safe-area-inset-bottom));
+  z-index: 130;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  max-width: min(26rem, calc(100vw - 2rem));
+  pointer-events: none;
+}
+.platform-toast-host__item {
+  pointer-events: auto;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  box-shadow: 0 12px 32px rgba(48, 32, 22, 0.18);
+}
+.platform-toast-host__text {
+  white-space: normal;
+  line-height: 1.5;
+}
+.platform-toast-host__close {
+  flex: 0 0 auto;
+  border: 0;
+  padding: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-size: 0.78rem;
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+/*
+ * 图谱里的卡**就是**广场作品卡的同一个组件（`GameCard`）：这里只做「放进画布/清单」所需的尺寸适配，
+ * 不改卡内视觉（标题/游玩数/作者等仍由该组件自己的样式决定）。
+ * 封面继续遵守 16:9 + 铺满（`.game-cover` 的 min-height 共享样式在卡里归零）。
+ */
+.game-lineage-node > .game-card--lineage {
+  width: 100%;
+  min-height: 100%;
+}
+.game-card--lineage .game-cover {
+  width: 100%;
+  aspect-ratio: 16 / 9;
+  min-height: 0;
+  border-radius: 0;
+}
+/*
+ * **阴影搬到这里**（用户口径：容器只应是一张卡，「可以稍微做点阴影」）：
+ * 容器 `.game-lineage-node` 已经透明无阴影，卡片自己是唯一的视觉主体 —— 用两层轻阴影
+ * （贴地 1px + 弥散 12px），比原来容器上那块 0 6px 18px 更轻，且高亮环会叠在它之前。
+ */
+.game-card--lineage {
+  box-shadow: var(--lineage-card-shadow);
+}
+/*
+ * 族谱卡的**唯一阴影来源**：容器已透明，只需要卡片自己「稍微做点阴影」。
+ * 两层：1px 贴地 + 12px 弥散；高亮环（路径 / 锁定 / 当前作品）会叠在它之前，因此两者不互斥。
+ */
+.game-lineage-page {
+  --lineage-card-shadow: 0 1px 2px rgba(0, 0, 0, 0.06), 0 4px 12px rgba(0, 0, 0, 0.08);
+}
+.game-card--lineage .game-cover__image,
+.game-card--lineage .game-cover img {
+  display: block;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  object-position: center;
+}
+/*
+ * 卡面角标槽：从「压在封面上」搬回**封面下方**的信息区第一行（截图反馈：母版 / 第 N 代 / 主干 /
+ * 当前作品 盖在封面图上，既遮挡又和卡内信息重复）。
+ *
+ * 为什么必须在这里覆盖：共享卡（广场卡）给角标槽的默认位置是卡内的绝对定位浮层
+ * （`top/left/right: .55rem`），那是为广场卡设计的；族谱卡沿用后角标又回到了封面上。
+ * 改成文档流里的静态行后，角标不可能再盖住封面，也不参与绝对定位。
+ * 组内尺寸/圆角/不换行仍按族谱自己的角标表（`.game-lineage-node__badges > *` 那套同值），
+ * 所以同一个语义在画布卡与大纲行里长得一样。
+ */
+.game-card--lineage .game-card__badges {
+  position: static;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.25rem;
+  /* 与卡内信息区同侧内边距（卡身左右 padding 是 1rem，角标行跟标题左对齐即可）。 */
+  padding: 0.5rem 1rem 0;
+}
+.game-card--lineage .game-card__badges > * {
+  position: static;
+  margin: 0;
+  border-radius: 999px;
+  padding: 0.05rem 0.4rem;
+  font-size: 0.6rem;
+  line-height: 1.6;
+  white-space: nowrap;
+}
+/*
+ * 族谱卡是**窄卡**（240 / 176 宽）：标题独占一行，游玩数落到标题下方 ——
+ * 截图反馈「标题、游玩次数、作者挤在一起」，挤是因为三者抢同一行宽。
+ * 标题拿到整行后 2 行截断的触发也更少，卡片反而更矮。
+ */
+.game-card--lineage .game-card__title-row {
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.1rem;
+}
+/* 游玩数与作者是同一级的次要信息，挨近一点读成一组（共享卡默认 0.85rem 是为广场宽卡留的）。 */
+.game-card--lineage .game-card__meta {
+  margin-top: 0.25rem;
+}
+/* 角标行已经在封面与标题之间，信息区顶部就不用再留共享卡那份 0.95rem（会变成双重留白）。 */
+.game-card--lineage .game-card__body {
+  padding-top: 0.55rem;
+}
+/*
+ * 窄屏紧凑卡（176 宽节点 → 卡内 148）：角标行与角标都再收紧一点，
+ * 让「第 N 代 + 主干 + 子代」三枚角标留在**一行**里（真机实测：1rem 行内边距 + 0.4rem 角标内边距时
+ * 三枚共 127.2px > 可用 114.4px，会折成两行、把卡片顶高 23px，层高估算就不准了）。
+ */
+.game-lineage-node--compact .game-card--lineage .game-card__badges {
+  padding-left: 0.5rem;
+  padding-right: 0.5rem;
+}
+.game-lineage-node--compact .game-card--lineage .game-card__badges > * {
+  padding: 0.05rem 0.3rem;
+}
+/*
+ * 图下方「父代 / 子代」清单：与画布节点卡**同一张卡、同一个卡宽**（2026-10-07 用户口径：
+ * 「父代子代应该都和血缘图里的用的是一个卡片，一起调宽一点」）。
+ *
+ * 卡宽的唯一来源是布局常量（`lineageTreeLayout.ts` 的 `LINEAGE_CARD_WIDTH`），
+ * 由 `GameLineagePage` 下发成 `--lineage-card-width`；这里**只读它**，不另写一套数字
+ * ⇒ 两处不可能再漂移。轨道就是卡宽本身（不是 `minmax`），所以列数随容器自然退化：
+ * - 1440：容器 864 ⇒ **3 列**（3×224 + 2×12 = 696 ≤ 864；第 4 列要 932，放不下）
+ * - 1024：容器 732.88 ⇒ **3 列**
+ * - 390：容器 316 ⇒ **1 列 224**（用户 2026-10-07 拍板：「宽 + 不截断」优先于「凑两列」——
+ *   窄屏不再降级到紧凑卡宽，因此 16 字标题在 224 宽里 2 行放得下、**不截断**）
+ */
+.lineage-relations {
+  max-width: 54rem;
+}
+.lineage-relation__grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, var(--lineage-card-width, 14rem));
+  gap: 0.75rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.lineage-relation__item {
+  display: flex;
+  min-width: 0;
+}
+.lineage-relation__item > .game-card--lineage {
+  width: 100%;
+}
+
+/*
+  共创页卡片的「被共创 N 次」指标（2026-10-07，取代同日早前的封面角标）。
+  位置由共享卡的 `metric` 槽决定：它就是标题行右侧原来「N 次游玩」那一格
+  （`.game-card__title-row` 里 `flex: none` 的右端），这里只负责**突出**它：
+  强调色（平台既有 `--platform-accent-strong`）+ 700 字重 + 比默认指标大一档
+  （0.72rem vs 0.66rem）+ 一个小星标（与共创 hero / 侧边栏同一套 `Sparkles` 语汇），
+  数字用 tabular-nums 对齐，保证同列多张卡的数字竖着能对齐。
+  只有「共创」页（`scope="forkable"`）会传这个槽，广场 / 游戏页卡片不传、零影响。
+*/
+.game-card__co-creation-count {
+  display: inline-flex;
+  align-items: center;
+  flex: none;
+  gap: 0.2rem;
+  color: var(--platform-accent-strong, var(--platform-accent));
+  font-size: 0.72rem;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+.game-card__co-creation-count svg {
+  width: 0.8rem;
+  height: 0.8rem;
+  flex: none;
+}
diff --git a/src/components/game-distribution/gameForkProtocol.ts b/src/components/game-distribution/gameForkProtocol.ts
new file mode 100644
index 000000000..1251c634d
--- /dev/null
+++ b/src/components/game-distribution/gameForkProtocol.ts
@@ -0,0 +1,35 @@
+/**
+ * 网页端唤起陶泥儿客户端的唯一收口。
+ *
+ * 客户端已约定协议 `genarrative://fork?gameId=<gameId>`（scheme 由 AGC 侧注册）。
+ * 这里不判断「客户端是否装了」——浏览器不会告诉我们；判定只能靠「页面有没有失焦」，
+ * 所以本模块只负责「发出唤起」这一件事，失焦判定与降级留在调用方。
+ */
+
+/** 与 AGC 约定的 Fork 协议前缀。 */
+export const FORK_PROTOCOL_URL_PREFIX = 'genarrative://fork';
+
+/**
+ * 唤起后等待「页面失焦」的窗口。超过它仍没失焦就认为没有客户端接手，走手动降级。
+ *
+ * 取值权衡：太大则没装客户端的用户要干等；太小则系统弹「是否打开陶泥儿？」的确认框期间
+ * 就可能误判成失败。1.2s 覆盖常见桌面浏览器的协议确认与进程启动。
+ */
+export const FORK_LAUNCH_FALLBACK_DELAY_MS = 1200;
+
+export function buildForkProtocolUrl(gameId: string) {
+  return `${FORK_PROTOCOL_URL_PREFIX}?gameId=${encodeURIComponent(gameId)}`;
+}
+
+/**
+ * 唤起客户端。
+ *
+ * 用顶层 `location.href` 赋值（不是 iframe / `window.open`）：
+ * - 协议**未注册**时桌面浏览器只会「什么都不发生」，不会把当前页导航走，也不会弹空白标签页；
+ * - iframe 方式在部分浏览器被当作下载/被拦截，且拿不到任何可观察信号，反而不如顶层导航干脆；
+ * - `window.open` 会被弹窗拦截器拦掉，失败信号同样不可观察。
+ * 因此顶层导航 + 失焦判定 + 定时降级是这里最可控的组合。
+ */
+export function openForkProtocol(gameId: string) {
+  window.location.href = buildForkProtocolUrl(gameId);
+}
diff --git a/src/components/game-distribution/gamePublishSubmission.ts b/src/components/game-distribution/gamePublishSubmission.ts
index a672f3dc4..3be7b7493 100644
--- a/src/components/game-distribution/gamePublishSubmission.ts
+++ b/src/components/game-distribution/gamePublishSubmission.ts
@@ -1,10 +1,10 @@
 import type {
-  GameMetadata,
   GameDistributionVersionStatus,
+  GameMetadata,
 } from '../../../packages/shared/src/contracts/gameDistribution';
 import type {
-  NewGameVersionRequest,
   GameDistributionPublishVersionResponse,
+  NewGameVersionRequest,
 } from '../../../packages/shared/src/contracts/gameDistributionPublish';
 import type { GameDistributionPublishMediaParts } from '../../services/gameDistributionClient';
 import {
@@ -43,6 +43,11 @@ export type GamePublishSubmissionInput = {
   /** 已由调用方本地校验并读好的发行包字节；提交模块原样上传。 */
   packageBody: Blob | ArrayBuffer;
   media?: GameDistributionPublishMediaParts;
+  /**
+   * 衍生作品的「本次核心改动说明」；母版不传。服务端按衍生判定做必填与长度校验，
+   * 页面只负责采集与本地同口径提示。
+   */
+  changeSummary?: string;
 };
 
 /** 网络与草稿存储依赖；测试注入假实现即可在接口层覆盖整条编排。 */
@@ -174,6 +179,10 @@ function buildPublishVersionRequest(
     packageFileCount: input.packageFileCount,
     packageEntryPath: input.packageEntryPath,
     gameMetadata: input.gameMetadata,
+    // 衍生作品才带：母版带上也会被服务端忽略，但省略可让幂等摘要与旧客户端逐字节一致。
+    ...(input.changeSummary?.trim()
+      ? { changeSummary: input.changeSummary.trim() }
+      : {}),
   };
 }
 
diff --git a/src/components/game-distribution/gameViewerRole.ts b/src/components/game-distribution/gameViewerRole.ts
new file mode 100644
index 000000000..c559f864b
--- /dev/null
+++ b/src/components/game-distribution/gameViewerRole.ts
@@ -0,0 +1,127 @@
+/**
+ * 观看者所处的**入口上下文**（2026-10-07 产品口径更正）：
+ * **游客 = 来玩游戏的玩家侧**（不是「未登录访客」），**共创者 = 开发游戏的那一侧**。
+ *
+ * 口径来源：产品会上定的「普通用户是游客（主要是玩游戏的），共创者是开发游戏的」，
+ * 并且明确「**游客是指点开游戏界面的用户**」——即差异取决于**从哪一侧点进来的**，
+ * 与**登录态无关**（登录态只决定「能不能真的开始共创」，不再决定「看不看得到血缘」）。
+ *
+ * 因此这个模块的输入是**入口来源**，不是 `isAuthenticated`：
+ * - 导航层（`PlatformEntryActiveFlowShell`）在打开详情页时按**当前所在的一侧**写入 URL 标记
+ *   `/games/detail?id=…&from=co-creation`；
+ * - 详情页只读这个标记（见 `GameDetailPage`），所以**刷新 / 深链 / 分享链接都稳定**；
+ * - 没有标记、或标记不是共创来源 ⇒ **玩家侧**（旧链接、直接把 URL 贴给别人的场景一律落玩家侧）。
+ *
+ * ⚠️ 若产品最终改为**账号角色 / 能力位**（例如后端下发 `isCreator` / `creatorLevel`），
+ * **只需要替换这一个模块的实现**：`isCoCreator` 是所有差异的唯一判据，调用点不用改。
+ */
+
+/** 详情页 URL 上的来源标记值：`/games/detail?id=…&from=co-creation`。 */
+export const CO_CREATION_DETAIL_SOURCE = 'co-creation';
+
+/**
+ * 「共创者侧」的导航阶段：从这些页面打开作品详情时算共创者侧。
+ * - `game-co-creation`：共创 Tab（侧边栏顶层入口）
+ * - `game-lineage`：创作族谱页
+ * - `game-compare`：原版与二创对比页（玩家的详情页不渲染对比入口，玩家到不了这里）
+ *
+ * 不在表里的（游戏 Tab / 广场 / 搜索 / 收藏 / 我的游戏 / 共创主题 / 默认深链）都算**玩家侧**；
+ * 其中「共创主题」页两边的用户都能到（详情页的主题入口对玩家也保留），
+ * 按「玩家也能到 ⇒ 落玩家侧」处理，避免玩家从主题页点进去又看到共创视图。
+ */
+export const CO_CREATION_ORIGIN_STAGES: readonly string[] = [
+  'game-co-creation',
+  'game-lineage',
+  'game-compare',
+];
+
+export type GameViewerContext = 'player' | 'co-creator';
+
+/**
+ * 游玩页 URL 上的**返回目标**参数：`backTo=<encodeURIComponent(站内路径)>`。
+ *
+ * 语义（2026-10-07 用户口径「看他从哪来的」）：进入游玩页时把**来处**记在 URL 上，游玩页的
+ * 「返回」按钮（以及浏览器返回的兜底）据此回到来处，刷新/深链都不丢。
+ * 只接受**站内相对路径**（单个 `/` 开头），绝对 URL / 协议相对 `//host` / 畸形值一律忽略 ⇒ 调用方走兜底。
+ * 它只表达「回哪」，**不**表达「哪一侧」——哪一侧仍然只由 `from` 决定，不新造第二套来源口径。
+ */
+export const PLAY_BACK_TO_QUERY_PARAM = 'backTo';
+
+/**
+ * 校验并归一化 `backTo`：返回可直接用于站内跳转的路径，或 `null`（不合法 ⇒ 调用方走兜底）。
+ * 防开放重定向：只放行 `/[^/]...` 这种单斜杠开头的站内路径。
+ */
+export function resolveInternalBackTo(
+  raw: string | null | undefined,
+): string | null {
+  const value = (raw ?? '').trim();
+  if (!value.startsWith('/') || value.startsWith('//')) return null;
+  if (/[\r\n\t]/u.test(value)) return null;
+  if (value === '/') return null;
+  return value;
+}
+
+/**
+ * 「已经在共创侧」的页面：**继续往下跳（或原地刷新）时要把来源标记带着走**，
+ * 别中途掉回玩家侧。
+ * - `game-detail`：详情页之间跳（血缘链 / 主题 / 相关作品）
+ * - `game-play`：从共创侧详情点「开始游戏 / 立即玩」进游玩页，以及游玩页自己刷新/分享
+ *   （游玩页要按来源保持 rail/dock 的「共创」高亮，见 `isCoCreationContext` 那一带）
+ */
+export const CO_CREATION_CARRY_STAGES: readonly string[] = [
+  'game-detail',
+  'game-play',
+];
+
+function isCoCreationSource(source: string | null | undefined) {
+  return (source ?? '').trim().toLowerCase() === CO_CREATION_DETAIL_SOURCE;
+}
+
+/**
+ * 来源标记 → 观看者所处的一侧。**缺省 / 未知一律 = 玩家侧**。
+ *
+ * `isAuthorViewer`（观看者就是这部作品的作者，即 `GameDetailPage` 的 `ownerView`，来自 `?owner=1`）
+ * **一律算共创者侧**（2026-10-07 产品拍板）：作者从「我的游戏」进自己的作品时必须看得到血缘入口，
+ * 不该因为「从游戏侧进来」被降级。
+ * ⚠️ 前端不做权限校验：`owner=1` 是前端标记（shell 只在「我的游戏」里写它），手改 URL 也能让页面
+ * 按共创者侧渲染 —— 它只影响「看不看得到血缘入口」这类**展示降级**，真正的作者数据仍由后端要求
+ * Bearer + owner 接口把关（未登录/非作者拿不到数据，页面落到 `找不到这款游戏`）。所以
+ * 「未登录 + owner」在**数据上**不可能同时成立，在**链接上**可以让前端按共创者侧渲染，不构成越权。
+ */
+export function resolveGameViewerContext(input: {
+  /** URL 上的来源标记（`from`）。 */
+  source?: string | null;
+  /** 观看者就是这部作品的作者（`?owner=1`）。 */
+  isAuthorViewer?: boolean;
+}): GameViewerContext {
+  if (input.isAuthorViewer) return 'co-creator';
+  return isCoCreationSource(input.source) ? 'co-creator' : 'player';
+}
+
+/**
+ * 导航层用：这一跳该不该带上「共创来源」标记？
+ *
+ * - 当前就在共创侧阶段（共创 Tab / 族谱 / 对比）→ 带上；
+ * - 当前已经在**共创侧的页面**里（详情页之间跳、以及从详情进游玩页/在游玩页里）→ **保留**来源，
+ *   别中途掉回玩家侧（游玩页的 rail/dock 高亮也按这个标记走）；
+ * - 其余（游戏 Tab / 广场 / 我的游戏 / 默认深链）→ 不带。
+ *
+ * 只认 `co-creation` 这一个值：族谱页自己的 `from=<gameId>`（高亮当前作品）含义不同，不能被当成来源。
+ */
+export function shouldCarryCoCreationSource(input: {
+  stage: string;
+  currentSource?: string | null;
+}): boolean {
+  if (CO_CREATION_ORIGIN_STAGES.includes(input.stage)) return true;
+  return (
+    CO_CREATION_CARRY_STAGES.includes(input.stage) &&
+    isCoCreationSource(input.currentSource)
+  );
+}
+
+/**
+ * 是不是「共创者」这一侧。**详情页所有差异都由它驱动**（一个谓词，判断不散落在 JSX 各处）。
+ */
+export function isCoCreator(context: GameViewerContext): boolean {
+  return context === 'co-creator';
+}
diff --git a/src/components/game-distribution/lineageTreeLayout.test.ts b/src/components/game-distribution/lineageTreeLayout.test.ts
new file mode 100644
index 000000000..f0ebc0fee
--- /dev/null
+++ b/src/components/game-distribution/lineageTreeLayout.test.ts
@@ -0,0 +1,902 @@
+/* @vitest-environment jsdom */
+
+import { describe, expect, it } from 'vitest';
+
+import type { GameDistributionLineageNode } from '../../services/gameDistributionClient';
+import {
+  buildLineageTreeLayout,
+  clampLineagePan,
+  collectLineageAncestorChain,
+  collectLineageHighlight,
+  collectLineageImmediateScope,
+  collectLineagePlayCountTotals,
+  collectLineageRelationRoles,
+  collectLineageSubtreeDepth,
+  estimateLineageCardHeight,
+  generationAxisLabel,
+  LINEAGE_CARD_BASE_HEIGHT,
+  LINEAGE_CARD_TITLE_LINE_HEIGHT,
+  LINEAGE_COLUMN_GAP,
+  LINEAGE_COVER_ASPECT,
+  LINEAGE_NODE_HEIGHT,
+  LINEAGE_NODE_WIDTH,
+  LINEAGE_ROW_GAP,
+} from './lineageTreeLayout';
+
+function node(
+  gameId: string,
+  generation: number,
+  parentGameId: string | null,
+  title = `作品 ${gameId}`,
+): GameDistributionLineageNode {
+  return {
+    gameId,
+    title,
+    authorName: `作者 ${gameId}`,
+    generation,
+    parentGameId,
+    playCount: generation * 10,
+    status: 'published',
+  };
+}
+
+/** 同层任意两节点必须至少隔着列间距：这是「绝不重叠」的可断言形式。 */
+function assertNoOverlap(
+  nodes: readonly { x: number; y: number; generation: number }[],
+) {
+  for (let left = 0; left < nodes.length; left += 1) {
+    for (let right = left + 1; right < nodes.length; right += 1) {
+      const a = nodes[left]!;
+      const b = nodes[right]!;
+      if (a.generation !== b.generation) continue;
+      expect(
+        Math.abs(a.x - b.x),
+        `${a.x} 与 ${b.x} 在第 ${a.generation} 代重叠`,
+      ).toBeGreaterThanOrEqual(LINEAGE_NODE_WIDTH);
+      expect(a.y).toBe(b.y);
+    }
+  }
+}
+
+describe('buildLineageTreeLayout', () => {
+  it('封面宽高比与平台封面约定一致（16:9 横版）', () => {
+    // 发布面板的封面预览就写死 16/9（gameDistribution.css 的 .game-publish-media__preview），
+    // 这里把它钉成常量：节点卡片误改成竖版会在单测里变红。
+    expect(LINEAGE_COVER_ASPECT).toBeCloseTo(16 / 9, 5);
+    expect(LINEAGE_NODE_WIDTH / LINEAGE_COVER_ASPECT).toBeLessThan(
+      LINEAGE_NODE_HEIGHT,
+    );
+  });
+
+  it('单节点：一个布局节点、零连线、一条代际轴', () => {
+    const layout = buildLineageTreeLayout([node('game-root', 0, null)]);
+    expect(layout.nodes).toHaveLength(1);
+    expect(layout.edges).toHaveLength(0);
+    expect(layout.axis).toEqual([
+      {
+        generation: 0,
+        label: '母版',
+        y: 0,
+        // 层高默认取节点高（没传 cardHeights 时退回 nodeHeight）。
+        height: LINEAGE_NODE_HEIGHT,
+        count: 1,
+      },
+    ]);
+    expect(layout.nodes[0]!.isStub).toBe(false);
+    expect(layout.width).toBeGreaterThan(LINEAGE_NODE_WIDTH);
+  });
+
+  it('空树：零节点零连线，尺寸仍是可渲染的正数', () => {
+    const layout = buildLineageTreeLayout([]);
+    expect(layout.nodes).toHaveLength(0);
+    expect(layout.edges).toHaveLength(0);
+    expect(layout.axis).toHaveLength(0);
+    expect(layout.width).toBeGreaterThan(0);
+    expect(layout.height).toBe(0);
+  });
+
+  it('深链（10 代）：逐代下行、x 对齐、连线数 = 代数 - 1', () => {
+    const chain = Array.from({ length: 10 }, (_, generation) =>
+      node(
+        `g${generation}`,
+        generation,
+        generation === 0 ? null : `g${generation - 1}`,
+      ),
+    );
+    const layout = buildLineageTreeLayout(chain);
+    expect(layout.nodes).toHaveLength(10);
+    expect(layout.edges).toHaveLength(9);
+    expect(layout.axis).toHaveLength(10);
+    // 单链：每一代的 x 相同，y 严格递增。
+    const xs = new Set(layout.nodes.map((item) => item.x));
+    expect(xs.size).toBe(1);
+    const ys = layout.nodes.map((item) => item.y);
+    for (let index = 1; index < ys.length; index += 1) {
+      expect(ys[index]!).toBeGreaterThan(ys[index - 1]!);
+    }
+    assertNoOverlap(layout.nodes);
+  });
+
+  it('宽扇出（1 父 24 子）：同层不重叠、父居中在子节点中间', () => {
+    const children = Array.from({ length: 24 }, (_, index) =>
+      node(`child${index}`, 1, 'root'),
+    );
+    const layout = buildLineageTreeLayout([node('root', 0, null), ...children]);
+    expect(layout.nodes).toHaveLength(25);
+    expect(layout.edges).toHaveLength(24);
+    const root = layout.nodes.find((item) => item.gameId === 'root')!;
+    const childXs = layout.nodes
+      .filter((item) => item.generation === 1)
+      .map((item) => item.x);
+    const expectedCenter =
+      (Math.min(...childXs) + Math.max(...childXs)) / 2 +
+      LINEAGE_NODE_WIDTH / 2;
+    expect(Math.abs(root.x + root.width / 2 - expectedCenter)).toBeLessThan(
+      0.51,
+    );
+    assertNoOverlap(layout.nodes);
+  });
+
+  it('对称分支：左右两支镜像分布，父节点居中', () => {
+    const layout = buildLineageTreeLayout([
+      node('root', 0, null),
+      node('left', 1, 'root'),
+      node('right', 1, 'root'),
+      node('left-a', 2, 'left'),
+      node('left-b', 2, 'left'),
+      node('right-a', 2, 'right'),
+      node('right-b', 2, 'right'),
+    ]);
+    const root = layout.nodes.find((item) => item.gameId === 'root')!;
+    const leftBranch = layout.nodes.filter((item) =>
+      item.gameId.startsWith('left'),
+    );
+    const rightBranch = layout.nodes.filter((item) =>
+      item.gameId.startsWith('right'),
+    );
+    // 对称：两支相对父中心镜像（同一代际各取一个点比较）。
+    const leftL1 = leftBranch.find((item) => item.generation === 1)!;
+    const rightL1 = rightBranch.find((item) => item.generation === 1)!;
+    const center = root.x + root.width / 2;
+    // 对称 = 两个子节点中心相对父中心的偏移互为相反数（和为零）。
+    const mirrorDelta =
+      leftL1.x +
+      LINEAGE_NODE_WIDTH / 2 -
+      center +
+      (rightL1.x + LINEAGE_NODE_WIDTH / 2 - center);
+    expect(Math.abs(mirrorDelta)).toBeLessThan(0.51);
+    assertNoOverlap(layout.nodes);
+  });
+
+  it('混合树的每一层都不重叠', () => {
+    const layout = buildLineageTreeLayout([
+      node('root', 0, null),
+      node('a', 1, 'root'),
+      node('b', 1, 'root'),
+      node('c', 1, 'root'),
+      node('a1', 2, 'a'),
+      node('a2', 2, 'a'),
+      node('b1', 2, 'b'),
+      node('c1', 2, 'c'),
+      node('c2', 2, 'c'),
+      node('c3', 2, 'c'),
+      node('a1x', 3, 'a1'),
+    ]);
+    assertNoOverlap(layout.nodes);
+    // 同层至少隔一个列间距（比「不重叠」更强）。
+    const byGeneration = new Map<number, number[]>();
+    for (const item of layout.nodes) {
+      byGeneration.set(item.generation, [
+        ...(byGeneration.get(item.generation) ?? []),
+        item.x,
+      ]);
+    }
+    for (const xs of byGeneration.values()) {
+      const sorted = [...xs].sort((left, right) => left - right);
+      for (let index = 1; index < sorted.length; index += 1) {
+        expect(sorted[index]! - sorted[index - 1]!).toBeGreaterThanOrEqual(
+          LINEAGE_NODE_WIDTH + LINEAGE_COLUMN_GAP - 0.01,
+        );
+      }
+    }
+  });
+
+  it('连线端点落在父底边中点与子顶边中点，路径是正交 elbow', () => {
+    const layout = buildLineageTreeLayout([
+      node('root', 0, null),
+      node('child', 1, 'root'),
+    ]);
+    const edge = layout.edges[0]!;
+    const root = layout.nodes.find((item) => item.gameId === 'root')!;
+    const child = layout.nodes.find((item) => item.gameId === 'child')!;
+    // 端点在布局里按 2 位小数取整（SVG path 精度），所以逐字段允许 2 位小数的舍入误差。
+    expect(edge.from.x).toBeCloseTo(root.x + root.width / 2, 2);
+    expect(edge.from.y).toBeCloseTo(root.y + root.height, 2);
+    expect(edge.to.x).toBeCloseTo(child.x + child.width / 2, 2);
+    expect(edge.to.y).toBeCloseTo(child.y, 2);
+    // 单链：父与子同一条竖线 → 纯竖直段。
+    expect(edge.path.startsWith('M ')).toBe(true);
+    expect(edge.path).toContain(' V ');
+    expect(edge.path).not.toContain(' C ');
+    expect(edge.id).toBe('root->child');
+
+    // 分叉：父与子不同列 → 竖直段 + 水平段 + 圆角（elbow），而不是一条弧。
+    const branched = buildLineageTreeLayout([
+      node('root', 0, null),
+      node('a', 1, 'root'),
+      node('b', 1, 'root'),
+      node('a1', 2, 'a'),
+      node('b1', 2, 'b'),
+    ]);
+    const elbow = branched.edges.find((item) => item.childGameId === 'a')!;
+    expect(elbow.path).toContain(' V ');
+    expect(elbow.path).toContain(' H ');
+    expect(elbow.path).toContain(' Q ');
+    expect(elbow.path).not.toContain(' C ');
+
+    // 每一条边（含「一个父 + 多个子」的扇出边）都必须钉在父卡下边中点 / 子卡上边中点上，
+    // 不允许任何横向扇出偏移：图谱连线垂直落在卡片水平中心（真机同口径）。
+    const byId = new Map(branched.nodes.map((item) => [item.gameId, item]));
+    expect(branched.edges).toHaveLength(4);
+    for (const item of branched.edges) {
+      const parent = byId.get(item.parentGameId)!;
+      const child = byId.get(item.childGameId)!;
+      expect(item.from.x).toBeCloseTo(parent.x + parent.width / 2, 2);
+      expect(item.from.y).toBeCloseTo(parent.y + parent.height, 2);
+      expect(item.to.x).toBeCloseTo(child.x + child.width / 2, 2);
+      expect(item.to.y).toBeCloseTo(child.y, 2);
+      // 路径首点 = 父锚点；路径末点写在最后一段 V/H 里（曲线控制点不是端点）。
+      expect(item.path.startsWith(`M ${item.from.x},${item.from.y}`)).toBe(
+        true,
+      );
+      expect(item.path.trimEnd().endsWith(` ${item.to.y}`)).toBe(true);
+    }
+  });
+
+  it('确定性：同一输入两次调用结果逐字段相同', () => {
+    const input = [
+      node('root', 0, null),
+      node('a', 1, 'root'),
+      node('b', 1, 'root'),
+      node('a1', 2, 'a'),
+    ];
+    expect(buildLineageTreeLayout(input)).toEqual(
+      buildLineageTreeLayout(input),
+    );
+  });
+
+  it('父作品不可用：补一个不带标题与作者名的占位节点，且连线仍然连通', () => {
+    const layout = buildLineageTreeLayout([
+      node('child', 1, 'game-removed', '当前作品'),
+    ]);
+    const stub = layout.nodes.find((item) => item.gameId === 'game-removed')!;
+    expect(stub.isStub).toBe(true);
+    expect(stub.title).toBeNull();
+    expect(stub.authorName).toBeNull();
+    expect(stub.generation).toBe(0);
+    // 占位节点不携带被删作品的任何身份信息。
+    expect(JSON.stringify(stub)).not.toContain('当前作品');
+    expect(layout.edges).toHaveLength(1);
+    expect(layout.edges[0]!.parentGameId).toBe('game-removed');
+    expect(layout.axis.map((entry) => entry.label)).toEqual([
+      generationAxisLabel(0),
+      generationAxisLabel(1),
+    ]);
+  });
+
+  it('同一不可用父只补一个占位节点（多个子共享）', () => {
+    const layout = buildLineageTreeLayout([
+      node('child-a', 1, 'game-removed'),
+      node('child-b', 1, 'game-removed'),
+    ]);
+    expect(
+      layout.nodes.filter((item) => item.gameId === 'game-removed'),
+    ).toHaveLength(1);
+    expect(layout.edges).toHaveLength(2);
+  });
+});
+
+describe('主干线（每代热度最高的版本）', () => {
+  it('按 playCount 选出每代主干节点，主干边标记 isTrunk', () => {
+    const layout = buildLineageTreeLayout([
+      node('root', 0, null),
+      node('hot', 1, 'root'),
+      node('cold', 1, 'root'),
+      node('hot-child', 2, 'hot'),
+    ]);
+    const byId = new Map(layout.nodes.map((item) => [item.gameId, item]));
+    // node() 里 playCount = generation * 10，同代并列 → 取先出现的那个。
+    expect(byId.get('root')!.isTrunk).toBe(true);
+    expect(byId.get('hot')!.isTrunk).toBe(true);
+    expect(byId.get('cold')!.isTrunk).toBe(false);
+    const trunkEdges = layout.edges.filter((edge) => edge.isTrunk);
+    expect(trunkEdges.map((edge) => edge.id)).toEqual([
+      'root->hot',
+      'hot->hot-child',
+    ]);
+  });
+
+  it('热度更高的节点成为主干（显式 playCount 覆盖）', () => {
+    const cold = {
+      ...node('cold', 1, 'root'),
+      playCount: 1000,
+    };
+    const layout = buildLineageTreeLayout([
+      node('root', 0, null),
+      node('hot', 1, 'root'),
+      cold,
+    ]);
+    const byId = new Map(layout.nodes.map((item) => [item.gameId, item]));
+    expect(byId.get('cold')!.isTrunk).toBe(true);
+    expect(byId.get('hot')!.isTrunk).toBe(false);
+  });
+});
+
+describe('横向朝向（移动端图谱视图）', () => {
+  const nodes = [
+    node('root', 0, null),
+    node('a', 1, 'root'),
+    node('b', 1, 'root'),
+    node('deep', 2, 'a'),
+  ];
+
+  it('代际沿 x 推进、兄弟沿 y 排开，且同代不重叠', () => {
+    const vertical = buildLineageTreeLayout(nodes);
+    const horizontal = buildLineageTreeLayout(nodes, {
+      orientation: 'horizontal',
+    });
+    const hById = new Map(horizontal.nodes.map((item) => [item.gameId, item]));
+    // 竖版：同代 y 相同；横版：同代 x 相同，兄弟 y 不同。
+    expect(hById.get('root')!.x).toBeLessThan(hById.get('a')!.x);
+    expect(hById.get('a')!.x).toBeLessThan(hById.get('deep')!.x);
+    expect(hById.get('a')!.y).not.toBe(hById.get('b')!.y);
+    expect(hById.get('a')!.x).toBe(hById.get('b')!.x);
+    // 同代（同一列）节点在纵向上至少隔一个列间距，结构上不重叠。
+    expect(
+      Math.abs(hById.get('a')!.y - hById.get('b')!.y),
+    ).toBeGreaterThanOrEqual(hById.get('a')!.height + 1);
+    expect(vertical.nodes[0]!.y).toBeLessThan(vertical.nodes[1]!.y);
+  });
+
+  it('连线改成「父右边中点 → 子左边中点」的水平 elbow', () => {
+    const horizontal = buildLineageTreeLayout(nodes, {
+      orientation: 'horizontal',
+    });
+    const edge = horizontal.edges.find((item) => item.id === 'root->a')!;
+    const root = horizontal.nodes.find((item) => item.gameId === 'root')!;
+    const child = horizontal.nodes.find((item) => item.gameId === 'a')!;
+    expect(edge.from).toEqual({
+      x: root.x + root.width,
+      y: root.y + root.height / 2,
+    });
+    expect(edge.to).toEqual({ x: child.x, y: child.y + child.height / 2 });
+    expect(edge.path).toContain(' H ');
+    expect(edge.path).not.toContain(' C ');
+  });
+});
+
+describe('collectLineageSubtreeDepth', () => {
+  it('深度 = 子树最大代际 − 本作品代际', () => {
+    const nodes = [
+      node('root', 0, null),
+      node('a', 1, 'root'),
+      node('b', 2, 'a'),
+      node('c', 3, 'b'),
+      node('sibling', 1, 'root'),
+    ];
+    expect(collectLineageSubtreeDepth(nodes, 'root')).toBe(3);
+    expect(collectLineageSubtreeDepth(nodes, 'a')).toBe(2);
+    expect(collectLineageSubtreeDepth(nodes, 'sibling')).toBe(0);
+  });
+
+  it('单节点 / 未知作品 / 断链都返回 0', () => {
+    expect(collectLineageSubtreeDepth([node('root', 0, null)], 'root')).toBe(0);
+    expect(collectLineageSubtreeDepth([node('root', 0, null)], 'game-x')).toBe(
+      0,
+    );
+    const orphan = [
+      node('orphan', 1, 'game-missing'),
+      node('child', 2, 'orphan'),
+    ];
+    // 父不可用不影响「本作品自己的子树」深度。
+    expect(collectLineageSubtreeDepth(orphan, 'orphan')).toBe(1);
+  });
+});
+
+describe('层高自适应：第 N 层层高 = 该层最高卡片（不重叠）', () => {
+  /**
+   * 树形状：root → mid（同层还有 sibling）→ deep1/deep2。
+   * 用 `cardHeights` 显式给 mid 一个「更高」的卡片（模拟 2 行标题），验证层高按它撑开。
+   */
+  const nodes = [
+    node('root', 0, null),
+    node('mid', 1, 'root'),
+    node('sibling', 1, 'root'),
+    node('deep1', 2, 'mid'),
+    node('deep2', 2, 'mid'),
+  ];
+
+  it('层高取该层最大卡片高度，下一层 y = 上一层 y + 层高 + rowGap', () => {
+    const heights = new Map([
+      ['root', 300],
+      ['mid', 400],
+      ['sibling', 300],
+      ['deep1', 300],
+      ['deep2', 320],
+    ]);
+    const layout = buildLineageTreeLayout(nodes, { cardHeights: heights });
+    const byId = new Map(layout.nodes.map((item) => [item.gameId, item]));
+    // 第 1 层被 400 的卡片撑开：两个兄弟都取 400（层内等高）。
+    expect(byId.get('mid')!.height).toBe(400);
+    expect(byId.get('sibling')!.height).toBe(400);
+    // 第 2 层取 320。
+    expect(byId.get('deep1')!.height).toBe(320);
+    expect(byId.get('deep2')!.height).toBe(320);
+    // y：0 → 300 + rowGap → 300 + gap + 400 + gap。
+    expect(byId.get('root')!.y).toBe(0);
+    expect(byId.get('mid')!.y).toBe(300 + LINEAGE_ROW_GAP);
+    expect(byId.get('deep1')!.y).toBe(300 + LINEAGE_ROW_GAP * 2 + 400);
+    // 代际轴跟着层高走（不再拿「第一个节点的高度」凑）。
+    expect(layout.axis.map((entry) => entry.height)).toEqual([300, 400, 320]);
+    expect(layout.axis.map((entry) => entry.y)).toEqual([
+      0,
+      300 + LINEAGE_ROW_GAP,
+      300 + LINEAGE_ROW_GAP * 2 + 400,
+    ]);
+  });
+
+  it('任意两层之间不重叠：层间空隙 ≥ rowGap，且层高 ≥ 该层每张卡的高度', () => {
+    const heights = new Map([
+      ['root', 260],
+      ['mid', 420], // 同层有一张「2 行标题」的高卡
+      ['sibling', 300],
+      ['deep1', 340],
+      ['deep2', 300],
+    ]);
+    const layout = buildLineageTreeLayout(nodes, { cardHeights: heights });
+    const layers = [...new Set(layout.nodes.map((item) => item.generation))]
+      .sort((a, b) => a - b)
+      .map((generation) =>
+        layout.nodes.filter((item) => item.generation === generation),
+      );
+    for (let index = 0; index < layers.length; index += 1) {
+      const layer = layers[index]!;
+      // 层内等高
+      expect(new Set(layer.map((item) => item.height)).size).toBe(1);
+      // 层高 ≥ 该层每张卡自己的高度
+      for (const item of layer) {
+        expect(item.height).toBeGreaterThanOrEqual(heights.get(item.gameId)!);
+      }
+      const next = layers[index + 1];
+      if (!next) continue;
+      const layerBottom = layer[0]!.y + layer[0]!.height;
+      // 层间不重叠：下一层顶部至少隔 rowGap
+      expect(next[0]!.y - layerBottom).toBeGreaterThanOrEqual(LINEAGE_ROW_GAP);
+    }
+    // 内容总高覆盖最后一层
+    const lastLayer = layers.at(-1)!;
+    expect(layout.height).toBeGreaterThanOrEqual(
+      lastLayer[0]!.y + lastLayer[0]!.height,
+    );
+  });
+
+  it('没传 cardHeights（或值非法）时退回 nodeHeight，几何与旧口径一致', () => {
+    const layout = buildLineageTreeLayout(nodes);
+    const byId = new Map(layout.nodes.map((item) => [item.gameId, item]));
+    expect(byId.get('mid')!.height).toBe(LINEAGE_NODE_HEIGHT);
+    expect(byId.get('deep1')!.y).toBe(
+      (LINEAGE_NODE_HEIGHT + LINEAGE_ROW_GAP) * 2,
+    );
+    // 横版：槽位高取全局最大（否则同一槽位的兄弟会互相压住）。
+    const horizontal = buildLineageTreeLayout(nodes, {
+      orientation: 'horizontal',
+      cardHeights: new Map([['deep2', 380]]),
+    });
+    expect(new Set(horizontal.nodes.map((item) => item.height)).size).toBe(1);
+  });
+});
+
+describe('estimateLineageCardHeight（纯函数估算）', () => {
+  it('一行标题 = 基础高；两行标题多一个行高；超过两行仍按两行封顶', () => {
+    const short = estimateLineageCardHeight({ title: '共创演示·A0' });
+    expect(short).toBe(LINEAGE_CARD_BASE_HEIGHT);
+    const twoLines = estimateLineageCardHeight({
+      title: '共创演示·A1｜星海工坊·深海回声｜超长标题超长标题',
+    });
+    expect(twoLines).toBe(
+      LINEAGE_CARD_BASE_HEIGHT + LINEAGE_CARD_TITLE_LINE_HEIGHT,
+    );
+    const veryLong = estimateLineageCardHeight({
+      title:
+        '共创演示·A11｜深海回声·潮汐秘境｜这是一条远超过两行的超长标题用于封顶断言',
+    });
+    expect(veryLong).toBe(
+      LINEAGE_CARD_BASE_HEIGHT + LINEAGE_CARD_TITLE_LINE_HEIGHT,
+    );
+  });
+
+  it('占位节点与空标题都有稳定的行数（不抛错、不返回 0）', () => {
+    expect(estimateLineageCardHeight({ title: null, isStub: true })).toBe(
+      LINEAGE_CARD_BASE_HEIGHT,
+    );
+    expect(estimateLineageCardHeight({ title: '   ' })).toBe(
+      LINEAGE_CARD_BASE_HEIGHT,
+    );
+    expect(estimateLineageCardHeight({ title: null })).toBeGreaterThan(0);
+  });
+
+  it('西文标题按 0.55 折算宽度（不会因为「字符数少」把行数算少）', () => {
+    // 40 个西文字符 ≈ 22 个全角单位 → 2 行。
+    const ascii = estimateLineageCardHeight({
+      title: 'CoCreation Demo Workspace Alpha Beta Gam',
+    });
+    expect(ascii).toBe(
+      LINEAGE_CARD_BASE_HEIGHT + LINEAGE_CARD_TITLE_LINE_HEIGHT,
+    );
+  });
+});
+
+describe('clampLineagePan（平移边界：不把内容拖飞）', () => {
+  it('内容比视口大：至少保留 keep 像素可见', () => {
+    // 内容 1000 宽、视口 400、keep 96 → offset ∈ [-904, 304]
+    expect(clampLineagePan(-5000, 400, 1000)).toBe(96 - 1000);
+    expect(clampLineagePan(5000, 400, 1000)).toBe(400 - 96);
+    // 区间内原样返回
+    expect(clampLineagePan(-100, 400, 1000)).toBe(-100);
+  });
+
+  it('内容比视口小：允许在小范围内自由摆放（区间取两侧 min/max）', () => {
+    // 内容 200、视口 400、keep 96 → leftBound=-104、rightBound=304 → 区间 [-104, 304]
+    expect(clampLineagePan(-9999, 400, 200)).toBe(-104);
+    expect(clampLineagePan(9999, 400, 200)).toBe(304);
+    expect(clampLineagePan(100, 400, 200)).toBe(100);
+  });
+
+  it('视口/内容尺寸拿不到（jsdom 或未挂载）时不做限制', () => {
+    expect(clampLineagePan(-9999, 0, 1000)).toBe(-9999);
+    expect(clampLineagePan(-9999, 400, 0)).toBe(-9999);
+  });
+});
+
+describe('collectLineageAncestorChain', () => {
+  const nodes = [
+    node('root', 0, null, '根原创'),
+    node('a', 1, 'root', '一代'),
+    node('b', 2, 'a', '二代'),
+    node('b2', 2, 'a', '二代旁支'),
+    node('orphan', 1, 'game-missing', '孤儿'),
+  ];
+
+  it('从根到目标按顺序返回（供「根原创 → 1 代 → … → 当前」展示）', () => {
+    expect(
+      collectLineageAncestorChain(nodes, 'b').map((item) => item.gameId),
+    ).toEqual(['root', 'a', 'b']);
+  });
+
+  it('父不在可见集合里时链就停在那里（父作品不可用口径一致）', () => {
+    expect(
+      collectLineageAncestorChain(nodes, 'orphan').map((item) => item.gameId),
+    ).toEqual(['orphan']);
+  });
+
+  it('未知节点返回空链，且遇到自环不会死循环', () => {
+    expect(collectLineageAncestorChain(nodes, 'game-missing-chain')).toEqual(
+      [],
+    );
+    const cyclic = [node('x', 1, 'y'), node('y', 0, 'x')];
+    expect(collectLineageAncestorChain(cyclic, 'x')).toHaveLength(2);
+  });
+});
+
+describe('collectLineagePlayCountTotals（显示=子树合计）', () => {
+  /** 链：root(1) → a(2) → a1(3) → a1x(4)。 */
+  const chain = [
+    { ...node('root', 0, null), playCount: 1 },
+    { ...node('a', 1, 'root'), playCount: 2 },
+    { ...node('a1', 2, 'a'), playCount: 3 },
+    { ...node('a1x', 3, 'a1'), playCount: 4 },
+  ];
+
+  it('链式数据：每个节点的合计 = 自己 + 全部后代', () => {
+    const totals = collectLineagePlayCountTotals(chain);
+    expect(totals.get('a1x')).toEqual({ own: 4, inherited: 0, total: 4 });
+    expect(totals.get('a1')).toEqual({ own: 3, inherited: 4, total: 7 });
+    expect(totals.get('a')).toEqual({ own: 2, inherited: 7, total: 9 });
+    expect(totals.get('root')).toEqual({ own: 1, inherited: 9, total: 10 });
+  });
+
+  it('分支数据：兄弟各自累加后再汇总给父代', () => {
+    const branch = [
+      { ...node('root', 0, null), playCount: 1 },
+      { ...node('a', 1, 'root'), playCount: 10 },
+      { ...node('a1', 2, 'a'), playCount: 5 },
+      { ...node('b', 1, 'root'), playCount: 20 },
+    ];
+    const totals = collectLineagePlayCountTotals(branch);
+    expect(totals.get('root')).toEqual({ own: 1, inherited: 35, total: 36 });
+    expect(totals.get('a')).toEqual({ own: 10, inherited: 5, total: 15 });
+    expect(totals.get('b')).toEqual({ own: 20, inherited: 0, total: 20 });
+  });
+
+  it('每个节点都满足服务端不变量 total = own + Σ 直接子代 total', () => {
+    const branch = [
+      { ...node('root', 0, null), playCount: 1 },
+      { ...node('a', 1, 'root'), playCount: 10 },
+      { ...node('a1', 2, 'a'), playCount: 5 },
+      { ...node('a2', 2, 'a'), playCount: 7 },
+      { ...node('b', 1, 'root'), playCount: 20 },
+    ];
+    const totals = collectLineagePlayCountTotals(branch);
+    for (const item of branch) {
+      const own = totals.get(item.gameId)!.own;
+      const directChildren = branch.filter(
+        (candidate) => candidate.parentGameId === item.gameId,
+      );
+      const sum = directChildren.reduce(
+        (acc, child) => acc + (totals.get(child.gameId)?.total ?? 0),
+        0,
+      );
+      expect(totals.get(item.gameId)!.total).toBe(own + sum);
+    }
+  });
+
+  it('单节点树：合计 = 自身', () => {
+    const totals = collectLineagePlayCountTotals([
+      { ...node('solo', 0, null), playCount: 12 },
+    ]);
+    expect(totals.get('solo')).toEqual({ own: 12, inherited: 0, total: 12 });
+  });
+
+  it('缺字段 / 非有限 / 负数一律按 0 计（不臆造）', () => {
+    const totals = collectLineagePlayCountTotals([
+      { gameId: 'root', parentGameId: null, playCount: undefined },
+      { gameId: 'a', parentGameId: 'root', playCount: Number.NaN },
+      { gameId: 'b', parentGameId: 'root', playCount: -5 },
+      { gameId: 'c', parentGameId: 'root', playCount: 4 },
+    ]);
+    expect(totals.get('a')).toEqual({ own: 0, inherited: 0, total: 0 });
+    expect(totals.get('b')).toEqual({ own: 0, inherited: 0, total: 0 });
+    expect(totals.get('root')).toEqual({ own: 0, inherited: 4, total: 4 });
+  });
+
+  it('父节点不在可见集合里时只统计可见子树，不向上虚构', () => {
+    const totals = collectLineagePlayCountTotals([
+      { ...node('child', 1, 'game-removed'), playCount: 5 },
+      { ...node('grandchild', 2, 'child'), playCount: 7 },
+    ]);
+    expect(totals.get('child')).toEqual({ own: 5, inherited: 7, total: 12 });
+    // 不可见的父作品不会被凭空造出来。
+    expect(totals.has('game-removed')).toBe(false);
+  });
+
+  it('脏数据里的环不会死循环，且每个节点只累加一次', () => {
+    const totals = collectLineagePlayCountTotals([
+      { gameId: 'x', parentGameId: 'y', playCount: 1 },
+      { gameId: 'y', parentGameId: 'x', playCount: 2 },
+    ]);
+    expect(totals.get('x')!.total).toBe(3);
+    expect(totals.get('y')!.total).toBeGreaterThanOrEqual(2);
+    expect(totals.get('x')!.total).toBeLessThanOrEqual(3);
+  });
+});
+
+describe('主干线判据 = 自身 playCount（不是子树合计）', () => {
+  it('自身高但合计低 与 自身低但合计高 的兄弟，主干线选**自身高**的那个', () => {
+    // A：自己 100、没有子代（合计 100）。B：自己 5、但有一个 200 播放的子代（合计 205）。
+    const layout = buildLineageTreeLayout([
+      { ...node('root', 0, null), playCount: 1 },
+      { ...node('a', 1, 'root'), playCount: 100 },
+      { ...node('b', 1, 'root'), playCount: 5 },
+      { ...node('b1', 2, 'b'), playCount: 200 },
+    ]);
+    const totals = collectLineagePlayCountTotals([
+      { ...node('root', 0, null), playCount: 1 },
+      { ...node('a', 1, 'root'), playCount: 100 },
+      { ...node('b', 1, 'root'), playCount: 5 },
+      { ...node('b1', 2, 'b'), playCount: 200 },
+    ]);
+    // 合计上 B 赢（205 > 100）……
+    expect(totals.get('b')!.total).toBeGreaterThan(totals.get('a')!.total);
+    const byId = new Map(layout.nodes.map((item) => [item.gameId, item]));
+    // ……但主干线判据是自身，所以主干是 A。
+    expect(byId.get('a')!.isTrunk).toBe(true);
+    expect(byId.get('b')!.isTrunk).toBe(false);
+  });
+});
+
+describe('主干唯一性（playCount 全 0 的演示树，输入顺序 = 服务端稳定序）', () => {
+  /**
+   * 演示树形状（`共创演示·A0` 那棵）：A0 → A1/A2/A3；A1 → A11/A12；A11 → A111；
+   * A2 → A21。全部 `playCount = 0`（演示数据没有播放）。
+   * 服务端 `/lineage` 契约保证「代际升序、同代按创建时间升序」，这里按该顺序喂入。
+   */
+  const demoTree = [
+    node('A0', 0, null),
+    node('A1', 1, 'A0'),
+    node('A2', 1, 'A0'),
+    node('A3', 1, 'A0'),
+    node('A11', 2, 'A1'),
+    node('A12', 2, 'A1'),
+    node('A21', 2, 'A2'),
+    node('A111', 3, 'A11'),
+  ].map((item) => ({ ...item, playCount: 0 }));
+
+  it('每代恰好一个主干（并列 0 热度时取同代中创建时间最早的），A2/A3 不是主干', () => {
+    const layout = buildLineageTreeLayout(demoTree);
+    const trunkByGeneration = new Map<number, string[]>();
+    for (const item of layout.nodes) {
+      if (!item.isTrunk) continue;
+      const bucket = trunkByGeneration.get(item.generation) ?? [];
+      bucket.push(item.gameId);
+      trunkByGeneration.set(item.generation, bucket);
+    }
+    // 每代最多一个（这就是「主干泛滥」的反例断言）。
+    for (const [generation, ids] of trunkByGeneration) {
+      expect(ids, `第 ${generation} 代的主干`).toHaveLength(1);
+    }
+    expect(trunkByGeneration.get(0)).toEqual(['A0']);
+    expect(trunkByGeneration.get(1)).toEqual(['A1']);
+    expect(trunkByGeneration.get(2)).toEqual(['A11']);
+    expect(trunkByGeneration.get(3)).toEqual(['A111']);
+    const byId = new Map(layout.nodes.map((item) => [item.gameId, item]));
+    expect(byId.get('A2')!.isTrunk).toBe(false);
+    expect(byId.get('A3')!.isTrunk).toBe(false);
+    expect(byId.get('A12')!.isTrunk).toBe(false);
+    expect(byId.get('A21')!.isTrunk).toBe(false);
+  });
+
+  it('同代并列零热度：结果与输入顺序绑定（稳定、不随渲染变化）', () => {
+    // 同一棵树跑两次必须完全一致；把同代顺序换一下，主干跟着换成更早创建的那个。
+    const first = buildLineageTreeLayout(demoTree);
+    const second = buildLineageTreeLayout(demoTree);
+    expect(first.nodes.map((item) => item.isTrunk)).toEqual(
+      second.nodes.map((item) => item.isTrunk),
+    );
+    const reordered = buildLineageTreeLayout([
+      node('A0', 0, null),
+      { ...node('A2', 1, 'A0'), playCount: 0 },
+      { ...node('A1', 1, 'A0'), playCount: 0 },
+    ]);
+    const byId = new Map(reordered.nodes.map((item) => [item.gameId, item]));
+    expect(byId.get('A2')!.isTrunk).toBe(true);
+    expect(byId.get('A1')!.isTrunk).toBe(false);
+  });
+});
+
+describe('collectLineageHighlight', () => {
+  const tree = buildLineageTreeLayout([
+    node('root', 0, null),
+    node('a', 1, 'root'),
+    node('b', 1, 'root'),
+    node('a1', 2, 'a'),
+    node('a1x', 3, 'a1'),
+  ]);
+
+  it('高亮节点自身 + 祖先路径（不含兄弟）', () => {
+    const highlighted = collectLineageHighlight(tree.nodes, 'a1', {
+      includeSubtree: false,
+    });
+    expect([...highlighted].sort()).toEqual(['a', 'a1', 'root']);
+    expect(highlighted.has('b')).toBe(false);
+    expect(highlighted.has('a1x')).toBe(false);
+  });
+
+  it('包含子树时把后代一并高亮', () => {
+    const highlighted = collectLineageHighlight(tree.nodes, 'a');
+    expect([...highlighted].sort()).toEqual(['a', 'a1', 'a1x', 'root']);
+  });
+
+  it('根节点 + 子树 = 整棵树', () => {
+    expect(collectLineageHighlight(tree.nodes, 'root').size).toBe(5);
+  });
+
+  it('激活不存在的节点时返回空集合（不抛错）', () => {
+    expect(collectLineageHighlight(tree.nodes, 'game-missing').size).toBe(0);
+  });
+
+  it('占位父节点也会被高亮（它是路径上的一环）', () => {
+    const withStub = buildLineageTreeLayout([node('child', 1, 'game-removed')]);
+    const highlighted = collectLineageHighlight(withStub.nodes, 'child');
+    expect([...highlighted].sort()).toEqual(['child', 'game-removed']);
+  });
+});
+
+/**
+ * 血缘关系数据集：root → a → a1 → a1x，root → b（旁支），a → a2（第二个子代）。
+ * 用来钉住「父代 / 子代 / 自己 / 旁支」四类角色与「只看父代与子代」的集合口径。
+ */
+const relationTree = [
+  node('root', 0, null),
+  node('a', 1, 'root'),
+  node('b', 1, 'root'),
+  node('a1', 2, 'a'),
+  node('a2', 2, 'a'),
+  node('a1x', 3, 'a1'),
+];
+
+describe('collectLineageRelationRoles', () => {
+  it('区分自己 / 父代（祖先链）/ 子代（整棵后代子树）/ 旁支', () => {
+    const roles = collectLineageRelationRoles(relationTree, 'a');
+    expect(roles.get('a')).toBe('self');
+    expect(roles.get('root')).toBe('ancestor');
+    expect(roles.get('a1')).toBe('descendant');
+    expect(roles.get('a2')).toBe('descendant');
+    expect(roles.get('a1x')).toBe('descendant');
+    // 兄弟分支是旁支：不冒充父代/子代。
+    expect(roles.get('b')).toBe('side');
+  });
+
+  it('根节点：自己没有父代，所有后代都是子代', () => {
+    const roles = collectLineageRelationRoles(relationTree, 'root');
+    expect([...roles.entries()].filter(([, r]) => r === 'ancestor')).toEqual(
+      [],
+    );
+    expect(
+      [...roles.entries()]
+        .filter(([, r]) => r === 'descendant')
+        .map(([id]) => id)
+        .sort(),
+    ).toEqual(['a', 'a1', 'a1x', 'a2', 'b']);
+  });
+
+  it('叶节点：只有父代链，没有子代', () => {
+    const roles = collectLineageRelationRoles(relationTree, 'a1x');
+    expect(roles.get('a1x')).toBe('self');
+    expect(
+      [...roles.entries()]
+        .filter(([, r]) => r === 'ancestor')
+        .map(([id]) => id)
+        .sort(),
+    ).toEqual(['a', 'a1', 'root']);
+    expect(
+      [...roles.values()].filter((role) => role === 'descendant'),
+    ).toHaveLength(0);
+  });
+
+  it('单节点树：自己是 self，没有父代/子代', () => {
+    const roles = collectLineageRelationRoles([node('solo', 0, null)], 'solo');
+    expect([...roles.entries()]).toEqual([['solo', 'self']]);
+  });
+
+  it('锚点不在可见集合里：全部按旁支返回（不抛错、不臆造关系）', () => {
+    const roles = collectLineageRelationRoles(relationTree, 'game-missing');
+    expect([...roles.values()].every((role) => role === 'side')).toBe(true);
+  });
+
+  it('自环数据不会死循环', () => {
+    const cyclic = [node('x', 1, 'y'), node('y', 0, 'x')];
+    const roles = collectLineageRelationRoles(cyclic, 'x');
+    expect(roles.get('x')).toBe('self');
+    expect(roles.get('y')).toBe('ancestor');
+  });
+});
+
+describe('collectLineageImmediateScope（只看父代与子代）', () => {
+  it('保留祖先链 + 自己 + **直接**子代（不含孙代）', () => {
+    const scope = collectLineageImmediateScope(relationTree, 'a');
+    // a1x 是孙代（a 的子代的子代），不在「只看父子」的范围里。
+    expect([...scope].sort()).toEqual(['a', 'a1', 'a2', 'root']);
+    expect(scope.has('a1x')).toBe(false);
+    expect(scope.has('b')).toBe(false);
+  });
+
+  it('根节点：自己 + 直接子代', () => {
+    expect(
+      [...collectLineageImmediateScope(relationTree, 'root')].sort(),
+    ).toEqual(['a', 'b', 'root']);
+  });
+
+  it('离树的锚点返回空集合（调用方据此不筛选）', () => {
+    expect(
+      collectLineageImmediateScope(relationTree, 'game-missing').size,
+    ).toBe(0);
+  });
+
+  it('父代不在可见集合里时链停在子节点上（父仍由布局层补占位）', () => {
+    const scope = collectLineageImmediateScope(
+      [node('child', 1, 'game-removed'), node('grandchild', 2, 'child')],
+      'child',
+    );
+    expect([...scope].sort()).toEqual(['child', 'grandchild']);
+  });
+});
diff --git a/src/components/game-distribution/lineageTreeLayout.ts b/src/components/game-distribution/lineageTreeLayout.ts
new file mode 100644
index 000000000..1686e4291
--- /dev/null
+++ b/src/components/game-distribution/lineageTreeLayout.ts
@@ -0,0 +1,875 @@
+import type { GameDistributionLineageNode } from '../../services/gameDistributionClient';
+
+/**
+ * 创作族谱树的可视化布局（tidy tree 的轻量实现）。
+ *
+ * 纯函数：输入节点列表，输出坐标 / 尺寸 / 连线端点，不依赖 DOM 也不依赖 React，
+ * 因此可以在单测里把「不重叠」「确定性」「深链 / 宽扇出 / 单节点」这些性质钉死。
+ *
+ * 算法（两趟，O(n log n) 里 log 只来自排序）：
+ * 1. **补降级父节点**：节点的 `parentGameId` 不在可见集合里（父作品已删 / 未公开）时，
+ *    为它补一个**占位节点**——只有 ID 与代际，没有标题与作者名（既有降级口径），
+ *    这样树在视觉上仍然连通，而不是让子节点孤零零飘着。
+ * 2. **按代际分行**：generation 决定行（父在上、子在下），行内 y 相同。
+ * 3. **槽位分配求 x**：对森林做后序遍历——叶子按访问顺序拿下一个整数槽位，内部节点取
+ *    子节点槽位的**中点**。因为 DFS 让每棵子树的槽位区间连续且互不相交，同层节点的中心
+ *    间距必然 ≥ 1 个槽位；再用「槽位间距 = 节点宽 + 列间距」把槽位映射成像素，
+ *    于是**同层任意两节点至少隔着 `LINEAGE_COLUMN_GAP`，结构上不可能重叠**。
+ * 4. **连线**：正交路由（elbow）——父节点底边中点竖直下行、在两代之间水平走线、再从子节点
+ *    顶边中点竖直进入，转角倒小圆角；`path` 字符串里同时给出端点坐标，测试可以直接断言端点
+ *    与「竖直段/水平段存在」而不是解析路径。
+ */
+
+/**
+ * 封面宽高比：与平台既有封面约定一致 = **16 / 9 横版**。
+ *
+ * 依据（仓库现役约定，不是我自定的）：
+ * - 发布面板的封面预览 `.game-publish-media__preview { aspect-ratio: 16 / 9 }`
+ *   （`src/components/game-distribution/gameDistribution.css:1645`）
+ * - 发布面板的截图/占位 `.game-publish-media__shot img|placeholder { aspect-ratio: 16 / 9 }`
+ *   （同文件 `:1733`、`:1740`）
+ * - 详情页媒体区同样按 16 / 9（`packages/shared/src/components/GameDetailDisplay/index.css:114`）
+ *
+ * 节点卡片按这个比例给封面留位，所以「竖图当封面」的问题从容器一侧就被消除。
+ */
+export const LINEAGE_COVER_ASPECT = 16 / 9;
+
+/**
+ * **卡片宽度的唯一来源**（2026-10-07 用户口径：「父代子代应该都和血缘图里的用的是一个卡片，
+ * 一起调宽一点」）——画布节点卡与「父代 / 子代」清单卡读**同一个值**：
+ * - JS 侧：本文件的布局常量（节点容器宽 = 卡宽 + 2×`LINEAGE_NODE_PADDING_X`）；
+ * - CSS 侧：族谱页把这两个值写进自定义属性 `--lineage-card-width` / `--lineage-compact-card-width`
+ *   （见 `GameLineagePage`），`.game-lineage-node` 与 `.lineage-relation__grid` 都只读它们，
+ *   **不在 CSS 里另写一套卡宽**。
+ *
+ * 取值依据：旧的画布卡 212.4px 宽时标题每行只放得下 10 个全角字符，
+ * 清单卡更是 152–174px、常见标题（如「共创演示·A2｜星海工坊·轨道集市」16 字）被单行截断；
+ * 加宽到 **224**（+11.6px）后每行约 11 字、2 行可完整容纳 16–22 字标题。
+ */
+export const LINEAGE_CARD_WIDTH = 224;
+/** 窄屏图谱（横版紧凑画布）的卡宽：与清单卡在 ≤820px 断点用的是同一个值。 */
+export const LINEAGE_COMPACT_CARD_WIDTH = 148;
+/**
+ * 节点容器左右内边距（px）。
+ *
+ * 为什么写成 px 且与 CSS 共享：容器宽 = 卡宽 + 2×该值，而布局要按**容器宽**排 x / 算连线锚点，
+ * 渲染层要按**卡宽**撑卡片 —— 两边必须是同一次计算结果。旧的 0.8rem 在不同根字号下会漂移，
+ * 因此这里定 px，并由页面把 `--lineage-node-pad-x` 一起下发（CSS 只消费、不自己写数）。
+ */
+export const LINEAGE_NODE_PADDING_X = 12.8;
+/** 节点容器上下内边距（px）：与 `LINEAGE_NODE_PADDING_X` 一样由页面下发给 CSS。 */
+export const LINEAGE_NODE_PADDING_Y = 11.2;
+
+export const LINEAGE_NODE_WIDTH =
+  LINEAGE_CARD_WIDTH + LINEAGE_NODE_PADDING_X * 2;
+/** 紧凑画布的容器宽（窄屏横版用）。 */
+export const LINEAGE_COMPACT_NODE_WIDTH =
+  LINEAGE_COMPACT_CARD_WIDTH + LINEAGE_NODE_PADDING_X * 2;
+/**
+ * 卡片高度的**缺省回退值**（调用方没传 `cardHeights` 时用）。
+ * 族谱页/血缘图真实渲染的是 `LINEAGE_CARD_WIDTH` 宽的广场卡变体，
+ * 走 `LINEAGE_CARD_BASE_HEIGHT`（含角标行与作者行）。
+ */
+export const LINEAGE_NODE_HEIGHT = 192;
+/** 同一层相邻槽位之间额外留的横向间隙（保证不重叠）。 */
+export const LINEAGE_COLUMN_GAP = 32;
+/** 相邻代际之间的纵向间隙。 */
+export const LINEAGE_ROW_GAP = 104;
+/** 左侧「代际轴」占的宽度（第 0 代 / 第 1 代 …）。 */
+export const LINEAGE_AXIS_WIDTH = 92;
+
+export type LineageLayoutNode = {
+  /** 真实作品是 gameId；占位父节点是那个不可用的父作品 ID。 */
+  gameId: string;
+  /** 占位节点没有原始节点（服务端不会把不可用父作品当成节点发出来）。 */
+  node: GameDistributionLineageNode | null;
+  /** 占位节点为 null：不展示被删作品的标题。 */
+  title: string | null;
+  /** 占位节点为 null：不展示被删作品的作者名。 */
+  authorName: string | null;
+  /** 平台封面对象键；服务端还没补或作品没有封面时为 null（渲染回退到代际色块）。 */
+  coverObjectKey: string | null;
+  generation: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  /** true = 父作品不可用的降级占位节点（可聚焦、不可点进详情）。 */
+  isStub: boolean;
+  /**
+   * 顶级分支序号（森林里第几棵子树，按 DFS 顺序）。
+   *
+   * 同一分支的节点与连线共用一种色系，因此**默认全览**下也能看出「哪几颗是一个共创分支」，
+   * 不必等 hover。占位父节点属于它子节点所在的分支。
+   */
+  branchIndex: number;
+  /**
+   * 主干线节点：**该代 `playCount` 最高**的那个（并列取先出现的；占位节点不参与）。
+   * 文档要求「每代热度最高的版本标为主干线，用粗实线连接」。
+   * 判据是**自身** `playCount`，不是子树合计（裁定见 `buildLineageTreeLayout` 里的注释）。
+   */
+  isTrunk: boolean;
+};
+
+export type LineageLayoutEdge = {
+  id: string;
+  parentGameId: string;
+  childGameId: string;
+  /** SVG path（正交 elbow，转角带圆角）。 */
+  path: string;
+  from: { x: number; y: number };
+  to: { x: number; y: number };
+  /** 该边属于哪棵顶级子树，用于默认态按分支着色。 */
+  branchIndex: number;
+  /** 主干线：父与子都是各自代际的热度最高节点（渲染成粗实线）。 */
+  isTrunk: boolean;
+};
+
+export type LineageGenerationAxisEntry = {
+  generation: number;
+  label: string;
+  /** 该代际所在行的顶部 y（竖版 = 累计层高）。 */
+  y: number;
+  /** 该层的高度（= 该层卡片的最大高度）；渲染代际轴时按它画行高，不再拿「第一个节点的高度」凑。 */
+  height: number;
+  /** 该行实际渲染的节点数（含占位节点）。 */
+  count: number;
+};
+
+export type LineageTreeLayout = {
+  nodes: LineageLayoutNode[];
+  edges: LineageLayoutEdge[];
+  axis: LineageGenerationAxisEntry[];
+  /** 内容总尺寸（含左侧代际轴），供画布与「总览」使用。 */
+  width: number;
+  height: number;
+};
+
+export type LineageLayoutOptions = {
+  nodeWidth?: number;
+  nodeHeight?: number;
+  columnGap?: number;
+  rowGap?: number;
+  axisWidth?: number;
+  /**
+   * 朝向：`vertical`（默认，根在上、代际向下）或 `horizontal`（根在左、代际向右）。
+   *
+   * 移动端「图谱视图」用横向：窄屏上代际沿横向推进、兄弟分支沿纵向排开，比顶→下省横向空间。
+   * 布局算法本身不变（只是把「行/列」这两个轴的像素映射与连线端点对调）。
+   */
+  orientation?: 'vertical' | 'horizontal';
+  /**
+   * 每个节点卡片的高度（`estimateLineageCardHeight` 的结果）。
+   *
+   * 竖版：**第 N 层的层高 = 该层卡片的最大高度**，下一层的 y 按累计层高 + `rowGap` 排 ——
+   * 这样「同层有一张 2 行标题的高卡」也不会被下一层压住（层内所有卡片同高：都取该层最大值）。
+   * 横版：兄弟沿 y 排开，槽位高取全局最大值。
+   * 缺省（不传 / 某节点没值）退回 `nodeHeight`。
+   */
+  cardHeights?: ReadonlyMap<string, number>;
+};
+
+/**
+ * 画布卡片的高度估算（**纯函数、确定性**，布局据此算「每层多高」）。
+ *
+ * 为什么必须估算而不是等渲染后测量：布局是纯函数（要能单测、要能离线复算），
+ * 一旦依赖 `getBoundingClientRect` 就会引入抖动与「先渲染再重排」的死循环。
+ * 估算公式 = 基础高 + (标题行数 - 1) × 行高，标题行数按**字符宽度**估（CJK 记 1、其余记 0.55），
+ * 上限 2 行（与 CSS 的 `-webkit-line-clamp: 2` 一致）。
+ *
+ * 常量由**真机实测校准**（2026-10-07 重测：角标槽从「压在封面上」改回**封面下方**的信息区第一行、
+ * 标题独占一行之后，卡片又高了 —— 老常量 214/20 已明显偏小，实测层间距被吃掉一半）。
+ * 实测（真机 Chromium、演示树 8 节点、桌面 1440×900、卡宽 224px / 节点盒 249.6px）：
+ * 节点盒高 = 16:9 封面 126 + 角标行 26.9 + 信息区（1 行标题）≈ 90 + 节点内边距 22.4 = **264.8**（真机实测）；
+ * 标题每多一行 = **+24**（标题行盒 24px）；
+ * 真机实测（2026-10-07，1440×1000、卡宽 224 / 节点盒 249.6、画布缩放 0.8216 换算回内容坐标）：
+ * 1 行标题节点盒 **264.8**、2 行 **288.8**（差 24 = 行高）⇒ 取 `base = 265` / `行高 = 24`（**估算 ≥ 实测**，只多 0.2px）。
+ */
+export const LINEAGE_CARD_BASE_HEIGHT = 265;
+/**
+ * 窄屏紧凑卡片（`LINEAGE_COMPACT_CARD_WIDTH` 宽、横版画布）的**节点盒**基础高。
+ * 真机实测（2026-10-07，390×844 / 图谱视图、画布缩放 0.35 换算回内容坐标）：
+ * 卡 148×223.7（1 行标题）⇒ 节点盒 173.6×**246.1**，取 **247**（估算 ≥ 实测）；
+ * 标题每多一行 +24（同 `LINEAGE_CARD_TITLE_LINE_HEIGHT`）。
+ */
+export const LINEAGE_COMPACT_CARD_BASE_HEIGHT = 247;
+/** 标题每多一行增加的高度（= 标题行盒高度，真机实测 24px）。 */
+export const LINEAGE_CARD_TITLE_LINE_HEIGHT = 24;
+/** 标题最多 2 行（CSS line-clamp 同值）。 */
+export const LINEAGE_CARD_TITLE_MAX_LINES = 2;
+/**
+ * 卡面一行大约能放下的「全角字符」数（估算用）。
+ * 广场卡在 224 宽画布卡里标题是 1rem 粗体、可用宽度 **192px** ⇒ 一行 ≈ **12** 个全角字符。
+ * 真机实测：「共创演示·A0｜星海工坊」（视觉宽度 10.65）**1 行**、
+ * 「共创演示·A1｜星海工坊·深海回声」（15.65）**2 行** —— 取 11 与两条实测都对得上
+ *（取 10 会把前者高估成 2 行，白高 24px）。
+ */
+export const LINEAGE_CARD_TITLE_CHARS_PER_LINE = 12;
+
+function titleVisualWidth(title: string) {
+  let width = 0;
+  for (const char of title) {
+    // CJK / 全角标点占一个「全角单位」，西文与半角按 0.55 折算（经验值，宁可高估行数）。
+    width +=
+      /[\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe30-\ufe6f\uff00-\uff60]/u.test(
+        char,
+      )
+        ? 1
+        : 0.55;
+  }
+  return width;
+}
+
+/**
+ * 给定标题，估算画布卡片高度（像素）。**同一层里取最大值**就是那一层的高度
+ * （`buildLineageTreeLayout` 的 `cardHeights` 输入就是这么用的）。
+ */
+export function estimateLineageCardHeight(input: {
+  title?: string | null;
+  isStub?: boolean;
+  baseHeight?: number;
+}): number {
+  const base = input.baseHeight ?? LINEAGE_CARD_BASE_HEIGHT;
+  const title = input.isStub
+    ? '原作品已不可用'
+    : (input.title ?? '').trim() || '未命名作品';
+  const lines = Math.min(
+    LINEAGE_CARD_TITLE_MAX_LINES,
+    Math.max(
+      1,
+      Math.ceil(titleVisualWidth(title) / LINEAGE_CARD_TITLE_CHARS_PER_LINE),
+    ),
+  );
+  return base + (lines - 1) * LINEAGE_CARD_TITLE_LINE_HEIGHT;
+}
+
+export function generationAxisLabel(generation: number) {
+  return generation === 0 ? '母版' : `第 ${generation} 代`;
+}
+
+function roundTo(value: number, digits = 2) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+export function buildLineageTreeLayout(
+  nodes: readonly GameDistributionLineageNode[],
+  options: LineageLayoutOptions = {},
+): LineageTreeLayout {
+  const nodeWidth = options.nodeWidth ?? LINEAGE_NODE_WIDTH;
+  const nodeHeight = options.nodeHeight ?? LINEAGE_NODE_HEIGHT;
+  const columnGap = options.columnGap ?? LINEAGE_COLUMN_GAP;
+  const rowGap = options.rowGap ?? LINEAGE_ROW_GAP;
+  const axisWidth = options.axisWidth ?? LINEAGE_AXIS_WIDTH;
+
+  const visibleIds = new Set(nodes.map((node) => node.gameId));
+  const entries: {
+    gameId: string;
+    node: GameDistributionLineageNode | null;
+    title: string | null;
+    authorName: string | null;
+    coverObjectKey: string | null;
+    generation: number;
+    parentGameId: string | null;
+    order: number;
+  }[] = [];
+  let order = 0;
+  for (const node of nodes) {
+    entries.push({
+      gameId: node.gameId,
+      node,
+      title: node.title,
+      authorName: node.authorName ?? null,
+      coverObjectKey: (node.coverObjectKey ?? '').trim() || null,
+      generation: node.generation,
+      parentGameId: node.parentGameId ?? null,
+      order: order++,
+    });
+  }
+  // 占位父节点：同一父只补一次；代际取所有子节点里最小代际 - 1。
+  const stubGenerations = new Map<string, number>();
+  for (const node of nodes) {
+    const parentGameId = node.parentGameId ?? null;
+    if (!parentGameId || visibleIds.has(parentGameId)) continue;
+    // 占位父节点的代际：至少 0；父代际未知时按「比子节点早一代」推断。
+    const candidate = node.generation > 0 ? node.generation - 1 : 0;
+    const current = stubGenerations.get(parentGameId);
+    stubGenerations.set(
+      parentGameId,
+      current === undefined ? candidate : Math.min(current, candidate),
+    );
+  }
+  for (const [gameId, generation] of stubGenerations) {
+    entries.push({
+      gameId,
+      node: null,
+      title: null,
+      authorName: null,
+      coverObjectKey: null,
+      generation,
+      parentGameId: null,
+      order: order++,
+    });
+  }
+
+  // 稳定顺序：代际升序 → 输入顺序（含占位节点）。同输入必然同输出。
+  entries.sort(
+    (left, right) =>
+      left.generation - right.generation || left.order - right.order,
+  );
+
+  const byId = new Map(entries.map((entry) => [entry.gameId, entry]));
+  const childrenByParent = new Map<string, typeof entries>();
+  for (const entry of entries) {
+    if (!entry.parentGameId || !byId.has(entry.parentGameId)) continue;
+    const bucket = childrenByParent.get(entry.parentGameId);
+    if (bucket) bucket.push(entry);
+    else childrenByParent.set(entry.parentGameId, [entry]);
+  }
+  const forestRoots = entries.filter(
+    (entry) => !entry.parentGameId || !byId.has(entry.parentGameId),
+  );
+
+  // 第 3 步：后序分配槽位；同时记录每棵顶级子树的编号（用于默认态分支着色）。
+  const slotByGameId = new Map<string, number>();
+  const branchByGameId = new Map<string, number>();
+  let nextSlot = 0;
+  let nextBranch = 0;
+  const visit = (
+    entry: (typeof entries)[number],
+    branchIndex: number,
+  ): number => {
+    branchByGameId.set(entry.gameId, branchIndex);
+    const children = childrenByParent.get(entry.gameId) ?? [];
+    if (children.length === 0) {
+      const slot = nextSlot;
+      nextSlot += 1;
+      slotByGameId.set(entry.gameId, slot);
+      return slot;
+    }
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const child of children) {
+      const childSlot = visit(child, branchIndex);
+      min = Math.min(min, childSlot);
+      max = Math.max(max, childSlot);
+    }
+    const slot = (min + max) / 2;
+    slotByGameId.set(entry.gameId, slot);
+    return slot;
+  };
+  for (const root of forestRoots) {
+    if (slotByGameId.has(root.gameId)) continue;
+    visit(root, nextBranch);
+    nextBranch += 1;
+  }
+
+  const generations = [
+    ...new Set(entries.map((entry) => entry.generation)),
+  ].sort((left, right) => left - right);
+  const rowByGeneration = new Map(
+    generations.map((generation, index) => [generation, index] as const),
+  );
+  const pitch = nodeWidth + columnGap;
+  const orientation = options.orientation ?? 'vertical';
+  /**
+   * 每个节点卡片的高度（调用方用 `estimateLineageCardHeight` 估算），缺省退回 `nodeHeight`。
+   * 布局**不测量 DOM**：所有几何都由这张表推出，纯函数可离线复算、可单测。
+   */
+  const cardHeightOf = (gameId: string) => {
+    const provided = options.cardHeights?.get(gameId);
+    return provided && Number.isFinite(provided) && provided > 0
+      ? provided
+      : nodeHeight;
+  };
+  // 竖版：**层高 = 该层卡片的最大高度**（层内所有卡片同高 → 同层等高，且下一层不会被压住）。
+  const layerHeightByGeneration = new Map<number, number>();
+  for (const entry of entries) {
+    const height = cardHeightOf(entry.gameId);
+    const current = layerHeightByGeneration.get(entry.generation);
+    layerHeightByGeneration.set(
+      entry.generation,
+      current === undefined ? height : Math.max(current, height),
+    );
+  }
+  /** 竖版：每层顶部 y（上一层的层高 + rowGap 累计）。 */
+  const rowTopByGeneration = new Map<number, number>();
+  {
+    let cursor = 0;
+    for (const generation of generations) {
+      rowTopByGeneration.set(generation, roundTo(cursor));
+      cursor +=
+        (layerHeightByGeneration.get(generation) ?? nodeHeight) + rowGap;
+    }
+  }
+  // 横版：兄弟沿 y 排开，槽位高取全局最大卡片高（否则同一槽位上的兄弟会互相压住）。
+  const slotHeight = Math.max(
+    nodeHeight,
+    ...[...new Set(entries.map((entry) => entry.gameId))].map(cardHeightOf),
+  );
+  const slotPitch = slotHeight + rowGap;
+  // 只在真正用到的槽位区间上铺像素：把左侧空槽位裁掉，内容因此更紧凑，
+  // 「整棵树居中」时右侧也不会留下大片空白。
+  const usedSlots = [...slotByGameId.values()];
+  const minSlot = usedSlots.length > 0 ? Math.min(...usedSlots) : 0;
+  const maxSlot = usedSlots.length > 0 ? Math.max(...usedSlots) : 0;
+
+  const layoutNodes: LineageLayoutNode[] = entries.map((entry) => {
+    const slot = slotByGameId.get(entry.gameId) ?? 0;
+    const row = rowByGeneration.get(entry.generation) ?? 0;
+    // 竖版：代际→y、槽位→x；横版：代际→x、槽位→y（同一套槽位算法，只换轴）。
+    const horizontal = orientation === 'horizontal';
+    const layerHeight =
+      layerHeightByGeneration.get(entry.generation) ?? nodeHeight;
+    return {
+      gameId: entry.gameId,
+      node: entry.node,
+      title: entry.title,
+      authorName: entry.authorName,
+      coverObjectKey: entry.coverObjectKey,
+      generation: entry.generation,
+      x: horizontal
+        ? roundTo(axisWidth + row * pitch)
+        : roundTo(axisWidth + (slot - minSlot) * pitch),
+      y: horizontal
+        ? roundTo((slot - minSlot) * slotPitch)
+        : (rowTopByGeneration.get(entry.generation) ?? 0),
+      width: nodeWidth,
+      // 层内同高：竖版取该层最大高度、横版取全局最大高度（卡片按 min-height 撑到同高）。
+      height: horizontal ? slotHeight : layerHeight,
+      isStub: entry.node === null,
+      branchIndex: branchByGameId.get(entry.gameId) ?? 0,
+      isTrunk: false,
+    };
+  });
+
+  // 主干线：每代取 `playCount` 最高的真实节点（占位节点不参与、并列取先出现的）。
+  //
+  // **判据裁定（2026-10-06）**：这里用的是**自身** `playCount`，**不是**子树合计
+  // （`collectLineagePlayCountTotals` 的 `total`）。主干线要表达「**这一版自己**有多热」；
+  // 换成合计会让「后代多但自己很冷」的节点压制真正热的叶子节点，整条主干线失去意义。
+  // 「显示=子树合计、主干线判据=自身」这两个口径同时成立，别把它们合并。
+  const trunkByGeneration = new Map<number, LineageLayoutNode>();
+  for (const node of layoutNodes) {
+    if (node.isStub) continue;
+    const current = trunkByGeneration.get(node.generation);
+    if (!current || node.node!.playCount > current.node!.playCount) {
+      trunkByGeneration.set(node.generation, node);
+    }
+  }
+  for (const node of layoutNodes) {
+    node.isTrunk = trunkByGeneration.get(node.generation) === node;
+  }
+
+  const layoutById = new Map(layoutNodes.map((node) => [node.gameId, node]));
+  const edges: LineageLayoutEdge[] = [];
+  for (const node of layoutNodes) {
+    const parentGameId = node.isStub ? null : (node.node?.parentGameId ?? null);
+    if (!parentGameId) continue;
+    const parent = layoutById.get(parentGameId);
+    if (!parent) continue;
+    const horizontal = orientation === 'horizontal';
+    // 竖版：父底中点 → 子顶中点；横版：父右边中点 → 子左边中点。
+    const from = horizontal
+      ? {
+          x: roundTo(parent.x + parent.width),
+          y: roundTo(parent.y + parent.height / 2),
+        }
+      : {
+          x: roundTo(parent.x + parent.width / 2),
+          y: roundTo(parent.y + parent.height),
+        };
+    const to = horizontal
+      ? { x: roundTo(node.x), y: roundTo(node.y + node.height / 2) }
+      : { x: roundTo(node.x + node.width / 2), y: roundTo(node.y) };
+    const delta = horizontal ? to.x - from.x : to.y - from.y;
+    const cornerRadius = Math.min(
+      12,
+      Math.abs(horizontal ? to.y - from.y : to.x - from.x) / 2,
+      Math.abs(delta) / 2,
+    );
+    const mid = roundTo((horizontal ? from.x : from.y) + delta * 0.5);
+    const path = (() => {
+      if (
+        cornerRadius <= 0 ||
+        (horizontal ? from.y === to.y : from.x === to.x)
+      ) {
+        return horizontal
+          ? `M ${from.x},${from.y} H ${to.x}`
+          : `M ${from.x},${from.y} V ${to.y}`;
+      }
+      if (horizontal) {
+        const direction = Math.sign(to.y - from.y);
+        return (
+          `M ${from.x},${from.y} ` +
+          `H ${roundTo(mid - cornerRadius)} ` +
+          `Q ${mid},${from.y} ${mid},${roundTo(from.y + direction * cornerRadius)} ` +
+          `V ${roundTo(to.y - direction * cornerRadius)} ` +
+          `Q ${mid},${to.y} ${roundTo(mid + cornerRadius)},${to.y} ` +
+          `H ${to.x}`
+        );
+      }
+      return (
+        `M ${from.x},${from.y} ` +
+        `V ${roundTo(mid - cornerRadius)} ` +
+        `Q ${from.x},${mid} ${roundTo(from.x + Math.sign(to.x - from.x) * cornerRadius)},${mid} ` +
+        `H ${roundTo(to.x - Math.sign(to.x - from.x) * cornerRadius)} ` +
+        `Q ${to.x},${mid} ${to.x},${roundTo(mid + cornerRadius)} ` +
+        `V ${to.y}`
+      );
+    })();
+    edges.push({
+      id: `${parentGameId}->${node.gameId}`,
+      parentGameId,
+      childGameId: node.gameId,
+      from,
+      to,
+      path,
+      branchIndex: parent.branchIndex,
+      isTrunk: parent.isTrunk && node.isTrunk,
+    });
+  }
+
+  const axis: LineageGenerationAxisEntry[] = generations.map((generation) => ({
+    generation,
+    label: generationAxisLabel(generation),
+    y: rowTopByGeneration.get(generation) ?? 0,
+    height: layerHeightByGeneration.get(generation) ?? nodeHeight,
+    count: layoutNodes.filter((node) => node.generation === generation).length,
+  }));
+
+  const maxSlotCount = slotByGameId.size > 0 ? maxSlot - minSlot + 1 : 0;
+  const horizontal = orientation === 'horizontal';
+  // 竖版纵向总高 = 各层层高累加 + 每层的行间距（层高按最高卡算，见上面的 layerHeightByGeneration）。
+  const verticalHeight = generations.reduce(
+    (sum, generation) =>
+      sum + (layerHeightByGeneration.get(generation) ?? nodeHeight) + rowGap,
+    0,
+  );
+  return {
+    nodes: layoutNodes,
+    edges,
+    axis,
+    // 竖版：横向由槽位数决定、纵向由代际层高决定；横版反过来（代际沿横向推进）。
+    width: roundTo(
+      axisWidth + (horizontal ? generations.length : maxSlotCount) * pitch,
+    ),
+    height: roundTo(horizontal ? maxSlotCount * slotPitch : verticalHeight),
+  };
+}
+
+/**
+ * 本作品的**子树深度** = 子树最大代际 − 本作品代际（文档「累计创作世代数」的语义）。
+ *
+ * 用同一份 `/lineage` 数据算，不发新请求；BFS 沿 `parentGameId` 的**反向**关系向下走。
+ * 空树 / 找不到本作品 → 0。注意：节点上限 200 时只在可见集合上计算（截断场景会在页面上标注）。
+ */
+export function collectLineageSubtreeDepth<
+  T extends {
+    gameId: string;
+    parentGameId?: string | null;
+    generation: number;
+  },
+>(nodes: readonly T[], gameId: string): number {
+  const self = nodes.find((node) => node.gameId === gameId);
+  if (!self) return 0;
+  const childrenByParent = new Map<string, string[]>();
+  for (const node of nodes) {
+    const parentGameId = node.parentGameId ?? null;
+    if (!parentGameId) continue;
+    const bucket = childrenByParent.get(parentGameId);
+    if (bucket) bucket.push(node.gameId);
+    else childrenByParent.set(parentGameId, [node.gameId]);
+  }
+  const generationById = new Map(
+    nodes.map((node) => [node.gameId, node.generation]),
+  );
+  const seen = new Set<string>([gameId]);
+  const queue = [...(childrenByParent.get(gameId) ?? [])];
+  let maxGeneration = self.generation;
+  while (queue.length > 0) {
+    const current = queue.shift() as string;
+    if (seen.has(current)) continue;
+    seen.add(current);
+    maxGeneration = Math.max(
+      maxGeneration,
+      generationById.get(current) ?? self.generation,
+    );
+    queue.push(...(childrenByParent.get(current) ?? []));
+  }
+  return Math.max(0, maxGeneration - self.generation);
+}
+
+/**
+ * 血缘链：从根到 `gameId` 的**有序**节点列表（血缘溯源条用）。
+ *
+ * 与 `collectLineageHighlight` 的区别：那个返回集合（给高亮用），这个返回顺序（给「根 → 1 代 → … → 当前」
+ * 展示与点击用）。父节点不在可见集合里时链就停在那里（与既有的「父作品不可用」口径一致）。
+ */
+export function collectLineageAncestorChain<
+  T extends {
+    gameId: string;
+    parentGameId?: string | null;
+    generation: number;
+  },
+>(nodes: readonly T[], gameId: string): T[] {
+  const byId = new Map(nodes.map((node) => [node.gameId, node]));
+  const chain: T[] = [];
+  let cursor = byId.get(gameId);
+  const guard = new Set<string>();
+  while (cursor && !guard.has(cursor.gameId)) {
+    guard.add(cursor.gameId);
+    chain.push(cursor);
+    cursor = cursor.parentGameId ? byId.get(cursor.parentGameId) : undefined;
+  }
+  return chain.reverse();
+}
+
+/** 平移时至少保留多少像素的内容可见（防止把画布拖飞、找不回来）。 */
+export const LINEAGE_PAN_KEEP_PX = 96;
+
+/**
+ * 平移边界：把候选 `offset` 夹到「至少留 `keep` 像素内容可见」的区间里。
+ *
+ * - 内容在视口里占 `[offset, offset + contentSize]`；
+ * - 约束：`offset + contentSize >= keep` 且 `offset <= viewportSize - keep`；
+ * - 内容比视口小的时候区间会反向，这里取两侧的 min/max 作区间，仍然允许在小范围内自由摆放。
+ *
+ * 纯函数，供画布拖动/缩放路径复用（单测直接钉住边界）。
+ */
+export function clampLineagePan(
+  offset: number,
+  viewportSize: number,
+  contentSize: number,
+  keep = LINEAGE_PAN_KEEP_PX,
+): number {
+  if (viewportSize <= 0 || contentSize <= 0) return offset;
+  const leftBound = keep - contentSize;
+  const rightBound = viewportSize - keep;
+  const lower = Math.min(leftBound, rightBound);
+  const upper = Math.max(leftBound, rightBound);
+  return Math.min(upper, Math.max(lower, offset));
+}
+
+/** 节点相对「当前作品」的角色（文档口径的**父代 / 子代**）。 */
+export type LineageRelationRole = 'self' | 'ancestor' | 'descendant' | 'side';
+
+/** 游玩次数的显示分解：自身值 + 全部后代的合计（= 显示值）。 */
+export type LineagePlayCountBreakdown = {
+  /** **自身**游玩次数：服务端公开字段 `playCount` 的原值（不做任何叠加）。 */
+  own: number;
+  /** 全部**后代**的合计（父代展示的「衍生」部分）。 */
+  inherited: number;
+  /** **显示值** = own + 全部后代合计，满足 `total(W) = own(W) + Σ 直接子代 total(C)`。 */
+  total: number;
+};
+
+/**
+ * 一次性自底向上遍历，算出每个节点的**子树游玩次数合计**（口径 2026-10-06）：
+ *
+ * > 游玩次数的**显示**必须是「子代叠加到父代」——父代展示的是自己 + 全部后代的合计。
+ *
+ * 与服务端贡献归集不变量完全一致（`total(W) = own(W) + Σ 直接子代 total(C)`），
+ * 但是**纯前端用已有的那棵树算**：详情页与族谱页本来就拿到了 `/lineage` 整棵树，
+ * 所以零额外请求、服务端零改动（公开接口的 `playCount` 字段仍是自身值，不要拿它去遍历子树）。
+ *
+ * 边界：
+ * - 缺 `playCount` / 非有限数 / 负数 → 按 0 计（占位与未知都不臆造）；
+ * - 父节点不在可见集合里（未公开 / 已删 / 被截断）→ 合计**只统计可见子树**，
+ *   不向上虚构（与「未公开不出现在树里」的既有可见性口径一致）；
+ * - 数据里出现环时每个节点只累加一次，不会死循环。
+ *
+ * 注意：**主干线判据不是它**。主干线（每代热度最高）用**自身** `playCount`，见
+ * `buildLineageTreeLayout` 里的说明。
+ */
+export function collectLineagePlayCountTotals<
+  T extends {
+    gameId: string;
+    parentGameId?: string | null;
+    playCount?: number | null;
+  },
+>(nodes: readonly T[]): Map<string, LineagePlayCountBreakdown> {
+  const ownById = new Map<string, number>();
+  const childrenByParent = new Map<string, string[]>();
+  for (const node of nodes) {
+    const raw = node.playCount;
+    ownById.set(
+      node.gameId,
+      typeof raw === 'number' && Number.isFinite(raw) ? Math.max(0, raw) : 0,
+    );
+  }
+  for (const node of nodes) {
+    const parentId = node.parentGameId ?? null;
+    // 父不在可见集合里 → 该节点是可见森林的根，不向外累加。
+    if (!parentId || !ownById.has(parentId)) continue;
+    const bucket = childrenByParent.get(parentId);
+    if (bucket) bucket.push(node.gameId);
+    else childrenByParent.set(parentId, [node.gameId]);
+  }
+
+  const totalById = new Map<string, number>();
+  const inProgress = new Set<string>();
+  const compute = (rootId: string) => {
+    // 迭代式后序遍历：链路可能很深，避免递归栈。
+    const stack: { id: string; expanded: boolean }[] = [
+      { id: rootId, expanded: false },
+    ];
+    while (stack.length > 0) {
+      const frame = stack.pop() as { id: string; expanded: boolean };
+      if (!frame.expanded) {
+        // 已算过，或正在这条链上（数据里出现环）→ 不再展开：环上每个节点只累加一次。
+        if (totalById.has(frame.id) || inProgress.has(frame.id)) continue;
+        inProgress.add(frame.id);
+        stack.push({ id: frame.id, expanded: true });
+        for (const childId of childrenByParent.get(frame.id) ?? []) {
+          stack.push({ id: childId, expanded: false });
+        }
+        continue;
+      }
+      let total = ownById.get(frame.id) ?? 0;
+      for (const childId of childrenByParent.get(frame.id) ?? []) {
+        total += totalById.get(childId) ?? 0;
+      }
+      totalById.set(frame.id, total);
+      inProgress.delete(frame.id);
+    }
+  };
+  for (const node of nodes) {
+    if (!totalById.has(node.gameId)) compute(node.gameId);
+  }
+
+  const breakdowns = new Map<string, LineagePlayCountBreakdown>();
+  for (const node of nodes) {
+    const own = ownById.get(node.gameId) ?? 0;
+    const total = totalById.get(node.gameId) ?? own;
+    breakdowns.set(node.gameId, { own, inherited: total - own, total });
+  }
+  return breakdowns;
+}
+
+/**
+ * 每个节点相对 `gameId` 的角色：
+ *
+ * - `self`：当前作品本体；
+ * - `ancestor`：沿 `parentGameId` 上溯到的**父代**（祖先链，不含自己）；
+ * - `descendant`：沿 `parentGameId` **反向**走到的**子代**（整棵后代子树）；
+ * - `side`：与当前作品没有直系血缘的旁支。
+ *
+ * 纯函数、稳定（同输入同输出）；渲染层据此打 `data-relation` 并显示「父代 / 子代」角标，
+ * 不用「颜色深浅」这类无法断言的表达。
+ */
+export function collectLineageRelationRoles<
+  T extends { gameId: string; parentGameId?: string | null },
+>(nodes: readonly T[], gameId: string): Map<string, LineageRelationRole> {
+  const roles = new Map<string, LineageRelationRole>();
+  for (const node of nodes) roles.set(node.gameId, 'side');
+  const byId = new Map(nodes.map((node) => [node.gameId, node]));
+  if (!byId.has(gameId)) return roles;
+
+  roles.set(gameId, 'self');
+  // 父代：沿 parentGameId 上溯（防环）。
+  const guard = new Set<string>([gameId]);
+  let cursor = byId.get(gameId);
+  while (cursor?.parentGameId) {
+    const parentId = cursor.parentGameId;
+    if (guard.has(parentId) || !byId.has(parentId)) break;
+    guard.add(parentId);
+    roles.set(parentId, 'ancestor');
+    cursor = byId.get(parentId);
+  }
+  // 子代：按 parentGameId 反向 BFS（整棵后代子树）。
+  const childrenByParent = new Map<string, string[]>();
+  for (const node of nodes) {
+    const parentId = node.parentGameId ?? null;
+    if (!parentId) continue;
+    const bucket = childrenByParent.get(parentId);
+    if (bucket) bucket.push(node.gameId);
+    else childrenByParent.set(parentId, [node.gameId]);
+  }
+  const stack = [...(childrenByParent.get(gameId) ?? [])];
+  while (stack.length > 0) {
+    const id = stack.pop() as string;
+    // 只给还是「旁支」的节点定子代：脏数据里出现环时（某人既是祖先又是后代），
+    // 先判定的**父代**优先，保证结果稳定、不来回翻。
+    if (roles.get(id) !== 'side') continue;
+    roles.set(id, 'descendant');
+    stack.push(...(childrenByParent.get(id) ?? []));
+  }
+  return roles;
+}
+
+/**
+ * 「只看父代与子代」要保留的节点集合：当前作品的**祖先链**（父代）+ **直接子代** + 自己。
+ *
+ * 注意是**直接**子代（下一层），不是整棵后代子树——开关的语义是「只看这个作品的上一步与下一步」，
+ * 想看整棵树关掉开关即可。父代不在可见集合里时链停在那里（与「父作品不可用」口径一致，
+ * 布局层仍会给那个缺失的父补一个占位节点）。
+ *
+ * 找不到 `gameId` 时返回空集合：调用方据此「不筛选」而不是渲染空图。
+ */
+export function collectLineageImmediateScope<
+  T extends { gameId: string; parentGameId?: string | null },
+>(nodes: readonly T[], gameId: string): Set<string> {
+  const scope = new Set<string>();
+  const byId = new Map(nodes.map((node) => [node.gameId, node]));
+  if (!byId.has(gameId)) return scope;
+  scope.add(gameId);
+  let cursor = byId.get(gameId);
+  while (cursor?.parentGameId) {
+    const parentId = cursor.parentGameId;
+    if (scope.has(parentId) || !byId.has(parentId)) break;
+    scope.add(parentId);
+    cursor = byId.get(parentId);
+  }
+  for (const node of nodes) {
+    if ((node.parentGameId ?? null) === gameId) scope.add(node.gameId);
+  }
+  return scope;
+}
+
+/**
+ * hover / 聚焦一个节点时要高亮的集合：它自己 + 它的祖先路径；`includeSubtree` 为真时再加上
+ * 它整棵子树。其余节点在渲染层降透明度。
+ */
+export function collectLineageHighlight(
+  layoutNodes: readonly LineageLayoutNode[],
+  activeGameId: string,
+  options: { includeSubtree?: boolean } = {},
+): Set<string> {
+  const includeSubtree = options.includeSubtree ?? true;
+  const byId = new Map(layoutNodes.map((node) => [node.gameId, node]));
+  const highlighted = new Set<string>();
+  if (!byId.has(activeGameId)) return highlighted;
+
+  // 祖先路径：沿 parentGameId 上溯（占位节点没有 parent，天然成为终点）。
+  let cursor: LineageLayoutNode | undefined = byId.get(activeGameId);
+  while (cursor) {
+    highlighted.add(cursor.gameId);
+    const parentGameId = cursor.isStub
+      ? null
+      : (cursor.node?.parentGameId ?? null);
+    cursor = parentGameId ? byId.get(parentGameId) : undefined;
+  }
+
+  if (includeSubtree) {
+    const childrenByParent = new Map<string, string[]>();
+    for (const node of layoutNodes) {
+      const parentGameId = node.isStub
+        ? null
+        : (node.node?.parentGameId ?? null);
+      if (!parentGameId || !byId.has(parentGameId)) continue;
+      const bucket = childrenByParent.get(parentGameId);
+      if (bucket) bucket.push(node.gameId);
+      else childrenByParent.set(parentGameId, [node.gameId]);
+    }
+    const stack = [...(childrenByParent.get(activeGameId) ?? [])];
+    while (stack.length > 0) {
+      const gameId = stack.pop() as string;
+      if (highlighted.has(gameId)) continue;
+      highlighted.add(gameId);
+      stack.push(...(childrenByParent.get(gameId) ?? []));
+    }
+  }
+
+  return highlighted;
+}
diff --git a/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.test.tsx b/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.test.tsx
index 58688c05e..ade916523 100644
--- a/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.test.tsx
+++ b/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.test.tsx
@@ -4,6 +4,7 @@ import { fireEvent, render, screen } from '@testing-library/react';
 import { expect, test, vi } from 'vitest';
 
 import {
+  MOBILE_WELCOME_EXEMPT_STAGES,
   PlatformActiveMobileWelcomeDialog,
   shouldOpenActiveMobileWelcomeDialog,
   shouldShowActiveMobileWelcomeDialog,
@@ -44,6 +45,60 @@ test('shows the active mobile welcome when entering the mobile site shell', () =
   ).toBe(true);
 });
 
+test('mobile welcome exempts read-only browsing stages（族谱 / 共创主题）', () => {
+  // 防退化：白名单内容必须与实现一致（不是只断言某一个 stage）。
+  expect(Object.keys(MOBILE_WELCOME_EXEMPT_STAGES).sort()).toEqual([
+    'game-co-creation',
+    'game-lineage',
+    'game-theme',
+    'game-themes',
+  ]);
+
+  // 每个豁免 stage（含带 ?id= 的公开深链）在移动端都不再弹。
+  for (const stage of Object.keys(MOBILE_WELCOME_EXEMPT_STAGES)) {
+    expect(
+      shouldShowActiveMobileWelcomeDialog({
+        isDesktopLayout: false,
+        selectionStage: stage,
+        platformTab: stage,
+        pathname:
+          stage === 'game-lineage'
+            ? '/games/lineage?id=game_ab12cd34'
+            : `/games/${stage}`,
+      }),
+      `${stage} 属于公开只读的「作品展示」页面，应豁免`,
+    ).toBe(false);
+    // 桌面端本来就不弹。
+    expect(
+      shouldShowActiveMobileWelcomeDialog({
+        isDesktopLayout: true,
+        selectionStage: stage,
+        platformTab: stage,
+        pathname: '/',
+      }),
+    ).toBe(false);
+  }
+
+  // 创作 / 项目 / 发布 / 我的 / 平台首页仍保持门限（只读浏览的豁免不外溢）。
+  for (const stage of [
+    'platform',
+    'creation-home',
+    'project',
+    'game-publish',
+    'game-mine',
+  ]) {
+    expect(
+      shouldShowActiveMobileWelcomeDialog({
+        isDesktopLayout: false,
+        selectionStage: stage,
+        platformTab: stage,
+        pathname: '/',
+      }),
+      `${stage} 不是只读浏览页，应保持门限`,
+    ).toBe(true);
+  }
+});
+
 test('keeps the active mobile welcome dismissed across site navigation', () => {
   expect(
     shouldOpenActiveMobileWelcomeDialog({
diff --git a/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.tsx b/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.tsx
index fa22cb944..607950392 100644
--- a/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.tsx
+++ b/src/components/platform-entry/PlatformActiveMobileWelcomeDialog.tsx
@@ -18,10 +18,33 @@ type PlatformActiveMobileWelcomeDialogProps = {
   onClose: () => void;
 };
 
+/**
+ * 移动端欢迎弹窗的**豁免清单**：这些 stage 是**公开只读的「作品展示」页面**。
+ *
+ * 为什么豁免它们：弹窗文案自己说的是「移动端仅支持作品展示」，而族谱树 / 共创主题页恰恰
+ * 就是作品展示；被弹窗盖住会让公开只读深链（例如客户端里分享出来的 `/games/lineage?id=…`）
+ * **首屏完全不可用**，需要用户先点掉才能看。这是口径不一致，不是有意的功能限制。
+ *
+ * 明确**不放进来**的：创作 / 项目 / 发布 / 我的 / 平台首页 —— 那些才是「移动端不支持」的部分，
+ * 门限照旧。新增豁免必须显式写在这里（键名 = stage 名），不要用范围匹配或前缀判断。
+ */
+export const MOBILE_WELCOME_EXEMPT_STAGES: Readonly<Record<string, true>> = {
+  // 创作族谱树：`/games/lineage?id=<rootGameId>`（公开只读）
+  'game-lineage': true,
+  // 共创主题列表：`/games/themes`（公开只读）
+  'game-themes': true,
+  // 「共创」页（顶层入口）：只列支持共创的作品（公开只读，本身就是「作品展示」）
+  'game-co-creation': true,
+  // 共创主题详情：`/games/theme?id=<themeId>`（公开只读）
+  'game-theme': true,
+};
+
 export function shouldShowActiveMobileWelcomeDialog({
   isDesktopLayout,
+  selectionStage,
 }: MobileHomeWelcomeDecisionInput) {
-  return !isDesktopLayout;
+  if (isDesktopLayout) return false;
+  return MOBILE_WELCOME_EXEMPT_STAGES[selectionStage] !== true;
 }
 
 export function shouldOpenActiveMobileWelcomeDialog({
diff --git a/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx b/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
index 8fb3d3d9d..d48ec5d3f 100644
--- a/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
+++ b/src/components/platform-entry/PlatformEntryActiveFlowShell.test.tsx
@@ -20,6 +20,11 @@ import {
   usePlatformWalletLifecycle,
   usePlatformWalletStore,
 } from '../../stores/usePlatformWalletStore';
+import {
+  isCoCreator,
+  resolveGameViewerContext,
+  shouldCarryCoCreationSource,
+} from '../game-distribution/gameViewerRole';
 import { PlatformEntryFlowShellImpl } from './PlatformEntryActiveFlowShell';
 import type { SelectionStage } from './platformEntryActiveTypes';
 
@@ -56,7 +61,11 @@ const profileCenterMock = vi.hoisted(() => ({
 const gameDistributionMock = vi.hoisted(() => ({
   cancelGameVersion: vi.fn(),
   deleteMyGame: vi.fn(),
+  getDerivedGames: vi.fn(),
   getGame: vi.fn(),
+  getGameLineage: vi.fn(),
+  getTheme: vi.fn(),
+  listThemes: vi.fn(),
   getGameVersion: vi.fn(),
   getMyGame: vi.fn(),
   listGames: vi.fn(),
@@ -476,7 +485,7 @@ describe('PlatformEntryActiveFlowShell', () => {
       within(navigation)
         .getAllByRole('button')
         .map((button) => button.getAttribute('aria-label')),
-    ).toEqual(['创作', '项目', '游戏', '创作者主页', '我的']);
+    ).toEqual(['创作', '项目', '游戏', '共创', '创作者主页', '我的']);
     expect(
       within(navigation)
         .getByRole('button', { name: '创作' })
@@ -542,7 +551,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(
@@ -559,6 +568,45 @@ describe('PlatformEntryActiveFlowShell', () => {
     });
   });
 
+  it.each(['game-lineage', 'game-themes', 'game-theme'] as const)(
+    'mobile deep link into the read-only %s stage skips the blocking welcome',
+    async (selectionStage) => {
+      responsiveMock.isDesktopLayout = false;
+      window.history.replaceState(
+        null,
+        '',
+        selectionStage === 'game-lineage'
+          ? '/games/lineage?id=game_ab12cd34'
+          : '/games/themes',
+      );
+      const { container } = render(
+        <PlatformEntryFlowShellImpl
+          selectionStage={selectionStage}
+          setSelectionStage={vi.fn()}
+        />,
+      );
+
+      // 只读浏览页（族谱 / 共创主题）属于「作品展示」，不该被欢迎弹窗盖住首屏。
+      expect(screen.queryByRole('dialog', { name: '欢迎' })).toBeNull();
+      expect(
+        container.querySelector('.platform-mobile-home-welcome-dialog'),
+      ).toBeNull();
+    },
+  );
+
+  it('non make-content mobile stages still show the blocking welcome', async () => {
+    responsiveMock.isDesktopLayout = false;
+    window.history.replaceState(null, '', '/profile');
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="profile"
+        setSelectionStage={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByRole('dialog', { name: '欢迎' })).toBeTruthy();
+  });
+
   it('restores the original blocking welcome on mobile until acknowledged', async () => {
     responsiveMock.isDesktopLayout = false;
     const { rerender } = render(
@@ -627,7 +675,7 @@ describe('PlatformEntryActiveFlowShell', () => {
         within(navigation)
           .getAllByRole('button')
           .map((button) => button.getAttribute('aria-label')),
-      ).toEqual(['游戏', '创作者主页', '我的']);
+      ).toEqual(['游戏', '共创', '创作者主页', '我的']);
       expect(
         within(navigation)
           .getByRole('button', { name: '我的' })
@@ -913,7 +961,10 @@ describe('游戏发布灰度入口', () => {
       agcTemplateLibraryEnabled: false,
       gameDistributionPublishEnabled: false,
     });
-    gameDistributionMock.listGames.mockResolvedValue([]);
+    gameDistributionMock.listGames.mockResolvedValue({
+      games: [],
+      nextCursor: null,
+    });
 
     render(<StatefulPlatformEntryFlowShell initialStage="games" />);
 
@@ -938,7 +989,10 @@ describe('游戏发布灰度入口', () => {
   });
 
   it('游戏广场等舞台仍保持页签容器滚动', async () => {
-    gameDistributionMock.listGames.mockResolvedValue([]);
+    gameDistributionMock.listGames.mockResolvedValue({
+      games: [],
+      nextCursor: null,
+    });
 
     const { container } = render(
       <StatefulPlatformEntryFlowShell initialStage="games" />,
@@ -954,7 +1008,10 @@ describe('游戏发布灰度入口', () => {
 
   it('灰度命中时广场展示发布入口', async () => {
     loginAsAuthor();
-    gameDistributionMock.listGames.mockResolvedValue([]);
+    gameDistributionMock.listGames.mockResolvedValue({
+      games: [],
+      nextCursor: null,
+    });
 
     render(<StatefulPlatformEntryFlowShell initialStage="games" />);
 
@@ -981,7 +1038,10 @@ describe('创作者页面深链与返回', () => {
       wechatBound: false,
     };
     authUiMock.value.canAccessProtectedData = true;
-    gameDistributionMock.listGames.mockResolvedValue([]);
+    gameDistributionMock.listGames.mockResolvedValue({
+      games: [],
+      nextCursor: null,
+    });
     creatorClientMock.getCreator.mockResolvedValue({
       user: authUiMock.value.user,
       followingCount: 0,
@@ -1165,6 +1225,100 @@ describe('游戏详情返回', () => {
     });
     expect(window.location.pathname).toBe('/games');
   });
+
+  it('游玩页透传来源标记：共创侧详情进游玩页带 from，玩家侧详情不带（回归）', async () => {
+    const clickPlay = async () => {
+      // 详情页是 lazy 加载的，CTA 出现得比壳层晚 —— 给它足够时间，别用默认 1s 超时。
+      const play = await screen.findByRole(
+        'button',
+        { name: /立即玩|开始游戏|前往体验/u },
+        { timeout: 8000 },
+      );
+      fireEvent.click(play);
+    };
+    // ① 共创侧详情（URL 带 `from=co-creation`）→ 点「立即玩」→ 游玩页 URL 继续带标记
+    mockDetailGame();
+    window.history.replaceState(
+      null,
+      '',
+      '/games/detail?id=game-1&from=co-creation',
+    );
+    const fromCoCreation = vi.fn();
+    const first = render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-detail"
+        setSelectionStage={fromCoCreation}
+      />,
+    );
+    await clickPlay();
+    expect(fromCoCreation).toHaveBeenCalledWith('game-play', {
+      path: '/games/play?id=game-1&from=co-creation&backTo=%2Fgames%2Fdetail%3Fid%3Dgame-1%26from%3Dco-creation',
+    });
+    first.unmount();
+
+    // ② 玩家侧详情（无标记）→ 游玩页**不带**标记（别弄反）
+    mockDetailGame();
+    window.history.replaceState(null, '', '/games/detail?id=game-1');
+    const fromPlayer = vi.fn();
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-detail"
+        setSelectionStage={fromPlayer}
+      />,
+    );
+    await clickPlay();
+    expect(fromPlayer).toHaveBeenCalledWith('game-play', {
+      path: '/games/play?id=game-1&backTo=%2Fgames%2Fdetail%3Fid%3Dgame-1',
+    });
+  });
+
+  it('来源标记携带规则（纯函数）：共创侧阶段带上、详情/游玩页保留已有标记、其它不带', () => {
+    // 共创侧阶段（进详情的入口）
+    for (const stage of ['game-co-creation', 'game-lineage', 'game-compare']) {
+      expect(shouldCarryCoCreationSource({ stage })).toBe(true);
+    }
+    // 已在共创侧页面里：详情页之间跳、以及详情→游玩页/游玩页刷新都要保留
+    for (const stage of ['game-detail', 'game-play']) {
+      expect(
+        shouldCarryCoCreationSource({ stage, currentSource: 'co-creation' }),
+      ).toBe(true);
+      expect(
+        shouldCarryCoCreationSource({ stage, currentSource: ' CO-CREATION ' }),
+      ).toBe(true);
+      expect(shouldCarryCoCreationSource({ stage, currentSource: null })).toBe(
+        false,
+      );
+      // 族谱页自己的 `from=<gameId>` 含义不同，不能被当成来源
+      expect(
+        shouldCarryCoCreationSource({ stage, currentSource: 'game-leaf' }),
+      ).toBe(false);
+    }
+    // 玩家侧来源
+    for (const stage of ['games', 'game-mine', 'game-themes', 'game-theme']) {
+      expect(shouldCarryCoCreationSource({ stage })).toBe(false);
+      expect(
+        shouldCarryCoCreationSource({ stage, currentSource: 'co-creation' }),
+      ).toBe(false);
+    }
+    // 来源值 → 一侧
+    expect(resolveGameViewerContext({ source: 'co-creation' })).toBe(
+      'co-creator',
+    );
+    expect(resolveGameViewerContext({ source: 'CO-CREATION' })).toBe(
+      'co-creator',
+    );
+    expect(resolveGameViewerContext({ source: null })).toBe('player');
+    expect(resolveGameViewerContext({ source: 'game-leaf' })).toBe('player');
+    // 作者本人（?owner=1）一律共创者侧，与入口来源无关（产品拍板）
+    expect(resolveGameViewerContext({ isAuthorViewer: true })).toBe(
+      'co-creator',
+    );
+    expect(
+      resolveGameViewerContext({ source: 'co-creation', isAuthorViewer: true }),
+    ).toBe('co-creator');
+    expect(isCoCreator('player')).toBe(false);
+    expect(isCoCreator('co-creator')).toBe(true);
+  });
 });
 
 describe('作品管理 owner 作用域', () => {
@@ -1259,7 +1413,7 @@ describe('作品管理 owner 作用域', () => {
     fireEvent.click(await screen.findByRole('button', { name: '查看详情' }));
 
     expect(setSelectionStage).toHaveBeenCalledWith('game-detail', {
-      path: '/games/detail?id=game-1&owner=1',
+      path: '/games/detail?id=game-1&owner=1&from=co-creation',
     });
   });
 
@@ -1322,3 +1476,527 @@ describe('作品管理 owner 作用域', () => {
     expect(gameDistributionMock.getMyGame).not.toHaveBeenCalled();
   });
 });
+
+describe('创作族谱', () => {
+  const lineageTree = {
+    rootGameId: 'game-root',
+    root: {
+      gameId: 'game-root',
+      title: '母版',
+      authorName: '原作者',
+      generation: 0,
+      parentGameId: null,
+      playCount: 3,
+      status: 'published',
+    },
+    nodes: [
+      {
+        gameId: 'game-root',
+        title: '母版',
+        authorName: '原作者',
+        generation: 0,
+        parentGameId: null,
+        playCount: 3,
+        status: 'published',
+      },
+      {
+        gameId: 'game-leaf',
+        title: '叶节点',
+        authorName: '改编者',
+        generation: 1,
+        parentGameId: 'game-root',
+        playCount: 1,
+        status: 'published',
+      },
+    ],
+    truncated: false,
+  };
+
+  it('族谱页按根作品渲染树，未登录也能浏览并跳转节点', async () => {
+    window.history.replaceState(
+      null,
+      '',
+      '/games/lineage?id=game-root&from=game-leaf',
+    );
+    gameDistributionMock.getGameLineage.mockResolvedValue(lineageTree);
+    const setSelectionStage = vi.fn();
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-lineage"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    expect(await screen.findByText('叶节点')).toBeTruthy();
+    expect(gameDistributionMock.getGameLineage).toHaveBeenCalledWith(
+      'game-root',
+    );
+    // 图下方的「父代/子代」块里也有同名节点，所以这里精确到**树里**的那一个：
+    // 树节点卡就是广场卡（卡内标题文本 = 作品标题，整卡一个 button）。
+    const treeNode = [
+      ...document.querySelectorAll('.game-lineage-canvas .game-lineage-node'),
+    ]
+      .find(
+        (node) =>
+          node.querySelector('.game-card__title-row > strong')?.textContent ===
+          '母版',
+      )
+      ?.querySelector('.game-card');
+    expect(treeNode).toBeTruthy();
+    fireEvent.click(treeNode as HTMLElement);
+    // 从族谱页（共创者侧）打开作品详情：来源标记**保留**下去，别中途掉回玩家侧。
+    expect(setSelectionStage).toHaveBeenCalledWith('game-detail', {
+      path: '/games/detail?id=game-root&from=co-creation',
+    });
+  });
+
+  it('详情页的族谱入口带上根作品与当前作品', async () => {
+    // 族谱入口只给**共创者侧**（2026-10-07 口径更正：看血缘与否取决于**入口上下文**，
+    // 与登录态无关）——所以这里**不登录**，只把入口来源标成共创侧。
+    window.history.replaceState(
+      null,
+      '',
+      '/games/detail?id=game-1&from=co-creation',
+    );
+    gameDistributionMock.getGame.mockResolvedValue({
+      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: 1,
+      createdAt: '2026-09-18T00:00:00.000Z',
+      forkCount: 0,
+      lineage: {
+        generation: 1,
+        rootGameId: 'game-root',
+        rootTitle: '母版',
+        parentGameId: 'game-root',
+        parentTitle: '母版',
+        parentAuthorName: '原作者',
+      },
+    });
+    const setSelectionStage = vi.fn();
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-detail"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    fireEvent.click(
+      await screen.findByRole('button', { name: '查看创作族谱' }),
+    );
+    expect(setSelectionStage).toHaveBeenCalledWith('game-lineage', {
+      path: '/games/lineage?id=game-root&from=game-1',
+    });
+  });
+
+  it('对比页按 left/right 参数左右渲染两侧作品', async () => {
+    window.history.replaceState(
+      null,
+      '',
+      '/games/compare?left=game-1&right=game-2',
+    );
+    gameDistributionMock.getGame.mockImplementation((gameId: string) =>
+      Promise.resolve({
+        id: gameId,
+        title: `对比作品 ${gameId}`,
+        summary: '并排对比',
+        description: '',
+        category: '动作',
+        tags: [],
+        coverColor: '#d77a51',
+        icon: '✦',
+        author: { id: 'author-1', name: '测试作者' },
+        deviceSupport: { desktop: true, mobile: true, touch: true },
+        status: 'published',
+        currentVersion: {
+          id: `version-${gameId}`,
+          version: '1.0.0',
+          entryUrl: `https://play.example.test/releases/${gameId}/index.html`,
+          sha256: 'sha256',
+          publishedAt: '2026-09-18T00:00:00.000Z',
+          controls: ['键盘'],
+        },
+        playCount: 1,
+        createdAt: '2026-09-18T00:00:00.000Z',
+      }),
+    );
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-compare"
+        setSelectionStage={vi.fn()}
+      />,
+    );
+
+    expect(await screen.findByText('对比作品 game-1')).toBeTruthy();
+    expect(screen.getByText('对比作品 game-2')).toBeTruthy();
+    expect(document.querySelectorAll('iframe.game-player-frame')).toHaveLength(
+      2,
+    );
+  });
+});
+
+it('打开详情页的来源标记：从共创 Tab 进 = 共创者侧，从游戏广场进 = 玩家侧（不带标记）', async () => {
+  const oneGame = {
+    id: 'game-1',
+    title: '可以共创的作品',
+    summary: 's',
+    description: '',
+    category: '动作',
+    tags: [],
+    coverColor: '#d77a51',
+    icon: '✦',
+    author: { id: 'author-1', name: '测试作者' },
+    deviceSupport: { desktop: true, mobile: true, touch: true },
+    status: 'published',
+    currentVersion: null,
+    playCount: 1,
+    createdAt: '2026-09-18T00:00:00.000Z',
+    coverObjectKey: null,
+    screenshots: [],
+    forkCount: 0,
+    forkAuthorization: 'full',
+  };
+  gameDistributionMock.listGames.mockResolvedValue({
+    games: [oneGame],
+    nextCursor: null,
+  });
+
+  // ① 共创 Tab（`/games/co-creation`）→ 带 `from=co-creation`
+  window.history.replaceState(null, '', '/games/co-creation');
+  const fromCoCreation = vi.fn();
+  const first = render(
+    <PlatformEntryFlowShellImpl
+      selectionStage="game-co-creation"
+      setSelectionStage={fromCoCreation}
+    />,
+  );
+  fireEvent.click(
+    await screen.findByRole('button', { name: /可以共创的作品/u }),
+  );
+  expect(fromCoCreation).toHaveBeenCalledWith('game-detail', {
+    path: '/games/detail?id=game-1&from=co-creation',
+  });
+  first.unmount();
+
+  // ② 游戏广场（`/games`）→ **不带**标记（默认玩家侧）
+  window.history.replaceState(null, '', '/games');
+  const fromPlaza = vi.fn();
+  render(
+    <PlatformEntryFlowShellImpl
+      selectionStage="games"
+      setSelectionStage={fromPlaza}
+    />,
+  );
+  fireEvent.click(
+    await screen.findByRole('button', { name: /可以共创的作品/u }),
+  );
+  expect(fromPlaza).toHaveBeenCalledWith('game-detail', {
+    path: '/games/detail?id=game-1',
+  });
+});
+
+describe('共创顶层入口（只列支持共创的作品）', () => {
+  it('侧边栏「共创」直达 game-co-creation，游戏页不再有「游戏/共创」子页签', async () => {
+    window.history.replaceState(null, '', '/games');
+    gameDistributionMock.listGames.mockResolvedValue({
+      games: [],
+      nextCursor: null,
+    });
+    gameDistributionMock.listThemes.mockResolvedValue({
+      themes: [],
+      nextCursor: null,
+    });
+    const setSelectionStage = vi.fn();
+
+    const { rerender } = render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="games"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    // ① 游戏页里**不再有**「游戏区」子页签（共创已升为顶层入口）。
+    expect(screen.queryByRole('tablist', { name: '游戏区' })).toBeNull();
+    expect(screen.queryByRole('tab', { name: '共创' })).toBeNull();
+
+    // ② 侧边栏「共创」与「游戏」平级，点它进共创页。
+    const rail = screen.getByRole('navigation', { name: '平台导航' });
+    expect(
+      within(rail)
+        .getAllByRole('button')
+        .map((button) => button.getAttribute('aria-label')),
+    ).toEqual(['创作', '项目', '游戏', '共创', '创作者主页', '我的']);
+    fireEvent.click(within(rail).getByRole('button', { name: '共创' }));
+    expect(setSelectionStage).toHaveBeenCalledWith('game-co-creation', {
+      path: '/games/co-creation',
+    });
+    // 主题列表接口在这条路径上**不该**被请求。
+    expect(gameDistributionMock.listThemes).not.toHaveBeenCalled();
+
+    // ③ 进共创页时高亮的是「共创」，不再高亮「游戏」。
+    rerender(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-co-creation"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+    expect(
+      within(rail)
+        .getByRole('button', { name: '共创' })
+        .getAttribute('aria-current'),
+    ).toBe('page');
+    expect(
+      within(rail)
+        .getByRole('button', { name: '游戏' })
+        .getAttribute('aria-current'),
+    ).toBeNull();
+  });
+
+  it('导航高亮认「入口来源」：从共创侧进的详情高亮共创，其余高亮游戏（用户报的 bug）', async () => {
+    gameDistributionMock.getGame.mockResolvedValue({
+      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: null,
+      playCount: 0,
+      createdAt: '2026-09-18T00:00:00.000Z',
+      forkCount: 0,
+    });
+    const cases = [
+      {
+        expected: '共创',
+        title: '共创页点卡（带 from=co-creation）',
+        url: '/games/detail?id=game-1&from=co-creation',
+      },
+      {
+        expected: '游戏',
+        title: '游戏页点卡（无来源标记）',
+        url: '/games/detail?id=game-1',
+      },
+      {
+        expected: '共创',
+        title: '族谱页（共创侧才进得来）',
+        url: '/games/lineage?id=game-root',
+      },
+      {
+        expected: '共创',
+        title: '对比页（共创侧才进得来）',
+        url: '/games/compare?left=game-1&right=game-2',
+      },
+    ] as const;
+    for (const item of cases) {
+      window.history.replaceState(null, '', item.url);
+      const view = render(
+        <PlatformEntryFlowShellImpl
+          selectionStage={
+            item.url.includes('/games/detail')
+              ? 'game-detail'
+              : item.url.includes('/games/lineage')
+                ? 'game-lineage'
+                : 'game-compare'
+          }
+          setSelectionStage={vi.fn()}
+        />,
+      );
+      const rail = screen.getByRole('navigation', { name: '平台导航' });
+      expect(
+        within(rail)
+          .getAllByRole('button')
+          .filter((button) => button.getAttribute('aria-current') === 'page')
+          .map((button) => button.getAttribute('aria-label')),
+      ).toEqual([item.expected]);
+      view.unmount();
+    }
+  });
+
+  it('窄屏底部导航也有「共创」，点它同样直达共创页', async () => {
+    responsiveMock.isDesktopLayout = false;
+    window.history.replaceState(null, '', '/games');
+    gameDistributionMock.listGames.mockResolvedValue({
+      games: [],
+      nextCursor: null,
+    });
+    const setSelectionStage = vi.fn();
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="games"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    const dock = await screen.findByRole('navigation', {
+      name: '移动平台导航',
+    });
+    expect(
+      within(dock)
+        .getAllByRole('button')
+        .map((button) => button.getAttribute('aria-label')),
+    ).toEqual(['游戏', '共创', '创作者主页', '我的']);
+    fireEvent.click(within(dock).getByRole('button', { name: '共创' }));
+    expect(setSelectionStage).toHaveBeenCalledWith('game-co-creation', {
+      path: '/games/co-creation',
+    });
+  });
+
+  it('game-co-creation 渲染的是游戏卡片，且请求带 forkable=1', async () => {
+    window.history.replaceState(null, '', '/games/co-creation');
+    gameDistributionMock.listGames.mockResolvedValue({
+      games: [
+        {
+          id: 'game-forkable',
+          title: '可以共创的作品',
+          summary: '简介',
+          description: '描述',
+          category: '动作',
+          tags: [],
+          coverColor: '#d77a51',
+          icon: '✦',
+          author: { id: 'author-1', name: '演示作者' },
+          deviceSupport: { desktop: true, mobile: true, touch: true },
+          status: 'published',
+          publicationRevision: 1,
+          currentVersion: {
+            id: 'version-1',
+            version: '1.0.0',
+            entryUrl: 'https://play.example.test/v1/index.html',
+            sha256: 'sha256',
+            publishedAt: '2026-09-18T00:00:00.000Z',
+            controls: ['键盘'],
+          },
+          playCount: 3,
+          createdAt: '2026-09-18T00:00:00.000Z',
+          forkAuthorization: 'full',
+        },
+      ],
+      nextCursor: null,
+    });
+    const setSelectionStage = vi.fn();
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-co-creation"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    // 卡片来自广场同一套组件（标题可见），而不是主题卡。
+    expect(await screen.findByText('可以共创的作品')).toBeTruthy();
+    expect(gameDistributionMock.listGames).toHaveBeenCalledWith(
+      expect.objectContaining({ forkable: true }),
+    );
+    // 共创页签里不该出现主题列表页。
+    expect(document.querySelector('.game-themes-page')).toBeNull();
+  });
+});
+
+describe('共创主题', () => {
+  it('主题列表页（保留路由、无页签入口）渲染主题并进入主题页', async () => {
+    window.history.replaceState(null, '', '/games/themes');
+    gameDistributionMock.listThemes.mockResolvedValue({
+      themes: [
+        {
+          themeId: 'theme-1',
+          name: '精选共创',
+          summary: '运营精选',
+          badge: '精选',
+          memberCount: 1,
+        },
+      ],
+      nextCursor: null,
+    });
+    const setSelectionStage = vi.fn();
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-themes"
+        setSelectionStage={setSelectionStage}
+      />,
+    );
+
+    fireEvent.click(await screen.findByRole('button', { name: /精选共创/u }));
+    expect(setSelectionStage).toHaveBeenCalledWith('game-theme', {
+      path: '/games/theme?id=theme-1',
+    });
+  });
+
+  it('主题详情按 ?id= 渲染主题名与成员根，并复用族谱查询', async () => {
+    window.history.replaceState(null, '', '/games/theme?id=theme-1');
+    gameDistributionMock.getTheme.mockResolvedValue({
+      themeId: 'theme-1',
+      name: '精选共创',
+      summary: '运营精选',
+      badge: '精选',
+      memberCount: 1,
+      roots: [
+        {
+          id: 'game-root-1',
+          title: '根作品',
+          summary: '根',
+          description: '',
+          category: '动作',
+          tags: [],
+          coverColor: '#d77a51',
+          icon: '✦',
+          author: { id: 'author-1', name: '测试作者' },
+          deviceSupport: { desktop: true, mobile: true, touch: true },
+          status: 'published',
+          currentVersion: null,
+          playCount: 1,
+          createdAt: '2026-09-18T00:00:00.000Z',
+        },
+      ],
+    });
+    gameDistributionMock.getGameLineage.mockResolvedValue({
+      rootGameId: 'game-root-1',
+      root: null,
+      nodes: [],
+      truncated: false,
+    });
+
+    render(
+      <PlatformEntryFlowShellImpl
+        selectionStage="game-theme"
+        setSelectionStage={vi.fn()}
+      />,
+    );
+
+    expect(
+      await screen.findByRole('heading', { name: '精选共创' }),
+    ).toBeTruthy();
+    expect(screen.getByText('根作品')).toBeTruthy();
+    expect(gameDistributionMock.getTheme).toHaveBeenCalledWith('theme-1');
+    // 树复用既有族谱查询：按根请求一次。
+    expect(gameDistributionMock.getGameLineage).toHaveBeenCalledWith(
+      'game-root-1',
+    );
+  });
+});
diff --git a/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx b/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
index 5d8393d56..7c618e259 100644
--- a/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
+++ b/src/components/platform-entry/PlatformEntryActiveFlowShell.tsx
@@ -5,6 +5,7 @@ import {
   Monitor,
   Palette,
   Search,
+  Sparkles,
   UserRound,
   UsersRound,
 } from 'lucide-react';
@@ -25,9 +26,11 @@ import { PlatformProfileWalletLedgerModal } from '../../../packages/shared/src/c
 import type { ProfileDashboardSummary } from '../../../packages/shared/src/contracts/runtime';
 import { resolveProfileMudPointDisplayTotal } from '../../../packages/shared/src/utils/mudPoints';
 import {
+  APP_STAGE_ROUTES,
   hasAppHistoryBackEntry,
   pushAppHistoryPath,
   replaceAppHistoryPath,
+  resolveSelectionStageFromPath,
 } from '../../routing/activeAppPageRoutes';
 import {
   connectionsPath,
@@ -43,6 +46,14 @@ import { PlatformActionButton } from '../common/PlatformActionButton';
 import { PlatformSubpanel } from '../common/PlatformSubpanel';
 import { ClientDownloadEntry } from '../creation-home/ClientDownloadEntry';
 import { setCreatorViewer } from '../creator/creatorRelationshipState';
+import {
+  CO_CREATION_DETAIL_SOURCE,
+  isCoCreator,
+  PLAY_BACK_TO_QUERY_PARAM,
+  resolveGameViewerContext,
+  resolveInternalBackTo,
+  shouldCarryCoCreationSource,
+} from '../game-distribution/gameViewerRole';
 import { PaymentCheckoutView } from './PaymentCheckoutView';
 import {
   PlatformActiveMobileWelcomeDialog,
@@ -116,6 +127,26 @@ const GamePlayPage = lazy(async () => {
   return { default: module.GamePlayPage };
 });
 
+const GameLineagePage = lazy(async () => {
+  const module = await import('../game-distribution/GameLineagePage');
+  return { default: module.GameLineagePage };
+});
+
+const GameComparePage = lazy(async () => {
+  const module = await import('../game-distribution/GameComparePage');
+  return { default: module.GameComparePage };
+});
+
+const GameThemesPage = lazy(async () => {
+  const module = await import('../game-distribution/GameThemesPage');
+  return { default: module.GameThemesPage };
+});
+
+const GameThemePage = lazy(async () => {
+  const module = await import('../game-distribution/GameThemePage');
+  return { default: module.GameThemePage };
+});
+
 type ActiveRailButtonProps = {
   active: boolean;
   emphasized?: boolean;
@@ -197,6 +228,8 @@ function MobileProfileDock({
   onOpenProfile,
   gameActive,
   onOpenGames,
+  coCreationActive,
+  onOpenCoCreation,
   creatorActive,
   onOpenCreator,
 }: {
@@ -204,13 +237,15 @@ function MobileProfileDock({
   onOpenProfile: () => void;
   gameActive: boolean;
   onOpenGames: () => void;
+  coCreationActive: boolean;
+  onOpenCoCreation: () => void;
   creatorActive: boolean;
   onOpenCreator: () => void;
 }) {
   return (
     <div className="platform-mobile-bottom-dock min-w-0 shrink-0 lg:hidden">
       <nav
-        className="platform-bottom-nav grid grid-cols-3"
+        className="platform-bottom-nav grid grid-cols-4"
         aria-label="移动平台导航"
       >
         <ActiveBottomNavButton
@@ -219,6 +254,16 @@ function MobileProfileDock({
           label="游戏"
           onClick={onOpenGames}
         />
+        {/*
+          「共创」是**顶层入口**（与游戏/创作者主页/我的并列），不再是游戏页里的子页签；
+          窄屏同样从底部导航直达 `/games/co-creation`。
+        */}
+        <ActiveBottomNavButton
+          active={coCreationActive}
+          icon={Sparkles}
+          label="共创"
+          onClick={onOpenCoCreation}
+        />
         <ActiveBottomNavButton
           active={creatorActive}
           icon={UsersRound}
@@ -517,26 +562,167 @@ export function PlatformEntryFlowShellImpl({
     setSelectionStage('game-mine', { path: '/games/mine' });
   }, [setSelectionStage]);
 
+  /**
+   * 导航层**唯一**写「共创来源标记」的地方：当前在共创侧阶段（共创 Tab / 族谱 / 对比），
+   * 或者已经在共创侧页面（详情页 / 游玩页）里，就返回要带上的来源值，否则 `null`。
+   * 详情页进详情、从详情进游玩页、游玩页里继续跳都走它 —— 规则只有一处
+   * （`shouldCarryCoCreationSource`），不新造第二套参数。
+   */
+  const currentCoCreationSource = useCallback((): string | null => {
+    const currentStage = resolveSelectionStageFromPath(
+      window.location.pathname,
+    );
+    const currentSource = new URLSearchParams(window.location.search).get(
+      'from',
+    );
+    return shouldCarryCoCreationSource({ stage: currentStage, currentSource })
+      ? CO_CREATION_DETAIL_SOURCE
+      : null;
+  }, []);
+
   const openGameDetail = useCallback(
     (gameId: string, options?: { owner?: boolean }) => {
       const params = new URLSearchParams({ id: gameId });
       // 作者视角要一直带着 owner 作用域：刷新或直接打开该链接时详情页仍读
       // `GET /my-games/{gameId}`，否则作者点自己的未公开作品只会拿到公开接口的 404。
       if (options?.owner) params.set('owner', '1');
+      /*
+       * **入口上下文**（2026-10-07 产品口径更正：游客 = 点开游戏界面的玩家，不是「未登录访客」）：
+       * 从共创侧（共创 Tab / 族谱页 / 对比页）打开详情时带上 `from=co-creation`，
+       * 详情页据此决定「看不看得到血缘图与共创标签」；其余来源 = 玩家侧（不带标记）。
+       * 已经在共创侧详情页里继续跳（血缘链 / 主题 / 相关作品）时保留标记，不中途掉回玩家侧。
+       * **作者本人**（`owner=1`）也带上标记：产品拍板「作者进自己的作品一律算共创者侧」，
+       * 而且 rail/dock 高亮读的就是 URL 上的 `from`（同一个谓词），标记到位就自动跟随。
+       * 用 URL 而不是内存 stage：刷新、深链、分享链接都稳定。
+       */
+      const source = options?.owner
+        ? CO_CREATION_DETAIL_SOURCE
+        : currentCoCreationSource();
+      if (source) params.set('from', source);
       const path = `/games/detail?${params.toString()}`;
       setSelectionStage('game-detail', { path });
     },
+    [currentCoCreationSource, setSelectionStage],
+  );
+
+  /**
+   * 打开游玩页。两件事都要带上：
+   * 1. **来源标记** `from`：游玩页的 rail/dock 高亮仍按共创侧（读 URL，见 `isCoCreationContext`）；
+   * 2. **返回目标** `backTo`（2026-10-07 用户口径「看他从哪来的」）：把**来处**写在 URL 上，
+   *    游玩页的「返回」据此回到来处（刷新/深链不丢）；已经在游玩页里再进游玩页时**保留原来处**。
+   *    只写站内路径（`APP_STAGE_ROUTES` 里认识的路径），不写绝对 URL。
+   */
+  const openGamePlay = useCallback(
+    (gameId: string) => {
+      const params = new URLSearchParams({ id: gameId });
+      const source = currentCoCreationSource();
+      if (source) params.set('from', source);
+      const currentStage = resolveSelectionStageFromPath(
+        window.location.pathname,
+      );
+      const currentLocation = `${window.location.pathname}${window.location.search}`;
+      const existingBackTo = resolveInternalBackTo(
+        new URLSearchParams(window.location.search).get(
+          PLAY_BACK_TO_QUERY_PARAM,
+        ),
+      );
+      const backTo =
+        currentStage === 'game-play'
+          ? existingBackTo
+          : Object.values(APP_STAGE_ROUTES).includes(window.location.pathname)
+            ? currentLocation
+            : null;
+      if (backTo) params.set(PLAY_BACK_TO_QUERY_PARAM, backTo);
+      const path = `/games/play?${params.toString()}`;
+      setSelectionStage('game-play', { path });
+    },
+    [currentCoCreationSource, setSelectionStage],
+  );
+
+  /**
+   * 打开创作族谱页。路由按规范只要求 `?id=<rootGameId>`；这里额外带上 `from=<当前作品>`，
+   * 让页面对「用户点进来时所在的作品」做高亮，直接打开链接时缺省高亮根节点。
+   */
+  const openGameLineage = useCallback(
+    (rootGameId: string, fromGameId?: string) => {
+      const params = new URLSearchParams({ id: rootGameId });
+      if (fromGameId && fromGameId !== rootGameId) {
+        params.set('from', fromGameId);
+      }
+      const path = `/games/lineage?${params.toString()}`;
+      setSelectionStage('game-lineage', { path });
+    },
     [setSelectionStage],
   );
 
-  const openGamePlay = useCallback(
-    (gameId: string) => {
-      const path = `/games/play?id=${encodeURIComponent(gameId)}`;
-      setSelectionStage('game-play', { path });
+  /** 族谱页从详情页进来，返回优先走浏览器原生返回，兜底回广场。 */
+  const backFromGameLineage = useCallback(() => {
+    if (hasAppHistoryBackEntry()) {
+      window.history.back();
+      return;
+    }
+    replaceAppHistoryPath('/games');
+    setSelectionStage('games', { path: '/games' });
+  }, [setSelectionStage]);
+
+  /** 打开「原版与二创对比」：左侧原版（父作品）、右侧二创（当前作品）。 */
+  const openGameCompare = useCallback(
+    (leftGameId: string, rightGameId: string) => {
+      const params = new URLSearchParams({
+        left: leftGameId,
+        right: rightGameId,
+      });
+      const path = `/games/compare?${params.toString()}`;
+      setSelectionStage('game-compare', { path });
     },
     [setSelectionStage],
   );
 
+  /** 对比页同理：原生返回优先，兜底回广场。 */
+  const backFromGameCompare = useCallback(() => {
+    if (hasAppHistoryBackEntry()) {
+      window.history.back();
+      return;
+    }
+    replaceAppHistoryPath('/games');
+    setSelectionStage('games', { path: '/games' });
+  }, [setSelectionStage]);
+
+  /**
+   * 「共创」页签：**只列支持共创的作品**（游戏卡片 + 同一套游标分页）。
+   * 它不再指向共创主题列表——主题列表页（stage `game-themes`）与路由保留，只是没有页签入口。
+   */
+  const openGameCoCreation = useCallback(() => {
+    setSelectionStage('game-co-creation', { path: '/games/co-creation' });
+  }, [setSelectionStage]);
+
+  const backFromGameThemes = useCallback(() => {
+    if (hasAppHistoryBackEntry()) {
+      window.history.back();
+      return;
+    }
+    replaceAppHistoryPath('/games');
+    setSelectionStage('games', { path: '/games' });
+  }, [setSelectionStage]);
+
+  /** 主题详情：复用 `?id=` 约定（与 `/games/lineage?id=`、`/games/detail?id=` 同款）。 */
+  const openGameTheme = useCallback(
+    (themeId: string) => {
+      const path = `/games/theme?id=${encodeURIComponent(themeId)}`;
+      setSelectionStage('game-theme', { path });
+    },
+    [setSelectionStage],
+  );
+
+  const backFromGameTheme = useCallback(() => {
+    if (hasAppHistoryBackEntry()) {
+      window.history.back();
+      return;
+    }
+    replaceAppHistoryPath('/games/co-creation');
+    setSelectionStage('game-co-creation', { path: '/games/co-creation' });
+  }, [setSelectionStage]);
+
   /**
    * 详情页可能从广场或「我的游戏」进入，返回优先走浏览器原生返回，这样能回到
    * 用户真正的来源页；直接打开详情链接等没有可回退的应用内历史时再兜底回广场。
@@ -550,19 +736,40 @@ export function PlatformEntryFlowShellImpl({
     setSelectionStage('games', { path: '/games' });
   }, [setSelectionStage]);
 
-  /** 游玩页同理，兜底是它自己的详情页，避免详情↔游玩互相塞历史条目。 */
+  /**
+   * 游玩页的「返回」按**来处**回（2026-10-07 用户口径「看他从哪来的」）：
+   * 1. URL 上有合法的 `backTo`（进入游玩页时由 `openGamePlay` 写上）→ **直接回那里**，
+   *    刷新/深链后同样成立；回详情时用 `resolveSelectionStageFromPath` 反推 stage。
+   * 2. 没有 `backTo` → 走既有的浏览器原生返回（站内历史）。
+   * 3. 都没有（直接深链进游玩页）→ 兜底回**它自己的详情页**，没有 id 才回 `/games`。
+   * 参数只表达「回哪」，不表达「哪一侧」；站外值由 `resolveInternalBackTo` 拦掉（防开放重定向）。
+   */
   const backFromGamePlay = useCallback(() => {
+    const params = new URLSearchParams(window.location.search);
+    const backTo = resolveInternalBackTo(params.get(PLAY_BACK_TO_QUERY_PARAM));
+    if (backTo) {
+      const stage = resolveSelectionStageFromPath(
+        new URL(backTo, window.location.origin).pathname,
+      );
+      replaceAppHistoryPath(backTo);
+      setSelectionStage(stage, { path: backTo });
+      return;
+    }
     if (hasAppHistoryBackEntry()) {
       window.history.back();
       return;
     }
-    const currentGameId = new URLSearchParams(window.location.search).get('id');
+    const currentGameId = params.get('id');
+    const source = currentCoCreationSource();
+    const fallbackParams = new URLSearchParams();
+    if (currentGameId) fallbackParams.set('id', currentGameId);
+    if (source) fallbackParams.set('from', source);
     const path = currentGameId
-      ? `/games/detail?id=${encodeURIComponent(currentGameId)}`
+      ? `/games/detail?${fallbackParams.toString()}`
       : '/games';
     replaceAppHistoryPath(path);
     setSelectionStage(currentGameId ? 'game-detail' : 'games', { path });
-  }, [setSelectionStage]);
+  }, [currentCoCreationSource, setSelectionStage]);
 
   const openEditorProject = useCallback(
     (projectId: string, options?: { guide?: boolean; tool?: string }) => {
@@ -625,10 +832,12 @@ export function PlatformEntryFlowShellImpl({
         <MobileProfileDock
           active={false}
           gameActive={false}
+          coCreationActive={false}
           creatorActive={false}
           onOpenCreator={() => openCreator()}
           onOpenProfile={openProfile}
           onOpenGames={openGames}
+          onOpenCoCreation={openGameCoCreation}
         />
         <PlatformActiveMobileWelcomeDialog
           open={shouldOpenMobileHomeWelcome}
@@ -668,11 +877,20 @@ export function PlatformEntryFlowShellImpl({
   const isCreatorStage =
     selectionStage === 'creator-home' ||
     selectionStage === 'creator-connections';
+  /**
+   * 游戏区（含共创）：决定「游戏味」的宿主行为——搜索框口语、面板是否内滚。
+   * **不再等于导航高亮**：共创是独立顶层入口，两者的高亮互斥（见 `isGamesNavActive`）。
+   */
   const isGamesStage =
     selectionStage === 'games' ||
     selectionStage === 'game-detail' ||
+    selectionStage === 'game-compare' ||
+    selectionStage === 'game-themes' ||
+    selectionStage === 'game-co-creation' ||
+    selectionStage === 'game-theme' ||
     selectionStage === 'game-play' ||
     selectionStage === 'game-mine' ||
+    selectionStage === 'game-lineage' ||
     selectionStage === 'game-publish';
   /**
    * 游玩页自己撑满剩余高度，面板不能再滚动，否则移动端会出现整页可滚的
@@ -682,7 +900,34 @@ export function PlatformEntryFlowShellImpl({
   const gameSearchParams = new URLSearchParams(
     typeof window === 'undefined' ? '' : window.location.search,
   );
+  /**
+   * 本屏的**入口来源标记**：详情页上是「从哪一侧点进来」（`from=co-creation`），
+   * 族谱页上含义不同（`from=<gameId>` = 高亮哪个作品）——所以只认 `co-creation` 这一个值
+   * （复用 `resolveGameViewerContext` 的白名单，不自己判字符串）。
+   */
+  const gameEntrySource = gameSearchParams.get('from');
+  /**
+   * 本屏是否属于「**共创侧**」上下文 —— **导航高亮（侧边栏 / 底部 dock）的唯一判据**。
+   *
+   * 用户报的 bug：共创页 → 点卡 → 详情后，侧边栏仍高亮「游戏」。根因是这里原先只看 `stage`，
+   * 而详情页的 stage 属于游戏区（`game-detail`），**来源被丢掉**。修法是复用详情页那套
+   * 已落地的来源判定（不新造参数、不新造标记）：
+   * ① URL 的来源标记就是 `co-creation`（详情页，以及从它继续跳过去的页面）；
+   * ② 或当前就在「共创侧才进得来的阶段」（共创页 / 族谱 / 对比，见 `shouldCarryCoCreationSource`）。
+   */
+  const isCoCreationContext =
+    isGamesStage &&
+    (isCoCreator(resolveGameViewerContext({ source: gameEntrySource })) ||
+      shouldCarryCoCreationSource({
+        stage: selectionStage,
+        currentSource: gameEntrySource,
+      }));
+  /** 游戏区、且**不在共创侧上下文**时，「游戏」这个导航项才是激活态（两者互斥、不双亮）。 */
+  const isGamesNavActive = isGamesStage && !isCoCreationContext;
   const gameId = gameSearchParams.get('id');
+  const lineageHighlightGameId = gameEntrySource;
+  const compareLeftGameId = gameSearchParams.get('left');
+  const compareRightGameId = gameSearchParams.get('right');
   const creatorConnectionTab = gameSearchParams.get('tab');
   const publishGameId = gameSearchParams.get('game');
   const avatarUrl = authUi?.user?.avatarUrl?.trim() || null;
@@ -740,13 +985,27 @@ export function PlatformEntryFlowShellImpl({
                   onClick={openProjects}
                 />
                 <ActiveRailButton
-                  active={isGamesStage}
-                  emphasized={isGamesStage}
+                  active={isGamesNavActive}
+                  emphasized={isGamesNavActive}
                   icon={Gamepad2}
                   iconSrc="/creation-home/nav-games.png"
                   label="游戏"
                   onClick={openGames}
                 />
+                {/*
+                  「共创」：**顶层入口**（2026-10-07 用户口径：不该是游戏页里的子页签）。
+                  指向 `scope="forkable"` 的那个列表页（`/games/co-creation`），与「游戏」平级。
+                  高亮读 `isCoCreationContext`：共创页本身、以及**从共创侧点进去的详情/族谱/对比**
+                  都算共创侧（用户报的「共创 → 详情后仍高亮游戏」就是这里原先只看 stage 造成的）。
+                */}
+                <ActiveRailButton
+                  active={isCoCreationContext}
+                  emphasized={isCoCreationContext}
+                  icon={Sparkles}
+                  iconSrc="/creation-home/nav-discover.png"
+                  label="共创"
+                  onClick={openGameCoCreation}
+                />
                 <ActiveRailButton
                   active={isCreatorStage}
                   icon={UsersRound}
@@ -975,6 +1234,42 @@ export function PlatformEntryFlowShellImpl({
                         onBack={backFromGameDetail}
                         onPlay={openGamePlay}
                         onOpenRecharge={openRecharge}
+                        onOpenLineage={openGameLineage}
+                        onOpenCompare={openGameCompare}
+                        onOpenTheme={openGameTheme}
+                        onOpenGameDetail={openGameDetail}
+                      />
+                    ) : selectionStage === 'game-lineage' ? (
+                      <GameLineagePage
+                        rootGameId={gameId}
+                        highlightGameId={lineageHighlightGameId}
+                        onBack={backFromGameLineage}
+                        onOpenDetail={openGameDetail}
+                      />
+                    ) : selectionStage === 'game-compare' ? (
+                      <GameComparePage
+                        leftGameId={compareLeftGameId}
+                        rightGameId={compareRightGameId}
+                        onBack={backFromGameCompare}
+                        onOpenDetail={openGameDetail}
+                      />
+                    ) : selectionStage === 'game-co-creation' ? (
+                      <GameGalleryPage
+                        searchKeyword={activeSearchKeyword}
+                        scope="forkable"
+                        onOpenDetail={openGameDetail}
+                      />
+                    ) : selectionStage === 'game-themes' ? (
+                      <GameThemesPage
+                        onBack={backFromGameThemes}
+                        onOpenTheme={openGameTheme}
+                      />
+                    ) : selectionStage === 'game-theme' ? (
+                      <GameThemePage
+                        themeId={gameId}
+                        onBack={backFromGameTheme}
+                        onOpenDetail={openGameDetail}
+                        onOpenLineage={openGameLineage}
                       />
                     ) : (
                       <GamePlayPage gameId={gameId} onBack={backFromGamePlay} />
@@ -993,11 +1288,13 @@ export function PlatformEntryFlowShellImpl({
           </div>
           <MobileProfileDock
             active={isProfileStage}
-            gameActive={isGamesStage}
+            gameActive={isGamesNavActive}
+            coCreationActive={isCoCreationContext}
             creatorActive={isCreatorStage}
             onOpenCreator={() => openCreator()}
             onOpenProfile={openProfile}
             onOpenGames={openGames}
+            onOpenCoCreation={openGameCoCreation}
           />
         </div>
       </div>
diff --git a/src/components/platform-entry/platformEntryActiveTypes.ts b/src/components/platform-entry/platformEntryActiveTypes.ts
index a6d786a9d..98187b9de 100644
--- a/src/components/platform-entry/platformEntryActiveTypes.ts
+++ b/src/components/platform-entry/platformEntryActiveTypes.ts
@@ -10,8 +10,13 @@ export type SelectionStage =
   | 'image-editor'
   | 'games'
   | 'game-detail'
+  | 'game-compare'
+  | 'game-themes'
+  | 'game-co-creation'
+  | 'game-theme'
   | 'game-play'
   | 'game-mine'
+  | 'game-lineage'
   | 'game-publish';
 
 export type PlatformEntryFlowShellProps = {
diff --git a/src/routing/activeAppPageRoutes.test.ts b/src/routing/activeAppPageRoutes.test.ts
index 869596062..51d7847a0 100644
--- a/src/routing/activeAppPageRoutes.test.ts
+++ b/src/routing/activeAppPageRoutes.test.ts
@@ -26,8 +26,19 @@ describe('appPageRoutes', () => {
     );
     expect(resolveSelectionStageFromPath('/games')).toBe('games');
     expect(resolveSelectionStageFromPath('/games/detail/')).toBe('game-detail');
+    expect(resolveSelectionStageFromPath('/games/compare')).toBe(
+      'game-compare',
+    );
+    expect(resolveSelectionStageFromPath('/games/themes')).toBe('game-themes');
+    expect(resolveSelectionStageFromPath('/games/co-creation')).toBe(
+      'game-co-creation',
+    );
+    expect(resolveSelectionStageFromPath('/games/theme')).toBe('game-theme');
     expect(resolveSelectionStageFromPath('/games/play')).toBe('game-play');
     expect(resolveSelectionStageFromPath('/games/mine')).toBe('game-mine');
+    expect(resolveSelectionStageFromPath('/games/lineage')).toBe(
+      'game-lineage',
+    );
     expect(resolveSelectionStageFromPath('/games/publish')).toBe(
       'game-publish',
     );
@@ -44,7 +55,14 @@ describe('appPageRoutes', () => {
     expect(resolvePathForSelectionStage('project')).toBe('/project');
     expect(resolvePathForSelectionStage('profile')).toBe('/profile');
     expect(resolvePathForSelectionStage('games')).toBe('/games');
+    expect(resolvePathForSelectionStage('game-compare')).toBe('/games/compare');
+    expect(resolvePathForSelectionStage('game-themes')).toBe('/games/themes');
+    expect(resolvePathForSelectionStage('game-co-creation')).toBe(
+      '/games/co-creation',
+    );
+    expect(resolvePathForSelectionStage('game-theme')).toBe('/games/theme');
     expect(resolvePathForSelectionStage('game-mine')).toBe('/games/mine');
+    expect(resolvePathForSelectionStage('game-lineage')).toBe('/games/lineage');
     expect(resolvePathForSelectionStage('game-publish')).toBe('/games/publish');
     expect(resolvePathForSelectionStage('profile-payment')).toBe(
       '/profile/payment',
diff --git a/src/routing/activeAppPageRoutes.ts b/src/routing/activeAppPageRoutes.ts
index afdb465fe..5b4ed76a4 100644
--- a/src/routing/activeAppPageRoutes.ts
+++ b/src/routing/activeAppPageRoutes.ts
@@ -15,8 +15,15 @@ const STAGE_ROUTE_ENTRIES = [
   ['image-editor', '/editor/canvas'],
   ['games', '/games'],
   ['game-detail', '/games/detail'],
+  ['game-compare', '/games/compare'],
+  ['game-themes', '/games/themes'],
+  // 「共创」页签：只列**支持共创**的作品（游戏卡片 + 同一套游标分页）。
+  // 主题列表（`/games/themes`）与主题详情仍保留路由，只是页签不再指向它们。
+  ['game-co-creation', '/games/co-creation'],
+  ['game-theme', '/games/theme'],
   ['game-play', '/games/play'],
   ['game-mine', '/games/mine'],
+  ['game-lineage', '/games/lineage'],
   ['game-publish', '/games/publish'],
 ] as const satisfies readonly (readonly [SelectionStage, string])[];
 
diff --git a/src/services/activeAppTitle.test.ts b/src/services/activeAppTitle.test.ts
index 950a1c98d..e8dbd564d 100644
--- a/src/services/activeAppTitle.test.ts
+++ b/src/services/activeAppTitle.test.ts
@@ -36,6 +36,21 @@ describe('activeAppTitle', () => {
     expect(resolveAppTitleForSelectionStage('game-mine')).toBe(
       '我的游戏 - 陶泥儿',
     );
+    expect(resolveAppTitleForSelectionStage('game-lineage')).toBe(
+      '创作族谱 - 陶泥儿',
+    );
+    expect(resolveAppTitleForSelectionStage('game-compare')).toBe(
+      '原版与二创对比 - 陶泥儿',
+    );
+    expect(resolveAppTitleForSelectionStage('game-themes')).toBe(
+      '共创主题 - 陶泥儿',
+    );
+    expect(resolveAppTitleForSelectionStage('game-co-creation')).toBe(
+      '共创 - 陶泥儿',
+    );
+    expect(resolveAppTitleForSelectionStage('game-theme')).toBe(
+      '共创主题详情 - 陶泥儿',
+    );
     expect(resolveAppTitleForSelectionStage('game-publish')).toBe(
       '发布游戏 - 陶泥儿',
     );
diff --git a/src/services/activeAppTitle.ts b/src/services/activeAppTitle.ts
index 2ecd32bdc..a76a2a382 100644
--- a/src/services/activeAppTitle.ts
+++ b/src/services/activeAppTitle.ts
@@ -16,8 +16,13 @@ const APP_TITLE_BY_SELECTION_STAGE: Record<SelectionStage, string> = {
   'image-editor': '美术编辑器 - 陶泥儿',
   games: '游戏 - 陶泥儿',
   'game-detail': '游戏详情 - 陶泥儿',
+  'game-compare': '原版与二创对比 - 陶泥儿',
+  'game-themes': '共创主题 - 陶泥儿',
+  'game-co-creation': '共创 - 陶泥儿',
+  'game-theme': '共创主题详情 - 陶泥儿',
   'game-play': '正在游玩 - 陶泥儿',
   'game-mine': '我的游戏 - 陶泥儿',
+  'game-lineage': '创作族谱 - 陶泥儿',
   'game-publish': '发布游戏 - 陶泥儿',
 };
 
diff --git a/src/services/clipboard.test.ts b/src/services/clipboard.test.ts
index f88d6dd24..afcdd6b0c 100644
--- a/src/services/clipboard.test.ts
+++ b/src/services/clipboard.test.ts
@@ -48,6 +48,30 @@ describe('copyTextToClipboard', () => {
     expect(writeText).toHaveBeenCalledWith('PZ-00000002');
   });
 
+  test('Clipboard API 永不 settle 时超时降级，不把调用方挂死', async () => {
+    vi.spyOn(hostBridge, 'writeHostClipboardText').mockResolvedValue(false);
+    // 页面未聚焦 / 无系统剪贴板时 writeText 可能既不成功也不拒绝——这里固定复现这个 promise。
+    const writeText = vi.fn(() => new Promise<void>(() => {}));
+    Object.defineProperty(navigator, 'clipboard', {
+      configurable: true,
+      value: { writeText },
+    });
+    const execCommand = vi.fn(() => false);
+    Object.defineProperty(document, 'execCommand', {
+      configurable: true,
+      value: execCommand,
+    });
+    vi.useFakeTimers();
+
+    const pending = copyTextToClipboard('  PZ-00000003  ');
+    await vi.advanceTimersByTimeAsync(1000);
+
+    // 超时后走兼容路径，得到确定结果（这里是 false = 复制失败），而不是永远挂着。
+    await expect(pending).resolves.toBe(false);
+    expect(writeText).toHaveBeenCalledWith('PZ-00000003');
+    vi.useRealTimers();
+  });
+
   test('空文本不触发宿主或浏览器复制', async () => {
     const writeHostClipboardText = vi
       .spyOn(hostBridge, 'writeHostClipboardText')
diff --git a/src/services/clipboard.ts b/src/services/clipboard.ts
index eb6a62606..e590c51ff 100644
--- a/src/services/clipboard.ts
+++ b/src/services/clipboard.ts
@@ -1,5 +1,16 @@
 import { writeHostClipboardText } from './host-bridge/hostBridge';
 
+/**
+ * 标准 Clipboard API 的等待上限。
+ *
+ * 为什么需要它：`navigator.clipboard.writeText` 在**页面未聚焦 / 无系统剪贴板 /
+ * 自动化上下文**里可能既不成功也不拒绝（promise 永不 settle）。调用方（复制按钮）是在
+ * await 之后才切状态的，一旦这里挂住，用户点下去就是「按钮没反应、剪贴板也没变」——
+ * 反馈窗口调多长都没用。超时后走下面的兼容路径（textarea + execCommand），
+ * 那条路径是同步的，总能给出一个确定结果。
+ */
+const CLIPBOARD_API_TIMEOUT_MS = 800;
+
 export async function copyTextToClipboard(value: string) {
   const text = value.trim();
   if (!text) {
@@ -12,8 +23,16 @@ export async function copyTextToClipboard(value: string) {
 
   if (typeof navigator !== 'undefined' && navigator.clipboard?.writeText) {
     try {
-      await navigator.clipboard.writeText(text);
-      return true;
+      const written = await Promise.race([
+        navigator.clipboard.writeText(text).then(() => true),
+        new Promise<boolean>((resolve) => {
+          setTimeout(() => resolve(false), CLIPBOARD_API_TIMEOUT_MS);
+        }),
+      ]);
+      if (written) {
+        return true;
+      }
+      // 超时：不在这里卡住，继续走兼容路径（结果是同步可判定的）。
     } catch {
       // 部分内嵌浏览器会暴露 Clipboard API，但会因权限上下文拒绝写入，继续走兼容路径。
     }
diff --git a/src/services/gameDistributionClient.test.ts b/src/services/gameDistributionClient.test.ts
index 25479b758..8038fc816 100644
--- a/src/services/gameDistributionClient.test.ts
+++ b/src/services/gameDistributionClient.test.ts
@@ -9,8 +9,10 @@ import {
 import {
   cancelGameVersion,
   createGamePlaySession,
+  getDerivedGames,
   getGame,
   getGameDistributionMediaReadUrl,
+  getGameLineage,
   getGameVersion,
   getMyGameReview,
   getOwnerGameDistributionMediaReadUrl,
@@ -22,6 +24,7 @@ import {
   recordGamePlay,
   saveMyGameReview,
   unpublishGame,
+  updateGameForkAuthorization,
   updateMyGame,
   uploadGamePackage,
 } from './gameDistributionClient';
@@ -92,9 +95,66 @@ describe('gameDistributionClient', () => {
         ),
       ),
     );
-    const games = await listGames({ keyword: '星轨', category: '动作' });
-    expect(games).toHaveLength(1);
-    expect(games[0]?.id).toBe('game-1');
+    const page = await listGames({ keyword: '星轨', category: '动作' });
+    expect(page.games).toHaveLength(1);
+    expect(page.games[0]?.id).toBe('game-1');
+    // 没有 nextCursor 就是末页。
+    expect(page.nextCursor).toBeNull();
+  });
+
+  it('游标分页：limit / cursor 原样透传，nextCursor 原样回传', async () => {
+    const fetchMock = vi.fn().mockImplementation(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            games: [
+              { id: 'game-2', title: '第二页', currentVersion: { id: 'v2' } },
+            ],
+            nextCursor: '1759000000000000:game-2',
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+    const page = await listGames({
+      keyword: '星轨',
+      category: '动作',
+      limit: 20,
+      cursor: '1759000000000000:game-1',
+    });
+    // 参数名与顺序：服务端按 `limit`/`cursor` 读；游标对客户端不透明，原样带回。
+    expect(fetchMock.mock.calls[0][0]).toBe(
+      `/api/game-distribution/games?keyword=${encodeURIComponent('星轨')}&category=${encodeURIComponent('动作')}&limit=20&cursor=${encodeURIComponent('1759000000000000:game-1')}`,
+    );
+    expect(page.nextCursor).toBe('1759000000000000:game-2');
+    expect(page.games.map((game) => game.id)).toEqual(['game-2']);
+
+    // 不传 limit / cursor 时不带这两个参数（服务端取默认 48）。
+    await listGames({});
+    expect(fetchMock.mock.calls[1][0]).toBe('/api/game-distribution/games');
+    // limit<=0 与空游标视同缺省，不发误导参数。
+    await listGames({ limit: 0, cursor: '   ' });
+    expect(fetchMock.mock.calls[2][0]).toBe('/api/game-distribution/games');
+  });
+
+  it('forkable 只发 1、省略时不带该参数（服务端未上线也不影响）', async () => {
+    const fetchMock = vi.fn().mockImplementation(() =>
+      Promise.resolve(
+        new Response(JSON.stringify({ games: [], nextCursor: null }), {
+          status: 200,
+        }),
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+    await listGames({ forkable: true });
+    expect(fetchMock.mock.calls[0][0]).toBe(
+      '/api/game-distribution/games?forkable=1',
+    );
+    await listGames({ forkable: false });
+    expect(fetchMock.mock.calls[1][0]).toBe('/api/game-distribution/games');
+    await listGames();
+    expect(fetchMock.mock.calls[2][0]).toBe('/api/game-distribution/games');
   });
 
   it('作者过滤由查询参数交给后端，显式空值不退回全站游戏', async () => {
@@ -120,6 +180,42 @@ describe('gameDistributionClient', () => {
     expect(await getGame('')).toBeNull();
   });
 
+  it('族谱与衍生列表走公开只读路径、不缓存，并拒绝空 id', async () => {
+    const fetchMock = vi.fn().mockImplementation(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            rootGameId: 'game-root',
+            root: null,
+            nodes: [],
+            truncated: false,
+            gameId: 'game-1',
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    await getGameLineage('game-1');
+    await getDerivedGames('game-1');
+
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(
+      '/api/game-distribution/games/game-1/lineage',
+    );
+    expect(fetchMock.mock.calls[1]?.[0]).toBe(
+      '/api/game-distribution/games/game-1/derived',
+    );
+    for (const [, init] of fetchMock.mock.calls) {
+      expect(init).toMatchObject({ method: 'GET', cache: 'no-store' });
+      expect(init?.headers?.Authorization).toBeUndefined();
+    }
+
+    expect(await getGameLineage('')).toBeNull();
+    expect(await getDerivedGames('  ')).toBeNull();
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
   it('详情可选鉴权：已登录带 bearer，未登录匿名且不补票', async () => {
     const fetchMock = vi.fn().mockImplementation(() =>
       Promise.resolve(
@@ -352,6 +448,58 @@ describe('gameDistributionClient 作者接口', () => {
     expect(unpublishCalls()).toHaveLength(1);
   });
 
+  it('共创授权提升只发 PUT，携带期望档位与幂等键，空入参本地失败关闭', async () => {
+    setStoredAccessToken('author-token', { emit: false });
+    const fetchMock = vi.fn().mockImplementation(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            game: { id: 'game-1', forkAuthorization: 'nonCommercial' },
+            replayed: false,
+          }),
+          { status: 200, headers: { 'Content-Type': 'application/json' } },
+        ),
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    await updateGameForkAuthorization(
+      'game-1',
+      'nonCommercial',
+      'forbidden',
+      'fork-key-1',
+    );
+    const forkCalls = () =>
+      fetchMock.mock.calls.filter(([url]) =>
+        String(url).includes('/fork-authorization'),
+      );
+    expect(forkCalls()).toHaveLength(1);
+    expect(forkCalls()[0]?.[0]).toBe(
+      '/api/game-distribution/games/game-1/fork-authorization',
+    );
+    expect(forkCalls()[0]?.[1]).toEqual(
+      expect.objectContaining({
+        method: 'PUT',
+        body: JSON.stringify({
+          expectedForkAuthorization: 'forbidden',
+          forkAuthorization: 'nonCommercial',
+        }),
+        headers: expect.objectContaining({
+          'Idempotency-Key': 'fork-key-1',
+        }),
+      }),
+    );
+
+    await expect(
+      updateGameForkAuthorization('   ', 'full', 'forbidden', 'k'),
+    ).rejects.toThrow('缺少游戏编号');
+    await expect(
+      updateGameForkAuthorization('game-1', 'full', 'forbidden', '   '),
+    ).rejects.toThrow('缺少幂等键');
+    // 本地校验失败不得发出任何授权请求。
+    expect(forkCalls()).toHaveLength(1);
+  });
+
   it('回读单个版本状态与服务端恢复动作', async () => {
     setStoredAccessToken('test-access-token', { emit: false });
     const fetchMock = vi.fn().mockImplementation(() =>
@@ -635,18 +783,16 @@ describe('gameDistributionClient 发布媒体 multipart', () => {
 
   it('统一发布把 metadata 序列化进 FormData，并按槽位追加封面与截图二进制', async () => {
     setStoredAccessToken('author-token', { emit: false });
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValue(
-        new Response(
-          JSON.stringify({
-            game: { id: 'game-1' },
-            version: { versionId: 'version-1', versionNumber: 1 },
-            replayed: false,
-          }),
-          { status: 200 },
-        ),
-      );
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          game: { id: 'game-1' },
+          version: { versionId: 'version-1', versionNumber: 1 },
+          replayed: false,
+        }),
+        { status: 200 },
+      ),
+    );
     vi.stubGlobal('fetch', fetchMock);
     const cover = new File(['cover-bytes'], 'cover.png', { type: 'image/png' });
     const screenshot = new File(['shot-bytes'], 'shot.png', {
@@ -696,18 +842,16 @@ describe('gameDistributionClient 发布媒体 multipart', () => {
 
   it('更新发布带 gameId 且媒体 part 独立提交', async () => {
     setStoredAccessToken('author-token', { emit: false });
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValue(
-        new Response(
-          JSON.stringify({
-            game: { id: 'game-1' },
-            version: { versionId: 'version-2', versionNumber: 2 },
-            replayed: false,
-          }),
-          { status: 200 },
-        ),
-      );
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          game: { id: 'game-1' },
+          version: { versionId: 'version-2', versionNumber: 2 },
+          replayed: false,
+        }),
+        { status: 200 },
+      ),
+    );
     vi.stubGlobal('fetch', fetchMock);
     const cover = new File(['cover-bytes'], 'cover.png', { type: 'image/png' });
 
diff --git a/src/services/gameDistributionClient.ts b/src/services/gameDistributionClient.ts
index 33896052d..ff2019755 100644
--- a/src/services/gameDistributionClient.ts
+++ b/src/services/gameDistributionClient.ts
@@ -2,8 +2,11 @@ import type {
   GameDistributionAuthor,
   GameDistributionCancelVersionResponse,
   GameDistributionCategory,
+  GameDistributionDerivedResponse,
   GameDistributionDeviceSupport,
+  GameDistributionForkAuthorization,
   GameDistributionGame,
+  GameDistributionLineageResponse,
   GameDistributionMyReviewResponse,
   GameDistributionPlaySessionResponse,
   GameDistributionPurchaseRequest,
@@ -12,14 +15,15 @@ import type {
   GameDistributionReviewsResponse,
   GameDistributionSaveReviewRequest,
   GameDistributionSaveReviewResponse,
+  GameDistributionSetForkAuthorizationRequest,
   GameDistributionUpdateGameMetadataRequest,
   GameDistributionVersionDetail,
   GameDistributionVersionStatus as GameDistributionVersionStatusValue,
   GameDistributionVersionSummary,
 } from '../../packages/shared/src/contracts/gameDistribution';
 import type {
-  NewGameVersionRequest,
   GameDistributionPublishVersionResponse,
+  NewGameVersionRequest,
 } from '../../packages/shared/src/contracts/gameDistributionPublish';
 import {
   type ApiRequestOptions,
@@ -30,9 +34,14 @@ import { getGamePlayClientId } from './gamePlayClientId';
 
 export type {
   GameDistributionAuthor,
+  GameDistributionDerivedResponse,
   GameDistributionDeviceSupport,
+  GameDistributionForkAuthorization,
   GameDistributionGame,
   GameDistributionInputMode,
+  GameDistributionLineage,
+  GameDistributionLineageNode,
+  GameDistributionLineageResponse,
   GameDistributionRatingSummary,
   GameDistributionRecoveryAction,
   GameDistributionReview,
@@ -49,6 +58,29 @@ export type GameListQuery = {
   authorId?: string;
   keyword?: string;
   category?: GameCategory | '全部';
+  /**
+   * 一页条数。缺省 = 服务端默认 **48**；上限 **100**（超界服务端**截断**不报错，`0` 视作缺省）。
+   */
+  limit?: number;
+  /**
+   * 只返回**支持共创**的作品（`forkAuthorization != 'forbidden'`）。
+   *
+   * 契约（2026-10-07 冻结）：请求参数 `forkable=1`；省略 = 全部（与现状一致）。
+   * 分页语义完全沿用（默认 48 / 上限 100、`created_at` 倒序 + game_id 升序、游标不透明、
+   * 末页 `null`、非法游标 `CATALOG_INVALID_CURSOR`）。
+   */
+  forkable?: boolean;
+  /**
+   * 上一页响应里的 `nextCursor`，**原样回传**即可（对客户端不透明；末页为 `null`）。
+   * 自己拼游标会破坏服务端的稳定全序（`created_at` 倒序 + `game_id` 升序），所以不允许。
+   */
+  cursor?: string;
+};
+
+/** 公开目录的一页：作品 + 下一页游标（末页 `nextCursor === null`）。 */
+export type GameListPage = {
+  games: GameDistributionGame[];
+  nextCursor: string | null;
 };
 
 /**
@@ -156,22 +188,48 @@ async function requestJson<T>(
   );
 }
 
-export async function listGames(query: GameListQuery = {}) {
+/**
+ * 公开目录（`/games`）。**游标分页**（2026-10-07 服务端已实现真分页）：
+ * - 只传 `limit` / `cursor`，`nextCursor` **原样透传**给调用方；
+ * - 服务端排序是稳定全序（`created_at` 倒序 + `game_id` 升序），所以「追加下一页」不会重不会漏；
+ * - 末页 `nextCursor = null`，调用方据此隐藏「加载更多」；
+ * - 非法游标服务端返回 400 + 稳定码 `CATALOG_INVALID_CURSOR`（前端只需展示消息、不要重试同一游标）。
+ *
+ * 旧实现在这里丢掉 `nextCursor` 且不传 `limit`/`cursor`，于是第 49 条之后的作品在网页上
+ * **永久不可见**——所以返回类型从「数组」改成「一页」，让调用方无法再假装「一次拿全」。
+ */
+export async function listGames(
+  query: GameListQuery = {},
+): Promise<GameListPage> {
   const params = new URLSearchParams();
   if (query.authorId !== undefined) params.set('authorId', query.authorId);
   if (query.keyword?.trim()) params.set('keyword', query.keyword.trim());
   if (query.category && query.category !== '全部')
     params.set('category', query.category);
+  if (typeof query.limit === 'number' && query.limit > 0) {
+    params.set('limit', String(Math.trunc(query.limit)));
+  }
+  if (query.forkable) params.set('forkable', '1');
+  if (query.cursor?.trim()) params.set('cursor', query.cursor.trim());
   const search = params.toString();
-  const payload = await requestJson<unknown>(
+  const payload = await requestJson<{ games?: unknown; nextCursor?: unknown }>(
     `/games${search ? `?${search}` : ''}`,
     { method: 'GET' },
     '读取游戏目录失败',
     PUBLIC_GAME_REQUEST_OPTIONS,
   );
-  return normalizeGameList(
-    Array.isArray(payload) ? payload : (payload as { games?: unknown[] }).games,
-  );
+  return {
+    games: normalizeGameList(
+      Array.isArray(payload)
+        ? payload
+        : (payload as { games?: unknown[] }).games,
+    ),
+    nextCursor:
+      typeof (payload as { nextCursor?: unknown }).nextCursor === 'string' &&
+      (payload as { nextCursor: string }).nextCursor.trim()
+        ? (payload as { nextCursor: string }).nextCursor.trim()
+        : null,
+  };
 }
 
 export type GameDistributionMyGame = GameDistributionGame & {
@@ -363,6 +421,42 @@ export async function unpublishGame(
   );
 }
 
+/**
+ * 提升作品共创授权（只升不降）。`expectedForkAuthorization` 为 CAS 期望值，
+ * 服务端发现档位冲突或降级时返回 409，错误信息由 `requestJson` 透传。
+ */
+export async function updateGameForkAuthorization(
+  gameId: string,
+  forkAuthorization: GameDistributionForkAuthorization,
+  expectedForkAuthorization: GameDistributionForkAuthorization,
+  idempotencyKey: string,
+) {
+  const normalizedGameId = gameId.trim();
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedGameId) throw new Error('缺少游戏编号');
+  if (!normalizedKey) throw new Error('设置共创授权缺少幂等键');
+  const payload: GameDistributionSetForkAuthorizationRequest = {
+    expectedForkAuthorization,
+    forkAuthorization,
+  };
+  return requestJson<{
+    ok?: boolean;
+    replayed?: boolean;
+    game: {
+      id: string;
+      forkAuthorization?: GameDistributionForkAuthorization;
+    };
+  }>(
+    `/games/${encodeURIComponent(normalizedGameId)}/fork-authorization`,
+    {
+      method: 'PUT',
+      headers: { 'Idempotency-Key': normalizedKey },
+      body: JSON.stringify(payload),
+    },
+    '设置共创授权失败',
+  );
+}
+
 /**
  * 读取游戏公开详情。
  *
@@ -372,7 +466,7 @@ export async function unpublishGame(
 export async function getGame(gameId: string) {
   const normalizedId = gameId.trim();
   if (!normalizedId) return null;
-  return requestJson<GameDistributionGame>(
+  return requestJson<GameDistributionGameWithCollection>(
     `/games/${encodeURIComponent(normalizedId)}`,
     { method: 'GET', cache: 'no-store' },
     '读取游戏详情失败',
@@ -453,6 +547,224 @@ export async function getOwnerGameDistributionMediaReadUrl(
   return readGameDistributionMediaSignedUrl(payload);
 }
 
+/**
+ * 公开详情在**已认证**时多带 `collected`；匿名请求**完全不返回该键**。
+ *
+ * 所以类型里它是可选的，读侧必须把「缺字段」与 `false` 区分开：缺字段 = 不可判定
+ * （未登录，或带过期 token 被服务端按匿名处理），不能渲染成「未收藏」。
+ */
+export type GameDistributionGameWithCollection = GameDistributionGame & {
+  collected?: boolean;
+  /**
+   * 该作品所属的公开共创主题（先取作品的根再按根反查，因此**第 N 代作品也会有值**）。
+   * 匿名也返回：没有所属主题时是 `[]` 而不是缺键。
+   */
+  themes?: GameDistributionThemeReference[];
+};
+
+/** 作品详情里的主题入口：只够渲染一个跳转（简介与成员数在主题页取）。 */
+export type GameDistributionThemeReference = {
+  themeId: string;
+  name: string;
+  badge: string;
+};
+
+/** 共创主题摘要（公开列表条目）。 */
+export type GameDistributionThemeSummary = {
+  themeId: string;
+  name: string;
+  summary: string;
+  badge: string;
+  /** 当前**可见**成员数（与主题详情 `roots` 长度同口径，不含草稿/已下架成员）。 */
+  memberCount: number;
+};
+
+/** 主题详情：摘要 + 成员根清单（逐条是公开目录同一份投影）。 */
+export type GameDistributionThemeDetail = GameDistributionThemeSummary & {
+  roots: GameDistributionGame[];
+  /**
+   * `roots` 是否被服务端的响应体积上限截断（与族谱响应的 `truncated` 同一种约定）。
+   *
+   * **`memberCount` 与 `roots.length` 不再保证相等**：`memberCount` 是真实可见成员数（不截断），
+   * `roots` 可能只含前 50 个。展示总数一律用 `memberCount`，这个布尔只负责决定要不要提示。
+   */
+  rootsTruncated: boolean;
+};
+
+function normalizeThemeList(value: unknown): GameDistributionThemeSummary[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!item || typeof item !== 'object') return [];
+    const theme = item as Partial<GameDistributionThemeSummary>;
+    const themeId =
+      typeof theme.themeId === 'string' ? theme.themeId.trim() : '';
+    const name = typeof theme.name === 'string' ? theme.name.trim() : '';
+    if (!themeId || !name) return [];
+    return [
+      {
+        themeId,
+        name,
+        summary: typeof theme.summary === 'string' ? theme.summary : '',
+        badge: typeof theme.badge === 'string' ? theme.badge : '',
+        memberCount:
+          typeof theme.memberCount === 'number' && theme.memberCount >= 0
+            ? theme.memberCount
+            : 0,
+      },
+    ];
+  });
+}
+
+/**
+ * 共创主题列表（匿名可读）。分页与 `/my-collections` 同口径：服务端默认 20 / 上限 50，
+ * `nextCursor` 是真实游标（末页为 `null`），客户端只在非空时渲染「加载更多」。
+ */
+export async function listThemes(cursor?: string) {
+  const params = new URLSearchParams();
+  const normalizedCursor = cursor?.trim();
+  if (normalizedCursor) params.set('cursor', normalizedCursor);
+  const query = params.toString();
+  const payload = await requestJson<{
+    themes?: unknown;
+    nextCursor?: string | null;
+  }>(
+    `/themes${query ? `?${query}` : ''}`,
+    { method: 'GET', cache: 'no-store' },
+    '读取共创主题失败',
+    PUBLIC_GAME_REQUEST_OPTIONS,
+  );
+  return {
+    themes: normalizeThemeList(payload.themes),
+    nextCursor: payload.nextCursor ?? null,
+  };
+}
+
+/**
+ * 共创主题详情（匿名可读）。主题不存在 / 未发布一律 404（服务端不返回空壳），
+ * 这里按失败抛出，由主题页渲染成「主题不存在或尚未发布」的降级态。
+ */
+export async function getTheme(
+  themeId: string,
+): Promise<GameDistributionThemeDetail | null> {
+  const normalizedThemeId = themeId.trim();
+  if (!normalizedThemeId) return null;
+  const payload = await requestJson<{
+    themeId?: string;
+    name?: string;
+    summary?: string;
+    badge?: string;
+    memberCount?: number;
+    /** `roots` 被响应体积上限截断：与 `roots` 同层，空成员时也是 `false`（不是缺键）。 */
+    rootsTruncated?: boolean;
+    roots?: unknown;
+  }>(
+    `/themes/${encodeURIComponent(normalizedThemeId)}`,
+    { method: 'GET', cache: 'no-store' },
+    '读取共创主题失败',
+    PUBLIC_GAME_REQUEST_OPTIONS,
+  );
+  return {
+    themeId: payload.themeId ?? normalizedThemeId,
+    name: payload.name ?? '',
+    summary: payload.summary ?? '',
+    badge: payload.badge ?? '',
+    memberCount: payload.memberCount ?? 0,
+    rootsTruncated: payload.rootsTruncated === true,
+    roots: normalizeGameList(payload.roots),
+  };
+}
+
+/** 收藏切换的响应；DELETE 不带 `replayed`。 */
+export type GameDistributionCollectionState = {
+  collected: boolean;
+  replayed?: boolean;
+};
+
+/**
+ * 收藏 / 取消收藏。收藏走 PUT（幂等键由调用方生成，重复提交返回同一结果）；
+ * 取消走 DELETE（确定性主键，重复调用结果相同，因此不需要幂等键）。
+ */
+export async function setGameCollection(
+  gameId: string,
+  collected: boolean,
+  idempotencyKey: string,
+) {
+  const normalizedId = gameId.trim();
+  if (!normalizedId) throw new Error('收藏缺少作品编号');
+  if (!collected) {
+    return requestJson<GameDistributionCollectionState>(
+      `/games/${encodeURIComponent(normalizedId)}/collection`,
+      { method: 'DELETE' },
+      '取消收藏失败',
+    );
+  }
+  const normalizedKey = idempotencyKey.trim();
+  if (!normalizedKey) throw new Error('收藏缺少幂等键');
+  return requestJson<GameDistributionCollectionState>(
+    `/games/${encodeURIComponent(normalizedId)}/collection`,
+    {
+      method: 'PUT',
+      headers: { 'Idempotency-Key': normalizedKey },
+    },
+    '收藏失败',
+  );
+}
+
+/**
+ * 「我的收藏」：只返回当前公开可读的收藏作品（下架/软删除的作品只是不出现，行不删除），
+ * 条目形状与公开目录逐字一致，因此可以复用同一套卡片组件渲染。
+ *
+ * `nextCursor` 服务端当前恒为 `null`（真分页是已知留白）；这里按「将来会有 cursor」的形态
+ * 读出来并原样交给调用方，调用方只在非空时渲染「加载更多」。
+ */
+export async function listMyCollections() {
+  const payload = await requestJson<{
+    games?: unknown;
+    nextCursor?: string | null;
+  }>(
+    '/my-collections',
+    { method: 'GET', cache: 'no-store' },
+    '读取我的收藏失败',
+  );
+  return {
+    games: normalizeGameList(payload.games),
+    nextCursor: payload.nextCursor ?? null,
+  };
+}
+
+/**
+ * 读取以某作品的根为顶的创作族谱树。公开只读接口，匿名可读；
+ * 作品不存在或已软删除时服务端返回 404，这里按失败抛出，由页面走既有错误态。
+ *
+ * 节点形状直接复用契约类型：`coverObjectKey` 已在 `GameDistributionLineageNode` 里
+ * （可选字段，无封面时为 null），因此这里不再需要本地宽化。
+ */
+export async function getGameLineage(gameId: string) {
+  const normalizedId = gameId.trim();
+  if (!normalizedId) return null;
+  return requestJson<GameDistributionLineageResponse>(
+    `/games/${encodeURIComponent(normalizedId)}/lineage`,
+    { method: 'GET', cache: 'no-store' },
+    '读取创作族谱失败',
+    PUBLIC_GAME_REQUEST_OPTIONS,
+  );
+}
+
+/**
+ * 读取某作品的直接衍生作品（「被改编」列表）。只含对外可见的直接子代，
+ * 与公开详情里 `forkCount` 的口径一致。
+ */
+export async function getDerivedGames(gameId: string) {
+  const normalizedId = gameId.trim();
+  if (!normalizedId) return null;
+  return requestJson<GameDistributionDerivedResponse>(
+    `/games/${encodeURIComponent(normalizedId)}/derived`,
+    { method: 'GET', cache: 'no-store' },
+    '读取衍生作品失败',
+    PUBLIC_GAME_REQUEST_OPTIONS,
+  );
+}
+
 /**
  * 上报一次「开始游戏」。调用方按 fire-and-forget 处理：失败只静默忽略，绝不阻断进入游戏。
  */