抓大鹅B4+B5进行中

server-rs/crates/spacetime-client/src/mapper.rs

@@ -1388,6 +1388,130 @@ pub(crate) fn map_big_fish_works_procedure_result(
         .collect())
 }
 
+pub(crate) fn map_match3d_agent_session_procedure_result(
+    result: Match3DAgentSessionProcedureResult,
+) -> Result<Match3DAgentSessionRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::Procedure(
+            result
+                .error_message
+                .unwrap_or_else(|| "SpacetimeDB procedure 返回未知错误".to_string()),
+        ));
+    }
+
+    let session_json = result.session_json.ok_or_else(|| {
+        SpacetimeClientError::Procedure(
+            "SpacetimeDB procedure 未返回 match3d agent session 快照".to_string(),
+        )
+    })?;
+    let session = serde_json::from_str::<Match3DAgentSessionJsonRecord>(&session_json)
+        .map_err(|error| {
+            SpacetimeClientError::Runtime(format!("match3d session_json 非法: {error}"))
+        })?;
+
+    Ok(map_match3d_agent_session_snapshot(session))
+}
+
+pub(crate) fn map_match3d_work_procedure_result(
+    result: Match3DWorkProcedureResult,
+) -> Result<Match3DWorkProfileRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::Procedure(
+            result
+                .error_message
+                .unwrap_or_else(|| "SpacetimeDB procedure 返回未知错误".to_string()),
+        ));
+    }
+
+    let work_json = result.work_json.ok_or_else(|| {
+        SpacetimeClientError::Procedure("SpacetimeDB procedure 未返回 match3d work 快照".to_string())
+    })?;
+    let work = serde_json::from_str::<Match3DWorkJsonRecord>(&work_json).map_err(|error| {
+        SpacetimeClientError::Runtime(format!("match3d work_json 非法: {error}"))
+    })?;
+
+    Ok(map_match3d_work_snapshot(work))
+}
+
+pub(crate) fn map_match3d_works_procedure_result(
+    result: Match3DWorksProcedureResult,
+) -> Result<Vec<Match3DWorkProfileRecord>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::Procedure(
+            result
+                .error_message
+                .unwrap_or_else(|| "SpacetimeDB procedure 返回未知错误".to_string()),
+        ));
+    }
+
+    let items_json = result.items_json.ok_or_else(|| {
+        SpacetimeClientError::Procedure(
+            "SpacetimeDB procedure 未返回 match3d works 快照".to_string(),
+        )
+    })?;
+    let items = serde_json::from_str::<Vec<Match3DWorkJsonRecord>>(&items_json)
+        .map_err(|error| {
+            SpacetimeClientError::Runtime(format!("match3d works items_json 非法: {error}"))
+        })?;
+
+    Ok(items.into_iter().map(map_match3d_work_snapshot).collect())
+}
+
+pub(crate) fn map_match3d_run_procedure_result(
+    result: Match3DRunProcedureResult,
+) -> Result<Match3DRunRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::Procedure(
+            result
+                .error_message
+                .unwrap_or_else(|| "SpacetimeDB procedure 返回未知错误".to_string()),
+        ));
+    }
+
+    let run_json = result.run_json.ok_or_else(|| {
+        SpacetimeClientError::Procedure("SpacetimeDB procedure 未返回 match3d run 快照".to_string())
+    })?;
+    map_match3d_run_json(run_json)
+}
+
+pub(crate) fn map_match3d_click_item_procedure_result(
+    result: Match3DClickItemProcedureResult,
+) -> Result<Match3DClickConfirmationRecord, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::Procedure(
+            result
+                .error_message
+                .unwrap_or_else(|| "SpacetimeDB procedure 返回未知错误".to_string()),
+        ));
+    }
+
+    let run_json = result.run_json.ok_or_else(|| {
+        SpacetimeClientError::Procedure(
+            "SpacetimeDB procedure 未返回 match3d click run 快照".to_string(),
+        )
+    })?;
+    let run = map_match3d_run_json(run_json)?;
+    let accepted = result.status == "Accepted";
+    let accepted_item_instance_id = result.accepted_item_instance_id.clone();
+    let entered_slot_index = accepted_item_instance_id.as_deref().and_then(|item_id| {
+        run.items
+            .iter()
+            .find(|item| item.item_instance_id == item_id)
+            .and_then(|item| item.tray_slot_index)
+    });
+
+    Ok(Match3DClickConfirmationRecord {
+        status: result.status.clone(),
+        accepted,
+        reject_reason: if accepted { None } else { Some(result.status) },
+        accepted_item_instance_id,
+        entered_slot_index,
+        cleared_item_instance_ids: result.cleared_item_instance_ids,
+        failure_reason: result.failure_reason,
+        run,
+    })
+}
+
 pub(crate) fn map_story_session_procedure_result(
     result: StorySessionProcedureResult,
 ) -> Result<StorySessionResultRecord, SpacetimeClientError> {
@@ -1917,7 +2041,7 @@ pub(crate) fn map_custom_world_gallery_entry_snapshot(
         play_count: snapshot.play_count,
         remix_count: snapshot.remix_count,
         like_count: snapshot.like_count,
-        recent_play_count_7d: snapshot.recent_play_count_7d,
+        recent_play_count_7d: snapshot.recent_play_count_7_d,
     })
 }
 
