GenarrativeAI/Genarrative
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

统一推荐页游客运行态与切换队列

Browse Source 
统一推荐页各玩法正式 runtime 的游客鉴权透传。

收口推荐页首页展示队列和嵌入运行态切换队列。

补齐未登录读档、签名资产和个人数据读取的游客态处理。

新增运行态 HUD 小尺寸 logo 资源并更新拼图与抓鹅展示。

补充推荐切换、runtime guest 启动和客户端请求回归测试。

更新玩法链路、后端契约和团队记忆文档。
This commit is contained in:
kdletters
2026-06-10 22:00:19 +08:00
parent e29992cf01
commit 7dd53e95d8
41 changed files with 1372 additions and 376 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/services/big-fish-runtime/bigFishRuntimeClient.ts
View File

@@ -58,10 +58,14 @@ export function startBigFishRun(
});
}
export function getBigFishRun(runId: string) {
export function getBigFishRun(
runId: string,
options: BigFishRuntimeRequestOptions = {},
) {
return requestRuntimeJson<BigFishRunResponse>({
url: buildRuntimeApiPath(BIG_FISH_RUNTIME_API_BASE, 'runs', runId),
fallbackMessage: '读取大鱼吃小鱼玩法失败',
requestOptions: options,
});
}

10
src/services/jump-hop/jumpHopClient.test.ts
View File

@@ -139,4 +139,14 @@ test('jump hop work detail preserves flattened back button asset', async () => {
const response = await jumpHopClient.getWorkDetail('profile-1');
expect(response.item.backButtonAsset).toEqual(backButtonAsset);
expect(requestJsonMock).toHaveBeenCalledWith(
'/api/runtime/jump-hop/works/profile-1',
{ method: 'GET' },
'读取跳一跳作品详情失败',
expect.objectContaining({
retry: expect.objectContaining({ maxRetries: 1 }),
skipAuth: true,
skipRefresh: true,
}),
);
});

10
src/services/jump-hop/jumpHopClient.ts
View File

@@ -19,6 +19,7 @@ import type {
JumpHopWorkSummaryResponse,
} from '../../../packages/shared/src/contracts/jumpHop';
import {
type ApiRequestOptions,
type ApiRetryOptions,
requestJson,
} from '../apiClient';
@@ -196,10 +197,19 @@ export async function getJumpHopWorkDetail(
options.audience === 'creation'
? JUMP_HOP_WORKS_API_BASE
: `${JUMP_HOP_RUNTIME_API_BASE}/works`;
const requestOptions: ApiRequestOptions =
options.audience === 'creation'
? {}
: {
retry: JUMP_HOP_RUNTIME_READ_RETRY,
skipAuth: true,
skipRefresh: true,
};
const response = await requestJson<JumpHopWorkDetailResponse>(
`${base}/${encodeURIComponent(profileId)}`,
{ method: 'GET' },
'读取跳一跳作品详情失败',
requestOptions,
);
return normalizeJumpHopWorkDetailResponse(response);
}

61
src/services/match3d-runtime/match3dRuntimeAdapter.test.ts
View File

@@ -64,30 +64,63 @@ test('server Match3D runtime adapter forwards the full runtime seam lazily', asy
stopRun: vi.fn().mockResolvedValue(stopResponse),
};
const adapter = createServerMatch3DRuntimeAdapter(dependencies);
const runtimeRequestOptions = {
runtimeGuestToken: 'runtime-guest-token',
skipRefresh: true,
};
expect(await adapter.startRun('server-profile-1', { skipRefresh: true })).toBe(
startResponse,
expect(
await adapter.startRun('server-profile-1', runtimeRequestOptions),
).toBe(startResponse);
expect(await adapter.getRun('server-run-start', runtimeRequestOptions)).toBe(
getResponse,
);
expect(await adapter.getRun('server-run-start')).toBe(getResponse);
expect(await adapter.clickItem('server-run-start', clickPayload)).toEqual({
expect(
await adapter.clickItem(
'server-run-start',
clickPayload,
runtimeRequestOptions,
),
).toEqual({
status: 'Accepted',
run: buildMockRun('server-run-click'),
});
expect(await adapter.restartRun('server-run-start')).toBe(restartResponse);
expect(await adapter.stopRun('server-run-restart')).toBe(stopResponse);
expect(await adapter.finishTimeUp('server-run-start')).toBe(finishResponse);
expect(
await adapter.restartRun('server-run-start', runtimeRequestOptions),
).toBe(restartResponse);
expect(await adapter.stopRun('server-run-restart', runtimeRequestOptions)).toBe(
stopResponse,
);
expect(
await adapter.finishTimeUp('server-run-start', runtimeRequestOptions),
).toBe(finishResponse);
expect(dependencies.startRun).toHaveBeenCalledWith('server-profile-1', {
skipRefresh: true,
});
expect(dependencies.getRun).toHaveBeenCalledWith('server-run-start');
expect(dependencies.startRun).toHaveBeenCalledWith(
'server-profile-1',
runtimeRequestOptions,
);
expect(dependencies.getRun).toHaveBeenCalledWith(
'server-run-start',
runtimeRequestOptions,
);
expect(dependencies.clickItem).toHaveBeenCalledWith(
'server-run-start',
clickPayload,
runtimeRequestOptions,
);
expect(dependencies.restartRun).toHaveBeenCalledWith(
'server-run-start',
runtimeRequestOptions,
);
expect(dependencies.stopRun).toHaveBeenCalledWith(
'server-run-restart',
undefined,
runtimeRequestOptions,
);
expect(dependencies.finishTimeUp).toHaveBeenCalledWith(
'server-run-start',
runtimeRequestOptions,
);
expect(dependencies.restartRun).toHaveBeenCalledWith('server-run-start');
expect(dependencies.stopRun).toHaveBeenCalledWith('server-run-restart');
expect(dependencies.finishTimeUp).toHaveBeenCalledWith('server-run-start');
});
test('local Match3D runtime adapter exposes the same runtime seam as the server client', async () => {

32
src/services/match3d-runtime/match3dRuntimeAdapter.ts
View File

@@ -24,14 +24,27 @@ export type Match3DRuntimeAdapter = {
profileId: string,
options?: Match3DRuntimeRequestOptions,
) => Promise<Match3DRunResponse>;
getRun: (runId: string) => Promise<Match3DRunResponse>;
getRun: (
runId: string,
options?: Match3DRuntimeRequestOptions,
) => Promise<Match3DRunResponse>;
clickItem: (
runId: string,
payload: Match3DClickItemRequest,
options?: Match3DRuntimeRequestOptions,
) => Promise<Match3DClickItemResult>;
restartRun: (runId: string) => Promise<Match3DRunResponse>;
stopRun: (runId: string) => Promise<Match3DRunResponse>;
finishTimeUp: (runId: string) => Promise<Match3DRunResponse>;
restartRun: (
runId: string,
options?: Match3DRuntimeRequestOptions,
) => Promise<Match3DRunResponse>;
stopRun: (
runId: string,
options?: Match3DRuntimeRequestOptions,
) => Promise<Match3DRunResponse>;
finishTimeUp: (
runId: string,
options?: Match3DRuntimeRequestOptions,
) => Promise<Match3DRunResponse>;
};
export type LocalMatch3DRuntimeAdapterOptions = {
@@ -63,12 +76,13 @@ export function createServerMatch3DRuntimeAdapter(
defaultServerMatch3DRuntimeAdapterDependencies,
): Match3DRuntimeAdapter {
return {
clickItem: (runId, payload) => dependencies.clickItem(runId, payload),
finishTimeUp: (runId) => dependencies.finishTimeUp(runId),
getRun: (runId) => dependencies.getRun(runId),
restartRun: (runId) => dependencies.restartRun(runId),
clickItem: (runId, payload, options) =>
dependencies.clickItem(runId, payload, options),
finishTimeUp: (runId, options) => dependencies.finishTimeUp(runId, options),
getRun: (runId, options) => dependencies.getRun(runId, options),
restartRun: (runId, options) => dependencies.restartRun(runId, options),
startRun: (profileId, options) => dependencies.startRun(profileId, options),
stopRun: (runId) => dependencies.stopRun(runId),
stopRun: (runId, options) => dependencies.stopRun(runId, undefined, options),
};
}

22
src/services/match3d-runtime/match3dRuntimeClient.ts
View File

@@ -89,11 +89,15 @@ export function startMatch3DRun(
/**
* 读取抓大鹅运行态快照。
*/
export function getMatch3DRun(runId: string) {
export function getMatch3DRun(
runId: string,
options: Match3DRuntimeRequestOptions = {},
) {
return requestRuntimeJson<Match3DRunResponse>({
url: buildRuntimeApiPath(MATCH3D_RUNTIME_API_BASE, 'runs', runId),
fallbackMessage: '读取抓大鹅运行快照失败',
retry: MATCH3D_RUNTIME_READ_RETRY,
requestOptions: options,
});
}
@@ -103,6 +107,7 @@ export function getMatch3DRun(runId: string) {
export async function clickMatch3DItem(
runId: string,
payload: Match3DClickItemRequest,
options: Match3DRuntimeRequestOptions = {},
) {
const response = await requestRuntimeJson<Match3DClickResponse>({
url: buildRuntimeApiPath(MATCH3D_RUNTIME_API_BASE, 'runs', runId, 'click'),
@@ -113,6 +118,7 @@ export async function clickMatch3DItem(
},
fallbackMessage: '确认抓大鹅点击失败',
retry: MATCH3D_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
return mapClickConfirmation(payload, response.confirmation);
@@ -126,6 +132,7 @@ export function stopMatch3DRun(
payload: StopMatch3DRunRequest = {
clientActionId: `match3d-stop-${Date.now()}`,
},
options: Match3DRuntimeRequestOptions = {},
) {
return requestRuntimeJson<Match3DRunResponse>({
url: buildRuntimeApiPath(MATCH3D_RUNTIME_API_BASE, 'runs', runId, 'stop'),
@@ -133,30 +140,39 @@ export function stopMatch3DRun(
jsonBody: payload,
fallbackMessage: '停止抓大鹅玩法失败',
retry: MATCH3D_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
/**
* 基于当前 run 重开一局。
*/
export function restartMatch3DRun(runId: string) {
export function restartMatch3DRun(
runId: string,
options: Match3DRuntimeRequestOptions = {},
) {
return requestRuntimeJson<Match3DRunResponse>({
url: buildRuntimeApiPath(MATCH3D_RUNTIME_API_BASE, 'runs', runId, 'restart'),
method: 'POST',
fallbackMessage: '重新开始抓大鹅玩法失败',
retry: MATCH3D_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
/**
* 前端倒计时归零后通知后端确认失败状态。
*/
export function finishMatch3DTimeUp(runId: string) {
export function finishMatch3DTimeUp(
runId: string,
options: Match3DRuntimeRequestOptions = {},
) {
return requestRuntimeJson<Match3DRunResponse>({
url: buildRuntimeApiPath(MATCH3D_RUNTIME_API_BASE, 'runs', runId, 'time-up'),
method: 'POST',
fallbackMessage: '同步抓大鹅倒计时失败',
retry: MATCH3D_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}

10
src/services/puzzle-runtime/puzzleRuntimeClient.test.ts
View File

@@ -61,7 +61,7 @@ describe('puzzleRuntimeClient', () => {
);
});
it('keeps pause requests on account auth options instead of guest auth', async () => {
it('uses runtime guest auth for pause requests when provided', async () => {
await updatePuzzleRunPause(
'run/1',
{ paused: true },
@@ -76,17 +76,19 @@ describe('puzzleRuntimeClient', () => {
expect(init).toEqual(
expect.objectContaining({
method: 'POST',
headers: { 'Content-Type': 'application/json' },
headers: {
'Content-Type': 'application/json',
Authorization: 'Bearer runtime-guest-token',
},
body: JSON.stringify({ paused: true }),
}),
);
expect(init.headers).not.toHaveProperty('Authorization');
expect(options).toEqual(
expect.objectContaining({
authImpact: 'local',
skipAuth: true,
skipRefresh: true,
}),
);
expect(options).not.toMatchObject({ skipAuth: true });
});
});

63
src/services/puzzle-runtime/puzzleRuntimeClient.ts
View File

@@ -8,10 +8,7 @@ import type {
UpdatePuzzleRuntimePauseRequest,
UsePuzzleRuntimePropRequest,
} from '../../../packages/shared/src/contracts/puzzleRuntimeSession';
import {
type ApiRetryOptions,
requestJson,
} from '../apiClient';
import { type ApiRetryOptions } from '../apiClient';
import { type RuntimeGuestRequestOptions } from '../runtimeGuestAuth';
import { buildRuntimeApiPath, requestRuntimeJson } from '../runtimeRequest';
@@ -52,11 +49,15 @@ export async function startPuzzleRun(
/**
* 读取拼图运行态快照。
*/
export async function getPuzzleRun(runId: string) {
export async function getPuzzleRun(
runId: string,
options: PuzzleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<PuzzleRunResponse>({
url: buildRuntimeApiPath(PUZZLE_RUNTIME_API_BASE, runId),
fallbackMessage: '读取拼图运行快照失败',
retry: PUZZLE_RUNTIME_READ_RETRY,
requestOptions: options,
});
}
@@ -66,6 +67,7 @@ export async function getPuzzleRun(runId: string) {
export async function swapPuzzlePieces(
runId: string,
payload: SwapPuzzlePiecesRequest,
options: PuzzleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<PuzzleRunResponse>({
url: buildRuntimeApiPath(PUZZLE_RUNTIME_API_BASE, runId, 'swap'),
@@ -73,6 +75,7 @@ export async function swapPuzzlePieces(
jsonBody: payload,
fallbackMessage: '交换拼图块失败',
retry: PUZZLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
@@ -82,6 +85,7 @@ export async function swapPuzzlePieces(
export async function dragPuzzlePieceOrGroup(
runId: string,
payload: DragPuzzlePieceRequest,
options: PuzzleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<PuzzleRunResponse>({
url: buildRuntimeApiPath(PUZZLE_RUNTIME_API_BASE, runId, 'drag'),
@@ -89,6 +93,7 @@ export async function dragPuzzlePieceOrGroup(
jsonBody: payload,
fallbackMessage: '拖动拼图块失败',
retry: PUZZLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
@@ -141,22 +146,14 @@ export async function updatePuzzleRunPause(
payload: UpdatePuzzleRuntimePauseRequest,
options: PuzzleRuntimeRequestOptions = {},
) {
return requestJson<PuzzleRunResponse>(
buildRuntimeApiPath(PUZZLE_RUNTIME_API_BASE, runId, 'pause'),
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
},
'更新拼图计时状态失败',
{
retry: PUZZLE_RUNTIME_WRITE_RETRY,
authImpact: options.authImpact,
skipRefresh: options.skipRefresh,
notifyAuthStateChange: options.notifyAuthStateChange,
clearAuthOnUnauthorized: options.clearAuthOnUnauthorized,
},
);
return requestRuntimeJson<PuzzleRunResponse>({
url: buildRuntimeApiPath(PUZZLE_RUNTIME_API_BASE, runId, 'pause'),
method: 'POST',
jsonBody: payload,
fallbackMessage: '更新拼图计时状态失败',
retry: PUZZLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
/**
@@ -167,22 +164,14 @@ export async function usePuzzleRuntimeProp(
payload: UsePuzzleRuntimePropRequest,
options: PuzzleRuntimeRequestOptions = {},
) {
return requestJson<PuzzleRunResponse>(
buildRuntimeApiPath(PUZZLE_RUNTIME_API_BASE, runId, 'props'),
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
},
'使用拼图道具失败',
{
retry: PUZZLE_RUNTIME_WRITE_RETRY,
authImpact: options.authImpact,
skipRefresh: options.skipRefresh,
notifyAuthStateChange: options.notifyAuthStateChange,
clearAuthOnUnauthorized: options.clearAuthOnUnauthorized,
},
);
return requestRuntimeJson<PuzzleRunResponse>({
url: buildRuntimeApiPath(PUZZLE_RUNTIME_API_BASE, runId, 'props'),
method: 'POST',
jsonBody: payload,
fallbackMessage: '使用拼图道具失败',
retry: PUZZLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
export const puzzleRuntimeClient = {

469
src/services/recommendedRuntimeGuestLaunch.test.ts
View File

@@ -13,17 +13,56 @@ vi.mock('./apiClient', async () => {
};
});
import { startBarkBattleRun } from './bark-battle-runtime/barkBattleRuntimeClient';
import { startBigFishRun } from './big-fish-runtime/bigFishRuntimeClient';
import {
finishBarkBattleRun,
getBarkBattleRuntimeConfig,
startBarkBattleRun,
} from './bark-battle-runtime/barkBattleRuntimeClient';
import {
getBigFishRun,
recordBigFishPlay,
startBigFishRun,
submitBigFishInput,
} from './big-fish-runtime/bigFishRuntimeClient';
import { startJumpHopRuntimeRun } from './jump-hop/jumpHopClient';
import { startMatch3DRun } from './match3d-runtime/match3dRuntimeClient';
import {
clickMatch3DItem,
finishMatch3DTimeUp,
getMatch3DRun,
restartMatch3DRun,
startMatch3DRun,
stopMatch3DRun,
} from './match3d-runtime/match3dRuntimeClient';
import {
advancePuzzleNextLevel,
dragPuzzlePieceOrGroup,
getPuzzleRun,
startPuzzleRun,
submitPuzzleLeaderboard,
swapPuzzlePieces,
updatePuzzleRunPause,
usePuzzleRuntimeProp,
} from './puzzle-runtime/puzzleRuntimeClient';
import { startSquareHoleRun } from './square-hole-runtime/squareHoleRuntimeClient';
import { startVisualNovelRun } from './visual-novel-runtime/visualNovelRuntimeClient';
import { puzzleClearClient } from './puzzle-clear/puzzleClearClient';
import {
dropSquareHoleShape,
finishSquareHoleTimeUp,
getSquareHoleRun,
restartSquareHoleRun,
startSquareHoleRun,
stopSquareHoleRun,
} from './square-hole-runtime/squareHoleRuntimeClient';
import {
checkpointWoodenFishRun,
finishWoodenFishRun,
startWoodenFishRuntimeRun,
} from './wooden-fish/woodenFishClient';
import {
getVisualNovelHistory,
getVisualNovelRun,
regenerateVisualNovelRun,
startVisualNovelRun,
} from './visual-novel-runtime/visualNovelRuntimeClient';
describe('recommended runtime guest launch clients', () => {
beforeEach(() => {
@@ -31,6 +70,25 @@ describe('recommended runtime guest launch clients', () => {
apiClientMocks.requestJson.mockResolvedValue({ run: {} });
});
function expectRuntimeGuestRequest(expectedUrl: string, expectedMethod: string) {
const [url, init, , options] = apiClientMocks.requestJson.mock.calls[0];
expect(url).toBe(expectedUrl);
expect(init).toEqual(
expect.objectContaining({
method: expectedMethod,
headers: expect.objectContaining({
Authorization: 'Bearer runtime-guest-token',
}),
}),
);
expect(options).toEqual(
expect.objectContaining({
skipAuth: true,
skipRefresh: true,
}),
);
}
it.each([
{
name: 'jump-hop',
@@ -82,6 +140,14 @@ describe('recommended runtime guest launch clients', () => {
}),
expectedUrl: '/api/runtime/bark-battle/works/bark-battle-work-1/runs',
},
{
name: 'wooden-fish',
start: () =>
startWoodenFishRuntimeRun('wooden-fish-profile-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/wooden-fish/runs',
},
{
name: 'puzzle',
start: () =>
@@ -187,4 +253,397 @@ describe('recommended runtime guest launch clients', () => {
}),
);
});
it.each([
{
name: 'puzzle get run',
run: () =>
getPuzzleRun('run-puzzle-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/puzzle/runs/run-puzzle-1',
expectedMethod: 'GET',
},
{
name: 'puzzle swap',
run: () =>
swapPuzzlePieces(
'run-puzzle-1',
{ firstPieceId: 'piece-a', secondPieceId: 'piece-b' },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/puzzle/runs/run-puzzle-1/swap',
expectedMethod: 'POST',
},
{
name: 'puzzle drag',
run: () =>
dragPuzzlePieceOrGroup(
'run-puzzle-1',
{ pieceId: 'piece-a', targetRow: 1, targetCol: 2 },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/puzzle/runs/run-puzzle-1/drag',
expectedMethod: 'POST',
},
{
name: 'puzzle pause',
run: () =>
updatePuzzleRunPause(
'run-puzzle-1',
{ paused: true },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/puzzle/runs/run-puzzle-1/pause',
expectedMethod: 'POST',
},
{
name: 'puzzle prop',
run: () =>
usePuzzleRuntimeProp(
'run-puzzle-1',
{ propKind: 'extendTime' },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/puzzle/runs/run-puzzle-1/props',
expectedMethod: 'POST',
},
{
name: 'puzzle-clear get run',
run: () =>
puzzleClearClient.getRun('puzzle-clear-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/puzzle-clear/runs/puzzle-clear-run-1',
expectedMethod: 'GET',
},
{
name: 'puzzle-clear swap',
run: () =>
puzzleClearClient.swapCards(
'puzzle-clear-run-1',
{ fromRow: 0, fromCol: 0, toRow: 0, toCol: 1 },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/puzzle-clear/runs/puzzle-clear-run-1/swap',
expectedMethod: 'POST',
},
{
name: 'puzzle-clear retry',
run: () =>
puzzleClearClient.retryLevel('puzzle-clear-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl:
'/api/runtime/puzzle-clear/runs/puzzle-clear-run-1/retry-level',
expectedMethod: 'POST',
},
{
name: 'puzzle-clear next',
run: () =>
puzzleClearClient.advanceNextLevel('puzzle-clear-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl:
'/api/runtime/puzzle-clear/runs/puzzle-clear-run-1/next-level',
expectedMethod: 'POST',
},
{
name: 'puzzle-clear time up',
run: () =>
puzzleClearClient.markTimeUp('puzzle-clear-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/puzzle-clear/runs/puzzle-clear-run-1/time-up',
expectedMethod: 'POST',
},
{
name: 'square-hole get run',
run: () =>
getSquareHoleRun('square-hole-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/square-hole/runs/square-hole-run-1',
expectedMethod: 'GET',
},
{
name: 'square-hole drop',
run: () =>
dropSquareHoleShape(
'square-hole-run-1',
{
holeId: 'hole-1',
clientSnapshotVersion: 1,
clientEventId: 'event-1',
droppedAtMs: 1_700_000_000_000,
},
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/square-hole/runs/square-hole-run-1/drop',
expectedMethod: 'POST',
},
{
name: 'square-hole stop',
run: () =>
stopSquareHoleRun(
'square-hole-run-1',
{ clientActionId: 'stop-1' },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/square-hole/runs/square-hole-run-1/stop',
expectedMethod: 'POST',
},
{
name: 'square-hole restart',
run: () =>
restartSquareHoleRun('square-hole-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/square-hole/runs/square-hole-run-1/restart',
expectedMethod: 'POST',
},
{
name: 'square-hole time up',
run: () =>
finishSquareHoleTimeUp('square-hole-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/square-hole/runs/square-hole-run-1/time-up',
expectedMethod: 'POST',
},
{
name: 'big-fish get run',
run: () =>
getBigFishRun('big-fish-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/big-fish/runs/big-fish-run-1',
expectedMethod: 'GET',
},
{
name: 'big-fish input',
run: () =>
submitBigFishInput(
'big-fish-run-1',
{ x: 0.25, y: 0.75 },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/big-fish/runs/big-fish-run-1/input',
expectedMethod: 'POST',
},
{
name: 'big-fish play report',
run: () =>
recordBigFishPlay(
'big-fish-session-1',
{ elapsedMs: 1_000 },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl:
'/api/runtime/big-fish/sessions/big-fish-session-1/play',
expectedMethod: 'POST',
},
{
name: 'bark-battle config',
run: () =>
getBarkBattleRuntimeConfig('bark-battle-work-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl:
'/api/runtime/bark-battle/works/bark-battle-work-1/config',
expectedMethod: 'GET',
},
{
name: 'bark-battle finish',
run: () =>
finishBarkBattleRun(
'bark-battle-run-1',
{
runId: 'bark-battle-run-1',
runToken: 'run-token',
workId: 'bark-battle-work-1',
configVersion: 1,
rulesetVersion: 'v1',
difficultyPreset: 'normal',
clientStartedAt: '2026-06-10T00:00:00Z',
clientFinishedAt: '2026-06-10T00:00:10Z',
durationMs: 10_000,
derivedMetrics: {
triggerCount: 1,
maxVolume: 0.8,
averageVolume: 0.4,
finalEnergy: 10,
comboMax: 1,
},
},
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/bark-battle/runs/bark-battle-run-1/finish',
expectedMethod: 'POST',
},
{
name: 'wooden-fish checkpoint',
run: () =>
checkpointWoodenFishRun(
'wooden-fish-run-1',
{ totalTapCount: 8, wordCounters: [] },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl:
'/api/runtime/wooden-fish/runs/wooden-fish-run-1/checkpoint',
expectedMethod: 'POST',
},
{
name: 'wooden-fish finish',
run: () =>
finishWoodenFishRun(
'wooden-fish-run-1',
{ totalTapCount: 8, wordCounters: [] },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/wooden-fish/runs/wooden-fish-run-1/finish',
expectedMethod: 'POST',
},
{
name: 'visual-novel get run',
run: () =>
getVisualNovelRun('visual-novel-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/visual-novel/runs/visual-novel-run-1',
expectedMethod: 'GET',
},
{
name: 'visual-novel history',
run: () =>
getVisualNovelHistory('visual-novel-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl:
'/api/runtime/visual-novel/runs/visual-novel-run-1/history',
expectedMethod: 'GET',
},
{
name: 'visual-novel regenerate',
run: () =>
regenerateVisualNovelRun(
'visual-novel-run-1',
{ historyEntryId: 'history-1', clientEventId: 'event-1' },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl:
'/api/runtime/visual-novel/runs/visual-novel-run-1/regenerate',
expectedMethod: 'POST',
},
])(
'$name uses the shared runtime guest bearer token without touching login auth',
async ({ run, expectedUrl, expectedMethod }) => {
await run();
expectRuntimeGuestRequest(expectedUrl, expectedMethod);
},
);
it.each([
{
name: 'get run',
run: () =>
getMatch3DRun('match3d-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/match3d/runs/match3d-run-1',
expectedMethod: 'GET',
},
{
name: 'restart',
run: () =>
restartMatch3DRun('match3d-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/match3d/runs/match3d-run-1/restart',
expectedMethod: 'POST',
},
{
name: 'stop',
run: () =>
stopMatch3DRun(
'match3d-run-1',
{ clientActionId: 'stop-1' },
{ runtimeGuestToken: 'runtime-guest-token' },
),
expectedUrl: '/api/runtime/match3d/runs/match3d-run-1/stop',
expectedMethod: 'POST',
},
{
name: 'time up',
run: () =>
finishMatch3DTimeUp('match3d-run-1', {
runtimeGuestToken: 'runtime-guest-token',
}),
expectedUrl: '/api/runtime/match3d/runs/match3d-run-1/time-up',
expectedMethod: 'POST',
},
])(
'match3d $name uses the runtime guest bearer token without touching login auth',
async ({ run, expectedUrl, expectedMethod }) => {
await run();
const [url, init, , options] = apiClientMocks.requestJson.mock.calls[0];
expect(url).toBe(expectedUrl);
expect(init).toEqual(
expect.objectContaining({
method: expectedMethod,
headers: expect.objectContaining({
Authorization: 'Bearer runtime-guest-token',
}),
}),
);
expect(options).toEqual(
expect.objectContaining({
skipAuth: true,
skipRefresh: true,
}),
);
},
);
it('match3d click uses the runtime guest bearer token without touching login auth', async () => {
apiClientMocks.requestJson.mockResolvedValueOnce({
confirmation: {
accepted: true,
run: {},
clearedItemInstanceIds: [],
},
});
await clickMatch3DItem(
'match3d-run-1',
{
runId: 'match3d-run-1',
itemInstanceId: 'item-1',
clientActionId: 'action-1',
clientEventId: 'event-1',
clickedAtMs: 1_700_000_000_000,
clientSnapshotVersion: 1,
},
{ runtimeGuestToken: 'runtime-guest-token' },
);
const [url, init, , options] = apiClientMocks.requestJson.mock.calls[0];
expect(url).toBe('/api/runtime/match3d/runs/match3d-run-1/click');
expect(init).toEqual(
expect.objectContaining({
method: 'POST',
headers: expect.objectContaining({
Authorization: 'Bearer runtime-guest-token',
}),
}),
);
expect(options).toEqual(
expect.objectContaining({
skipAuth: true,
skipRefresh: true,
}),
);
});
});

22
src/services/square-hole-runtime/squareHoleRuntimeClient.ts
View File

@@ -49,11 +49,15 @@ export function startSquareHoleRun(
/**
* 读取方洞挑战运行态快照。
*/
export function getSquareHoleRun(runId: string) {
export function getSquareHoleRun(
runId: string,
options: SquareHoleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<SquareHoleRunResponse>({
url: buildRuntimeApiPath(SQUARE_HOLE_RUNTIME_API_BASE, 'runs', runId),
fallbackMessage: '读取方洞挑战运行快照失败',
retry: SQUARE_HOLE_RUNTIME_READ_RETRY,
requestOptions: options,
});
}
@@ -63,6 +67,7 @@ export function getSquareHoleRun(runId: string) {
export function dropSquareHoleShape(
runId: string,
payload: DropSquareHoleShapeRequest,
options: SquareHoleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<SquareHoleDropResponse>({
url: buildRuntimeApiPath(
@@ -78,6 +83,7 @@ export function dropSquareHoleShape(
},
fallbackMessage: '确认方洞挑战投入失败',
retry: SQUARE_HOLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
@@ -89,6 +95,7 @@ export function stopSquareHoleRun(
payload: StopSquareHoleRunRequest = {
clientActionId: `square-hole-stop-${Date.now()}`,
},
options: SquareHoleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<SquareHoleRunResponse>({
url: buildRuntimeApiPath(SQUARE_HOLE_RUNTIME_API_BASE, 'runs', runId, 'stop'),
@@ -96,13 +103,17 @@ export function stopSquareHoleRun(
jsonBody: payload,
fallbackMessage: '停止方洞挑战失败',
retry: SQUARE_HOLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
/**
* 基于当前 run 重开一局。
*/
export function restartSquareHoleRun(runId: string) {
export function restartSquareHoleRun(
runId: string,
options: SquareHoleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<SquareHoleRunResponse>({
url: buildRuntimeApiPath(
SQUARE_HOLE_RUNTIME_API_BASE,
@@ -113,13 +124,17 @@ export function restartSquareHoleRun(runId: string) {
method: 'POST',
fallbackMessage: '重新开始方洞挑战失败',
retry: SQUARE_HOLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}
/**
* 前端倒计时归零后通知后端确认失败状态。
*/
export function finishSquareHoleTimeUp(runId: string) {
export function finishSquareHoleTimeUp(
runId: string,
options: SquareHoleRuntimeRequestOptions = {},
) {
return requestRuntimeJson<SquareHoleRunResponse>({
url: buildRuntimeApiPath(
SQUARE_HOLE_RUNTIME_API_BASE,
@@ -130,6 +145,7 @@ export function finishSquareHoleTimeUp(runId: string) {
method: 'POST',
fallbackMessage: '同步方洞挑战倒计时失败',
retry: SQUARE_HOLE_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}

14
src/services/visual-novel-runtime/visualNovelRuntimeClient.ts
View File

@@ -135,15 +135,22 @@ export async function startVisualNovelRun(
);
}
export async function getVisualNovelRun(runId: string) {
export async function getVisualNovelRun(
runId: string,
options: VisualNovelRuntimeRequestOptions = {},
) {
return requestRuntimeJson<VisualNovelRunResponse>({
url: buildRuntimeApiPath(VISUAL_NOVEL_RUNTIME_API_BASE, 'runs', runId),
fallbackMessage: '读取视觉小说运行快照失败',
retry: VISUAL_NOVEL_RUNTIME_READ_RETRY,
requestOptions: options,
});
}
export async function getVisualNovelHistory(runId: string) {
export async function getVisualNovelHistory(
runId: string,
options: VisualNovelRuntimeRequestOptions = {},
) {
return requestRuntimeJson<VisualNovelHistoryResponse>({
url: buildRuntimeApiPath(
VISUAL_NOVEL_RUNTIME_API_BASE,
@@ -153,6 +160,7 @@ export async function getVisualNovelHistory(runId: string) {
),
fallbackMessage: '读取视觉小说历史失败',
retry: VISUAL_NOVEL_RUNTIME_READ_RETRY,
requestOptions: options,
});
}
@@ -185,6 +193,7 @@ export async function streamVisualNovelRuntimeAction(
export async function regenerateVisualNovelRun(
runId: string,
payload: VisualNovelRegenerateRequest,
options: VisualNovelRuntimeRequestOptions = {},
) {
return requestRuntimeJson<VisualNovelRunResponse>({
url: buildRuntimeApiPath(
@@ -197,6 +206,7 @@ export async function regenerateVisualNovelRun(
jsonBody: payload,
fallbackMessage: '重生成视觉小说历史失败',
retry: VISUAL_NOVEL_RUNTIME_WRITE_RETRY,
requestOptions: options,
});
}

24
src/services/wooden-fish/woodenFishClient.test.ts
View File

@@ -55,6 +55,30 @@ test('wooden fish list works uses creation works endpoint', async () => {
);
});
test('wooden fish runtime work detail reads public profile without auth refresh coupling', async () => {
const { woodenFishClient } = await import('./woodenFishClient');
requestJsonMock.mockResolvedValueOnce({
item: {
summary: {
profileId: 'profile-1',
},
},
});
await woodenFishClient.getWorkDetail('profile-1');
expect(requestJsonMock).toHaveBeenCalledWith(
'/api/runtime/wooden-fish/works/profile-1',
{ method: 'GET' },
'读取敲木鱼作品详情失败',
expect.objectContaining({
retry: expect.objectContaining({ maxRetries: 1 }),
skipAuth: true,
skipRefresh: true,
}),
);
});
test('wooden fish start run uses runtime guest json skeleton', async () => {
const { woodenFishClient } = await import('./woodenFishClient');
requestJsonMock.mockResolvedValueOnce({ run: { runId: 'run-1' } });

16
src/services/wooden-fish/woodenFishClient.ts
View File

@@ -17,7 +17,11 @@ import type {
WoodenFishWorksResponse,
WoodenFishWorkSummaryResponse,
} from '../../../packages/shared/src/contracts/woodenFish';
import { type ApiRetryOptions, requestJson } from '../apiClient';
import {
type ApiRequestOptions,
type ApiRetryOptions,
requestJson,
} from '../apiClient';
import { createCreationAgentClient } from '../creation-agent';
import { type RuntimeGuestRequestOptions } from '../runtimeGuestAuth';
import { buildRuntimeApiPath, requestRuntimeJson } from '../runtimeRequest';
@@ -176,11 +180,19 @@ export function executeWoodenFishCreationAction(
.then(normalizeWoodenFishActionResponse);
}
export async function getWoodenFishWorkDetail(profileId: string) {
export async function getWoodenFishWorkDetail(
profileId: string,
options: ApiRequestOptions = {
retry: WOODEN_FISH_RUNTIME_READ_RETRY,
skipAuth: true,
skipRefresh: true,
},
) {
const response = await requestJson<WoodenFishWorkDetailResponse>(
`${WOODEN_FISH_RUNTIME_API_BASE}/works/${encodeURIComponent(profileId)}`,
{ method: 'GET' },
'读取敲木鱼作品详情失败',
options,
);
return normalizeWoodenFishWorkDetailResponse(response);
}