@@ -2327,6 +2451,246 @@ pub(crate) fn map_puzzle_agent_message_snapshot(
     }
 }
 
+fn map_match3d_agent_session_snapshot(
+    snapshot: Match3DAgentSessionJsonRecord,
+) -> Match3DAgentSessionRecord {
+    let config = map_match3d_creator_config(snapshot.config);
+    Match3DAgentSessionRecord {
+        session_id: snapshot.session_id,
+        current_turn: snapshot.current_turn,
+        progress_percent: snapshot.progress_percent,
+        stage: normalize_match3d_stage(&snapshot.stage).to_string(),
+        anchor_pack: build_match3d_anchor_pack(&config),
+        draft: snapshot
+            .draft
+            .map(|draft| map_match3d_result_draft(draft, config.reference_image_src.clone())),
+        config: Some(config),
+        messages: snapshot
+            .messages
+            .into_iter()
+            .map(map_match3d_agent_message_snapshot)
+            .collect(),
+        last_assistant_reply: empty_string_to_none(snapshot.last_assistant_reply),
+        published_profile_id: snapshot.published_profile_id,
+        updated_at: format_timestamp_micros(snapshot.updated_at_micros),
+    }
+}
+
+fn map_match3d_creator_config(
+    snapshot: Match3DCreatorConfigJsonRecord,
+) -> Match3DCreatorConfigRecord {
+    Match3DCreatorConfigRecord {
+        theme_text: snapshot.theme_text,
+        reference_image_src: snapshot.reference_image_src,
+        clear_count: snapshot.clear_count,
+        difficulty: snapshot.difficulty,
+    }
+}
+
+fn map_match3d_result_draft(
+    snapshot: Match3DDraftJsonRecord,
+    reference_image_src: Option<String>,
+) -> Match3DResultDraftRecord {
+    Match3DResultDraftRecord {
+        profile_id: snapshot.profile_id,
+        game_name: snapshot.game_name,
+        theme_text: snapshot.theme_text,
+        summary_text: snapshot.summary_text,
+        tags: snapshot.tags,
+        cover_image_src: None,
+        reference_image_src,
+        clear_count: snapshot.clear_count,
+        difficulty: snapshot.difficulty,
+        total_item_count: snapshot.clear_count.saturating_mul(3),
+        publish_ready: false,
+        blockers: Vec::new(),
+    }
+}
+
+fn map_match3d_agent_message_snapshot(
+    snapshot: Match3DAgentMessageJsonRecord,
+) -> Match3DAgentMessageRecord {
+    Match3DAgentMessageRecord {
+        message_id: snapshot.message_id,
+        role: snapshot.role,
+        kind: normalize_match3d_message_kind(&snapshot.kind).to_string(),
+        text: snapshot.text,
+        created_at: format_timestamp_micros(snapshot.created_at_micros),
+    }
+}
+
+fn map_match3d_work_snapshot(
+    snapshot: Match3DWorkJsonRecord,
+) -> Match3DWorkProfileRecord {
+    let config = map_match3d_creator_config(snapshot.config);
+    Match3DWorkProfileRecord {
+        work_id: snapshot.profile_id.clone(),
+        profile_id: snapshot.profile_id,
+        owner_user_id: snapshot.owner_user_id,
+        source_session_id: empty_string_to_none(snapshot.source_session_id),
+        author_display_name: snapshot.author_display_name,
+        game_name: snapshot.game_name,
+        theme_text: snapshot.theme_text,
+        summary: snapshot.summary_text,
+        tags: snapshot.tags,
+        cover_image_src: empty_string_to_none(snapshot.cover_image_src),
+        cover_asset_id: empty_string_to_none(snapshot.cover_asset_id),
+        reference_image_src: config.reference_image_src,
+        clear_count: snapshot.clear_count,
+        difficulty: snapshot.difficulty,
+        publication_status: normalize_match3d_publication_status(&snapshot.publication_status)
+            .to_string(),
+        play_count: snapshot.play_count,
+        updated_at: format_timestamp_micros(snapshot.updated_at_micros),
+        published_at: snapshot.published_at_micros.map(format_timestamp_micros),
+        publish_ready: snapshot.publish_ready,
+    }
+}
+
+fn map_match3d_run_json(run_json: String) -> Result<Match3DRunRecord, SpacetimeClientError> {
+    let run = serde_json::from_str::<Match3DRunJsonRecord>(&run_json).map_err(|error| {
+        SpacetimeClientError::Runtime(format!("match3d run_json 非法: {error}"))
+    })?;
+    Ok(map_match3d_run_snapshot(run))
+}
+
+fn map_match3d_run_snapshot(snapshot: Match3DRunJsonRecord) -> Match3DRunRecord {
+    let tray_slots = snapshot
+        .tray_slots
+        .into_iter()
+        .map(map_match3d_tray_slot_snapshot)
+        .collect::<Vec<_>>();
+    let items = snapshot
+        .items
+        .into_iter()
+        .map(|item| {
+            let tray_slot_index = tray_slots
+                .iter()
+                .find(|slot| slot.item_instance_id.as_deref() == Some(item.item_instance_id.as_str()))
+                .map(|slot| slot.slot_index);
+            map_match3d_item_snapshot(item, tray_slot_index)
+        })
+        .collect();
+
+    Match3DRunRecord {
+        run_id: snapshot.run_id,
+        profile_id: snapshot.profile_id,
+        owner_user_id: String::new(),
+        status: snapshot.status,
+        snapshot_version: u64::from(snapshot.snapshot_version),
+        started_at_ms: i64_to_u64_ms(snapshot.started_at_ms),
+        duration_limit_ms: i64_to_u64_ms(snapshot.duration_limit_ms),
+        server_now_ms: Some(i64_to_u64_ms(snapshot.server_now_ms)),
+        remaining_ms: i64_to_u64_ms(snapshot.remaining_ms),
+        clear_count: snapshot.clear_count,
+        total_item_count: snapshot.total_item_count,
+        cleared_item_count: snapshot.cleared_item_count,
+        items,
+        tray_slots,
+        failure_reason: snapshot.failure_reason,
+        last_confirmed_action_id: None,
+    }
+}
+
+fn map_match3d_item_snapshot(
+    snapshot: Match3DItemJsonRecord,
+    tray_slot_index: Option<u32>,
+) -> Match3DItemSnapshotRecord {
+    Match3DItemSnapshotRecord {
+        item_instance_id: snapshot.item_instance_id,
+        item_type_id: snapshot.item_type_id,
+        visual_key: snapshot.visual_key,
+        x: snapshot.x,
+        y: snapshot.y,
+        radius: snapshot.radius,
+        layer: snapshot.layer,
+        state: snapshot.state,
+        clickable: snapshot.clickable,
+        tray_slot_index,
+    }
+}
+
+fn map_match3d_tray_slot_snapshot(
+    snapshot: Match3DTraySlotJsonRecord,
+) -> Match3DTraySlotRecord {
+    Match3DTraySlotRecord {
+        slot_index: snapshot.slot_index,
+        item_instance_id: snapshot.item_instance_id,
+        item_type_id: snapshot.item_type_id,
+        visual_key: snapshot.visual_key,
+    }
+}
+
+fn build_match3d_anchor_pack(config: &Match3DCreatorConfigRecord) -> Match3DAnchorPackRecord {
+    let clear_count = config.clear_count.to_string();
+    let difficulty = config.difficulty.to_string();
+    Match3DAnchorPackRecord {
+        theme: build_match3d_anchor_item("theme", "题材主题", config.theme_text.as_str()),
+        clear_count: build_match3d_anchor_item(
+            "clearCount",
+            "需要消除次数",
+            clear_count.as_str(),
+        ),
+        difficulty: build_match3d_anchor_item(
+            "difficulty",
+            "难度",
+            difficulty.as_str(),
+        ),
+    }
+}
+
+fn build_match3d_anchor_item(key: &str, label: &str, value: &str) -> Match3DAnchorItemRecord {
+    Match3DAnchorItemRecord {
+        key: key.to_string(),
+        label: label.to_string(),
+        value: value.to_string(),
+        status: if value.trim().is_empty() {
+            "missing"
+        } else {
+            "confirmed"
+        }
+        .to_string(),
+    }
+}
+
+fn normalize_match3d_stage(value: &str) -> &str {
+    match value {
+        "Collecting" | "collecting" | "collecting_config" => "collecting_config",
+        "ReadyToCompile" | "ready_to_compile" => "ready_to_compile",
+        "DraftCompiled" | "draft_compiled" | "draft_ready" => "draft_ready",
+        "Published" | "published" => "published",
+        _ => value,
+    }
+}
+
+fn normalize_match3d_publication_status(value: &str) -> &str {
+    match value {
+        "Draft" | "draft" => "draft",
+        "Published" | "published" => "published",
+        _ => value,
+    }
+}
+
+fn normalize_match3d_message_kind(value: &str) -> &str {
+    match value {
+        "text" => "chat",
+        _ => value,
+    }
+}
+
+fn empty_string_to_none(value: String) -> Option<String> {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+fn i64_to_u64_ms(value: i64) -> u64 {
+    value.max(0) as u64
+}
+
 pub(crate) fn map_puzzle_suggested_action(
     snapshot: DomainPuzzleAgentSuggestedAction,
 ) -> PuzzleAgentSuggestedActionRecord {
@@ -4456,6 +4820,367 @@ pub struct BigFishWorkRemixRecordInput {
     pub remixed_at_micros: i64,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DAgentSessionCreateRecordInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub seed_text: String,
+    pub welcome_message_id: String,
+    pub welcome_message_text: String,
+    pub config_json: Option<String>,
+    pub created_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DAgentMessageSubmitRecordInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub user_message_id: String,
+    pub user_message_text: String,
+    pub submitted_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DAgentMessageFinalizeRecordInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub assistant_message_id: Option<String>,
+    pub assistant_reply_text: Option<String>,
+    pub config_json: Option<String>,
+    pub progress_percent: u32,
+    pub stage: String,
+    pub updated_at_micros: i64,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DCompileDraftRecordInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub author_display_name: String,
+    pub game_name: Option<String>,
+    pub summary_text: Option<String>,
+    pub tags_json: Option<String>,
+    pub cover_image_src: Option<String>,
+    pub cover_asset_id: Option<String>,
+    pub compiled_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DWorkUpdateRecordInput {
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub game_name: String,
+    pub theme_text: String,
+    pub summary_text: String,
+    pub tags_json: String,
+    pub cover_image_src: String,
+    pub cover_asset_id: String,
+    pub clear_count: u32,
+    pub difficulty: u32,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DRunStartRecordInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub started_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DRunClickRecordInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub item_instance_id: String,
+    pub client_snapshot_version: u32,
+    pub client_event_id: String,
+    pub clicked_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DRunStopRecordInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub stopped_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DRunRestartRecordInput {
+    pub source_run_id: String,
+    pub next_run_id: String,
+    pub owner_user_id: String,
+    pub restarted_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DRunTimeUpRecordInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub finished_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DAnchorItemRecord {
+    pub key: String,
+    pub label: String,
+    pub value: String,
+    pub status: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DAnchorPackRecord {
+    pub theme: Match3DAnchorItemRecord,
+    pub clear_count: Match3DAnchorItemRecord,
+    pub difficulty: Match3DAnchorItemRecord,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DCreatorConfigRecord {
+    pub theme_text: String,
+    pub reference_image_src: Option<String>,
+    pub clear_count: u32,
+    pub difficulty: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DResultDraftRecord {
+    pub profile_id: String,
+    pub game_name: String,
+    pub theme_text: String,
+    pub summary_text: String,
+    pub tags: Vec<String>,
+    pub cover_image_src: Option<String>,
+    pub reference_image_src: Option<String>,
+    pub clear_count: u32,
+    pub difficulty: u32,
+    pub total_item_count: u32,
+    pub publish_ready: bool,
+    pub blockers: Vec<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DAgentMessageRecord {
+    pub message_id: String,
+    pub role: String,
+    pub kind: String,
+    pub text: String,
+    pub created_at: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DAgentSessionRecord {
+    pub session_id: String,
+    pub current_turn: u32,
+    pub progress_percent: u32,
+    pub stage: String,
+    pub anchor_pack: Match3DAnchorPackRecord,
+    pub config: Option<Match3DCreatorConfigRecord>,
+    pub draft: Option<Match3DResultDraftRecord>,
+    pub messages: Vec<Match3DAgentMessageRecord>,
+    pub last_assistant_reply: Option<String>,
+    pub published_profile_id: Option<String>,
+    pub updated_at: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DWorkProfileRecord {
+    pub work_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub source_session_id: Option<String>,
+    pub author_display_name: String,
+    pub game_name: String,
+    pub theme_text: String,
+    pub summary: String,
+    pub tags: Vec<String>,
+    pub cover_image_src: Option<String>,
+    pub cover_asset_id: Option<String>,
+    pub reference_image_src: Option<String>,
+    pub clear_count: u32,
+    pub difficulty: u32,
+    pub publication_status: String,
+    pub play_count: u32,
+    pub updated_at: String,
+    pub published_at: Option<String>,
+    pub publish_ready: bool,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Match3DItemSnapshotRecord {
+    pub item_instance_id: String,
+    pub item_type_id: String,
+    pub visual_key: String,
+    pub x: f32,
+    pub y: f32,
+    pub radius: f32,
+    pub layer: u32,
+    pub state: String,
+    pub clickable: bool,
+    pub tray_slot_index: Option<u32>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Match3DTraySlotRecord {
+    pub slot_index: u32,
+    pub item_instance_id: Option<String>,
+    pub item_type_id: Option<String>,
+    pub visual_key: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Match3DRunRecord {
+    pub run_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub status: String,
+    pub snapshot_version: u64,
+    pub started_at_ms: u64,
+    pub duration_limit_ms: u64,
+    pub server_now_ms: Option<u64>,
+    pub remaining_ms: u64,
+    pub clear_count: u32,
+    pub total_item_count: u32,
+    pub cleared_item_count: u32,
+    pub items: Vec<Match3DItemSnapshotRecord>,
+    pub tray_slots: Vec<Match3DTraySlotRecord>,
+    pub failure_reason: Option<String>,
+    pub last_confirmed_action_id: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Match3DClickConfirmationRecord {
+    pub status: String,
+    pub accepted: bool,
+    pub reject_reason: Option<String>,
+    pub accepted_item_instance_id: Option<String>,
+    pub entered_slot_index: Option<u32>,
+    pub cleared_item_instance_ids: Vec<String>,
+    pub failure_reason: Option<String>,
+    pub run: Match3DRunRecord,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DCreatorConfigJsonRecord {
+    theme_text: String,
+    reference_image_src: Option<String>,
+    clear_count: u32,
+    difficulty: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DAgentMessageJsonRecord {
+    message_id: String,
+    #[allow(dead_code)]
+    session_id: String,
+    role: String,
+    kind: String,
+    text: String,
+    created_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DDraftJsonRecord {
+    profile_id: String,
+    game_name: String,
+    theme_text: String,
+    summary_text: String,
+    tags: Vec<String>,
+    clear_count: u32,
+    difficulty: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DAgentSessionJsonRecord {
+    session_id: String,
+    #[allow(dead_code)]
+    owner_user_id: String,
+    #[allow(dead_code)]
+    seed_text: String,
+    current_turn: u32,
+    progress_percent: u32,
+    stage: String,
+    config: Match3DCreatorConfigJsonRecord,
+    draft: Option<Match3DDraftJsonRecord>,
+    messages: Vec<Match3DAgentMessageJsonRecord>,
+    last_assistant_reply: String,
+    published_profile_id: Option<String>,
+    #[allow(dead_code)]
+    created_at_micros: i64,
+    updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DWorkJsonRecord {
+    profile_id: String,
+    owner_user_id: String,
+    source_session_id: String,
+    author_display_name: String,
+    game_name: String,
+    theme_text: String,
+    summary_text: String,
+    tags: Vec<String>,
+    cover_image_src: String,
+    cover_asset_id: String,
+    clear_count: u32,
+    difficulty: u32,
+    config: Match3DCreatorConfigJsonRecord,
+    publication_status: String,
+    publish_ready: bool,
+    play_count: u32,
+    updated_at_micros: i64,
+    published_at_micros: Option<i64>,
+}
+
+#[derive(Clone, Debug, PartialEq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DItemJsonRecord {
+    item_instance_id: String,
+    item_type_id: String,
+    visual_key: String,
+    x: f32,
+    y: f32,
+    radius: f32,
+    layer: u32,
+    state: String,
+    clickable: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DTraySlotJsonRecord {
+    slot_index: u32,
+    item_instance_id: Option<String>,
+    item_type_id: Option<String>,
+    visual_key: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Match3DRunJsonRecord {
+    run_id: String,
+    profile_id: String,
+    status: String,
+    snapshot_version: u32,
+    started_at_ms: i64,
+    duration_limit_ms: i64,
+    server_now_ms: i64,
+    remaining_ms: i64,
+    clear_count: u32,
+    total_item_count: u32,
+    cleared_item_count: u32,
+    tray_slots: Vec<Match3DTraySlotJsonRecord>,
+    items: Vec<Match3DItemJsonRecord>,
+    failure_reason: Option<String>,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct PuzzleAnchorItemRecord {
     pub key: String,