Enforce Genarrative play-type SOP and update docs

Rewrite Genarrative play-type integration guidance across .codex and .hermes to define a platform-level SOP: default to form/image workbench, unify single-image asset slots (CreativeImageInputPanel), standardize series-material sheet->cut->transparent->OSS pipeline, and forbid copying legacy chat/agent workflows as the default. Add decision-log entry freezing the SOP and a pitfalls note warning against direct reuse of old play tools. Update CONTEXT.md and docs/README.md, add a new PRD file, and apply related small server-side changes (module-auth, spacetime-client mappers and runtime) to align back-end code with the new contracts and flows.

server-rs/Cargo.lock

@@ -1827,6 +1827,15 @@ dependencies = [
  "spacetimedb",
 ]
 
+[[package]]
+name = "module-jump-hop"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "shared-kernel",
+ "spacetimedb",
+]
+
 [[package]]
 name = "module-match3d"
 version = "0.1.0"
@@ -3259,6 +3268,7 @@ dependencies = [
  "module-combat",
  "module-custom-world",
  "module-inventory",
+ "module-jump-hop",
  "module-match3d",
  "module-npc",
  "module-puzzle",
@@ -3291,6 +3301,7 @@ dependencies = [
  "module-combat",
  "module-custom-world",
  "module-inventory",
+ "module-jump-hop",
  "module-match3d",
  "module-npc",
  "module-progression",

server-rs/Cargo.toml

@@ -17,6 +17,7 @@ members = [
     "crates/module-creative-agent",
     "crates/module-inventory",
     "crates/module-custom-world",
+    "crates/module-jump-hop",
     "crates/module-match3d",
     "crates/module-npc",
     "crates/module-puzzle",
@@ -57,6 +58,7 @@ module-combat = { path = "crates/module-combat", default-features = false }
 module-creative-agent = { path = "crates/module-creative-agent", default-features = false }
 module-custom-world = { path = "crates/module-custom-world", default-features = false }
 module-inventory = { path = "crates/module-inventory", default-features = false }
+module-jump-hop = { path = "crates/module-jump-hop", default-features = false }
 module-match3d = { path = "crates/module-match3d", default-features = false }
 module-npc = { path = "crates/module-npc", default-features = false }
 module-progression = { path = "crates/module-progression", default-features = false }

server-rs/crates/api-server/src/app.rs

@@ -59,6 +59,7 @@ pub fn build_router(state: AppState) -> Router {
         .merge(modules::bark_battle::router(state.clone()))
         .merge(modules::match3d::router(state.clone()))
         .merge(modules::square_hole::router(state.clone()))
+        .merge(modules::jump_hop::router(state.clone()))
         .merge(modules::puzzle::router(state.clone()))
         .merge(visual_novel_router(state.clone()))
         .route(

server-rs/crates/api-server/src/creation_entry_config.rs

@@ -87,6 +87,12 @@ pub fn resolve_creation_entry_route_id(path: &str) -> Option<&'static str> {
     if normalized.starts_with("/api/runtime/square-hole") {
         return Some("square-hole");
     }
+    if normalized.starts_with("/api/runtime/jump-hop") {
+        return Some("jump-hop");
+    }
+    if normalized.starts_with("/api/creation/jump-hop") {
+        return Some("jump-hop");
+    }
     if normalized.starts_with("/api/runtime/big-fish") {
         return Some("big-fish");
     }

server-rs/crates/api-server/src/jump_hop.rs

@@ -0,0 +1,447 @@
+use axum::{
+    Json,
+    extract::{Extension, Path, State, rejection::JsonRejection},
+    http::{HeaderName, StatusCode, header},
+    response::Response,
+};
+use serde_json::{Value, json};
+use shared_contracts::jump_hop::{
+    JumpHopActionRequest, JumpHopDraftResponse, JumpHopGalleryDetailResponse,
+    JumpHopGenerationStatus, JumpHopJumpRequest, JumpHopJumpResponse, JumpHopRestartRunRequest,
+    JumpHopRunResponse, JumpHopSessionResponse, JumpHopSessionSnapshotResponse,
+    JumpHopStartRunRequest, JumpHopWorkDetailResponse, JumpHopWorkMutationResponse,
+    JumpHopWorkspaceCreateRequest,
+};
+use shared_kernel::{build_prefixed_uuid_id, format_timestamp_micros};
+use spacetime_client::SpacetimeClientError;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::{
+    api_response::json_success_body, auth::AuthenticatedAccessToken, http_error::AppError,
+    request_context::RequestContext, state::AppState,
+};
+
+const JUMP_HOP_PROVIDER: &str = "jump-hop";
+const JUMP_HOP_CREATION_PROVIDER: &str = "jump-hop-creation";
+const JUMP_HOP_RUNTIME_PROVIDER: &str = "jump-hop-runtime";
+const JUMP_HOP_TEMPLATE_ID: &str = "jump-hop";
+const JUMP_HOP_TEMPLATE_NAME: &str = "跳一跳";
+
+pub async fn create_jump_hop_session(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<JumpHopWorkspaceCreateRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = jump_hop_json(payload, &request_context, JUMP_HOP_CREATION_PROVIDER)?;
+    validate_workspace_request(&request_context, &payload)?;
+
+    let owner_user_id = authenticated.claims().user_id().to_string();
+    let session_id = build_prefixed_uuid_id("jump-hop-session-");
+    let now = current_utc_micros();
+    let draft = build_jump_hop_draft(&payload);
+    let session = JumpHopSessionSnapshotResponse {
+        session_id,
+        owner_user_id,
+        status: JumpHopGenerationStatus::Draft,
+        draft: Some(draft),
+        created_at: format_timestamp_micros(now),
+        updated_at: format_timestamp_micros(now),
+    };
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopSessionResponse {
+            session: state
+                .spacetime_client()
+                .create_jump_hop_session(session)
+                .await
+                .map_err(|error| {
+                    jump_hop_error_response(
+                        &request_context,
+                        JUMP_HOP_CREATION_PROVIDER,
+                        map_jump_hop_client_error(error),
+                    )
+                })?,
+        },
+    ))
+}
+
+pub async fn get_jump_hop_session(
+    State(state): State<AppState>,
+    Path(session_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &session_id, "sessionId")?;
+    let owner_user_id = authenticated.claims().user_id().to_string();
+    let session = state
+        .spacetime_client()
+        .get_jump_hop_session(session_id, owner_user_id)
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_CREATION_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopSessionResponse { session },
+    ))
+}
+
+pub async fn execute_jump_hop_action(
+    State(state): State<AppState>,
+    Path(session_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<JumpHopActionRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &session_id, "sessionId")?;
+    let Json(payload) = jump_hop_json(payload, &request_context, JUMP_HOP_CREATION_PROVIDER)?;
+    let owner_user_id = authenticated.claims().user_id().to_string();
+    let response = state
+        .spacetime_client()
+        .execute_jump_hop_action(session_id, owner_user_id, payload)
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_CREATION_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(Some(&request_context), response))
+}
+
+pub async fn publish_jump_hop_work(
+    State(state): State<AppState>,
+    Path(profile_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &profile_id, "profileId")?;
+    let work = state
+        .spacetime_client()
+        .publish_jump_hop_work(profile_id, authenticated.claims().user_id().to_string())
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_CREATION_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopWorkMutationResponse { item: work },
+    ))
+}
+
+pub async fn get_jump_hop_runtime_work(
+    State(state): State<AppState>,
+    Path(profile_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &profile_id, "profileId")?;
+    let work = state
+        .spacetime_client()
+        .get_jump_hop_runtime_work(profile_id)
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_RUNTIME_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopWorkDetailResponse { item: work },
+    ))
+}
+
+pub async fn start_jump_hop_run(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<JumpHopStartRunRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = jump_hop_json(payload, &request_context, JUMP_HOP_RUNTIME_PROVIDER)?;
+    ensure_non_empty(&request_context, &payload.profile_id, "profileId")?;
+    let run = state
+        .spacetime_client()
+        .start_jump_hop_run(payload, authenticated.claims().user_id().to_string())
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_RUNTIME_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopRunResponse { run },
+    ))
+}
+
+pub async fn jump_hop_run_jump(
+    State(state): State<AppState>,
+    Path(run_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<JumpHopJumpRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &run_id, "runId")?;
+    let Json(payload) = jump_hop_json(payload, &request_context, JUMP_HOP_RUNTIME_PROVIDER)?;
+    let run = state
+        .spacetime_client()
+        .jump_hop_run_jump(
+            run_id,
+            authenticated.claims().user_id().to_string(),
+            payload,
+        )
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_RUNTIME_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopJumpResponse { run },
+    ))
+}
+
+pub async fn restart_jump_hop_run(
+    State(state): State<AppState>,
+    Path(run_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<JumpHopRestartRunRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &run_id, "runId")?;
+    let Json(payload) = jump_hop_json(payload, &request_context, JUMP_HOP_RUNTIME_PROVIDER)?;
+    let run = state
+        .spacetime_client()
+        .restart_jump_hop_run(
+            run_id,
+            authenticated.claims().user_id().to_string(),
+            payload,
+        )
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_RUNTIME_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopRunResponse { run },
+    ))
+}
+
+pub async fn list_jump_hop_gallery(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+) -> Result<Json<Value>, Response> {
+    let gallery = state
+        .spacetime_client()
+        .list_jump_hop_gallery()
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_RUNTIME_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(Some(&request_context), gallery))
+}
+
+pub async fn get_jump_hop_gallery_detail(
+    State(state): State<AppState>,
+    Path(public_work_code): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &public_work_code, "publicWorkCode")?;
+    let work = state
+        .spacetime_client()
+        .get_jump_hop_gallery_detail(public_work_code)
+        .await
+        .map_err(|error| {
+            jump_hop_error_response(
+                &request_context,
+                JUMP_HOP_RUNTIME_PROVIDER,
+                map_jump_hop_client_error(error),
+            )
+        })?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        JumpHopGalleryDetailResponse { item: work },
+    ))
+}
+
+fn build_jump_hop_draft(payload: &JumpHopWorkspaceCreateRequest) -> JumpHopDraftResponse {
+    JumpHopDraftResponse {
+        template_id: JUMP_HOP_TEMPLATE_ID.to_string(),
+        template_name: JUMP_HOP_TEMPLATE_NAME.to_string(),
+        profile_id: None,
+        work_title: payload.work_title.trim().to_string(),
+        work_description: payload.work_description.trim().to_string(),
+        theme_tags: normalize_tags(payload.theme_tags.clone()),
+        difficulty: payload.difficulty.clone(),
+        style_preset: payload.style_preset.clone(),
+        character_prompt: payload.character_prompt.trim().to_string(),
+        tile_prompt: payload.tile_prompt.trim().to_string(),
+        end_mood_prompt: payload
+            .end_mood_prompt
+            .as_ref()
+            .map(|value| value.trim().to_string())
+            .filter(|value| !value.is_empty()),
+        character_asset: None,
+        tile_atlas_asset: None,
+        tile_assets: Vec::new(),
+        path: None,
+        cover_composite: None,
+        generation_status: JumpHopGenerationStatus::Draft,
+    }
+}
+
+fn validate_workspace_request(
+    request_context: &RequestContext,
+    payload: &JumpHopWorkspaceCreateRequest,
+) -> Result<(), Response> {
+    ensure_non_empty(request_context, &payload.work_title, "workTitle")?;
+    ensure_non_empty(
+        request_context,
+        &payload.character_prompt,
+        "characterPrompt",
+    )?;
+    ensure_non_empty(request_context, &payload.tile_prompt, "tilePrompt")?;
+    if payload.template_id.trim() != JUMP_HOP_TEMPLATE_ID {
+        return Err(jump_hop_error_response(
+            request_context,
+            JUMP_HOP_CREATION_PROVIDER,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": JUMP_HOP_PROVIDER,
+                "message": "templateId 必须为 jump-hop",
+            })),
+        ));
+    }
+    Ok(())
+}
+
+fn ensure_non_empty(
+    request_context: &RequestContext,
+    value: &str,
+    field: &str,
+) -> Result<(), Response> {
+    if value.trim().is_empty() {
+        return Err(jump_hop_error_response(
+            request_context,
+            JUMP_HOP_PROVIDER,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": JUMP_HOP_PROVIDER,
+                "field": field,
+                "message": format!("{field} 不能为空"),
+            })),
+        ));
+    }
+    Ok(())
+}
+
+fn normalize_tags(tags: Vec<String>) -> Vec<String> {
+    let mut normalized = Vec::new();
+    for tag in tags {
+        let tag = tag.trim();
+        if tag.is_empty() || normalized.iter().any(|item| item == tag) {
+            continue;
+        }
+        normalized.push(tag.to_string());
+        if normalized.len() >= 6 {
+            break;
+        }
+    }
+    normalized
+}
+
+fn jump_hop_json<T>(
+    payload: Result<Json<T>, JsonRejection>,
+    request_context: &RequestContext,
+    provider: &str,
+) -> Result<Json<T>, Response> {
+    payload.map_err(|error| {
+        jump_hop_error_response(
+            request_context,
+            provider,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": provider,
+                "message": error.to_string(),
+            })),
+        )
+    })
+}
+
+fn map_jump_hop_client_error(error: SpacetimeClientError) -> AppError {
+    let status = match &error {
+        SpacetimeClientError::Runtime(_) => StatusCode::BAD_REQUEST,
+        SpacetimeClientError::Procedure(message)
+            if message.contains("不存在")
+                || message.contains("not found")
+                || message.contains("does not exist") =>
+        {
+            StatusCode::NOT_FOUND
+        }
+        SpacetimeClientError::Procedure(message)
+            if message.contains("发布需要")
+                || message.contains("不能为空")
+                || message.contains("必须") =>
+        {
+            StatusCode::BAD_REQUEST
+        }
+        _ => StatusCode::BAD_GATEWAY,
+    };
+
+    AppError::from_status(status).with_details(json!({
+        "provider": "spacetimedb",
+        "message": error.to_string(),
+    }))
+}
+
+fn jump_hop_error_response(
+    request_context: &RequestContext,
+    provider: &str,
+    error: AppError,
+) -> Response {
+    let mut response = error.into_response_with_context(Some(request_context));
+    response.headers_mut().insert(
+        HeaderName::from_static("x-genarrative-provider"),
+        header::HeaderValue::from_str(provider)
+            .unwrap_or_else(|_| header::HeaderValue::from_static("jump-hop")),
+    );
+    response
+}
+
+fn current_utc_micros() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_micros().min(i64::MAX as u128) as i64)
+        .unwrap_or(0)
+}

server-rs/crates/api-server/src/main.rs

@@ -39,10 +39,12 @@ mod custom_world_rpg_draft_prompts;
 mod edutainment_baby_drawing;
 mod edutainment_baby_object;
 mod error_middleware;
+pub(crate) mod generated_asset_sheets;
 mod generated_image_assets;
 mod health;
 mod http_error;
 mod hyper3d_generation;
+mod jump_hop;
 mod llm;
 mod llm_model_routing;
 mod login_options;

server-rs/crates/api-server/src/match3d.rs

@@ -16,7 +16,7 @@ use axum::{
 };
 use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
 use futures_util::{StreamExt, stream::FuturesUnordered};
-use image::{GenericImageView, ImageFormat};
+use image::ImageFormat;
 use module_match3d::{
     MATCH3D_MESSAGE_ID_PREFIX, MATCH3D_PROFILE_ID_PREFIX, MATCH3D_RUN_ID_PREFIX,
     MATCH3D_SESSION_ID_PREFIX,
@@ -98,11 +98,6 @@ const MATCH3D_ITEM_ASSETS_POINTS_PER_BATCH: u64 = 2;
 const MATCH3D_MATERIAL_ITEM_BATCH_SIZE: usize = 5;
 const MATCH3D_ITEM_VIEW_COUNT: usize = 5;
 const MATCH3D_MATERIAL_GRID_SIZE: u32 = 5;
-const MATCH3D_MATERIAL_FOREGROUND_DIFF_THRESHOLD: i32 = 36;
-const MATCH3D_MATERIAL_FOREGROUND_ALPHA_THRESHOLD: i32 = 36;
-const MATCH3D_MATERIAL_GREEN_SCREEN_MIN_SCORE: f32 = 0.34;
-const MATCH3D_MATERIAL_GREEN_SCREEN_SOFT_SCORE: f32 = 0.18;
-const MATCH3D_MATERIAL_HARD_GREEN_SCREEN_SCORE: f32 = 0.82;
 const MATCH3D_MAX_GENERATED_ITEM_COUNT: usize = 25;
 const MATCH3D_MATERIAL_VECTOR_ENGINE_GEMINI_MODEL: &str = "gemini-3-pro-image-preview";
 const MATCH3D_MATERIAL_VECTOR_ENGINE_GEMINI_ASPECT_RATIO: &str = "1:1";

server-rs/crates/api-server/src/match3d/draft.rs

@@ -532,7 +532,9 @@ fn build_config_from_message(
     }
 }
 
-pub(super) fn resolve_config_or_default(config: Option<&Match3DCreatorConfigRecord>) -> Match3DConfigJson {
+pub(super) fn resolve_config_or_default(
+    config: Option<&Match3DCreatorConfigRecord>,
+) -> Match3DConfigJson {
     config
         .map(|config| Match3DConfigJson {
             theme_text: config.theme_text.clone(),
@@ -595,7 +597,10 @@ fn build_match3d_assistant_reply(config: &Match3DConfigJson) -> String {
     )
 }
 
-pub(super) fn build_match3d_assistant_reply_for_turn(config: &Match3DConfigJson, current_turn: u32) -> String {
+pub(super) fn build_match3d_assistant_reply_for_turn(
+    config: &Match3DConfigJson,
+    current_turn: u32,
+) -> String {
     match current_turn {
         0 => MATCH3D_QUESTION_THEME.to_string(),
         1 => MATCH3D_QUESTION_CLEAR_COUNT.to_string(),

server-rs/crates/api-server/src/match3d/mappers.rs

@@ -134,12 +134,11 @@ pub(super) fn map_match3d_draft_response(
     draft: Match3DResultDraftRecord,
 ) -> Match3DResultDraftResponse {
     // 中文注释：session draft 自身也可能携带生成素材快照，不能只依赖 work detail 回读补齐 UI 背景和容器图。
-    let generated_item_assets = parse_match3d_generated_item_assets(
-        draft.generated_item_assets_json.as_deref(),
-    )
-    .into_iter()
-    .map(Match3DGeneratedItemAsset::from)
-    .collect::<Vec<_>>();
+    let generated_item_assets =
+        parse_match3d_generated_item_assets(draft.generated_item_assets_json.as_deref())
+            .into_iter()
+            .map(Match3DGeneratedItemAsset::from)
+            .collect::<Vec<_>>();
     let background_asset = find_match3d_generated_background_asset(&generated_item_assets);
     let mut response = Match3DResultDraftResponse {
         profile_id: draft.profile_id,

server-rs/crates/api-server/src/match3d/vector_engine_gemini.rs

@@ -26,6 +26,7 @@ pub(super) async fn generate_match3d_material_sheet(
 
     Ok(Match3DMaterialSheet {
         task_id: generated.task_id,
+        prompt,
         image,
     })
 }

server-rs/crates/api-server/src/match3d/works.rs

@@ -587,7 +587,10 @@ async fn load_match3d_container_reference_image() -> Result<OpenAiReferenceImage
     })
 }
 
-pub(super) fn build_match3d_background_generation_prompt(config: &Match3DConfigJson, prompt: &str) -> String {
+pub(super) fn build_match3d_background_generation_prompt(
+    config: &Match3DConfigJson,
+    prompt: &str,
+) -> String {
     let style_clause = resolve_match3d_asset_style_prompt(config)
         .map(|style| format!("整体美术风格参考：{style}。"))
         .unwrap_or_default();
@@ -596,7 +599,10 @@ pub(super) fn build_match3d_background_generation_prompt(config: &Match3DConfigJ
     )
 }
 
-pub(super) fn build_match3d_container_generation_prompt(config: &Match3DConfigJson, prompt: &str) -> String {
+pub(super) fn build_match3d_container_generation_prompt(
+    config: &Match3DConfigJson,
+    prompt: &str,
+) -> String {
     let style_clause = resolve_match3d_asset_style_prompt(config)
         .map(|style| format!("整体美术风格参考：{style}。"))
         .unwrap_or_default();
@@ -1183,7 +1189,9 @@ pub(super) async fn persist_match3d_generated_bytes(
     })
 }
 
-pub(super) fn require_match3d_oss_client(state: &AppState) -> Result<&platform_oss::OssClient, AppError> {
+pub(super) fn require_match3d_oss_client(
+    state: &AppState,
+) -> Result<&platform_oss::OssClient, AppError> {
     state
         .oss_client()
         .ok_or_else(|| match3d_oss_config_error(&state.config))

server-rs/crates/api-server/src/modules.rs

@@ -7,6 +7,7 @@ pub mod custom_world;
 pub mod edutainment;
 pub mod health;
 pub mod internal;
+pub mod jump_hop;
 pub mod match3d;
 pub mod platform;
 pub mod profile;

server-rs/crates/api-server/src/modules/jump_hop.rs

@@ -0,0 +1,76 @@
+use axum::{
+    Router, middleware,
+    routing::{get, post},
+};
+
+use crate::{
+    auth::require_bearer_auth,
+    jump_hop::{
+        create_jump_hop_session, execute_jump_hop_action, get_jump_hop_gallery_detail,
+        get_jump_hop_runtime_work, get_jump_hop_session, jump_hop_run_jump, list_jump_hop_gallery,
+        publish_jump_hop_work, restart_jump_hop_run, start_jump_hop_run,
+    },
+    state::AppState,
+};
+
+pub fn router(state: AppState) -> Router<AppState> {
+    Router::new()
+        .route(
+            "/api/creation/jump-hop/sessions",
+            post(create_jump_hop_session).route_layer(middleware::from_fn_with_state(
+                state.clone(),
+                require_bearer_auth,
+            )),
+        )
+        .route(
+            "/api/creation/jump-hop/sessions/{session_id}",
+            get(get_jump_hop_session).route_layer(middleware::from_fn_with_state(
+                state.clone(),
+                require_bearer_auth,
+            )),
+        )
+        .route(
+            "/api/creation/jump-hop/sessions/{session_id}/actions",
+            post(execute_jump_hop_action).route_layer(middleware::from_fn_with_state(
+                state.clone(),
+                require_bearer_auth,
+            )),
+        )
+        .route(
+            "/api/creation/jump-hop/works/{profile_id}/publish",
+            post(publish_jump_hop_work).route_layer(middleware::from_fn_with_state(
+                state.clone(),
+                require_bearer_auth,
+            )),
+        )
+        .route(
+            "/api/runtime/jump-hop/works/{profile_id}",
+            get(get_jump_hop_runtime_work),
+        )
+        .route(
+            "/api/runtime/jump-hop/runs",
+            post(start_jump_hop_run).route_layer(middleware::from_fn_with_state(
+                state.clone(),
+                require_bearer_auth,
+            )),
+        )
+        .route(
+            "/api/runtime/jump-hop/runs/{run_id}/jump",
+            post(jump_hop_run_jump).route_layer(middleware::from_fn_with_state(
+                state.clone(),
+                require_bearer_auth,
+            )),
+        )
+        .route(
+            "/api/runtime/jump-hop/runs/{run_id}/restart",
+            post(restart_jump_hop_run).route_layer(middleware::from_fn_with_state(
+                state.clone(),
+                require_bearer_auth,
+            )),
+        )
+        .route("/api/runtime/jump-hop/gallery", get(list_jump_hop_gallery))
+        .route(
+            "/api/runtime/jump-hop/gallery/{public_work_code}",
+            get(get_jump_hop_gallery_detail),
+        )
+}

server-rs/crates/api-server/src/process_metrics.rs

@@ -199,11 +199,9 @@ fn cpu_usage_ratio_between_samples(
 
 #[cfg(windows)]
 fn collect_process_metrics() -> Result<ProcessMetricsSnapshot, String> {
-    use windows_sys::Win32::{
-        System::{
-            ProcessStatus::{GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS_EX},
-            Threading::{GetCurrentProcess, GetCurrentProcessId, GetProcessHandleCount},
-        },
+    use windows_sys::Win32::System::{
+        ProcessStatus::{GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS_EX},
+        Threading::{GetCurrentProcess, GetCurrentProcessId, GetProcessHandleCount},
     };
 
     let handle = unsafe { GetCurrentProcess() };
@@ -212,11 +210,7 @@ fn collect_process_metrics() -> Result<ProcessMetricsSnapshot, String> {
         ..Default::default()
     };
     let ok = unsafe {
-        GetProcessMemoryInfo(
-            handle,
-            std::ptr::addr_of_mut!(counters).cast(),
-            counters.cb,
-        )
+        GetProcessMemoryInfo(handle, std::ptr::addr_of_mut!(counters).cast(), counters.cb)
     };
     if ok == 0 {
         return Err("GetProcessMemoryInfo returned false".to_string());
@@ -244,10 +238,7 @@ fn collect_process_metrics() -> Result<ProcessMetricsSnapshot, String> {
 
 #[cfg(windows)]
 fn windows_process_cpu_time_seconds(handle: windows_sys::Win32::Foundation::HANDLE) -> Option<f64> {
-    use windows_sys::Win32::{
-        Foundation::FILETIME,
-        System::Threading::GetProcessTimes,
-    };
+    use windows_sys::Win32::{Foundation::FILETIME, System::Threading::GetProcessTimes};
 
     let mut creation_time = FILETIME::default();
     let mut exit_time = FILETIME::default();
@@ -337,8 +328,8 @@ fn collect_process_metrics() -> Result<ProcessMetricsSnapshot, String> {
         .ok_or_else(|| "missing VmSize/statm size field".to_string())?;
     let private_bytes = parse_status_kb(&status, "VmData:").map(|value| value * 1024);
     let cpu_time_seconds = linux_cpu_time_seconds(&stat)?;
-    let thread_count = parse_status_u64(&status, "Threads:")
-        .ok_or_else(|| "missing Threads field".to_string())?;
+    let thread_count =
+        parse_status_u64(&status, "Threads:").ok_or_else(|| "missing Threads field".to_string())?;
 
     Ok(ProcessMetricsSnapshot {
         rss_bytes,
@@ -427,11 +418,7 @@ fn parse_status_u64(status: &str, key: &str) -> Option<u64> {
 
 #[cfg(target_os = "linux")]
 fn parse_statm_pages(statm: &str, index: usize) -> Option<u64> {
-    statm
-        .split_whitespace()
-        .nth(index)?
-        .parse::<u64>()
-        .ok()
+    statm.split_whitespace().nth(index)?.parse::<u64>().ok()
 }
 
 #[cfg(not(any(windows, target_os = "linux")))]

server-rs/crates/module-auth/src/lib.rs

@@ -2061,7 +2061,6 @@ fn map_sms_provider_error_to_phone_error(error: SmsProviderError) -> PhoneAuthEr
         SmsProviderError::InvalidConfig(message) => {
             PhoneAuthError::SmsProviderInvalidConfig(message)
         }
-        SmsProviderError::InvalidVerifyCode => PhoneAuthError::InvalidVerifyCode,
         SmsProviderError::Upstream(message) => PhoneAuthError::SmsProviderUpstream(message),
     }
 }

server-rs/crates/module-jump-hop/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "module-jump-hop"
+edition.workspace = true
+version.workspace = true
+license.workspace = true
+
+[features]
+default = []
+spacetime-types = ["dep:spacetimedb"]
+
+[dependencies]
+serde = { workspace = true }
+shared-kernel = { workspace = true }
+spacetimedb = { workspace = true, optional = true }

server-rs/crates/module-jump-hop/src/application.rs

@@ -0,0 +1,395 @@
+use shared_kernel::normalize_required_string;
+
+use crate::{
+    JumpHopDifficulty, JumpHopError, JumpHopJumpResultKind, JumpHopLastJump, JumpHopPath,
+    JumpHopPlatform, JumpHopRunSnapshot, JumpHopRunStatus, JumpHopScoring, JumpHopTileType,
+};
+
+pub fn generate_jump_hop_path(seed: &str, difficulty: JumpHopDifficulty) -> JumpHopPath {
+    let config = difficulty_config(difficulty);
+    let mut rng = DeterministicRng::new(seed, difficulty.as_str());
+    let platform_count = rng.range_u32(config.min_platforms, config.max_platforms) as usize;
+    let mut platforms = Vec::with_capacity(platform_count);
+    let mut x = 0.0f32;
+    let mut y = 0.0f32;
+
+    for index in 0..platform_count {
+        let tile_type = if index == 0 {
+            JumpHopTileType::Start
+        } else if index + 1 == platform_count {
+            JumpHopTileType::Finish
+        } else if index % 7 == 0 {
+            JumpHopTileType::Bonus
+        } else if index % 5 == 0 {
+            JumpHopTileType::Target
+        } else if index % 4 == 0 {
+            JumpHopTileType::Accent
+        } else {
+            JumpHopTileType::Normal
+        };
+        let width = rng.range_f32(config.min_width, config.max_width);
+        let height = width * rng.range_f32(0.86, 1.04);
+        let landing_radius = width * config.landing_radius_factor;
+        let perfect_radius = landing_radius * config.perfect_radius_factor;
+
+        platforms.push(JumpHopPlatform {
+            platform_id: format!("jump-hop-platform-{index:03}"),
+            tile_type,
+            x,
+            y,
+            width,
+            height,
+            landing_radius,
+            perfect_radius,
+            score_value: if tile_type == JumpHopTileType::Bonus {
+                180
+            } else {
+                100
+            },
+        });
+
+        if index + 1 < platform_count {
+            let distance = rng.range_f32(config.min_gap, config.max_gap);
+            let direction = if rng.next_u32() % 2 == 0 { 1.0 } else { -1.0 };
+            x += distance * 0.62 * direction;
+            y += distance;
+        }
+    }
+
+    JumpHopPath {
+        seed: seed.trim().to_string(),
+        difficulty,
+        finish_index: platform_count.saturating_sub(1) as u32,
+        platforms,
+        camera_preset: "portrait-isometric-9x16".to_string(),
+        scoring: JumpHopScoring {
+            charge_to_distance_ratio: config.charge_to_distance_ratio,
+            max_charge_ms: config.max_charge_ms,
+            hit_bonus: 20,
+            perfect_bonus: 60,
+        },
+    }
+}
+
+pub fn start_run(
+    run_id: String,
+    owner_user_id: String,
+    profile_id: String,
+    path: JumpHopPath,
+    started_at_ms: u64,
+) -> Result<JumpHopRunSnapshot, JumpHopError> {
+    let run_id = normalize_required_string(run_id).ok_or(JumpHopError::MissingRunId)?;
+    let owner_user_id =
+        normalize_required_string(owner_user_id).ok_or(JumpHopError::MissingOwnerUserId)?;
+    let profile_id = normalize_required_string(profile_id).ok_or(JumpHopError::MissingProfileId)?;
+    if path.platforms.is_empty() {
+        return Err(JumpHopError::EmptyPath);
+    }
+
+    Ok(JumpHopRunSnapshot {
+        run_id,
+        profile_id,
+        owner_user_id,
+        status: JumpHopRunStatus::Playing,
+        current_platform_index: 0,
+        score: 0,
+        combo: 0,
+        last_jump: None,
+        started_at_ms,
+        finished_at_ms: None,
+        path,
+    })
+}
+
+pub fn apply_jump(
+    run: &JumpHopRunSnapshot,
+    charge_ms: u32,
+    jumped_at_ms: u64,
+) -> Result<JumpHopRunSnapshot, JumpHopError> {
+    if run.status != JumpHopRunStatus::Playing {
+        return Err(JumpHopError::RunNotPlaying);
+    }
+    let current_index = run.current_platform_index as usize;
+    let next_index = current_index + 1;
+    let current = run
+        .path
+        .platforms
+        .get(current_index)
+        .ok_or(JumpHopError::EmptyPath)?;
+    let target = run
+        .path
+        .platforms
+        .get(next_index)
+        .ok_or(JumpHopError::NoNextPlatform)?;
+    let capped_charge = charge_ms.min(run.path.scoring.max_charge_ms);
+    let jump_distance = capped_charge as f32 * run.path.scoring.charge_to_distance_ratio;
+    let vector_x = target.x - current.x;
+    let vector_y = target.y - current.y;
+    let target_distance = vector_x.hypot(vector_y).max(0.0001);
+    let unit_x = vector_x / target_distance;
+    let unit_y = vector_y / target_distance;
+    let landed_x = current.x + unit_x * jump_distance;
+    let landed_y = current.y + unit_y * jump_distance;
+    let landing_error = (landed_x - target.x).hypot(landed_y - target.y);
+
+    let mut next = run.clone();
+    let result = if landing_error <= target.perfect_radius {
+        if next_index as u32 == run.path.finish_index {
+            JumpHopJumpResultKind::Finish
+        } else {
+            JumpHopJumpResultKind::Perfect
+        }
+    } else if landing_error <= target.landing_radius {
+        if next_index as u32 == run.path.finish_index {
+            JumpHopJumpResultKind::Finish
+        } else {
+            JumpHopJumpResultKind::Hit
+        }
+    } else {
+        JumpHopJumpResultKind::Miss
+    };
+
+    next.last_jump = Some(JumpHopLastJump {
+        charge_ms: capped_charge,
+        jump_distance,
+        target_platform_index: next_index as u32,
+        landed_x,
+        landed_y,
+        result,
+    });
+
+    if result == JumpHopJumpResultKind::Miss {
+        next.status = JumpHopRunStatus::Failed;
+        next.combo = 0;
+        next.finished_at_ms = Some(jumped_at_ms);
+        return Ok(next);
+    }
+
+    next.current_platform_index = next_index as u32;
+    next.combo = next.combo.saturating_add(1);
+    next.score = next.score.saturating_add(target.score_value);
+    if matches!(
+        result,
+        JumpHopJumpResultKind::Perfect | JumpHopJumpResultKind::Finish
+    ) {
+        next.score = next
+            .score
+            .saturating_add(run.path.scoring.perfect_bonus)
+            .saturating_add(next.combo.saturating_mul(run.path.scoring.hit_bonus));
+    } else {
+        next.score = next.score.saturating_add(run.path.scoring.hit_bonus);
+    }
+    if result == JumpHopJumpResultKind::Finish {
+        next.status = JumpHopRunStatus::Cleared;
+        next.finished_at_ms = Some(jumped_at_ms);
+    }
+
+    Ok(next)
+}
+
+pub fn restart_run(
+    run: &JumpHopRunSnapshot,
+    next_run_id: String,
+    restarted_at_ms: u64,
+) -> Result<JumpHopRunSnapshot, JumpHopError> {
+    start_run(
+        next_run_id,
+        run.owner_user_id.clone(),
+        run.profile_id.clone(),
+        run.path.clone(),
+        restarted_at_ms,
+    )
+}
+
+struct DifficultyConfig {
+    min_platforms: u32,
+    max_platforms: u32,
+    min_gap: f32,
+    max_gap: f32,
+    min_width: f32,
+    max_width: f32,
+    landing_radius_factor: f32,
+    perfect_radius_factor: f32,
+    charge_to_distance_ratio: f32,
+    max_charge_ms: u32,
+}
+
+fn difficulty_config(difficulty: JumpHopDifficulty) -> DifficultyConfig {
+    match difficulty {
+        JumpHopDifficulty::Easy => DifficultyConfig {
+            min_platforms: 12,
+            max_platforms: 14,
+            min_gap: 1.0,
+            max_gap: 1.45,
+            min_width: 0.9,
+            max_width: 1.08,
+            landing_radius_factor: 0.62,
+            perfect_radius_factor: 0.32,
+            charge_to_distance_ratio: 0.004,
+            max_charge_ms: 700,
+        },
+        JumpHopDifficulty::Standard => DifficultyConfig {
+            min_platforms: 16,
+            max_platforms: 18,
+            min_gap: 1.22,
+            max_gap: 1.78,
+            min_width: 0.82,
+            max_width: 1.0,
+            landing_radius_factor: 0.54,
+            perfect_radius_factor: 0.26,
+            charge_to_distance_ratio: 0.004,
+            max_charge_ms: 780,
+        },
+        JumpHopDifficulty::Advanced => DifficultyConfig {
+            min_platforms: 20,
+            max_platforms: 24,
+            min_gap: 1.45,
+            max_gap: 2.05,
+            min_width: 0.72,
+            max_width: 0.94,
+            landing_radius_factor: 0.48,
+            perfect_radius_factor: 0.22,
+            charge_to_distance_ratio: 0.004,
+            max_charge_ms: 860,
+        },
+        JumpHopDifficulty::Challenge => DifficultyConfig {
+            min_platforms: 26,
+            max_platforms: 32,
+            min_gap: 1.7,
+            max_gap: 2.35,
+            min_width: 0.66,
+            max_width: 0.88,
+            landing_radius_factor: 0.42,
+            perfect_radius_factor: 0.18,
+            charge_to_distance_ratio: 0.004,
+            max_charge_ms: 950,
+        },
+    }
+}
+
+struct DeterministicRng {
+    state: u64,
+}
+
+impl DeterministicRng {
+    fn new(seed: &str, salt: &str) -> Self {
+        let mut state = 0xcbf2_9ce4_8422_2325u64;
+        for byte in seed.bytes().chain(salt.bytes()) {
+            state ^= u64::from(byte);
+            state = state.wrapping_mul(0x1000_0000_01b3);
+        }
+        Self { state }
+    }
+
+    fn next_u32(&mut self) -> u32 {
+        self.state = self
+            .state
+            .wrapping_mul(6_364_136_223_846_793_005)
+            .wrapping_add(1);
+        (self.state >> 32) as u32
+    }
+
+    fn range_u32(&mut self, min: u32, max: u32) -> u32 {
+        if max <= min {
+            return min;
+        }
+        min + self.next_u32() % (max - min + 1)
+    }
+
+    fn range_f32(&mut self, min: f32, max: f32) -> f32 {
+        if max <= min {
+            return min;
+        }
+        let unit = self.next_u32() as f32 / u32::MAX as f32;
+        min + (max - min) * unit
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        JumpHopDifficulty, JumpHopJumpResultKind, JumpHopRunStatus, apply_jump,
+        generate_jump_hop_path, restart_run, start_run,
+    };
+
+    #[test]
+    fn path_generation_is_seeded_and_uses_difficulty_ranges() {
+        let first = generate_jump_hop_path("seed-a", JumpHopDifficulty::Standard);
+        let second = generate_jump_hop_path("seed-a", JumpHopDifficulty::Standard);
+        let challenge = generate_jump_hop_path("seed-a", JumpHopDifficulty::Challenge);
+
+        assert_eq!(first, second);
+        assert!((16..=18).contains(&first.platforms.len()));
+        assert!((26..=32).contains(&challenge.platforms.len()));
+        assert_eq!(first.platforms.first().unwrap().tile_type.as_str(), "start");
+        assert_eq!(first.platforms.last().unwrap().tile_type.as_str(), "finish");
+    }
+
+    #[test]
+    fn jump_resolution_distinguishes_perfect_hit_and_miss() {
+        let path = generate_jump_hop_path("seed-b", JumpHopDifficulty::Easy);
+        let run = start_run(
+            "run-1".to_string(),
+            "user-1".to_string(),
+            "profile-1".to_string(),
+            path,
+            100,
+        )
+        .expect("run should start");
+        let target = &run.path.platforms[1];
+        let distance = target.x.hypot(target.y);
+        let perfect_charge = (distance / run.path.scoring.charge_to_distance_ratio) as u32;
+
+        let perfect = apply_jump(&run, perfect_charge, 200).expect("jump should resolve");
+        assert_eq!(
+            perfect.last_jump.as_ref().unwrap().result,
+            JumpHopJumpResultKind::Perfect
+        );
+        assert_eq!(perfect.status, JumpHopRunStatus::Playing);
+        assert_eq!(perfect.current_platform_index, 1);
+
+        let hit = apply_jump(&run, perfect_charge.saturating_add(80), 200)
+            .expect("jump should resolve");
+        assert_eq!(
+            hit.last_jump.as_ref().unwrap().result,
+            JumpHopJumpResultKind::Hit
+        );
+
+        let miss = apply_jump(&run, perfect_charge.saturating_add(900), 200)
+            .expect("jump should resolve");
+        assert_eq!(miss.status, JumpHopRunStatus::Failed);
+        assert_eq!(
+            miss.last_jump.as_ref().unwrap().result,
+            JumpHopJumpResultKind::Miss
+        );
+    }
+
+    #[test]
+    fn restart_returns_to_first_platform_and_playing_state() {
+        let path = generate_jump_hop_path("seed-c", JumpHopDifficulty::Easy);
+        let mut run = start_run(
+            "run-1".to_string(),
+            "user-1".to_string(),
+            "profile-1".to_string(),
+            path,
+            100,
+        )
+        .expect("run should start");
+        run.status = JumpHopRunStatus::Failed;
+        run.current_platform_index = 3;
+        run.score = 300;
+        run.combo = 2;
+        run.finished_at_ms = Some(200);
+
+        let restarted = restart_run(&run, "run-2".to_string(), 300).expect("run should restart");
+
+        assert_eq!(restarted.run_id, "run-2");
+        assert_eq!(restarted.status, JumpHopRunStatus::Playing);
+        assert_eq!(restarted.current_platform_index, 0);
+        assert_eq!(restarted.score, 0);
+        assert_eq!(restarted.combo, 0);
+        assert!(restarted.last_jump.is_none());
+        assert_eq!(restarted.started_at_ms, 300);
+        assert!(restarted.finished_at_ms.is_none());
+    }
+}

server-rs/crates/module-jump-hop/src/commands.rs

@@ -0,0 +1,18 @@
+use shared_kernel::normalize_required_string;
+
+use crate::JumpHopDifficulty;
+
+pub fn parse_jump_hop_difficulty(value: &str) -> JumpHopDifficulty {
+    match value.trim().to_ascii_lowercase().as_str() {
+        "easy" | "轻松" => JumpHopDifficulty::Easy,
+        "advanced" | "进阶" => JumpHopDifficulty::Advanced,
+        "challenge" | "挑战" => JumpHopDifficulty::Challenge,
+        _ => JumpHopDifficulty::Standard,
+    }
+}
+
+pub fn normalize_jump_hop_seed(seed: &str, fallback: &str) -> String {
+    normalize_required_string(seed)
+        .or_else(|| normalize_required_string(fallback))
+        .unwrap_or_else(|| "jump-hop".to_string())
+}

server-rs/crates/module-jump-hop/src/domain.rs

@@ -0,0 +1,151 @@
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "spacetime-types")]
+use spacetimedb::SpacetimeType;
+
+pub const JUMP_HOP_SESSION_ID_PREFIX: &str = "jump-hop-session-";
+pub const JUMP_HOP_PROFILE_ID_PREFIX: &str = "jump-hop-profile-";
+pub const JUMP_HOP_WORK_ID_PREFIX: &str = "jump-hop-work-";
+pub const JUMP_HOP_RUN_ID_PREFIX: &str = "jump-hop-run-";
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum JumpHopDifficulty {
+    Easy,
+    Standard,
+    Advanced,
+    Challenge,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum JumpHopTileType {
+    Start,
+    Normal,
+    Target,
+    Finish,
+    Bonus,
+    Accent,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum JumpHopRunStatus {
+    Playing,
+    Failed,
+    Cleared,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum JumpHopJumpResultKind {
+    Miss,
+    Hit,
+    Perfect,
+    Finish,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JumpHopScoring {
+    pub charge_to_distance_ratio: f32,
+    pub max_charge_ms: u32,
+    pub hit_bonus: u32,
+    pub perfect_bonus: u32,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JumpHopPlatform {
+    pub platform_id: String,
+    pub tile_type: JumpHopTileType,
+    pub x: f32,
+    pub y: f32,
+    pub width: f32,
+    pub height: f32,
+    pub landing_radius: f32,
+    pub perfect_radius: f32,
+    pub score_value: u32,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JumpHopPath {
+    pub seed: String,
+    pub difficulty: JumpHopDifficulty,
+    pub platforms: Vec<JumpHopPlatform>,
+    pub finish_index: u32,
+    pub camera_preset: String,
+    pub scoring: JumpHopScoring,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JumpHopLastJump {
+    pub charge_ms: u32,
+    pub jump_distance: f32,
+    pub target_platform_index: u32,
+    pub landed_x: f32,
+    pub landed_y: f32,
+    pub result: JumpHopJumpResultKind,
+}
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JumpHopRunSnapshot {
+    pub run_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub status: JumpHopRunStatus,
+    pub current_platform_index: u32,
+    pub score: u32,
+    pub combo: u32,
+    pub last_jump: Option<JumpHopLastJump>,
+    pub started_at_ms: u64,
+    pub finished_at_ms: Option<u64>,
+    pub path: JumpHopPath,
+}
+
+impl JumpHopDifficulty {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Easy => "easy",
+            Self::Standard => "standard",
+            Self::Advanced => "advanced",
+            Self::Challenge => "challenge",
+        }
+    }
+}
+
+impl JumpHopTileType {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Start => "start",
+            Self::Normal => "normal",
+            Self::Target => "target",
+            Self::Finish => "finish",
+            Self::Bonus => "bonus",
+            Self::Accent => "accent",
+        }
+    }
+}
+
+impl JumpHopRunStatus {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Playing => "playing",
+            Self::Failed => "failed",
+            Self::Cleared => "cleared",
+        }
+    }
+}
+
+impl JumpHopJumpResultKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Miss => "miss",
+            Self::Hit => "hit",
+            Self::Perfect => "perfect",
+            Self::Finish => "finish",
+        }
+    }
+}

server-rs/crates/module-jump-hop/src/errors.rs

@@ -0,0 +1,27 @@
+use std::fmt::{self, Display};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum JumpHopError {
+    MissingRunId,
+    MissingProfileId,
+    MissingOwnerUserId,
+    EmptyPath,
+    RunNotPlaying,
+    NoNextPlatform,
+}
+
+impl Display for JumpHopError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let message = match self {
+            Self::MissingRunId => "缺少 runId",
+            Self::MissingProfileId => "缺少 profileId",
+            Self::MissingOwnerUserId => "owner_user_id 缺失",
+            Self::EmptyPath => "跳一跳路径为空",
+            Self::RunNotPlaying => "当前运行态不是 playing",
+            Self::NoNextPlatform => "没有下一块平台",
+        };
+        write!(f, "{message}")
+    }
+}
+
+impl std::error::Error for JumpHopError {}

server-rs/crates/module-jump-hop/src/events.rs

@@ -0,0 +1,23 @@
+//! 跳一跳领域事件。
+//!
+//! 事件只表达已发生的领域事实，是否持久化、投影或广播由 SpacetimeDB adapter 决定。
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum JumpHopDomainEvent {
+    DraftCompiled {
+        profile_id: String,
+        owner_user_id: String,
+        occurred_at_micros: i64,
+    },
+    WorkPublished {
+        profile_id: String,
+        owner_user_id: String,
+        occurred_at_micros: i64,
+    },
+    RunSettled {
+        run_id: String,
+        owner_user_id: String,
+        status: String,
+        occurred_at_micros: i64,
+    },
+}

server-rs/crates/module-jump-hop/src/lib.rs

@@ -0,0 +1,11 @@
+mod application;
+mod commands;
+mod domain;
+mod errors;
+mod events;
+
+pub use application::*;
+pub use commands::*;
+pub use domain::*;
+pub use errors::*;
+pub use events::*;

server-rs/crates/module-runtime/src/application.rs

@@ -94,6 +94,17 @@ pub fn default_creation_entry_type_snapshots(
             40,
             updated_at_micros,
         ),
+        build_default_creation_entry_type_snapshot(
+            "jump-hop",
+            "跳一跳",
+            "俯视角跳跃闯关",
+            "可创建",
+            "/creation-type-references/puzzle.webp",
+            true,
+            true,
+            45,
+            updated_at_micros,
+        ),
         build_default_creation_entry_type_snapshot(
             "square-hole",
             "方洞",

server-rs/crates/shared-contracts/src/jump_hop.rs

@@ -0,0 +1,401 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopDifficulty {
+    Easy,
+    Standard,
+    Advanced,
+    Challenge,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopStylePreset {
+    MinimalBlocks,
+    PaperToy,
+    NeonGlass,
+    ForestStone,
+    FutureMetal,
+    Custom,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopGenerationStatus {
+    Draft,
+    Generating,
+    Ready,
+    Failed,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopTileType {
+    Start,
+    Normal,
+    Target,
+    Finish,
+    Bonus,
+    Accent,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopActionType {
+    CompileDraft,
+    RegenerateCharacter,
+    RegenerateTiles,
+    UpdateWorkMeta,
+    UpdateDifficulty,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopRunStatus {
+    Playing,
+    Failed,
+    Cleared,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum JumpHopJumpResult {
+    Miss,
+    Hit,
+    Perfect,
+    Finish,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopWorkspaceCreateRequest {
+    pub template_id: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: JumpHopDifficulty,
+    pub style_preset: JumpHopStylePreset,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    #[serde(default)]
+    pub end_mood_prompt: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopActionRequest {
+    pub action_type: JumpHopActionType,
+    #[serde(default)]
+    pub work_title: Option<String>,
+    #[serde(default)]
+    pub work_description: Option<String>,
+    #[serde(default)]
+    pub theme_tags: Option<Vec<String>>,
+    #[serde(default)]
+    pub difficulty: Option<JumpHopDifficulty>,
+    #[serde(default)]
+    pub style_preset: Option<JumpHopStylePreset>,
+    #[serde(default)]
+    pub character_prompt: Option<String>,
+    #[serde(default)]
+    pub tile_prompt: Option<String>,
+    #[serde(default)]
+    pub end_mood_prompt: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopCharacterAsset {
+    pub asset_id: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub generation_provider: String,
+    pub prompt: String,
+    pub width: u32,
+    pub height: u32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopTileAsset {
+    pub tile_type: JumpHopTileType,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub source_atlas_cell: String,
+    pub visual_width: u32,
+    pub visual_height: u32,
+    pub top_surface_radius: f32,
+    pub landing_radius: f32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopScoring {
+    pub charge_to_distance_ratio: f32,
+    pub max_charge_ms: u32,
+    pub hit_bonus: u32,
+    pub perfect_bonus: u32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopPlatform {
+    pub platform_id: String,
+    pub tile_type: JumpHopTileType,
+    pub x: f32,
+    pub y: f32,
+    pub width: f32,
+    pub height: f32,
+    pub landing_radius: f32,
+    pub perfect_radius: f32,
+    pub score_value: u32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopPath {
+    pub seed: String,
+    pub difficulty: JumpHopDifficulty,
+    pub platforms: Vec<JumpHopPlatform>,
+    pub finish_index: u32,
+    pub camera_preset: String,
+    pub scoring: JumpHopScoring,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopLastJump {
+    pub charge_ms: u32,
+    pub jump_distance: f32,
+    pub target_platform_index: u32,
+    pub landed_x: f32,
+    pub landed_y: f32,
+    pub result: JumpHopJumpResult,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopDraftResponse {
+    pub template_id: String,
+    pub template_name: String,
+    #[serde(default)]
+    pub profile_id: Option<String>,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: JumpHopDifficulty,
+    pub style_preset: JumpHopStylePreset,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    #[serde(default)]
+    pub end_mood_prompt: Option<String>,
+    #[serde(default)]
+    pub character_asset: Option<JumpHopCharacterAsset>,
+    #[serde(default)]
+    pub tile_atlas_asset: Option<JumpHopCharacterAsset>,
+    #[serde(default)]
+    pub tile_assets: Vec<JumpHopTileAsset>,
+    #[serde(default)]
+    pub path: Option<JumpHopPath>,
+    #[serde(default)]
+    pub cover_composite: Option<String>,
+    pub generation_status: JumpHopGenerationStatus,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopSessionSnapshotResponse {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub status: JumpHopGenerationStatus,
+    #[serde(default)]
+    pub draft: Option<JumpHopDraftResponse>,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopSessionResponse {
+    pub session: JumpHopSessionSnapshotResponse,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopActionResponse {
+    pub action_type: JumpHopActionType,
+    pub session: JumpHopSessionSnapshotResponse,
+    #[serde(default)]
+    pub work: Option<JumpHopWorkProfileResponse>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopWorkSummaryResponse {
+    pub runtime_kind: String,
+    pub work_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    #[serde(default)]
+    pub source_session_id: Option<String>,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: JumpHopDifficulty,
+    pub style_preset: JumpHopStylePreset,
+    #[serde(default)]
+    pub cover_image_src: Option<String>,
+    pub publication_status: String,
+    pub play_count: u32,
+    pub updated_at: String,
+    #[serde(default)]
+    pub published_at: Option<String>,
+    pub publish_ready: bool,
+    pub generation_status: JumpHopGenerationStatus,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopWorkProfileResponse {
+    #[serde(flatten)]
+    pub summary: JumpHopWorkSummaryResponse,
+    pub draft: JumpHopDraftResponse,
+    pub path: JumpHopPath,
+    pub character_asset: JumpHopCharacterAsset,
+    pub tile_atlas_asset: JumpHopCharacterAsset,
+    pub tile_assets: Vec<JumpHopTileAsset>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopWorksResponse {
+    pub items: Vec<JumpHopWorkSummaryResponse>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopWorkDetailResponse {
+    pub item: JumpHopWorkProfileResponse,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopWorkMutationResponse {
+    pub item: JumpHopWorkProfileResponse,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopGalleryCardResponse {
+    pub public_work_code: String,
+    pub work_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub author_display_name: String,
+    pub work_title: String,
+    pub work_description: String,
+    #[serde(default)]
+    pub cover_image_src: Option<String>,
+    pub theme_tags: Vec<String>,
+    pub difficulty: JumpHopDifficulty,
+    pub style_preset: JumpHopStylePreset,
+    pub publication_status: String,
+    pub play_count: u32,
+    pub updated_at: String,
+    #[serde(default)]
+    pub published_at: Option<String>,
+    pub generation_status: JumpHopGenerationStatus,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopGalleryResponse {
+    pub items: Vec<JumpHopGalleryCardResponse>,
+    pub has_more: bool,
+    #[serde(default)]
+    pub next_cursor: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopGalleryDetailResponse {
+    pub item: JumpHopWorkProfileResponse,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopRuntimeRunSnapshotResponse {
+    pub run_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub status: JumpHopRunStatus,
+    pub current_platform_index: u32,
+    pub score: u32,
+    pub combo: u32,
+    pub path: JumpHopPath,
+    #[serde(default)]
+    pub last_jump: Option<JumpHopLastJump>,
+    pub started_at_ms: u64,
+    #[serde(default)]
+    pub finished_at_ms: Option<u64>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopRunResponse {
+    pub run: JumpHopRuntimeRunSnapshotResponse,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopStartRunRequest {
+    pub profile_id: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopJumpRequest {
+    pub charge_ms: u32,
+    pub client_event_id: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopRestartRunRequest {
+    pub client_action_id: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopJumpResponse {
+    pub run: JumpHopRuntimeRunSnapshotResponse,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn jump_hop_workspace_request_uses_camel_case() {
+        let payload = serde_json::to_value(JumpHopWorkspaceCreateRequest {
+            template_id: "jump-hop".to_string(),
+            work_title: "跳一跳".to_string(),
+            work_description: "俯视角跳跃闯关".to_string(),
+            theme_tags: vec!["休闲".to_string()],
+            difficulty: JumpHopDifficulty::Easy,
+            style_preset: JumpHopStylePreset::MinimalBlocks,
+            character_prompt: "角色".to_string(),
+            tile_prompt: "地块".to_string(),
+            end_mood_prompt: None,
+        })
+        .expect("payload should serialize");
+
+        assert_eq!(payload["templateId"], json!("jump-hop"));
+        assert_eq!(payload["difficulty"], json!("easy"));
+        assert_eq!(payload["stylePreset"], json!("minimal-blocks"));
+    }
+}

server-rs/crates/shared-contracts/src/lib.rs

@@ -12,6 +12,7 @@ pub mod creation_audio;
 pub mod creation_entry_config;
 pub mod creative_agent;
 pub mod hyper3d;
+pub mod jump_hop;
 pub mod llm;
 pub mod match3d_agent;
 pub mod match3d_runtime;

server-rs/crates/spacetime-client/Cargo.toml

@@ -11,6 +11,7 @@ module-big-fish = { workspace = true }
 module-combat = { workspace = true }
 module-custom-world = { workspace = true }
 module-inventory = { workspace = true }
+module-jump-hop = { workspace = true }
 module-match3d = { workspace = true }
 module-npc = { workspace = true }
 module-puzzle = { workspace = true }

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

@@ -38,6 +38,16 @@ pub use mapper::{
     Match3DRunClickRecordInput, Match3DRunRecord, Match3DRunRestartRecordInput,
     Match3DRunStartRecordInput, Match3DRunStopRecordInput, Match3DRunTimeUpRecordInput,
     Match3DTraySlotRecord, Match3DWorkProfileRecord, Match3DWorkUpdateRecordInput,
+    JumpHopActionRequest, JumpHopActionResponse, JumpHopActionType, JumpHopCharacterAsset,
+    JumpHopDifficulty, JumpHopDraftResponse, JumpHopGalleryCardResponse,
+    JumpHopGalleryDetailResponse, JumpHopGalleryResponse, JumpHopGenerationStatus,
+    JumpHopJumpRequest, JumpHopJumpResponse, JumpHopJumpResult, JumpHopLastJump, JumpHopPath,
+    JumpHopPlatform, JumpHopRestartRunRequest, JumpHopRunResponse, JumpHopRunStatus,
+    JumpHopRuntimeRunSnapshotResponse, JumpHopScoring, JumpHopSessionResponse,
+    JumpHopSessionSnapshotResponse, JumpHopStartRunRequest, JumpHopStylePreset, JumpHopTileAsset,
+    JumpHopTileType, JumpHopWorkDetailResponse, JumpHopWorkMutationResponse,
+    JumpHopWorkProfileResponse, JumpHopWorkSummaryResponse, JumpHopWorksResponse,
+    JumpHopWorkspaceCreateRequest,
     NpcBattleInteractionRecord, NpcInteractionRecord, NpcStateRecord,
     PuzzleAgentMessageFinalizeRecordInput, PuzzleAgentMessageRecord,
     PuzzleAgentMessageSubmitRecordInput, PuzzleAgentSessionCreateRecordInput,
@@ -86,6 +96,7 @@ pub mod big_fish;
 pub mod combat;
 pub mod custom_world;
 pub mod inventory;
+pub mod jump_hop;
 pub mod match3d;
 pub mod npc;
 pub mod puzzle;
@@ -551,6 +562,7 @@ impl SpacetimeClient {
         let mut subscriptions = Vec::new();
         for query in [
             "SELECT * FROM puzzle_gallery_card_view",
+            "SELECT * FROM jump_hop_gallery_card_view",
             "SELECT * FROM custom_world_gallery_entry",
             "SELECT * FROM match_3_d_gallery_view",
             "SELECT * FROM square_hole_gallery_view",
@@ -565,6 +577,7 @@ impl SpacetimeClient {
 
         for query in [
             "SELECT * FROM public_work_play_daily_stat WHERE source_type = 'puzzle'",
+            "SELECT * FROM public_work_play_daily_stat WHERE source_type = 'jump-hop'",
             "SELECT * FROM public_work_play_daily_stat WHERE source_type = 'custom-world'",
             "SELECT * FROM public_work_play_daily_stat WHERE source_type = 'match3d'",
             "SELECT * FROM public_work_play_daily_stat WHERE source_type = 'square-hole'",

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

@@ -9,6 +9,7 @@ mod combat;
 mod common;
 mod custom_world;
 mod inventory;
+mod jump_hop;
 mod match3d;
 mod npc;
 mod puzzle;
@@ -35,6 +36,18 @@ pub use self::combat::{
     BarkBattleDraftConfigRecord, BarkBattleRunRecord, BarkBattleRuntimeConfigRecord,
     ResolveCombatActionRecord,
 };
+pub use self::jump_hop::{
+    JumpHopActionRequest, JumpHopActionResponse, JumpHopActionType, JumpHopCharacterAsset,
+    JumpHopDifficulty, JumpHopDraftResponse, JumpHopGalleryCardResponse,
+    JumpHopGalleryDetailResponse, JumpHopGalleryResponse, JumpHopGenerationStatus,
+    JumpHopJumpRequest, JumpHopJumpResponse, JumpHopJumpResult, JumpHopLastJump, JumpHopPath,
+    JumpHopPlatform, JumpHopRestartRunRequest, JumpHopRunResponse, JumpHopRunStatus,
+    JumpHopRuntimeRunSnapshotResponse, JumpHopScoring, JumpHopSessionResponse,
+    JumpHopSessionSnapshotResponse, JumpHopStartRunRequest, JumpHopStylePreset, JumpHopTileAsset,
+    JumpHopTileType, JumpHopWorkDetailResponse, JumpHopWorkMutationResponse,
+    JumpHopWorkProfileResponse, JumpHopWorkSummaryResponse, JumpHopWorksResponse,
+    JumpHopWorkspaceCreateRequest,
+};
 pub use self::common::{
     BigFishAgentMessageRecord, BigFishAnchorItemRecord, BigFishAnchorPackRecord,
     BigFishBackgroundBlueprintRecord, BigFishDraftCompileRecordInput,
@@ -139,6 +152,11 @@ pub(crate) use self::inventory::{
     map_runtime_inventory_state_procedure_result, map_runtime_item_reward_item_snapshot,
     map_runtime_item_reward_item_snapshot_back,
 };
+pub(crate) use self::jump_hop::{
+    map_jump_hop_agent_session_procedure_result, map_jump_hop_gallery_card_view_row,
+    map_jump_hop_run_procedure_result, map_jump_hop_work_procedure_result,
+    map_jump_hop_works_procedure_result,
+};
 pub(crate) use self::match3d::{
     map_match3d_agent_session_procedure_result, map_match3d_click_item_procedure_result,
     map_match3d_gallery_view_row, map_match3d_run_procedure_result,
@@ -158,9 +176,9 @@ pub(crate) use self::runtime::{
     build_creation_entry_config_record_from_rows, map_creation_entry_config_procedure_result,
     map_runtime_setting_procedure_result, map_runtime_snapshot_delete_procedure_result,
     map_runtime_snapshot_procedure_result, map_runtime_snapshot_required_procedure_result,
-    map_runtime_tracking_event_procedure_result, map_runtime_tracking_scope_kind,
-    map_runtime_tracking_scope_kind_back, parse_json_array, parse_json_string_array,
-    parse_json_value, parse_supported_actions_json,
+    map_runtime_tracking_event_batch_procedure_result, map_runtime_tracking_event_procedure_result,
+    map_runtime_tracking_scope_kind, map_runtime_tracking_scope_kind_back, parse_json_array,
+    parse_json_string_array, parse_json_value, parse_supported_actions_json,
 };
 pub(crate) use self::runtime_profile::{
     map_analytics_metric_query_procedure_result, map_runtime_profile_dashboard_procedure_result,

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

@@ -0,0 +1,344 @@
+use super::*;
+pub use shared_contracts::jump_hop::{
+    JumpHopActionRequest, JumpHopActionResponse, JumpHopActionType, JumpHopCharacterAsset,
+    JumpHopDifficulty, JumpHopDraftResponse, JumpHopGalleryCardResponse,
+    JumpHopGalleryDetailResponse, JumpHopGalleryResponse, JumpHopGenerationStatus,
+    JumpHopJumpRequest, JumpHopJumpResponse, JumpHopJumpResult, JumpHopLastJump, JumpHopPath,
+    JumpHopPlatform, JumpHopRestartRunRequest, JumpHopRunResponse, JumpHopRunStatus,
+    JumpHopRuntimeRunSnapshotResponse, JumpHopScoring, JumpHopSessionResponse,
+    JumpHopSessionSnapshotResponse, JumpHopStartRunRequest, JumpHopStylePreset, JumpHopTileAsset,
+    JumpHopTileType, JumpHopWorkDetailResponse, JumpHopWorkMutationResponse,
+    JumpHopWorkProfileResponse, JumpHopWorkSummaryResponse, JumpHopWorksResponse,
+    JumpHopWorkspaceCreateRequest,
+};
+
+pub(crate) fn map_jump_hop_agent_session_procedure_result(
+    result: JumpHopAgentSessionProcedureResult,
+) -> Result<JumpHopSessionSnapshotResponse, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    let session = result
+        .session
+        .ok_or_else(|| SpacetimeClientError::missing_snapshot("jump hop agent session 快照"))?;
+    Ok(map_jump_hop_session_snapshot(session))
+}
+
+pub(crate) fn map_jump_hop_work_procedure_result(
+    result: JumpHopWorkProcedureResult,
+) -> Result<JumpHopWorkProfileResponse, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    let work = result
+        .work
+        .ok_or_else(|| SpacetimeClientError::missing_snapshot("jump hop work 快照"))?;
+    map_jump_hop_work_snapshot(work)
+}
+
+pub(crate) fn map_jump_hop_works_procedure_result(
+    result: JumpHopWorksProcedureResult,
+) -> Result<Vec<JumpHopWorkProfileResponse>, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    result
+        .items
+        .into_iter()
+        .map(map_jump_hop_work_snapshot)
+        .collect()
+}
+
+pub(crate) fn map_jump_hop_run_procedure_result(
+    result: JumpHopRunProcedureResult,
+) -> Result<JumpHopRuntimeRunSnapshotResponse, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+    let run = result
+        .run
+        .ok_or_else(|| SpacetimeClientError::missing_snapshot("jump hop run 快照"))?;
+    Ok(map_jump_hop_run_snapshot(run))
+}
+
+pub(crate) fn map_jump_hop_gallery_card_view_row(
+    row: JumpHopGalleryCardViewRow,
+) -> JumpHopGalleryCardResponse {
+    JumpHopGalleryCardResponse {
+        public_work_code: row.public_work_code,
+        work_id: row.work_id,
+        profile_id: row.profile_id,
+        owner_user_id: row.owner_user_id,
+        author_display_name: row.author_display_name,
+        work_title: row.work_title,
+        work_description: row.work_description,
+        cover_image_src: empty_string_to_none(row.cover_image_src),
+        theme_tags: row.theme_tags,
+        difficulty: parse_difficulty(&row.difficulty),
+        style_preset: parse_style_preset(&row.style_preset),
+        publication_status: normalize_publication_status(&row.publication_status).to_string(),
+        play_count: row.play_count,
+        updated_at: format_timestamp_micros(row.updated_at_micros),
+        published_at: row.published_at_micros.map(format_timestamp_micros),
+        generation_status: parse_generation_status(&row.generation_status),
+    }
+}
+
+fn map_jump_hop_session_snapshot(
+    snapshot: JumpHopAgentSessionSnapshot,
+) -> JumpHopSessionSnapshotResponse {
+    JumpHopSessionSnapshotResponse {
+        session_id: snapshot.session_id,
+        owner_user_id: snapshot.owner_user_id,
+        status: snapshot
+            .draft
+            .as_ref()
+            .map(|draft| parse_generation_status(&draft.generation_status))
+            .unwrap_or(JumpHopGenerationStatus::Draft),
+        draft: snapshot.draft.map(map_jump_hop_draft_snapshot),
+        created_at: format_timestamp_micros(snapshot.created_at_micros),
+        updated_at: format_timestamp_micros(snapshot.updated_at_micros),
+    }
+}
+
+fn map_jump_hop_work_snapshot(
+    snapshot: JumpHopWorkSnapshot,
+) -> Result<JumpHopWorkProfileResponse, SpacetimeClientError> {
+    let draft = JumpHopDraftResponse {
+        template_id: "jump-hop".to_string(),
+        template_name: "跳一跳".to_string(),
+        profile_id: Some(snapshot.profile_id.clone()),
+        work_title: snapshot.work_title.clone(),
+        work_description: snapshot.work_description.clone(),
+        theme_tags: snapshot.theme_tags.clone(),
+        difficulty: parse_difficulty(&snapshot.difficulty),
+        style_preset: parse_style_preset(&snapshot.style_preset),
+        character_prompt: snapshot.character_prompt.clone(),
+        tile_prompt: snapshot.tile_prompt.clone(),
+        end_mood_prompt: snapshot.end_mood_prompt.clone(),
+        character_asset: snapshot.character_asset.clone().map(map_character_asset),
+        tile_atlas_asset: snapshot.tile_atlas_asset.clone().map(map_character_asset),
+        tile_assets: snapshot
+            .tile_assets
+            .clone()
+            .into_iter()
+            .map(map_tile_asset)
+            .collect(),
+        path: Some(map_jump_hop_path(snapshot.path.clone())),
+        cover_composite: snapshot.cover_composite.clone(),
+        generation_status: parse_generation_status(&snapshot.generation_status),
+    };
+    let character_asset = draft
+        .character_asset
+        .clone()
+        .ok_or_else(|| SpacetimeClientError::missing_snapshot("jump hop character asset"))?;
+    let tile_atlas_asset = draft
+        .tile_atlas_asset
+        .clone()
+        .ok_or_else(|| SpacetimeClientError::missing_snapshot("jump hop tile atlas asset"))?;
+    Ok(JumpHopWorkProfileResponse {
+        summary: JumpHopWorkSummaryResponse {
+            runtime_kind: "jump-hop".to_string(),
+            work_id: snapshot.work_id,
+            profile_id: snapshot.profile_id,
+            owner_user_id: snapshot.owner_user_id,
+            source_session_id: empty_string_to_none(snapshot.source_session_id),
+            work_title: snapshot.work_title,
+            work_description: snapshot.work_description,
+            theme_tags: snapshot.theme_tags,
+            difficulty: parse_difficulty(&snapshot.difficulty),
+            style_preset: parse_style_preset(&snapshot.style_preset),
+            cover_image_src: empty_string_to_none(snapshot.cover_image_src),
+            publication_status: normalize_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,
+            generation_status: parse_generation_status(&snapshot.generation_status),
+        },
+        draft,
+        path: map_jump_hop_path(snapshot.path),
+        character_asset,
+        tile_atlas_asset,
+        tile_assets: snapshot.tile_assets.into_iter().map(map_tile_asset).collect(),
+    })
+}
+
+fn map_jump_hop_draft_snapshot(snapshot: JumpHopDraftSnapshot) -> JumpHopDraftResponse {
+    JumpHopDraftResponse {
+        template_id: snapshot.template_id,
+        template_name: snapshot.template_name,
+        profile_id: snapshot.profile_id,
+        work_title: snapshot.work_title,
+        work_description: snapshot.work_description,
+        theme_tags: snapshot.theme_tags,
+        difficulty: parse_difficulty(&snapshot.difficulty),
+        style_preset: parse_style_preset(&snapshot.style_preset),
+        character_prompt: snapshot.character_prompt,
+        tile_prompt: snapshot.tile_prompt,
+        end_mood_prompt: snapshot.end_mood_prompt,
+        character_asset: snapshot.character_asset.map(map_character_asset),
+        tile_atlas_asset: snapshot.tile_atlas_asset.map(map_character_asset),
+        tile_assets: snapshot.tile_assets.into_iter().map(map_tile_asset).collect(),
+        path: snapshot.path.map(map_jump_hop_path),
+        cover_composite: snapshot.cover_composite,
+        generation_status: parse_generation_status(&snapshot.generation_status),
+    }
+}
+
+fn map_character_asset(snapshot: JumpHopCharacterAssetSnapshot) -> JumpHopCharacterAsset {
+    JumpHopCharacterAsset {
+        asset_id: snapshot.asset_id,
+        image_src: snapshot.image_src,
+        image_object_key: snapshot.image_object_key,
+        asset_object_id: snapshot.asset_object_id,
+        generation_provider: snapshot.generation_provider,
+        prompt: snapshot.prompt,
+        width: snapshot.width,
+        height: snapshot.height,
+    }
+}
+
+fn map_tile_asset(snapshot: JumpHopTileAssetSnapshot) -> JumpHopTileAsset {
+    JumpHopTileAsset {
+        tile_type: parse_tile_type(&snapshot.tile_type),
+        image_src: snapshot.image_src,
+        image_object_key: snapshot.image_object_key,
+        asset_object_id: snapshot.asset_object_id,
+        source_atlas_cell: snapshot.source_atlas_cell,
+        visual_width: snapshot.visual_width,
+        visual_height: snapshot.visual_height,
+        top_surface_radius: snapshot.top_surface_radius,
+        landing_radius: snapshot.landing_radius,
+    }
+}
+
+fn map_jump_hop_path(snapshot: crate::module_bindings::JumpHopPath) -> JumpHopPath {
+    JumpHopPath {
+        seed: snapshot.seed,
+        difficulty: parse_domain_difficulty(snapshot.difficulty),
+        platforms: snapshot
+            .platforms
+            .into_iter()
+            .map(|platform| JumpHopPlatform {
+                platform_id: platform.platform_id,
+                tile_type: parse_domain_tile_type(platform.tile_type),
+                x: platform.x,
+                y: platform.y,
+                width: platform.width,
+                height: platform.height,
+                landing_radius: platform.landing_radius,
+                perfect_radius: platform.perfect_radius,
+                score_value: platform.score_value,
+            })
+            .collect(),
+        finish_index: snapshot.finish_index,
+        camera_preset: snapshot.camera_preset,
+        scoring: JumpHopScoring {
+            charge_to_distance_ratio: snapshot.scoring.charge_to_distance_ratio,
+            max_charge_ms: snapshot.scoring.max_charge_ms,
+            hit_bonus: snapshot.scoring.hit_bonus,
+            perfect_bonus: snapshot.scoring.perfect_bonus,
+        },
+    }
+}
+
+fn map_jump_hop_run_snapshot(snapshot: JumpHopRunSnapshot) -> JumpHopRuntimeRunSnapshotResponse {
+    JumpHopRuntimeRunSnapshotResponse {
+        run_id: snapshot.run_id,
+        profile_id: snapshot.profile_id,
+        owner_user_id: snapshot.owner_user_id,
+        status: match snapshot.status {
+            crate::module_bindings::JumpHopRunStatus::Failed => JumpHopRunStatus::Failed,
+            crate::module_bindings::JumpHopRunStatus::Cleared => JumpHopRunStatus::Cleared,
+            crate::module_bindings::JumpHopRunStatus::Playing => JumpHopRunStatus::Playing,
+        },
+        current_platform_index: snapshot.current_platform_index,
+        score: snapshot.score,
+        combo: snapshot.combo,
+        path: map_jump_hop_path(snapshot.path),
+        last_jump: snapshot.last_jump.map(|jump| JumpHopLastJump {
+            charge_ms: jump.charge_ms,
+            jump_distance: jump.jump_distance,
+            target_platform_index: jump.target_platform_index,
+            landed_x: jump.landed_x,
+            landed_y: jump.landed_y,
+            result: match jump.result {
+                crate::module_bindings::JumpHopJumpResultKind::Miss => JumpHopJumpResult::Miss,
+                crate::module_bindings::JumpHopJumpResultKind::Hit => JumpHopJumpResult::Hit,
+                crate::module_bindings::JumpHopJumpResultKind::Finish => JumpHopJumpResult::Finish,
+                crate::module_bindings::JumpHopJumpResultKind::Perfect => JumpHopJumpResult::Perfect,
+            },
+        }),
+        started_at_ms: snapshot.started_at_ms,
+        finished_at_ms: snapshot.finished_at_ms,
+    }
+}
+
+fn parse_difficulty(value: &str) -> JumpHopDifficulty {
+    match value {
+        "easy" => JumpHopDifficulty::Easy,
+        "advanced" => JumpHopDifficulty::Advanced,
+        "challenge" => JumpHopDifficulty::Challenge,
+        _ => JumpHopDifficulty::Standard,
+    }
+}
+
+fn parse_domain_difficulty(value: crate::module_bindings::JumpHopDifficulty) -> JumpHopDifficulty {
+    match value {
+        crate::module_bindings::JumpHopDifficulty::Easy => JumpHopDifficulty::Easy,
+        crate::module_bindings::JumpHopDifficulty::Advanced => JumpHopDifficulty::Advanced,
+        crate::module_bindings::JumpHopDifficulty::Challenge => JumpHopDifficulty::Challenge,
+        crate::module_bindings::JumpHopDifficulty::Standard => JumpHopDifficulty::Standard,
+    }
+}
+
+fn parse_style_preset(value: &str) -> JumpHopStylePreset {
+    match value {
+        "paper-toy" => JumpHopStylePreset::PaperToy,
+        "neon-glass" => JumpHopStylePreset::NeonGlass,
+        "forest-stone" => JumpHopStylePreset::ForestStone,
+        "future-metal" => JumpHopStylePreset::FutureMetal,
+        "custom" => JumpHopStylePreset::Custom,
+        _ => JumpHopStylePreset::MinimalBlocks,
+    }
+}
+
+fn parse_tile_type(value: &str) -> JumpHopTileType {
+    match value {
+        "start" => JumpHopTileType::Start,
+        "target" => JumpHopTileType::Target,
+        "finish" => JumpHopTileType::Finish,
+        "bonus" => JumpHopTileType::Bonus,
+        "accent" => JumpHopTileType::Accent,
+        _ => JumpHopTileType::Normal,
+    }
+}
+
+fn parse_domain_tile_type(value: crate::module_bindings::JumpHopTileType) -> JumpHopTileType {
+    match value {
+        crate::module_bindings::JumpHopTileType::Start => JumpHopTileType::Start,
+        crate::module_bindings::JumpHopTileType::Target => JumpHopTileType::Target,
+        crate::module_bindings::JumpHopTileType::Finish => JumpHopTileType::Finish,
+        crate::module_bindings::JumpHopTileType::Bonus => JumpHopTileType::Bonus,
+        crate::module_bindings::JumpHopTileType::Accent => JumpHopTileType::Accent,
+        crate::module_bindings::JumpHopTileType::Normal => JumpHopTileType::Normal,
+    }
+}
+
+fn parse_generation_status(value: &str) -> JumpHopGenerationStatus {
+    match value {
+        "generating" => JumpHopGenerationStatus::Generating,
+        "ready" => JumpHopGenerationStatus::Ready,
+        "failed" => JumpHopGenerationStatus::Failed,
+        _ => JumpHopGenerationStatus::Draft,
+    }
+}
+
+fn normalize_publication_status(value: &str) -> &str {
+    match value {
+        "Published" | "published" => "published",
+        _ => "draft",
+    }
+}

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

@@ -213,6 +213,16 @@ pub(crate) fn map_runtime_tracking_event_procedure_result(
     Ok(())
 }
 
+pub(crate) fn map_runtime_tracking_event_batch_procedure_result(
+    result: RuntimeTrackingEventBatchProcedureResult,
+) -> Result<u32, SpacetimeClientError> {
+    if !result.ok {
+        return Err(SpacetimeClientError::procedure_failed(result.error_message));
+    }
+
+    Ok(result.accepted_count)
+}
+
 pub(crate) fn map_runtime_snapshot_procedure_result(
     result: RuntimeSnapshotProcedureResult,
 ) -> Result<Option<RuntimeSnapshotRecord>, SpacetimeClientError> {

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

@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 2.2.0 (commit eb11e2f5c41dce6979715ad407996270d61329f6).
+// This was generated using spacetimedb cli version 2.1.0 (commit 6981f48b4bc1a71c8dd9bdfe5a2c343f6370243d).
 
 #![allow(unused, clippy::all)]
 use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
@@ -199,6 +199,7 @@ pub mod click_match_3_d_item_procedure;
 pub mod combat_outcome_type;
 pub mod compile_big_fish_draft_procedure;
 pub mod compile_custom_world_published_profile_procedure;
+pub mod compile_jump_hop_draft_procedure;
 pub mod compile_match_3_d_draft_procedure;
 pub mod compile_puzzle_agent_draft_procedure;
 pub mod compile_square_hole_draft_procedure;
@@ -218,6 +219,7 @@ pub mod create_battle_state_and_return_procedure;
 pub mod create_battle_state_reducer;
 pub mod create_big_fish_session_procedure;
 pub mod create_custom_world_agent_session_procedure;
+pub mod create_jump_hop_agent_session_procedure;
 pub mod create_match_3_d_agent_session_procedure;
 pub mod create_profile_recharge_order_and_return_procedure;
 pub mod create_puzzle_agent_session_procedure;
@@ -349,6 +351,9 @@ pub mod get_custom_world_agent_session_procedure;
 pub mod get_custom_world_gallery_detail_by_code_procedure;
 pub mod get_custom_world_gallery_detail_procedure;
 pub mod get_custom_world_library_detail_procedure;
+pub mod get_jump_hop_agent_session_procedure;
+pub mod get_jump_hop_run_procedure;
+pub mod get_jump_hop_work_profile_procedure;
 pub mod get_match_3_d_agent_session_procedure;
 pub mod get_match_3_d_run_procedure;
 pub mod get_match_3_d_work_detail_procedure;
@@ -393,11 +398,55 @@ pub mod inventory_mutation_type;
 pub mod inventory_slot_snapshot_type;
 pub mod inventory_slot_table;
 pub mod inventory_slot_type;
+pub mod jump_hop_agent_session_create_input_type;
+pub mod jump_hop_agent_session_get_input_type;
+pub mod jump_hop_agent_session_procedure_result_type;
+pub mod jump_hop_agent_session_row_type;
+pub mod jump_hop_agent_session_snapshot_type;
+pub mod jump_hop_agent_session_table;
+pub mod jump_hop_character_asset_snapshot_type;
+pub mod jump_hop_creator_config_snapshot_type;
+pub mod jump_hop_difficulty_type;
+pub mod jump_hop_draft_compile_input_type;
+pub mod jump_hop_draft_snapshot_type;
+pub mod jump_hop_event_row_type;
+pub mod jump_hop_event_table;
+pub mod jump_hop_gallery_card_view_row_type;
+pub mod jump_hop_gallery_card_view_table;
+pub mod jump_hop_gallery_view_row_type;
+pub mod jump_hop_gallery_view_table;
+pub mod jump_hop_jump_procedure;
+pub mod jump_hop_jump_result_kind_type;
+pub mod jump_hop_last_jump_type;
+pub mod jump_hop_path_type;
+pub mod jump_hop_platform_type;
+pub mod jump_hop_run_get_input_type;
+pub mod jump_hop_run_jump_input_type;
+pub mod jump_hop_run_procedure_result_type;
+pub mod jump_hop_run_restart_input_type;
+pub mod jump_hop_run_snapshot_type;
+pub mod jump_hop_run_start_input_type;
+pub mod jump_hop_run_status_type;
+pub mod jump_hop_runtime_run_row_type;
+pub mod jump_hop_runtime_run_table;
+pub mod jump_hop_scoring_type;
+pub mod jump_hop_tile_asset_snapshot_type;
+pub mod jump_hop_tile_type_type;
+pub mod jump_hop_work_get_input_type;
+pub mod jump_hop_work_procedure_result_type;
+pub mod jump_hop_work_profile_row_type;
+pub mod jump_hop_work_profile_table;
+pub mod jump_hop_work_publish_input_type;
+pub mod jump_hop_work_snapshot_type;
+pub mod jump_hop_work_update_input_type;
+pub mod jump_hop_works_list_input_type;
+pub mod jump_hop_works_procedure_result_type;
 pub mod list_asset_history_and_return_procedure;
 pub mod list_big_fish_works_procedure;
 pub mod list_custom_world_gallery_entries_procedure;
 pub mod list_custom_world_profiles_procedure;
 pub mod list_custom_world_works_procedure;
+pub mod list_jump_hop_works_procedure;
 pub mod list_match_3_d_works_procedure;
 pub mod list_platform_browse_history_procedure;
 pub mod list_profile_save_archives_procedure;
@@ -508,6 +557,7 @@ pub mod publish_big_fish_game_procedure;
 pub mod publish_custom_world_profile_and_return_procedure;
 pub mod publish_custom_world_profile_reducer;
 pub mod publish_custom_world_world_procedure;
+pub mod publish_jump_hop_work_procedure;
 pub mod publish_match_3_d_work_procedure;
 pub mod publish_puzzle_work_procedure;
 pub mod publish_square_hole_work_procedure;
@@ -649,6 +699,7 @@ pub mod resolve_npc_social_action_input_type;
 pub mod resolve_npc_social_action_reducer;
 pub mod resolve_treasure_interaction_and_return_procedure;
 pub mod resolve_treasure_interaction_reducer;
+pub mod restart_jump_hop_run_procedure;
 pub mod restart_match_3_d_run_procedure;
 pub mod restart_square_hole_run_procedure;
 pub mod resume_profile_save_archive_and_return_procedure;
@@ -820,6 +871,7 @@ pub mod start_ai_task_reducer;
 pub mod start_ai_task_stage_reducer;
 pub mod start_bark_battle_run_procedure;
 pub mod start_big_fish_run_procedure;
+pub mod start_jump_hop_run_procedure;
 pub mod start_match_3_d_run_procedure;
 pub mod start_puzzle_run_procedure;
 pub mod start_square_hole_run_procedure;
@@ -864,6 +916,7 @@ pub mod unequip_inventory_item_input_type;
 pub mod unpublish_custom_world_profile_and_return_procedure;
 pub mod unpublish_custom_world_profile_reducer;
 pub mod update_bark_battle_draft_config_procedure;
+pub mod update_jump_hop_work_procedure;
 pub mod update_match_3_d_work_procedure;
 pub mod update_puzzle_run_pause_procedure;
 pub mod update_puzzle_work_procedure;
@@ -1125,6 +1178,7 @@ pub use click_match_3_d_item_procedure::click_match_3_d_item;
 pub use combat_outcome_type::CombatOutcome;
 pub use compile_big_fish_draft_procedure::compile_big_fish_draft;
 pub use compile_custom_world_published_profile_procedure::compile_custom_world_published_profile;
+pub use compile_jump_hop_draft_procedure::compile_jump_hop_draft;
 pub use compile_match_3_d_draft_procedure::compile_match_3_d_draft;
 pub use compile_puzzle_agent_draft_procedure::compile_puzzle_agent_draft;
 pub use compile_square_hole_draft_procedure::compile_square_hole_draft;
@@ -1144,6 +1198,7 @@ pub use create_battle_state_and_return_procedure::create_battle_state_and_return
 pub use create_battle_state_reducer::create_battle_state;
 pub use create_big_fish_session_procedure::create_big_fish_session;
 pub use create_custom_world_agent_session_procedure::create_custom_world_agent_session;
+pub use create_jump_hop_agent_session_procedure::create_jump_hop_agent_session;
 pub use create_match_3_d_agent_session_procedure::create_match_3_d_agent_session;
 pub use create_profile_recharge_order_and_return_procedure::create_profile_recharge_order_and_return;
 pub use create_puzzle_agent_session_procedure::create_puzzle_agent_session;
@@ -1275,6 +1330,9 @@ pub use get_custom_world_agent_session_procedure::get_custom_world_agent_session
 pub use get_custom_world_gallery_detail_by_code_procedure::get_custom_world_gallery_detail_by_code;
 pub use get_custom_world_gallery_detail_procedure::get_custom_world_gallery_detail;
 pub use get_custom_world_library_detail_procedure::get_custom_world_library_detail;
+pub use get_jump_hop_agent_session_procedure::get_jump_hop_agent_session;
+pub use get_jump_hop_run_procedure::get_jump_hop_run;
+pub use get_jump_hop_work_profile_procedure::get_jump_hop_work_profile;
 pub use get_match_3_d_agent_session_procedure::get_match_3_d_agent_session;
 pub use get_match_3_d_run_procedure::get_match_3_d_run;
 pub use get_match_3_d_work_detail_procedure::get_match_3_d_work_detail;
@@ -1319,11 +1377,55 @@ pub use inventory_mutation_type::InventoryMutation;
 pub use inventory_slot_snapshot_type::InventorySlotSnapshot;
 pub use inventory_slot_table::*;
 pub use inventory_slot_type::InventorySlot;
+pub use jump_hop_agent_session_create_input_type::JumpHopAgentSessionCreateInput;
+pub use jump_hop_agent_session_get_input_type::JumpHopAgentSessionGetInput;
+pub use jump_hop_agent_session_procedure_result_type::JumpHopAgentSessionProcedureResult;
+pub use jump_hop_agent_session_row_type::JumpHopAgentSessionRow;
+pub use jump_hop_agent_session_snapshot_type::JumpHopAgentSessionSnapshot;
+pub use jump_hop_agent_session_table::*;
+pub use jump_hop_character_asset_snapshot_type::JumpHopCharacterAssetSnapshot;
+pub use jump_hop_creator_config_snapshot_type::JumpHopCreatorConfigSnapshot;
+pub use jump_hop_difficulty_type::JumpHopDifficulty;
+pub use jump_hop_draft_compile_input_type::JumpHopDraftCompileInput;
+pub use jump_hop_draft_snapshot_type::JumpHopDraftSnapshot;
+pub use jump_hop_event_row_type::JumpHopEventRow;
+pub use jump_hop_event_table::*;
+pub use jump_hop_gallery_card_view_row_type::JumpHopGalleryCardViewRow;
+pub use jump_hop_gallery_card_view_table::*;
+pub use jump_hop_gallery_view_row_type::JumpHopGalleryViewRow;
+pub use jump_hop_gallery_view_table::*;
+pub use jump_hop_jump_procedure::jump_hop_jump;
+pub use jump_hop_jump_result_kind_type::JumpHopJumpResultKind;
+pub use jump_hop_last_jump_type::JumpHopLastJump;
+pub use jump_hop_path_type::JumpHopPath;
+pub use jump_hop_platform_type::JumpHopPlatform;
+pub use jump_hop_run_get_input_type::JumpHopRunGetInput;
+pub use jump_hop_run_jump_input_type::JumpHopRunJumpInput;
+pub use jump_hop_run_procedure_result_type::JumpHopRunProcedureResult;
+pub use jump_hop_run_restart_input_type::JumpHopRunRestartInput;
+pub use jump_hop_run_snapshot_type::JumpHopRunSnapshot;
+pub use jump_hop_run_start_input_type::JumpHopRunStartInput;
+pub use jump_hop_run_status_type::JumpHopRunStatus;
+pub use jump_hop_runtime_run_row_type::JumpHopRuntimeRunRow;
+pub use jump_hop_runtime_run_table::*;
+pub use jump_hop_scoring_type::JumpHopScoring;
+pub use jump_hop_tile_asset_snapshot_type::JumpHopTileAssetSnapshot;
+pub use jump_hop_tile_type_type::JumpHopTileType;
+pub use jump_hop_work_get_input_type::JumpHopWorkGetInput;
+pub use jump_hop_work_procedure_result_type::JumpHopWorkProcedureResult;
+pub use jump_hop_work_profile_row_type::JumpHopWorkProfileRow;
+pub use jump_hop_work_profile_table::*;
+pub use jump_hop_work_publish_input_type::JumpHopWorkPublishInput;
+pub use jump_hop_work_snapshot_type::JumpHopWorkSnapshot;
+pub use jump_hop_work_update_input_type::JumpHopWorkUpdateInput;
+pub use jump_hop_works_list_input_type::JumpHopWorksListInput;
+pub use jump_hop_works_procedure_result_type::JumpHopWorksProcedureResult;
 pub use list_asset_history_and_return_procedure::list_asset_history_and_return;
 pub use list_big_fish_works_procedure::list_big_fish_works;
 pub use list_custom_world_gallery_entries_procedure::list_custom_world_gallery_entries;
 pub use list_custom_world_profiles_procedure::list_custom_world_profiles;
 pub use list_custom_world_works_procedure::list_custom_world_works;
+pub use list_jump_hop_works_procedure::list_jump_hop_works;
 pub use list_match_3_d_works_procedure::list_match_3_d_works;
 pub use list_platform_browse_history_procedure::list_platform_browse_history;
 pub use list_profile_save_archives_procedure::list_profile_save_archives;
@@ -1434,6 +1536,7 @@ pub use publish_big_fish_game_procedure::publish_big_fish_game;
 pub use publish_custom_world_profile_and_return_procedure::publish_custom_world_profile_and_return;
 pub use publish_custom_world_profile_reducer::publish_custom_world_profile;
 pub use publish_custom_world_world_procedure::publish_custom_world_world;
+pub use publish_jump_hop_work_procedure::publish_jump_hop_work;
 pub use publish_match_3_d_work_procedure::publish_match_3_d_work;
 pub use publish_puzzle_work_procedure::publish_puzzle_work;
 pub use publish_square_hole_work_procedure::publish_square_hole_work;
@@ -1575,6 +1678,7 @@ pub use resolve_npc_social_action_input_type::ResolveNpcSocialActionInput;
 pub use resolve_npc_social_action_reducer::resolve_npc_social_action;
 pub use resolve_treasure_interaction_and_return_procedure::resolve_treasure_interaction_and_return;
 pub use resolve_treasure_interaction_reducer::resolve_treasure_interaction;
+pub use restart_jump_hop_run_procedure::restart_jump_hop_run;
 pub use restart_match_3_d_run_procedure::restart_match_3_d_run;
 pub use restart_square_hole_run_procedure::restart_square_hole_run;
 pub use resume_profile_save_archive_and_return_procedure::resume_profile_save_archive_and_return;
@@ -1746,6 +1850,7 @@ pub use start_ai_task_reducer::start_ai_task;
 pub use start_ai_task_stage_reducer::start_ai_task_stage;
 pub use start_bark_battle_run_procedure::start_bark_battle_run;
 pub use start_big_fish_run_procedure::start_big_fish_run;
+pub use start_jump_hop_run_procedure::start_jump_hop_run;
 pub use start_match_3_d_run_procedure::start_match_3_d_run;
 pub use start_puzzle_run_procedure::start_puzzle_run;
 pub use start_square_hole_run_procedure::start_square_hole_run;
@@ -1790,6 +1895,7 @@ pub use unequip_inventory_item_input_type::UnequipInventoryItemInput;
 pub use unpublish_custom_world_profile_and_return_procedure::unpublish_custom_world_profile_and_return;
 pub use unpublish_custom_world_profile_reducer::unpublish_custom_world_profile;
 pub use update_bark_battle_draft_config_procedure::update_bark_battle_draft_config;
+pub use update_jump_hop_work_procedure::update_jump_hop_work;
 pub use update_match_3_d_work_procedure::update_match_3_d_work;
 pub use update_puzzle_run_pause_procedure::update_puzzle_run_pause;
 pub use update_puzzle_work_procedure::update_puzzle_work;
@@ -2169,6 +2275,12 @@ pub struct DbUpdate {
     database_migration_import_chunk: __sdk::TableUpdate<DatabaseMigrationImportChunk>,
     database_migration_operator: __sdk::TableUpdate<DatabaseMigrationOperator>,
     inventory_slot: __sdk::TableUpdate<InventorySlot>,
+    jump_hop_agent_session: __sdk::TableUpdate<JumpHopAgentSessionRow>,
+    jump_hop_event: __sdk::TableUpdate<JumpHopEventRow>,
+    jump_hop_gallery_card_view: __sdk::TableUpdate<JumpHopGalleryCardViewRow>,
+    jump_hop_gallery_view: __sdk::TableUpdate<JumpHopGalleryViewRow>,
+    jump_hop_runtime_run: __sdk::TableUpdate<JumpHopRuntimeRunRow>,
+    jump_hop_work_profile: __sdk::TableUpdate<JumpHopWorkProfileRow>,
     match_3_d_agent_message: __sdk::TableUpdate<Match3DAgentMessageRow>,
     match_3_d_agent_session: __sdk::TableUpdate<Match3DAgentSessionRow>,
     match_3_d_gallery_view: __sdk::TableUpdate<Match3DGalleryViewRow>,
@@ -2358,6 +2470,24 @@ impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate {
                 "inventory_slot" => db_update
                     .inventory_slot
                     .append(inventory_slot_table::parse_table_update(table_update)?),
+                "jump_hop_agent_session" => db_update.jump_hop_agent_session.append(
+                    jump_hop_agent_session_table::parse_table_update(table_update)?,
+                ),
+                "jump_hop_event" => db_update
+                    .jump_hop_event
+                    .append(jump_hop_event_table::parse_table_update(table_update)?),
+                "jump_hop_gallery_card_view" => db_update.jump_hop_gallery_card_view.append(
+                    jump_hop_gallery_card_view_table::parse_table_update(table_update)?,
+                ),
+                "jump_hop_gallery_view" => db_update.jump_hop_gallery_view.append(
+                    jump_hop_gallery_view_table::parse_table_update(table_update)?,
+                ),
+                "jump_hop_runtime_run" => db_update.jump_hop_runtime_run.append(
+                    jump_hop_runtime_run_table::parse_table_update(table_update)?,
+                ),
+                "jump_hop_work_profile" => db_update.jump_hop_work_profile.append(
+                    jump_hop_work_profile_table::parse_table_update(table_update)?,
+                ),
                 "match_3_d_agent_message" => db_update.match_3_d_agent_message.append(
                     match_3_d_agent_message_table::parse_table_update(table_update)?,
                 ),
@@ -2748,6 +2878,27 @@ impl __sdk::DbUpdate for DbUpdate {
         diff.inventory_slot = cache
             .apply_diff_to_table::<InventorySlot>("inventory_slot", &self.inventory_slot)
             .with_updates_by_pk(|row| &row.slot_id);
+        diff.jump_hop_agent_session = cache
+            .apply_diff_to_table::<JumpHopAgentSessionRow>(
+                "jump_hop_agent_session",
+                &self.jump_hop_agent_session,
+            )
+            .with_updates_by_pk(|row| &row.session_id);
+        diff.jump_hop_event = cache
+            .apply_diff_to_table::<JumpHopEventRow>("jump_hop_event", &self.jump_hop_event)
+            .with_updates_by_pk(|row| &row.event_id);
+        diff.jump_hop_runtime_run = cache
+            .apply_diff_to_table::<JumpHopRuntimeRunRow>(
+                "jump_hop_runtime_run",
+                &self.jump_hop_runtime_run,
+            )
+            .with_updates_by_pk(|row| &row.run_id);
+        diff.jump_hop_work_profile = cache
+            .apply_diff_to_table::<JumpHopWorkProfileRow>(
+                "jump_hop_work_profile",
+                &self.jump_hop_work_profile,
+            )
+            .with_updates_by_pk(|row| &row.profile_id);
         diff.match_3_d_agent_message = cache
             .apply_diff_to_table::<Match3DAgentMessageRow>(
                 "match_3_d_agent_message",
@@ -3012,6 +3163,14 @@ impl __sdk::DbUpdate for DbUpdate {
             "big_fish_gallery_view",
             &self.big_fish_gallery_view,
         );
+        diff.jump_hop_gallery_card_view = cache.apply_diff_to_table::<JumpHopGalleryCardViewRow>(
+            "jump_hop_gallery_card_view",
+            &self.jump_hop_gallery_card_view,
+        );
+        diff.jump_hop_gallery_view = cache.apply_diff_to_table::<JumpHopGalleryViewRow>(
+            "jump_hop_gallery_view",
+            &self.jump_hop_gallery_view,
+        );
         diff.match_3_d_gallery_view = cache.apply_diff_to_table::<Match3DGalleryViewRow>(
             "match_3_d_gallery_view",
             &self.match_3_d_gallery_view,
@@ -3156,6 +3315,24 @@ impl __sdk::DbUpdate for DbUpdate {
                 "inventory_slot" => db_update
                     .inventory_slot
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "jump_hop_agent_session" => db_update
+                    .jump_hop_agent_session
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "jump_hop_event" => db_update
+                    .jump_hop_event
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "jump_hop_gallery_card_view" => db_update
+                    .jump_hop_gallery_card_view
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "jump_hop_gallery_view" => db_update
+                    .jump_hop_gallery_view
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "jump_hop_runtime_run" => db_update
+                    .jump_hop_runtime_run
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                "jump_hop_work_profile" => db_update
+                    .jump_hop_work_profile
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
                 "match_3_d_agent_message" => db_update
                     .match_3_d_agent_message
                     .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
@@ -3454,6 +3631,24 @@ impl __sdk::DbUpdate for DbUpdate {
                 "inventory_slot" => db_update
                     .inventory_slot
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "jump_hop_agent_session" => db_update
+                    .jump_hop_agent_session
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "jump_hop_event" => db_update
+                    .jump_hop_event
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "jump_hop_gallery_card_view" => db_update
+                    .jump_hop_gallery_card_view
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "jump_hop_gallery_view" => db_update
+                    .jump_hop_gallery_view
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "jump_hop_runtime_run" => db_update
+                    .jump_hop_runtime_run
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                "jump_hop_work_profile" => db_update
+                    .jump_hop_work_profile
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
                 "match_3_d_agent_message" => db_update
                     .match_3_d_agent_message
                     .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
@@ -3678,6 +3873,12 @@ pub struct AppliedDiff<'r> {
     database_migration_import_chunk: __sdk::TableAppliedDiff<'r, DatabaseMigrationImportChunk>,
     database_migration_operator: __sdk::TableAppliedDiff<'r, DatabaseMigrationOperator>,
     inventory_slot: __sdk::TableAppliedDiff<'r, InventorySlot>,
+    jump_hop_agent_session: __sdk::TableAppliedDiff<'r, JumpHopAgentSessionRow>,
+    jump_hop_event: __sdk::TableAppliedDiff<'r, JumpHopEventRow>,
+    jump_hop_gallery_card_view: __sdk::TableAppliedDiff<'r, JumpHopGalleryCardViewRow>,
+    jump_hop_gallery_view: __sdk::TableAppliedDiff<'r, JumpHopGalleryViewRow>,
+    jump_hop_runtime_run: __sdk::TableAppliedDiff<'r, JumpHopRuntimeRunRow>,
+    jump_hop_work_profile: __sdk::TableAppliedDiff<'r, JumpHopWorkProfileRow>,
     match_3_d_agent_message: __sdk::TableAppliedDiff<'r, Match3DAgentMessageRow>,
     match_3_d_agent_session: __sdk::TableAppliedDiff<'r, Match3DAgentSessionRow>,
     match_3_d_gallery_view: __sdk::TableAppliedDiff<'r, Match3DGalleryViewRow>,
@@ -3935,6 +4136,36 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
             &self.inventory_slot,
             event,
         );
+        callbacks.invoke_table_row_callbacks::<JumpHopAgentSessionRow>(
+            "jump_hop_agent_session",
+            &self.jump_hop_agent_session,
+            event,
+        );
+        callbacks.invoke_table_row_callbacks::<JumpHopEventRow>(
+            "jump_hop_event",
+            &self.jump_hop_event,
+            event,
+        );
+        callbacks.invoke_table_row_callbacks::<JumpHopGalleryCardViewRow>(
+            "jump_hop_gallery_card_view",
+            &self.jump_hop_gallery_card_view,
+            event,
+        );
+        callbacks.invoke_table_row_callbacks::<JumpHopGalleryViewRow>(
+            "jump_hop_gallery_view",
+            &self.jump_hop_gallery_view,
+            event,
+        );
+        callbacks.invoke_table_row_callbacks::<JumpHopRuntimeRunRow>(
+            "jump_hop_runtime_run",
+            &self.jump_hop_runtime_run,
+            event,
+        );
+        callbacks.invoke_table_row_callbacks::<JumpHopWorkProfileRow>(
+            "jump_hop_work_profile",
+            &self.jump_hop_work_profile,
+            event,
+        );
         callbacks.invoke_table_row_callbacks::<Match3DAgentMessageRow>(
             "match_3_d_agent_message",
             &self.match_3_d_agent_message,
@@ -4902,6 +5133,12 @@ impl __sdk::SpacetimeModule for RemoteModule {
         database_migration_import_chunk_table::register_table(client_cache);
         database_migration_operator_table::register_table(client_cache);
         inventory_slot_table::register_table(client_cache);
+        jump_hop_agent_session_table::register_table(client_cache);
+        jump_hop_event_table::register_table(client_cache);
+        jump_hop_gallery_card_view_table::register_table(client_cache);
+        jump_hop_gallery_view_table::register_table(client_cache);
+        jump_hop_runtime_run_table::register_table(client_cache);
+        jump_hop_work_profile_table::register_table(client_cache);
         match_3_d_agent_message_table::register_table(client_cache);
         match_3_d_agent_session_table::register_table(client_cache);
         match_3_d_gallery_view_table::register_table(client_cache);
@@ -4999,6 +5236,12 @@ impl __sdk::SpacetimeModule for RemoteModule {
         "database_migration_import_chunk",
         "database_migration_operator",
         "inventory_slot",
+        "jump_hop_agent_session",
+        "jump_hop_event",
+        "jump_hop_gallery_card_view",
+        "jump_hop_gallery_view",
+        "jump_hop_runtime_run",
+        "jump_hop_work_profile",
         "match_3_d_agent_message",
         "match_3_d_agent_session",
         "match_3_d_gallery_view",

server-rs/crates/spacetime-client/src/module_bindings/compile_jump_hop_draft_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::jump_hop_agent_session_procedure_result_type::JumpHopAgentSessionProcedureResult;
+use super::jump_hop_draft_compile_input_type::JumpHopDraftCompileInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct CompileJumpHopDraftArgs {
+    pub input: JumpHopDraftCompileInput,
+}
+
+impl __sdk::InModule for CompileJumpHopDraftArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `compile_jump_hop_draft`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait compile_jump_hop_draft {
+    fn compile_jump_hop_draft(&self, input: JumpHopDraftCompileInput) {
+        self.compile_jump_hop_draft_then(input, |_, _| {});
+    }
+
+    fn compile_jump_hop_draft_then(
+        &self,
+        input: JumpHopDraftCompileInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopAgentSessionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl compile_jump_hop_draft for super::RemoteProcedures {
+    fn compile_jump_hop_draft_then(
+        &self,
+        input: JumpHopDraftCompileInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopAgentSessionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopAgentSessionProcedureResult>(
+                "compile_jump_hop_draft",
+                CompileJumpHopDraftArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/create_jump_hop_agent_session_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::jump_hop_agent_session_create_input_type::JumpHopAgentSessionCreateInput;
+use super::jump_hop_agent_session_procedure_result_type::JumpHopAgentSessionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct CreateJumpHopAgentSessionArgs {
+    pub input: JumpHopAgentSessionCreateInput,
+}
+
+impl __sdk::InModule for CreateJumpHopAgentSessionArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `create_jump_hop_agent_session`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait create_jump_hop_agent_session {
+    fn create_jump_hop_agent_session(&self, input: JumpHopAgentSessionCreateInput) {
+        self.create_jump_hop_agent_session_then(input, |_, _| {});
+    }
+
+    fn create_jump_hop_agent_session_then(
+        &self,
+        input: JumpHopAgentSessionCreateInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopAgentSessionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl create_jump_hop_agent_session for super::RemoteProcedures {
+    fn create_jump_hop_agent_session_then(
+        &self,
+        input: JumpHopAgentSessionCreateInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopAgentSessionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopAgentSessionProcedureResult>(
+                "create_jump_hop_agent_session",
+                CreateJumpHopAgentSessionArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/get_custom_world_agent_operation_procedure.rs

@@ -1,3 +1,4 @@
+
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 

server-rs/crates/spacetime-client/src/module_bindings/get_jump_hop_agent_session_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::jump_hop_agent_session_get_input_type::JumpHopAgentSessionGetInput;
+use super::jump_hop_agent_session_procedure_result_type::JumpHopAgentSessionProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetJumpHopAgentSessionArgs {
+    pub input: JumpHopAgentSessionGetInput,
+}
+
+impl __sdk::InModule for GetJumpHopAgentSessionArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_jump_hop_agent_session`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_jump_hop_agent_session {
+    fn get_jump_hop_agent_session(&self, input: JumpHopAgentSessionGetInput) {
+        self.get_jump_hop_agent_session_then(input, |_, _| {});
+    }
+
+    fn get_jump_hop_agent_session_then(
+        &self,
+        input: JumpHopAgentSessionGetInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopAgentSessionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl get_jump_hop_agent_session for super::RemoteProcedures {
+    fn get_jump_hop_agent_session_then(
+        &self,
+        input: JumpHopAgentSessionGetInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopAgentSessionProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopAgentSessionProcedureResult>(
+                "get_jump_hop_agent_session",
+                GetJumpHopAgentSessionArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/get_jump_hop_run_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::jump_hop_run_get_input_type::JumpHopRunGetInput;
+use super::jump_hop_run_procedure_result_type::JumpHopRunProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetJumpHopRunArgs {
+    pub input: JumpHopRunGetInput,
+}
+
+impl __sdk::InModule for GetJumpHopRunArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_jump_hop_run`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_jump_hop_run {
+    fn get_jump_hop_run(&self, input: JumpHopRunGetInput) {
+        self.get_jump_hop_run_then(input, |_, _| {});
+    }
+
+    fn get_jump_hop_run_then(
+        &self,
+        input: JumpHopRunGetInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl get_jump_hop_run for super::RemoteProcedures {
+    fn get_jump_hop_run_then(
+        &self,
+        input: JumpHopRunGetInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopRunProcedureResult>(
+                "get_jump_hop_run",
+                GetJumpHopRunArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/get_jump_hop_work_profile_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::jump_hop_work_get_input_type::JumpHopWorkGetInput;
+use super::jump_hop_work_procedure_result_type::JumpHopWorkProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct GetJumpHopWorkProfileArgs {
+    pub input: JumpHopWorkGetInput,
+}
+
+impl __sdk::InModule for GetJumpHopWorkProfileArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `get_jump_hop_work_profile`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait get_jump_hop_work_profile {
+    fn get_jump_hop_work_profile(&self, input: JumpHopWorkGetInput) {
+        self.get_jump_hop_work_profile_then(input, |_, _| {});
+    }
+
+    fn get_jump_hop_work_profile_then(
+        &self,
+        input: JumpHopWorkGetInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorkProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl get_jump_hop_work_profile for super::RemoteProcedures {
+    fn get_jump_hop_work_profile_then(
+        &self,
+        input: JumpHopWorkGetInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorkProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopWorkProcedureResult>(
+                "get_jump_hop_work_profile",
+                GetJumpHopWorkProfileArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_agent_session_create_input_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 JumpHopAgentSessionCreateInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub seed_text: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags_json: Option<String>,
+    pub welcome_message_text: String,
+    pub config_json: Option<String>,
+    pub created_at_micros: i64,
+}
+
+impl __sdk::InModule for JumpHopAgentSessionCreateInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_agent_session_get_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 JumpHopAgentSessionGetInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+}
+
+impl __sdk::InModule for JumpHopAgentSessionGetInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_agent_session_procedure_result_type.rs

@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::jump_hop_agent_session_snapshot_type::JumpHopAgentSessionSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopAgentSessionProcedureResult {
+    pub ok: bool,
+    pub session: Option<JumpHopAgentSessionSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for JumpHopAgentSessionProcedureResult {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_agent_session_row_type.rs

@@ -0,0 +1,90 @@
+// 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 JumpHopAgentSessionRow {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub seed_text: String,
+    pub current_turn: u32,
+    pub progress_percent: u32,
+    pub stage: String,
+    pub config_json: String,
+    pub draft_json: String,
+    pub last_assistant_reply: String,
+    pub published_profile_id: String,
+    pub created_at: __sdk::Timestamp,
+    pub updated_at: __sdk::Timestamp,
+}
+
+impl __sdk::InModule for JumpHopAgentSessionRow {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `JumpHopAgentSessionRow`.
+///
+/// Provides typed access to columns for query building.
+pub struct JumpHopAgentSessionRowCols {
+    pub session_id: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub seed_text: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub current_turn: __sdk::__query_builder::Col<JumpHopAgentSessionRow, u32>,
+    pub progress_percent: __sdk::__query_builder::Col<JumpHopAgentSessionRow, u32>,
+    pub stage: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub config_json: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub draft_json: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub last_assistant_reply: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub published_profile_id: __sdk::__query_builder::Col<JumpHopAgentSessionRow, String>,
+    pub created_at: __sdk::__query_builder::Col<JumpHopAgentSessionRow, __sdk::Timestamp>,
+    pub updated_at: __sdk::__query_builder::Col<JumpHopAgentSessionRow, __sdk::Timestamp>,
+}
+
+impl __sdk::__query_builder::HasCols for JumpHopAgentSessionRow {
+    type Cols = JumpHopAgentSessionRowCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        JumpHopAgentSessionRowCols {
+            session_id: __sdk::__query_builder::Col::new(table_name, "session_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            seed_text: __sdk::__query_builder::Col::new(table_name, "seed_text"),
+            current_turn: __sdk::__query_builder::Col::new(table_name, "current_turn"),
+            progress_percent: __sdk::__query_builder::Col::new(table_name, "progress_percent"),
+            stage: __sdk::__query_builder::Col::new(table_name, "stage"),
+            config_json: __sdk::__query_builder::Col::new(table_name, "config_json"),
+            draft_json: __sdk::__query_builder::Col::new(table_name, "draft_json"),
+            last_assistant_reply: __sdk::__query_builder::Col::new(
+                table_name,
+                "last_assistant_reply",
+            ),
+            published_profile_id: __sdk::__query_builder::Col::new(
+                table_name,
+                "published_profile_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 `JumpHopAgentSessionRow`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct JumpHopAgentSessionRowIxCols {
+    pub owner_user_id: __sdk::__query_builder::IxCol<JumpHopAgentSessionRow, String>,
+    pub session_id: __sdk::__query_builder::IxCol<JumpHopAgentSessionRow, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for JumpHopAgentSessionRow {
+    type IxCols = JumpHopAgentSessionRowIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        JumpHopAgentSessionRowIxCols {
+            owner_user_id: __sdk::__query_builder::IxCol::new(table_name, "owner_user_id"),
+            session_id: __sdk::__query_builder::IxCol::new(table_name, "session_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for JumpHopAgentSessionRow {}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_agent_session_snapshot_type.rs

@@ -0,0 +1,29 @@
+// 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::jump_hop_creator_config_snapshot_type::JumpHopCreatorConfigSnapshot;
+use super::jump_hop_draft_snapshot_type::JumpHopDraftSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopAgentSessionSnapshot {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub seed_text: String,
+    pub current_turn: u32,
+    pub progress_percent: u32,
+    pub stage: String,
+    pub config: JumpHopCreatorConfigSnapshot,
+    pub draft: Option<JumpHopDraftSnapshot>,
+    pub last_assistant_reply: String,
+    pub published_profile_id: Option<String>,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+impl __sdk::InModule for JumpHopAgentSessionSnapshot {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_agent_session_table.rs

@@ -0,0 +1,161 @@
+// 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::jump_hop_agent_session_row_type::JumpHopAgentSessionRow;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `jump_hop_agent_session`.
+///
+/// Obtain a handle from the [`JumpHopAgentSessionTableAccess::jump_hop_agent_session`] method on [`super::RemoteTables`],
+/// like `ctx.db.jump_hop_agent_session()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_agent_session().on_insert(...)`.
+pub struct JumpHopAgentSessionTableHandle<'ctx> {
+    imp: __sdk::TableHandle<JumpHopAgentSessionRow>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `jump_hop_agent_session`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait JumpHopAgentSessionTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`JumpHopAgentSessionTableHandle`], which mediates access to the table `jump_hop_agent_session`.
+    fn jump_hop_agent_session(&self) -> JumpHopAgentSessionTableHandle<'_>;
+}
+
+impl JumpHopAgentSessionTableAccess for super::RemoteTables {
+    fn jump_hop_agent_session(&self) -> JumpHopAgentSessionTableHandle<'_> {
+        JumpHopAgentSessionTableHandle {
+            imp: self
+                .imp
+                .get_table::<JumpHopAgentSessionRow>("jump_hop_agent_session"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct JumpHopAgentSessionInsertCallbackId(__sdk::CallbackId);
+pub struct JumpHopAgentSessionDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::Table for JumpHopAgentSessionTableHandle<'ctx> {
+    type Row = JumpHopAgentSessionRow;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = JumpHopAgentSessionRow> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = JumpHopAgentSessionInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopAgentSessionInsertCallbackId {
+        JumpHopAgentSessionInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: JumpHopAgentSessionInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = JumpHopAgentSessionDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopAgentSessionDeleteCallbackId {
+        JumpHopAgentSessionDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: JumpHopAgentSessionDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct JumpHopAgentSessionUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for JumpHopAgentSessionTableHandle<'ctx> {
+    type UpdateCallbackId = JumpHopAgentSessionUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> JumpHopAgentSessionUpdateCallbackId {
+        JumpHopAgentSessionUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: JumpHopAgentSessionUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `session_id` unique index on the table `jump_hop_agent_session`,
+/// which allows point queries on the field of the same name
+/// via the [`JumpHopAgentSessionSessionIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_agent_session().session_id().find(...)`.
+pub struct JumpHopAgentSessionSessionIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<JumpHopAgentSessionRow, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> JumpHopAgentSessionTableHandle<'ctx> {
+    /// Get a handle on the `session_id` unique index on the table `jump_hop_agent_session`.
+    pub fn session_id(&self) -> JumpHopAgentSessionSessionIdUnique<'ctx> {
+        JumpHopAgentSessionSessionIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("session_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> JumpHopAgentSessionSessionIdUnique<'ctx> {
+    /// Find the subscribed row whose `session_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<JumpHopAgentSessionRow> {
+        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::<JumpHopAgentSessionRow>("jump_hop_agent_session");
+    _table.add_unique_constraint::<String>("session_id", |row| &row.session_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<JumpHopAgentSessionRow>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<JumpHopAgentSessionRow>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `JumpHopAgentSessionRow`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait jump_hop_agent_sessionQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `JumpHopAgentSessionRow`.
+    fn jump_hop_agent_session(&self) -> __sdk::__query_builder::Table<JumpHopAgentSessionRow>;
+}
+
+impl jump_hop_agent_sessionQueryTableAccess for __sdk::QueryTableAccessor {
+    fn jump_hop_agent_session(&self) -> __sdk::__query_builder::Table<JumpHopAgentSessionRow> {
+        __sdk::__query_builder::Table::new("jump_hop_agent_session")
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_character_asset_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 JumpHopCharacterAssetSnapshot {
+    pub asset_id: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub generation_provider: String,
+    pub prompt: String,
+    pub width: u32,
+    pub height: u32,
+}
+
+impl __sdk::InModule for JumpHopCharacterAssetSnapshot {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_creator_config_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 JumpHopCreatorConfigSnapshot {
+    pub theme_text: String,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    pub end_mood_prompt: String,
+}
+
+impl __sdk::InModule for JumpHopCreatorConfigSnapshot {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_difficulty_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)]
+#[derive(Copy, Eq, Hash)]
+pub enum JumpHopDifficulty {
+    Easy,
+
+    Standard,
+
+    Advanced,
+
+    Challenge,
+}
+
+impl __sdk::InModule for JumpHopDifficulty {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_draft_compile_input_type.rs

@@ -0,0 +1,34 @@
+// 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 JumpHopDraftCompileInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub author_display_name: String,
+    pub seed_text: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags_json: Option<String>,
+    pub theme_text: Option<String>,
+    pub difficulty: Option<String>,
+    pub style_preset: Option<String>,
+    pub character_prompt: Option<String>,
+    pub tile_prompt: Option<String>,
+    pub end_mood_prompt: Option<String>,
+    pub character_asset_json: Option<String>,
+    pub tile_atlas_asset_json: Option<String>,
+    pub tile_assets_json: Option<String>,
+    pub cover_composite: Option<String>,
+    pub generation_status: Option<String>,
+    pub compiled_at_micros: i64,
+}
+
+impl __sdk::InModule for JumpHopDraftCompileInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_draft_snapshot_type.rs

@@ -0,0 +1,35 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::jump_hop_character_asset_snapshot_type::JumpHopCharacterAssetSnapshot;
+use super::jump_hop_path_type::JumpHopPath;
+use super::jump_hop_tile_asset_snapshot_type::JumpHopTileAssetSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopDraftSnapshot {
+    pub template_id: String,
+    pub template_name: String,
+    pub profile_id: Option<String>,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    pub end_mood_prompt: Option<String>,
+    pub character_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_atlas_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_assets: Vec<JumpHopTileAssetSnapshot>,
+    pub path: Option<JumpHopPath>,
+    pub cover_composite: Option<String>,
+    pub generation_status: String,
+}
+
+impl __sdk::InModule for JumpHopDraftSnapshot {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_event_row_type.rs

@@ -0,0 +1,71 @@
+// 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 JumpHopEventRow {
+    pub event_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub run_id: String,
+    pub event_type: String,
+    pub result: String,
+    pub occurred_at: __sdk::Timestamp,
+}
+
+impl __sdk::InModule for JumpHopEventRow {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `JumpHopEventRow`.
+///
+/// Provides typed access to columns for query building.
+pub struct JumpHopEventRowCols {
+    pub event_id: __sdk::__query_builder::Col<JumpHopEventRow, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<JumpHopEventRow, String>,
+    pub profile_id: __sdk::__query_builder::Col<JumpHopEventRow, String>,
+    pub run_id: __sdk::__query_builder::Col<JumpHopEventRow, String>,
+    pub event_type: __sdk::__query_builder::Col<JumpHopEventRow, String>,
+    pub result: __sdk::__query_builder::Col<JumpHopEventRow, String>,
+    pub occurred_at: __sdk::__query_builder::Col<JumpHopEventRow, __sdk::Timestamp>,
+}
+
+impl __sdk::__query_builder::HasCols for JumpHopEventRow {
+    type Cols = JumpHopEventRowCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        JumpHopEventRowCols {
+            event_id: __sdk::__query_builder::Col::new(table_name, "event_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            profile_id: __sdk::__query_builder::Col::new(table_name, "profile_id"),
+            run_id: __sdk::__query_builder::Col::new(table_name, "run_id"),
+            event_type: __sdk::__query_builder::Col::new(table_name, "event_type"),
+            result: __sdk::__query_builder::Col::new(table_name, "result"),
+            occurred_at: __sdk::__query_builder::Col::new(table_name, "occurred_at"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `JumpHopEventRow`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct JumpHopEventRowIxCols {
+    pub event_id: __sdk::__query_builder::IxCol<JumpHopEventRow, String>,
+    pub profile_id: __sdk::__query_builder::IxCol<JumpHopEventRow, String>,
+    pub run_id: __sdk::__query_builder::IxCol<JumpHopEventRow, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for JumpHopEventRow {
+    type IxCols = JumpHopEventRowIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        JumpHopEventRowIxCols {
+            event_id: __sdk::__query_builder::IxCol::new(table_name, "event_id"),
+            profile_id: __sdk::__query_builder::IxCol::new(table_name, "profile_id"),
+            run_id: __sdk::__query_builder::IxCol::new(table_name, "run_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for JumpHopEventRow {}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_event_table.rs

@@ -0,0 +1,159 @@
+// 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::jump_hop_event_row_type::JumpHopEventRow;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `jump_hop_event`.
+///
+/// Obtain a handle from the [`JumpHopEventTableAccess::jump_hop_event`] method on [`super::RemoteTables`],
+/// like `ctx.db.jump_hop_event()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_event().on_insert(...)`.
+pub struct JumpHopEventTableHandle<'ctx> {
+    imp: __sdk::TableHandle<JumpHopEventRow>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `jump_hop_event`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait JumpHopEventTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`JumpHopEventTableHandle`], which mediates access to the table `jump_hop_event`.
+    fn jump_hop_event(&self) -> JumpHopEventTableHandle<'_>;
+}
+
+impl JumpHopEventTableAccess for super::RemoteTables {
+    fn jump_hop_event(&self) -> JumpHopEventTableHandle<'_> {
+        JumpHopEventTableHandle {
+            imp: self.imp.get_table::<JumpHopEventRow>("jump_hop_event"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct JumpHopEventInsertCallbackId(__sdk::CallbackId);
+pub struct JumpHopEventDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::Table for JumpHopEventTableHandle<'ctx> {
+    type Row = JumpHopEventRow;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = JumpHopEventRow> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = JumpHopEventInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopEventInsertCallbackId {
+        JumpHopEventInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: JumpHopEventInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = JumpHopEventDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopEventDeleteCallbackId {
+        JumpHopEventDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: JumpHopEventDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct JumpHopEventUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for JumpHopEventTableHandle<'ctx> {
+    type UpdateCallbackId = JumpHopEventUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> JumpHopEventUpdateCallbackId {
+        JumpHopEventUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: JumpHopEventUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `event_id` unique index on the table `jump_hop_event`,
+/// which allows point queries on the field of the same name
+/// via the [`JumpHopEventEventIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_event().event_id().find(...)`.
+pub struct JumpHopEventEventIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<JumpHopEventRow, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> JumpHopEventTableHandle<'ctx> {
+    /// Get a handle on the `event_id` unique index on the table `jump_hop_event`.
+    pub fn event_id(&self) -> JumpHopEventEventIdUnique<'ctx> {
+        JumpHopEventEventIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("event_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> JumpHopEventEventIdUnique<'ctx> {
+    /// Find the subscribed row whose `event_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<JumpHopEventRow> {
+        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::<JumpHopEventRow>("jump_hop_event");
+    _table.add_unique_constraint::<String>("event_id", |row| &row.event_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<JumpHopEventRow>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<JumpHopEventRow>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `JumpHopEventRow`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait jump_hop_eventQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `JumpHopEventRow`.
+    fn jump_hop_event(&self) -> __sdk::__query_builder::Table<JumpHopEventRow>;
+}
+
+impl jump_hop_eventQueryTableAccess for __sdk::QueryTableAccessor {
+    fn jump_hop_event(&self) -> __sdk::__query_builder::Table<JumpHopEventRow> {
+        __sdk::__query_builder::Table::new("jump_hop_event")
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_gallery_card_view_row_type.rs

@@ -0,0 +1,82 @@
+// 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 JumpHopGalleryCardViewRow {
+    pub public_work_code: String,
+    pub work_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub author_display_name: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub cover_image_src: String,
+    pub publication_status: String,
+    pub play_count: u32,
+    pub updated_at_micros: i64,
+    pub published_at_micros: Option<i64>,
+    pub generation_status: String,
+}
+
+impl __sdk::InModule for JumpHopGalleryCardViewRow {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `JumpHopGalleryCardViewRow`.
+///
+/// Provides typed access to columns for query building.
+pub struct JumpHopGalleryCardViewRowCols {
+    pub public_work_code: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub work_id: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub profile_id: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub author_display_name: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub work_title: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub work_description: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub theme_tags: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, Vec<String>>,
+    pub difficulty: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub style_preset: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub cover_image_src: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub publication_status: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+    pub play_count: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, u32>,
+    pub updated_at_micros: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, i64>,
+    pub published_at_micros: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, Option<i64>>,
+    pub generation_status: __sdk::__query_builder::Col<JumpHopGalleryCardViewRow, String>,
+}
+
+impl __sdk::__query_builder::HasCols for JumpHopGalleryCardViewRow {
+    type Cols = JumpHopGalleryCardViewRowCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        JumpHopGalleryCardViewRowCols {
+            public_work_code: __sdk::__query_builder::Col::new(table_name, "public_work_code"),
+            work_id: __sdk::__query_builder::Col::new(table_name, "work_id"),
+            profile_id: __sdk::__query_builder::Col::new(table_name, "profile_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            author_display_name: __sdk::__query_builder::Col::new(
+                table_name,
+                "author_display_name",
+            ),
+            work_title: __sdk::__query_builder::Col::new(table_name, "work_title"),
+            work_description: __sdk::__query_builder::Col::new(table_name, "work_description"),
+            theme_tags: __sdk::__query_builder::Col::new(table_name, "theme_tags"),
+            difficulty: __sdk::__query_builder::Col::new(table_name, "difficulty"),
+            style_preset: __sdk::__query_builder::Col::new(table_name, "style_preset"),
+            cover_image_src: __sdk::__query_builder::Col::new(table_name, "cover_image_src"),
+            publication_status: __sdk::__query_builder::Col::new(table_name, "publication_status"),
+            play_count: __sdk::__query_builder::Col::new(table_name, "play_count"),
+            updated_at_micros: __sdk::__query_builder::Col::new(table_name, "updated_at_micros"),
+            published_at_micros: __sdk::__query_builder::Col::new(
+                table_name,
+                "published_at_micros",
+            ),
+            generation_status: __sdk::__query_builder::Col::new(table_name, "generation_status"),
+        }
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_gallery_card_view_table.rs

@@ -0,0 +1,118 @@
+// 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::jump_hop_gallery_card_view_row_type::JumpHopGalleryCardViewRow;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `jump_hop_gallery_card_view`.
+///
+/// Obtain a handle from the [`JumpHopGalleryCardViewTableAccess::jump_hop_gallery_card_view`] method on [`super::RemoteTables`],
+/// like `ctx.db.jump_hop_gallery_card_view()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_gallery_card_view().on_insert(...)`.
+pub struct JumpHopGalleryCardViewTableHandle<'ctx> {
+    imp: __sdk::TableHandle<JumpHopGalleryCardViewRow>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `jump_hop_gallery_card_view`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait JumpHopGalleryCardViewTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`JumpHopGalleryCardViewTableHandle`], which mediates access to the table `jump_hop_gallery_card_view`.
+    fn jump_hop_gallery_card_view(&self) -> JumpHopGalleryCardViewTableHandle<'_>;
+}
+
+impl JumpHopGalleryCardViewTableAccess for super::RemoteTables {
+    fn jump_hop_gallery_card_view(&self) -> JumpHopGalleryCardViewTableHandle<'_> {
+        JumpHopGalleryCardViewTableHandle {
+            imp: self
+                .imp
+                .get_table::<JumpHopGalleryCardViewRow>("jump_hop_gallery_card_view"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct JumpHopGalleryCardViewInsertCallbackId(__sdk::CallbackId);
+pub struct JumpHopGalleryCardViewDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::Table for JumpHopGalleryCardViewTableHandle<'ctx> {
+    type Row = JumpHopGalleryCardViewRow;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = JumpHopGalleryCardViewRow> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = JumpHopGalleryCardViewInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopGalleryCardViewInsertCallbackId {
+        JumpHopGalleryCardViewInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: JumpHopGalleryCardViewInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = JumpHopGalleryCardViewDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopGalleryCardViewDeleteCallbackId {
+        JumpHopGalleryCardViewDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: JumpHopGalleryCardViewDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+#[doc(hidden)]
+pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
+    let _table =
+        client_cache.get_or_make_table::<JumpHopGalleryCardViewRow>("jump_hop_gallery_card_view");
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<JumpHopGalleryCardViewRow>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<JumpHopGalleryCardViewRow>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `JumpHopGalleryCardViewRow`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait jump_hop_gallery_card_viewQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `JumpHopGalleryCardViewRow`.
+    fn jump_hop_gallery_card_view(
+        &self,
+    ) -> __sdk::__query_builder::Table<JumpHopGalleryCardViewRow>;
+}
+
+impl jump_hop_gallery_card_viewQueryTableAccess for __sdk::QueryTableAccessor {
+    fn jump_hop_gallery_card_view(
+        &self,
+    ) -> __sdk::__query_builder::Table<JumpHopGalleryCardViewRow> {
+        __sdk::__query_builder::Table::new("jump_hop_gallery_card_view")
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_gallery_view_row_type.rs

@@ -0,0 +1,116 @@
+// 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::jump_hop_character_asset_snapshot_type::JumpHopCharacterAssetSnapshot;
+use super::jump_hop_path_type::JumpHopPath;
+use super::jump_hop_tile_asset_snapshot_type::JumpHopTileAssetSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopGalleryViewRow {
+    pub work_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub source_session_id: String,
+    pub author_display_name: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    pub end_mood_prompt: Option<String>,
+    pub character_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_atlas_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_assets: Vec<JumpHopTileAssetSnapshot>,
+    pub path: JumpHopPath,
+    pub cover_image_src: String,
+    pub cover_composite: Option<String>,
+    pub publication_status: String,
+    pub publish_ready: bool,
+    pub play_count: u32,
+    pub generation_status: String,
+    pub updated_at_micros: i64,
+    pub published_at_micros: Option<i64>,
+}
+
+impl __sdk::InModule for JumpHopGalleryViewRow {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `JumpHopGalleryViewRow`.
+///
+/// Provides typed access to columns for query building.
+pub struct JumpHopGalleryViewRowCols {
+    pub work_id: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub profile_id: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub source_session_id: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub author_display_name: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub work_title: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub work_description: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub theme_tags: __sdk::__query_builder::Col<JumpHopGalleryViewRow, Vec<String>>,
+    pub difficulty: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub style_preset: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub character_prompt: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub tile_prompt: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub end_mood_prompt: __sdk::__query_builder::Col<JumpHopGalleryViewRow, Option<String>>,
+    pub character_asset:
+        __sdk::__query_builder::Col<JumpHopGalleryViewRow, Option<JumpHopCharacterAssetSnapshot>>,
+    pub tile_atlas_asset:
+        __sdk::__query_builder::Col<JumpHopGalleryViewRow, Option<JumpHopCharacterAssetSnapshot>>,
+    pub tile_assets:
+        __sdk::__query_builder::Col<JumpHopGalleryViewRow, Vec<JumpHopTileAssetSnapshot>>,
+    pub path: __sdk::__query_builder::Col<JumpHopGalleryViewRow, JumpHopPath>,
+    pub cover_image_src: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub cover_composite: __sdk::__query_builder::Col<JumpHopGalleryViewRow, Option<String>>,
+    pub publication_status: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub publish_ready: __sdk::__query_builder::Col<JumpHopGalleryViewRow, bool>,
+    pub play_count: __sdk::__query_builder::Col<JumpHopGalleryViewRow, u32>,
+    pub generation_status: __sdk::__query_builder::Col<JumpHopGalleryViewRow, String>,
+    pub updated_at_micros: __sdk::__query_builder::Col<JumpHopGalleryViewRow, i64>,
+    pub published_at_micros: __sdk::__query_builder::Col<JumpHopGalleryViewRow, Option<i64>>,
+}
+
+impl __sdk::__query_builder::HasCols for JumpHopGalleryViewRow {
+    type Cols = JumpHopGalleryViewRowCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        JumpHopGalleryViewRowCols {
+            work_id: __sdk::__query_builder::Col::new(table_name, "work_id"),
+            profile_id: __sdk::__query_builder::Col::new(table_name, "profile_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            source_session_id: __sdk::__query_builder::Col::new(table_name, "source_session_id"),
+            author_display_name: __sdk::__query_builder::Col::new(
+                table_name,
+                "author_display_name",
+            ),
+            work_title: __sdk::__query_builder::Col::new(table_name, "work_title"),
+            work_description: __sdk::__query_builder::Col::new(table_name, "work_description"),
+            theme_tags: __sdk::__query_builder::Col::new(table_name, "theme_tags"),
+            difficulty: __sdk::__query_builder::Col::new(table_name, "difficulty"),
+            style_preset: __sdk::__query_builder::Col::new(table_name, "style_preset"),
+            character_prompt: __sdk::__query_builder::Col::new(table_name, "character_prompt"),
+            tile_prompt: __sdk::__query_builder::Col::new(table_name, "tile_prompt"),
+            end_mood_prompt: __sdk::__query_builder::Col::new(table_name, "end_mood_prompt"),
+            character_asset: __sdk::__query_builder::Col::new(table_name, "character_asset"),
+            tile_atlas_asset: __sdk::__query_builder::Col::new(table_name, "tile_atlas_asset"),
+            tile_assets: __sdk::__query_builder::Col::new(table_name, "tile_assets"),
+            path: __sdk::__query_builder::Col::new(table_name, "path"),
+            cover_image_src: __sdk::__query_builder::Col::new(table_name, "cover_image_src"),
+            cover_composite: __sdk::__query_builder::Col::new(table_name, "cover_composite"),
+            publication_status: __sdk::__query_builder::Col::new(table_name, "publication_status"),
+            publish_ready: __sdk::__query_builder::Col::new(table_name, "publish_ready"),
+            play_count: __sdk::__query_builder::Col::new(table_name, "play_count"),
+            generation_status: __sdk::__query_builder::Col::new(table_name, "generation_status"),
+            updated_at_micros: __sdk::__query_builder::Col::new(table_name, "updated_at_micros"),
+            published_at_micros: __sdk::__query_builder::Col::new(
+                table_name,
+                "published_at_micros",
+            ),
+        }
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_gallery_view_table.rs

@@ -0,0 +1,116 @@
+// 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::jump_hop_character_asset_snapshot_type::JumpHopCharacterAssetSnapshot;
+use super::jump_hop_gallery_view_row_type::JumpHopGalleryViewRow;
+use super::jump_hop_path_type::JumpHopPath;
+use super::jump_hop_tile_asset_snapshot_type::JumpHopTileAssetSnapshot;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `jump_hop_gallery_view`.
+///
+/// Obtain a handle from the [`JumpHopGalleryViewTableAccess::jump_hop_gallery_view`] method on [`super::RemoteTables`],
+/// like `ctx.db.jump_hop_gallery_view()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_gallery_view().on_insert(...)`.
+pub struct JumpHopGalleryViewTableHandle<'ctx> {
+    imp: __sdk::TableHandle<JumpHopGalleryViewRow>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `jump_hop_gallery_view`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait JumpHopGalleryViewTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`JumpHopGalleryViewTableHandle`], which mediates access to the table `jump_hop_gallery_view`.
+    fn jump_hop_gallery_view(&self) -> JumpHopGalleryViewTableHandle<'_>;
+}
+
+impl JumpHopGalleryViewTableAccess for super::RemoteTables {
+    fn jump_hop_gallery_view(&self) -> JumpHopGalleryViewTableHandle<'_> {
+        JumpHopGalleryViewTableHandle {
+            imp: self
+                .imp
+                .get_table::<JumpHopGalleryViewRow>("jump_hop_gallery_view"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct JumpHopGalleryViewInsertCallbackId(__sdk::CallbackId);
+pub struct JumpHopGalleryViewDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::Table for JumpHopGalleryViewTableHandle<'ctx> {
+    type Row = JumpHopGalleryViewRow;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = JumpHopGalleryViewRow> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = JumpHopGalleryViewInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopGalleryViewInsertCallbackId {
+        JumpHopGalleryViewInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: JumpHopGalleryViewInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = JumpHopGalleryViewDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopGalleryViewDeleteCallbackId {
+        JumpHopGalleryViewDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: JumpHopGalleryViewDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+#[doc(hidden)]
+pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
+    let _table = client_cache.get_or_make_table::<JumpHopGalleryViewRow>("jump_hop_gallery_view");
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<JumpHopGalleryViewRow>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<JumpHopGalleryViewRow>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `JumpHopGalleryViewRow`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait jump_hop_gallery_viewQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `JumpHopGalleryViewRow`.
+    fn jump_hop_gallery_view(&self) -> __sdk::__query_builder::Table<JumpHopGalleryViewRow>;
+}
+
+impl jump_hop_gallery_viewQueryTableAccess for __sdk::QueryTableAccessor {
+    fn jump_hop_gallery_view(&self) -> __sdk::__query_builder::Table<JumpHopGalleryViewRow> {
+        __sdk::__query_builder::Table::new("jump_hop_gallery_view")
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_jump_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::jump_hop_run_jump_input_type::JumpHopRunJumpInput;
+use super::jump_hop_run_procedure_result_type::JumpHopRunProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct JumpHopJumpArgs {
+    pub input: JumpHopRunJumpInput,
+}
+
+impl __sdk::InModule for JumpHopJumpArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `jump_hop_jump`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait jump_hop_jump {
+    fn jump_hop_jump(&self, input: JumpHopRunJumpInput) {
+        self.jump_hop_jump_then(input, |_, _| {});
+    }
+
+    fn jump_hop_jump_then(
+        &self,
+        input: JumpHopRunJumpInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl jump_hop_jump for super::RemoteProcedures {
+    fn jump_hop_jump_then(
+        &self,
+        input: JumpHopRunJumpInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopRunProcedureResult>(
+                "jump_hop_jump",
+                JumpHopJumpArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_jump_result_kind_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)]
+#[derive(Copy, Eq, Hash)]
+pub enum JumpHopJumpResultKind {
+    Miss,
+
+    Hit,
+
+    Perfect,
+
+    Finish,
+}
+
+impl __sdk::InModule for JumpHopJumpResultKind {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_last_jump_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::jump_hop_jump_result_kind_type::JumpHopJumpResultKind;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopLastJump {
+    pub charge_ms: u32,
+    pub jump_distance: f32,
+    pub target_platform_index: u32,
+    pub landed_x: f32,
+    pub landed_y: f32,
+    pub result: JumpHopJumpResultKind,
+}
+
+impl __sdk::InModule for JumpHopLastJump {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_path_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};
+
+use super::jump_hop_difficulty_type::JumpHopDifficulty;
+use super::jump_hop_platform_type::JumpHopPlatform;
+use super::jump_hop_scoring_type::JumpHopScoring;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopPath {
+    pub seed: String,
+    pub difficulty: JumpHopDifficulty,
+    pub platforms: Vec<JumpHopPlatform>,
+    pub finish_index: u32,
+    pub camera_preset: String,
+    pub scoring: JumpHopScoring,
+}
+
+impl __sdk::InModule for JumpHopPath {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_platform_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::jump_hop_tile_type_type::JumpHopTileType;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopPlatform {
+    pub platform_id: String,
+    pub tile_type: JumpHopTileType,
+    pub x: f32,
+    pub y: f32,
+    pub width: f32,
+    pub height: f32,
+    pub landing_radius: f32,
+    pub perfect_radius: f32,
+    pub score_value: u32,
+}
+
+impl __sdk::InModule for JumpHopPlatform {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_run_get_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 JumpHopRunGetInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+}
+
+impl __sdk::InModule for JumpHopRunGetInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_run_jump_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 JumpHopRunJumpInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub charge_ms: u32,
+    pub client_event_id: String,
+    pub jumped_at_ms: i64,
+}
+
+impl __sdk::InModule for JumpHopRunJumpInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_run_procedure_result_type.rs

@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::jump_hop_run_snapshot_type::JumpHopRunSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopRunProcedureResult {
+    pub ok: bool,
+    pub run: Option<JumpHopRunSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for JumpHopRunProcedureResult {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_run_restart_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 JumpHopRunRestartInput {
+    pub source_run_id: String,
+    pub next_run_id: String,
+    pub owner_user_id: String,
+    pub client_action_id: String,
+    pub restarted_at_ms: i64,
+}
+
+impl __sdk::InModule for JumpHopRunRestartInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_run_snapshot_type.rs

@@ -0,0 +1,29 @@
+// 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::jump_hop_last_jump_type::JumpHopLastJump;
+use super::jump_hop_path_type::JumpHopPath;
+use super::jump_hop_run_status_type::JumpHopRunStatus;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopRunSnapshot {
+    pub run_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub status: JumpHopRunStatus,
+    pub current_platform_index: u32,
+    pub score: u32,
+    pub combo: u32,
+    pub last_jump: Option<JumpHopLastJump>,
+    pub started_at_ms: u64,
+    pub finished_at_ms: Option<u64>,
+    pub path: JumpHopPath,
+}
+
+impl __sdk::InModule for JumpHopRunSnapshot {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_run_start_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 JumpHopRunStartInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub client_event_id: String,
+    pub started_at_ms: i64,
+}
+
+impl __sdk::InModule for JumpHopRunStartInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_run_status_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)]
+#[derive(Copy, Eq, Hash)]
+pub enum JumpHopRunStatus {
+    Playing,
+
+    Failed,
+
+    Cleared,
+}
+
+impl __sdk::InModule for JumpHopRunStatus {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_runtime_run_row_type.rs

@@ -0,0 +1,89 @@
+// 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 JumpHopRuntimeRunRow {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub status: String,
+    pub started_at_ms: i64,
+    pub finished_at_ms: i64,
+    pub current_platform_index: u32,
+    pub score: u32,
+    pub combo: u32,
+    pub snapshot_json: String,
+    pub created_at: __sdk::Timestamp,
+    pub updated_at: __sdk::Timestamp,
+}
+
+impl __sdk::InModule for JumpHopRuntimeRunRow {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `JumpHopRuntimeRunRow`.
+///
+/// Provides typed access to columns for query building.
+pub struct JumpHopRuntimeRunRowCols {
+    pub run_id: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, String>,
+    pub profile_id: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, String>,
+    pub status: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, String>,
+    pub started_at_ms: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, i64>,
+    pub finished_at_ms: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, i64>,
+    pub current_platform_index: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, u32>,
+    pub score: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, u32>,
+    pub combo: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, u32>,
+    pub snapshot_json: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, String>,
+    pub created_at: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, __sdk::Timestamp>,
+    pub updated_at: __sdk::__query_builder::Col<JumpHopRuntimeRunRow, __sdk::Timestamp>,
+}
+
+impl __sdk::__query_builder::HasCols for JumpHopRuntimeRunRow {
+    type Cols = JumpHopRuntimeRunRowCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        JumpHopRuntimeRunRowCols {
+            run_id: __sdk::__query_builder::Col::new(table_name, "run_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            profile_id: __sdk::__query_builder::Col::new(table_name, "profile_id"),
+            status: __sdk::__query_builder::Col::new(table_name, "status"),
+            started_at_ms: __sdk::__query_builder::Col::new(table_name, "started_at_ms"),
+            finished_at_ms: __sdk::__query_builder::Col::new(table_name, "finished_at_ms"),
+            current_platform_index: __sdk::__query_builder::Col::new(
+                table_name,
+                "current_platform_index",
+            ),
+            score: __sdk::__query_builder::Col::new(table_name, "score"),
+            combo: __sdk::__query_builder::Col::new(table_name, "combo"),
+            snapshot_json: __sdk::__query_builder::Col::new(table_name, "snapshot_json"),
+            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 `JumpHopRuntimeRunRow`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct JumpHopRuntimeRunRowIxCols {
+    pub owner_user_id: __sdk::__query_builder::IxCol<JumpHopRuntimeRunRow, String>,
+    pub profile_id: __sdk::__query_builder::IxCol<JumpHopRuntimeRunRow, String>,
+    pub run_id: __sdk::__query_builder::IxCol<JumpHopRuntimeRunRow, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for JumpHopRuntimeRunRow {
+    type IxCols = JumpHopRuntimeRunRowIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        JumpHopRuntimeRunRowIxCols {
+            owner_user_id: __sdk::__query_builder::IxCol::new(table_name, "owner_user_id"),
+            profile_id: __sdk::__query_builder::IxCol::new(table_name, "profile_id"),
+            run_id: __sdk::__query_builder::IxCol::new(table_name, "run_id"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for JumpHopRuntimeRunRow {}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_runtime_run_table.rs

@@ -0,0 +1,161 @@
+// 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::jump_hop_runtime_run_row_type::JumpHopRuntimeRunRow;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `jump_hop_runtime_run`.
+///
+/// Obtain a handle from the [`JumpHopRuntimeRunTableAccess::jump_hop_runtime_run`] method on [`super::RemoteTables`],
+/// like `ctx.db.jump_hop_runtime_run()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_runtime_run().on_insert(...)`.
+pub struct JumpHopRuntimeRunTableHandle<'ctx> {
+    imp: __sdk::TableHandle<JumpHopRuntimeRunRow>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `jump_hop_runtime_run`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait JumpHopRuntimeRunTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`JumpHopRuntimeRunTableHandle`], which mediates access to the table `jump_hop_runtime_run`.
+    fn jump_hop_runtime_run(&self) -> JumpHopRuntimeRunTableHandle<'_>;
+}
+
+impl JumpHopRuntimeRunTableAccess for super::RemoteTables {
+    fn jump_hop_runtime_run(&self) -> JumpHopRuntimeRunTableHandle<'_> {
+        JumpHopRuntimeRunTableHandle {
+            imp: self
+                .imp
+                .get_table::<JumpHopRuntimeRunRow>("jump_hop_runtime_run"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct JumpHopRuntimeRunInsertCallbackId(__sdk::CallbackId);
+pub struct JumpHopRuntimeRunDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::Table for JumpHopRuntimeRunTableHandle<'ctx> {
+    type Row = JumpHopRuntimeRunRow;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = JumpHopRuntimeRunRow> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = JumpHopRuntimeRunInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopRuntimeRunInsertCallbackId {
+        JumpHopRuntimeRunInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: JumpHopRuntimeRunInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = JumpHopRuntimeRunDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopRuntimeRunDeleteCallbackId {
+        JumpHopRuntimeRunDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: JumpHopRuntimeRunDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct JumpHopRuntimeRunUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for JumpHopRuntimeRunTableHandle<'ctx> {
+    type UpdateCallbackId = JumpHopRuntimeRunUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> JumpHopRuntimeRunUpdateCallbackId {
+        JumpHopRuntimeRunUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: JumpHopRuntimeRunUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `run_id` unique index on the table `jump_hop_runtime_run`,
+/// which allows point queries on the field of the same name
+/// via the [`JumpHopRuntimeRunRunIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_runtime_run().run_id().find(...)`.
+pub struct JumpHopRuntimeRunRunIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<JumpHopRuntimeRunRow, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> JumpHopRuntimeRunTableHandle<'ctx> {
+    /// Get a handle on the `run_id` unique index on the table `jump_hop_runtime_run`.
+    pub fn run_id(&self) -> JumpHopRuntimeRunRunIdUnique<'ctx> {
+        JumpHopRuntimeRunRunIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("run_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> JumpHopRuntimeRunRunIdUnique<'ctx> {
+    /// Find the subscribed row whose `run_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<JumpHopRuntimeRunRow> {
+        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::<JumpHopRuntimeRunRow>("jump_hop_runtime_run");
+    _table.add_unique_constraint::<String>("run_id", |row| &row.run_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<JumpHopRuntimeRunRow>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<JumpHopRuntimeRunRow>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `JumpHopRuntimeRunRow`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait jump_hop_runtime_runQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `JumpHopRuntimeRunRow`.
+    fn jump_hop_runtime_run(&self) -> __sdk::__query_builder::Table<JumpHopRuntimeRunRow>;
+}
+
+impl jump_hop_runtime_runQueryTableAccess for __sdk::QueryTableAccessor {
+    fn jump_hop_runtime_run(&self) -> __sdk::__query_builder::Table<JumpHopRuntimeRunRow> {
+        __sdk::__query_builder::Table::new("jump_hop_runtime_run")
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_scoring_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 JumpHopScoring {
+    pub charge_to_distance_ratio: f32,
+    pub max_charge_ms: u32,
+    pub hit_bonus: u32,
+    pub perfect_bonus: u32,
+}
+
+impl __sdk::InModule for JumpHopScoring {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_asset_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 JumpHopTileAssetSnapshot {
+    pub tile_type: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub source_atlas_cell: String,
+    pub visual_width: u32,
+    pub visual_height: u32,
+    pub top_surface_radius: f32,
+    pub landing_radius: f32,
+}
+
+impl __sdk::InModule for JumpHopTileAssetSnapshot {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_tile_type_type.rs

@@ -0,0 +1,26 @@
+// 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)]
+#[derive(Copy, Eq, Hash)]
+pub enum JumpHopTileType {
+    Start,
+
+    Normal,
+
+    Target,
+
+    Finish,
+
+    Bonus,
+
+    Accent,
+}
+
+impl __sdk::InModule for JumpHopTileType {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_work_get_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 JumpHopWorkGetInput {
+    pub profile_id: String,
+    pub owner_user_id: String,
+}
+
+impl __sdk::InModule for JumpHopWorkGetInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_work_procedure_result_type.rs

@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::jump_hop_work_snapshot_type::JumpHopWorkSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopWorkProcedureResult {
+    pub ok: bool,
+    pub work: Option<JumpHopWorkSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for JumpHopWorkProcedureResult {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_work_profile_row_type.rs

@@ -0,0 +1,134 @@
+// 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 JumpHopWorkProfileRow {
+    pub profile_id: String,
+    pub work_id: String,
+    pub owner_user_id: String,
+    pub source_session_id: String,
+    pub author_display_name: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags_json: String,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    pub end_mood_prompt: String,
+    pub character_asset_json: String,
+    pub tile_atlas_asset_json: String,
+    pub tile_assets_json: String,
+    pub path_json: String,
+    pub cover_image_src: String,
+    pub cover_composite: String,
+    pub generation_status: String,
+    pub publication_status: String,
+    pub play_count: u32,
+    pub updated_at: __sdk::Timestamp,
+    pub published_at: Option<__sdk::Timestamp>,
+}
+
+impl __sdk::InModule for JumpHopWorkProfileRow {
+    type Module = super::RemoteModule;
+}
+
+/// Column accessor struct for the table `JumpHopWorkProfileRow`.
+///
+/// Provides typed access to columns for query building.
+pub struct JumpHopWorkProfileRowCols {
+    pub profile_id: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub work_id: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub owner_user_id: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub source_session_id: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub author_display_name: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub work_title: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub work_description: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub theme_tags_json: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub difficulty: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub style_preset: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub character_prompt: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub tile_prompt: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub end_mood_prompt: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub character_asset_json: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub tile_atlas_asset_json: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub tile_assets_json: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub path_json: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub cover_image_src: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub cover_composite: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub generation_status: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub publication_status: __sdk::__query_builder::Col<JumpHopWorkProfileRow, String>,
+    pub play_count: __sdk::__query_builder::Col<JumpHopWorkProfileRow, u32>,
+    pub updated_at: __sdk::__query_builder::Col<JumpHopWorkProfileRow, __sdk::Timestamp>,
+    pub published_at: __sdk::__query_builder::Col<JumpHopWorkProfileRow, Option<__sdk::Timestamp>>,
+}
+
+impl __sdk::__query_builder::HasCols for JumpHopWorkProfileRow {
+    type Cols = JumpHopWorkProfileRowCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        JumpHopWorkProfileRowCols {
+            profile_id: __sdk::__query_builder::Col::new(table_name, "profile_id"),
+            work_id: __sdk::__query_builder::Col::new(table_name, "work_id"),
+            owner_user_id: __sdk::__query_builder::Col::new(table_name, "owner_user_id"),
+            source_session_id: __sdk::__query_builder::Col::new(table_name, "source_session_id"),
+            author_display_name: __sdk::__query_builder::Col::new(
+                table_name,
+                "author_display_name",
+            ),
+            work_title: __sdk::__query_builder::Col::new(table_name, "work_title"),
+            work_description: __sdk::__query_builder::Col::new(table_name, "work_description"),
+            theme_tags_json: __sdk::__query_builder::Col::new(table_name, "theme_tags_json"),
+            difficulty: __sdk::__query_builder::Col::new(table_name, "difficulty"),
+            style_preset: __sdk::__query_builder::Col::new(table_name, "style_preset"),
+            character_prompt: __sdk::__query_builder::Col::new(table_name, "character_prompt"),
+            tile_prompt: __sdk::__query_builder::Col::new(table_name, "tile_prompt"),
+            end_mood_prompt: __sdk::__query_builder::Col::new(table_name, "end_mood_prompt"),
+            character_asset_json: __sdk::__query_builder::Col::new(
+                table_name,
+                "character_asset_json",
+            ),
+            tile_atlas_asset_json: __sdk::__query_builder::Col::new(
+                table_name,
+                "tile_atlas_asset_json",
+            ),
+            tile_assets_json: __sdk::__query_builder::Col::new(table_name, "tile_assets_json"),
+            path_json: __sdk::__query_builder::Col::new(table_name, "path_json"),
+            cover_image_src: __sdk::__query_builder::Col::new(table_name, "cover_image_src"),
+            cover_composite: __sdk::__query_builder::Col::new(table_name, "cover_composite"),
+            generation_status: __sdk::__query_builder::Col::new(table_name, "generation_status"),
+            publication_status: __sdk::__query_builder::Col::new(table_name, "publication_status"),
+            play_count: __sdk::__query_builder::Col::new(table_name, "play_count"),
+            updated_at: __sdk::__query_builder::Col::new(table_name, "updated_at"),
+            published_at: __sdk::__query_builder::Col::new(table_name, "published_at"),
+        }
+    }
+}
+
+/// Indexed column accessor struct for the table `JumpHopWorkProfileRow`.
+///
+/// Provides typed access to indexed columns for query building.
+pub struct JumpHopWorkProfileRowIxCols {
+    pub owner_user_id: __sdk::__query_builder::IxCol<JumpHopWorkProfileRow, String>,
+    pub profile_id: __sdk::__query_builder::IxCol<JumpHopWorkProfileRow, String>,
+    pub publication_status: __sdk::__query_builder::IxCol<JumpHopWorkProfileRow, String>,
+}
+
+impl __sdk::__query_builder::HasIxCols for JumpHopWorkProfileRow {
+    type IxCols = JumpHopWorkProfileRowIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        JumpHopWorkProfileRowIxCols {
+            owner_user_id: __sdk::__query_builder::IxCol::new(table_name, "owner_user_id"),
+            profile_id: __sdk::__query_builder::IxCol::new(table_name, "profile_id"),
+            publication_status: __sdk::__query_builder::IxCol::new(
+                table_name,
+                "publication_status",
+            ),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for JumpHopWorkProfileRow {}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_work_profile_table.rs

@@ -0,0 +1,161 @@
+// 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::jump_hop_work_profile_row_type::JumpHopWorkProfileRow;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+/// Table handle for the table `jump_hop_work_profile`.
+///
+/// Obtain a handle from the [`JumpHopWorkProfileTableAccess::jump_hop_work_profile`] method on [`super::RemoteTables`],
+/// like `ctx.db.jump_hop_work_profile()`.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_work_profile().on_insert(...)`.
+pub struct JumpHopWorkProfileTableHandle<'ctx> {
+    imp: __sdk::TableHandle<JumpHopWorkProfileRow>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the table `jump_hop_work_profile`.
+///
+/// Implemented for [`super::RemoteTables`].
+pub trait JumpHopWorkProfileTableAccess {
+    #[allow(non_snake_case)]
+    /// Obtain a [`JumpHopWorkProfileTableHandle`], which mediates access to the table `jump_hop_work_profile`.
+    fn jump_hop_work_profile(&self) -> JumpHopWorkProfileTableHandle<'_>;
+}
+
+impl JumpHopWorkProfileTableAccess for super::RemoteTables {
+    fn jump_hop_work_profile(&self) -> JumpHopWorkProfileTableHandle<'_> {
+        JumpHopWorkProfileTableHandle {
+            imp: self
+                .imp
+                .get_table::<JumpHopWorkProfileRow>("jump_hop_work_profile"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct JumpHopWorkProfileInsertCallbackId(__sdk::CallbackId);
+pub struct JumpHopWorkProfileDeleteCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::Table for JumpHopWorkProfileTableHandle<'ctx> {
+    type Row = JumpHopWorkProfileRow;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = JumpHopWorkProfileRow> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = JumpHopWorkProfileInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopWorkProfileInsertCallbackId {
+        JumpHopWorkProfileInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: JumpHopWorkProfileInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = JumpHopWorkProfileDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> JumpHopWorkProfileDeleteCallbackId {
+        JumpHopWorkProfileDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: JumpHopWorkProfileDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+pub struct JumpHopWorkProfileUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::TableWithPrimaryKey for JumpHopWorkProfileTableHandle<'ctx> {
+    type UpdateCallbackId = JumpHopWorkProfileUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> JumpHopWorkProfileUpdateCallbackId {
+        JumpHopWorkProfileUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: JumpHopWorkProfileUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+/// Access to the `profile_id` unique index on the table `jump_hop_work_profile`,
+/// which allows point queries on the field of the same name
+/// via the [`JumpHopWorkProfileProfileIdUnique::find`] method.
+///
+/// Users are encouraged not to explicitly reference this type,
+/// but to directly chain method calls,
+/// like `ctx.db.jump_hop_work_profile().profile_id().find(...)`.
+pub struct JumpHopWorkProfileProfileIdUnique<'ctx> {
+    imp: __sdk::UniqueConstraintHandle<JumpHopWorkProfileRow, String>,
+    phantom: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+impl<'ctx> JumpHopWorkProfileTableHandle<'ctx> {
+    /// Get a handle on the `profile_id` unique index on the table `jump_hop_work_profile`.
+    pub fn profile_id(&self) -> JumpHopWorkProfileProfileIdUnique<'ctx> {
+        JumpHopWorkProfileProfileIdUnique {
+            imp: self.imp.get_unique_constraint::<String>("profile_id"),
+            phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'ctx> JumpHopWorkProfileProfileIdUnique<'ctx> {
+    /// Find the subscribed row whose `profile_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<JumpHopWorkProfileRow> {
+        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::<JumpHopWorkProfileRow>("jump_hop_work_profile");
+    _table.add_unique_constraint::<String>("profile_id", |row| &row.profile_id);
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<JumpHopWorkProfileRow>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<JumpHopWorkProfileRow>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for query builder access to the table `JumpHopWorkProfileRow`.
+///
+/// Implemented for [`__sdk::QueryTableAccessor`].
+pub trait jump_hop_work_profileQueryTableAccess {
+    #[allow(non_snake_case)]
+    /// Get a query builder for the table `JumpHopWorkProfileRow`.
+    fn jump_hop_work_profile(&self) -> __sdk::__query_builder::Table<JumpHopWorkProfileRow>;
+}
+
+impl jump_hop_work_profileQueryTableAccess for __sdk::QueryTableAccessor {
+    fn jump_hop_work_profile(&self) -> __sdk::__query_builder::Table<JumpHopWorkProfileRow> {
+        __sdk::__query_builder::Table::new("jump_hop_work_profile")
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_work_publish_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 JumpHopWorkPublishInput {
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub published_at_micros: i64,
+}
+
+impl __sdk::InModule for JumpHopWorkPublishInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_work_snapshot_type.rs

@@ -0,0 +1,43 @@
+// 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::jump_hop_character_asset_snapshot_type::JumpHopCharacterAssetSnapshot;
+use super::jump_hop_path_type::JumpHopPath;
+use super::jump_hop_tile_asset_snapshot_type::JumpHopTileAssetSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopWorkSnapshot {
+    pub work_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub source_session_id: String,
+    pub author_display_name: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    pub end_mood_prompt: Option<String>,
+    pub character_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_atlas_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_assets: Vec<JumpHopTileAssetSnapshot>,
+    pub path: JumpHopPath,
+    pub cover_image_src: String,
+    pub cover_composite: Option<String>,
+    pub publication_status: String,
+    pub publish_ready: bool,
+    pub play_count: u32,
+    pub generation_status: String,
+    pub updated_at_micros: i64,
+    pub published_at_micros: Option<i64>,
+}
+
+impl __sdk::InModule for JumpHopWorkSnapshot {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_work_update_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 JumpHopWorkUpdateInput {
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags_json: String,
+    pub difficulty: Option<String>,
+    pub style_preset: Option<String>,
+    pub cover_image_src: Option<String>,
+    pub cover_composite: Option<String>,
+    pub updated_at_micros: i64,
+}
+
+impl __sdk::InModule for JumpHopWorkUpdateInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_works_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 JumpHopWorksListInput {
+    pub owner_user_id: String,
+    pub published_only: bool,
+}
+
+impl __sdk::InModule for JumpHopWorksListInput {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/jump_hop_works_procedure_result_type.rs

@@ -0,0 +1,19 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+use super::jump_hop_work_snapshot_type::JumpHopWorkSnapshot;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct JumpHopWorksProcedureResult {
+    pub ok: bool,
+    pub items: Vec<JumpHopWorkSnapshot>,
+    pub error_message: Option<String>,
+}
+
+impl __sdk::InModule for JumpHopWorksProcedureResult {
+    type Module = super::RemoteModule;
+}

server-rs/crates/spacetime-client/src/module_bindings/list_jump_hop_works_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::jump_hop_works_list_input_type::JumpHopWorksListInput;
+use super::jump_hop_works_procedure_result_type::JumpHopWorksProcedureResult;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct ListJumpHopWorksArgs {
+    pub input: JumpHopWorksListInput,
+}
+
+impl __sdk::InModule for ListJumpHopWorksArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `list_jump_hop_works`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait list_jump_hop_works {
+    fn list_jump_hop_works(&self, input: JumpHopWorksListInput) {
+        self.list_jump_hop_works_then(input, |_, _| {});
+    }
+
+    fn list_jump_hop_works_then(
+        &self,
+        input: JumpHopWorksListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorksProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl list_jump_hop_works for super::RemoteProcedures {
+    fn list_jump_hop_works_then(
+        &self,
+        input: JumpHopWorksListInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorksProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopWorksProcedureResult>(
+                "list_jump_hop_works",
+                ListJumpHopWorksArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/publish_jump_hop_work_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::jump_hop_work_procedure_result_type::JumpHopWorkProcedureResult;
+use super::jump_hop_work_publish_input_type::JumpHopWorkPublishInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct PublishJumpHopWorkArgs {
+    pub input: JumpHopWorkPublishInput,
+}
+
+impl __sdk::InModule for PublishJumpHopWorkArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `publish_jump_hop_work`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait publish_jump_hop_work {
+    fn publish_jump_hop_work(&self, input: JumpHopWorkPublishInput) {
+        self.publish_jump_hop_work_then(input, |_, _| {});
+    }
+
+    fn publish_jump_hop_work_then(
+        &self,
+        input: JumpHopWorkPublishInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorkProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl publish_jump_hop_work for super::RemoteProcedures {
+    fn publish_jump_hop_work_then(
+        &self,
+        input: JumpHopWorkPublishInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorkProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopWorkProcedureResult>(
+                "publish_jump_hop_work",
+                PublishJumpHopWorkArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/restart_jump_hop_run_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::jump_hop_run_procedure_result_type::JumpHopRunProcedureResult;
+use super::jump_hop_run_restart_input_type::JumpHopRunRestartInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct RestartJumpHopRunArgs {
+    pub input: JumpHopRunRestartInput,
+}
+
+impl __sdk::InModule for RestartJumpHopRunArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `restart_jump_hop_run`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait restart_jump_hop_run {
+    fn restart_jump_hop_run(&self, input: JumpHopRunRestartInput) {
+        self.restart_jump_hop_run_then(input, |_, _| {});
+    }
+
+    fn restart_jump_hop_run_then(
+        &self,
+        input: JumpHopRunRestartInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl restart_jump_hop_run for super::RemoteProcedures {
+    fn restart_jump_hop_run_then(
+        &self,
+        input: JumpHopRunRestartInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopRunProcedureResult>(
+                "restart_jump_hop_run",
+                RestartJumpHopRunArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/start_jump_hop_run_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::jump_hop_run_procedure_result_type::JumpHopRunProcedureResult;
+use super::jump_hop_run_start_input_type::JumpHopRunStartInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct StartJumpHopRunArgs {
+    pub input: JumpHopRunStartInput,
+}
+
+impl __sdk::InModule for StartJumpHopRunArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `start_jump_hop_run`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait start_jump_hop_run {
+    fn start_jump_hop_run(&self, input: JumpHopRunStartInput) {
+        self.start_jump_hop_run_then(input, |_, _| {});
+    }
+
+    fn start_jump_hop_run_then(
+        &self,
+        input: JumpHopRunStartInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl start_jump_hop_run for super::RemoteProcedures {
+    fn start_jump_hop_run_then(
+        &self,
+        input: JumpHopRunStartInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopRunProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopRunProcedureResult>(
+                "start_jump_hop_run",
+                StartJumpHopRunArgs { input },
+                __callback,
+            );
+    }
+}

server-rs/crates/spacetime-client/src/module_bindings/update_jump_hop_work_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::jump_hop_work_procedure_result_type::JumpHopWorkProcedureResult;
+use super::jump_hop_work_update_input_type::JumpHopWorkUpdateInput;
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+struct UpdateJumpHopWorkArgs {
+    pub input: JumpHopWorkUpdateInput,
+}
+
+impl __sdk::InModule for UpdateJumpHopWorkArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+/// Extension trait for access to the procedure `update_jump_hop_work`.
+///
+/// Implemented for [`super::RemoteProcedures`].
+pub trait update_jump_hop_work {
+    fn update_jump_hop_work(&self, input: JumpHopWorkUpdateInput) {
+        self.update_jump_hop_work_then(input, |_, _| {});
+    }
+
+    fn update_jump_hop_work_then(
+        &self,
+        input: JumpHopWorkUpdateInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorkProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    );
+}
+
+impl update_jump_hop_work for super::RemoteProcedures {
+    fn update_jump_hop_work_then(
+        &self,
+        input: JumpHopWorkUpdateInput,
+
+        __callback: impl FnOnce(
+            &super::ProcedureEventContext,
+            Result<JumpHopWorkProcedureResult, __sdk::InternalError>,
+        ) + Send
+        + 'static,
+    ) {
+        self.imp
+            .invoke_procedure_with_callback::<_, JumpHopWorkProcedureResult>(
+                "update_jump_hop_work",
+                UpdateJumpHopWorkArgs { input },
+                __callback,
+            );
+    }
+}

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

@@ -595,7 +595,18 @@ impl SpacetimeClient {
 
         let procedure_inputs = events
             .into_iter()
-            .map(crate::module_bindings::RuntimeTrackingEventInput::from)
+            .map(|event| crate::module_bindings::RuntimeTrackingEventInput {
+                event_id: event.event_id,
+                event_key: event.event_key,
+                scope_kind: map_runtime_tracking_scope_kind(event.scope_kind),
+                scope_id: event.scope_id,
+                user_id: event.user_id,
+                owner_user_id: event.owner_user_id,
+                profile_id: event.profile_id,
+                module_key: event.module_key,
+                metadata_json: event.metadata_json,
+                occurred_at_micros: event.occurred_at_micros,
+            })
             .collect::<Vec<_>>();
 
         self.call_after_connect(

server-rs/crates/spacetime-module/Cargo.toml

@@ -18,6 +18,7 @@ module-big-fish = { workspace = true, features = ["spacetime-types"] }
 module-combat = { workspace = true, features = ["spacetime-types"] }
 module-inventory = { workspace = true, features = ["spacetime-types"] }
 module-custom-world = { workspace = true, features = ["spacetime-types"] }
+module-jump-hop = { workspace = true, features = ["spacetime-types"] }
 module-match3d = { workspace = true }
 module-npc = { workspace = true, features = ["spacetime-types"] }
 module-puzzle = { workspace = true, features = ["spacetime-types"] }

server-rs/crates/spacetime-module/src/jump_hop/tables.rs

@@ -0,0 +1,91 @@
+use crate::*;
+
+#[spacetimedb::table(
+    accessor = jump_hop_agent_session,
+    index(accessor = by_jump_hop_agent_session_owner_user_id, btree(columns = [owner_user_id]))
+)]
+pub struct JumpHopAgentSessionRow {
+    #[primary_key]
+    pub(crate) session_id: String,
+    pub(crate) owner_user_id: String,
+    pub(crate) seed_text: String,
+    pub(crate) current_turn: u32,
+    pub(crate) progress_percent: u32,
+    pub(crate) stage: String,
+    pub(crate) config_json: String,
+    pub(crate) draft_json: String,
+    pub(crate) last_assistant_reply: String,
+    pub(crate) published_profile_id: String,
+    pub(crate) created_at: Timestamp,
+    pub(crate) updated_at: Timestamp,
+}
+
+#[spacetimedb::table(
+    accessor = jump_hop_work_profile,
+    index(accessor = by_jump_hop_work_owner_user_id, btree(columns = [owner_user_id])),
+    index(accessor = by_jump_hop_work_publication_status, btree(columns = [publication_status]))
+)]
+pub struct JumpHopWorkProfileRow {
+    #[primary_key]
+    pub(crate) profile_id: String,
+    pub(crate) work_id: String,
+    pub(crate) owner_user_id: String,
+    pub(crate) source_session_id: String,
+    pub(crate) author_display_name: String,
+    pub(crate) work_title: String,
+    pub(crate) work_description: String,
+    pub(crate) theme_tags_json: String,
+    pub(crate) difficulty: String,
+    pub(crate) style_preset: String,
+    pub(crate) character_prompt: String,
+    pub(crate) tile_prompt: String,
+    pub(crate) end_mood_prompt: String,
+    pub(crate) character_asset_json: String,
+    pub(crate) tile_atlas_asset_json: String,
+    pub(crate) tile_assets_json: String,
+    pub(crate) path_json: String,
+    pub(crate) cover_image_src: String,
+    pub(crate) cover_composite: String,
+    pub(crate) generation_status: String,
+    pub(crate) publication_status: String,
+    pub(crate) play_count: u32,
+    pub(crate) updated_at: Timestamp,
+    pub(crate) published_at: Option<Timestamp>,
+}
+
+#[spacetimedb::table(
+    accessor = jump_hop_runtime_run,
+    index(accessor = by_jump_hop_run_owner_user_id, btree(columns = [owner_user_id])),
+    index(accessor = by_jump_hop_run_profile_id, btree(columns = [profile_id]))
+)]
+pub struct JumpHopRuntimeRunRow {
+    #[primary_key]
+    pub(crate) run_id: String,
+    pub(crate) owner_user_id: String,
+    pub(crate) profile_id: String,
+    pub(crate) status: String,
+    pub(crate) started_at_ms: i64,
+    pub(crate) finished_at_ms: i64,
+    pub(crate) current_platform_index: u32,
+    pub(crate) score: u32,
+    pub(crate) combo: u32,
+    pub(crate) snapshot_json: String,
+    pub(crate) created_at: Timestamp,
+    pub(crate) updated_at: Timestamp,
+}
+
+#[spacetimedb::table(
+    accessor = jump_hop_event,
+    index(accessor = by_jump_hop_event_profile_id, btree(columns = [profile_id])),
+    index(accessor = by_jump_hop_event_run_id, btree(columns = [run_id]))
+)]
+pub struct JumpHopEventRow {
+    #[primary_key]
+    pub(crate) event_id: String,
+    pub(crate) owner_user_id: String,
+    pub(crate) profile_id: String,
+    pub(crate) run_id: String,
+    pub(crate) event_type: String,
+    pub(crate) result: String,
+    pub(crate) occurred_at: Timestamp,
+}

server-rs/crates/spacetime-module/src/jump_hop/types.rs

@@ -0,0 +1,261 @@
+use crate::*;
+use serde::{Deserialize, Serialize};
+
+pub const JUMP_HOP_TEMPLATE_ID: &str = "jump-hop";
+pub const JUMP_HOP_TEMPLATE_NAME: &str = "跳一跳";
+pub const JUMP_HOP_STYLE_MINIMAL_BLOCKS: &str = "minimal-blocks";
+pub const JUMP_HOP_STAGE_COLLECTING: &str = "Collecting";
+pub const JUMP_HOP_STAGE_DRAFT_COMPILED: &str = "DraftCompiled";
+pub const JUMP_HOP_STAGE_PUBLISHED: &str = "Published";
+pub const JUMP_HOP_PUBLICATION_DRAFT: &str = "Draft";
+pub const JUMP_HOP_PUBLICATION_PUBLISHED: &str = "Published";
+pub const JUMP_HOP_GENERATION_DRAFT: &str = "draft";
+pub const JUMP_HOP_GENERATION_READY: &str = "ready";
+pub const JUMP_HOP_EVENT_RUN_STARTED: &str = "run-started";
+pub const JUMP_HOP_EVENT_RUN_RESTARTED: &str = "run-restarted";
+pub const JUMP_HOP_EVENT_JUMP: &str = "jump";
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopAgentSessionCreateInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub seed_text: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags_json: Option<String>,
+    pub welcome_message_text: String,
+    pub config_json: Option<String>,
+    pub created_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopAgentSessionGetInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopDraftCompileInput {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub author_display_name: String,
+    pub seed_text: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags_json: Option<String>,
+    pub theme_text: Option<String>,
+    pub difficulty: Option<String>,
+    pub style_preset: Option<String>,
+    pub character_prompt: Option<String>,
+    pub tile_prompt: Option<String>,
+    pub end_mood_prompt: Option<String>,
+    pub character_asset_json: Option<String>,
+    pub tile_atlas_asset_json: Option<String>,
+    pub tile_assets_json: Option<String>,
+    pub cover_composite: Option<String>,
+    pub generation_status: Option<String>,
+    pub compiled_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopWorkUpdateInput {
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags_json: String,
+    pub difficulty: Option<String>,
+    pub style_preset: Option<String>,
+    pub cover_image_src: Option<String>,
+    pub cover_composite: Option<String>,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopWorkPublishInput {
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub published_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopWorksListInput {
+    pub owner_user_id: String,
+    pub published_only: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopWorkGetInput {
+    pub profile_id: String,
+    pub owner_user_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopRunStartInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub profile_id: String,
+    pub client_event_id: String,
+    pub started_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopRunGetInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopRunJumpInput {
+    pub run_id: String,
+    pub owner_user_id: String,
+    pub charge_ms: u32,
+    pub client_event_id: String,
+    pub jumped_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, SpacetimeType)]
+pub struct JumpHopRunRestartInput {
+    pub source_run_id: String,
+    pub next_run_id: String,
+    pub owner_user_id: String,
+    pub client_action_id: String,
+    pub restarted_at_ms: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct JumpHopAgentSessionProcedureResult {
+    pub ok: bool,
+    pub session: Option<JumpHopAgentSessionSnapshot>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct JumpHopWorkProcedureResult {
+    pub ok: bool,
+    pub work: Option<JumpHopWorkSnapshot>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct JumpHopWorksProcedureResult {
+    pub ok: bool,
+    pub items: Vec<JumpHopWorkSnapshot>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, SpacetimeType)]
+pub struct JumpHopRunProcedureResult {
+    pub ok: bool,
+    pub run: Option<module_jump_hop::JumpHopRunSnapshot>,
+    pub error_message: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopCreatorConfigSnapshot {
+    pub theme_text: String,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    #[serde(default)]
+    pub end_mood_prompt: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopCharacterAssetSnapshot {
+    pub asset_id: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub generation_provider: String,
+    pub prompt: String,
+    pub width: u32,
+    pub height: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopTileAssetSnapshot {
+    pub tile_type: String,
+    pub image_src: String,
+    pub image_object_key: String,
+    pub asset_object_id: String,
+    pub source_atlas_cell: String,
+    pub visual_width: u32,
+    pub visual_height: u32,
+    pub top_surface_radius: f32,
+    pub landing_radius: f32,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopDraftSnapshot {
+    pub template_id: String,
+    pub template_name: String,
+    pub profile_id: Option<String>,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    pub end_mood_prompt: Option<String>,
+    pub character_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_atlas_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_assets: Vec<JumpHopTileAssetSnapshot>,
+    pub path: Option<module_jump_hop::JumpHopPath>,
+    pub cover_composite: Option<String>,
+    pub generation_status: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopAgentSessionSnapshot {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub seed_text: String,
+    pub current_turn: u32,
+    pub progress_percent: u32,
+    pub stage: String,
+    pub config: JumpHopCreatorConfigSnapshot,
+    pub draft: Option<JumpHopDraftSnapshot>,
+    pub last_assistant_reply: String,
+    pub published_profile_id: Option<String>,
+    pub created_at_micros: i64,
+    pub updated_at_micros: i64,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, SpacetimeType)]
+#[serde(rename_all = "camelCase")]
+pub struct JumpHopWorkSnapshot {
+    pub work_id: String,
+    pub profile_id: String,
+    pub owner_user_id: String,
+    pub source_session_id: String,
+    pub author_display_name: String,
+    pub work_title: String,
+    pub work_description: String,
+    pub theme_tags: Vec<String>,
+    pub difficulty: String,
+    pub style_preset: String,
+    pub character_prompt: String,
+    pub tile_prompt: String,
+    pub end_mood_prompt: Option<String>,
+    pub character_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_atlas_asset: Option<JumpHopCharacterAssetSnapshot>,
+    pub tile_assets: Vec<JumpHopTileAssetSnapshot>,
+    pub path: module_jump_hop::JumpHopPath,
+    pub cover_image_src: String,
+    pub cover_composite: Option<String>,
+    pub publication_status: String,
+    pub publish_ready: bool,
+    pub play_count: u32,
+    pub generation_status: String,
+    pub updated_at_micros: i64,
+    pub published_at_micros: Option<i64>,
+}

server-rs/crates/spacetime-module/src/lib.rs

@@ -8,6 +8,7 @@ pub use module_big_fish::*;
 pub use module_combat::*;
 pub use module_custom_world::*;
 pub use module_inventory::*;
+pub use module_jump_hop::*;
 pub use module_npc::*;
 pub use module_progression::*;
 pub use module_quest::*;
@@ -29,6 +30,7 @@ mod custom_world;
 mod domain_types;
 mod entry;
 mod gameplay;
+mod jump_hop;
 mod match3d;
 mod migration;
 mod puzzle;
@@ -45,6 +47,7 @@ pub use custom_world::*;
 pub use domain_types::*;
 pub use entry::*;
 pub use gameplay::*;
+pub use jump_hop::*;
 pub use match3d::*;
 pub use migration::*;
 pub use runtime::*;

server-rs/crates/spacetime-module/src/migration.rs

@@ -12,6 +12,9 @@ use crate::bark_battle::tables::{
     bark_battle_work_stats_projection,
 };
 use crate::big_fish::big_fish_runtime_run;
+use crate::jump_hop::tables::{
+    jump_hop_agent_session, jump_hop_event, jump_hop_runtime_run, jump_hop_work_profile,
+};
 use crate::match3d::tables::{
     match3d_agent_message, match3d_agent_session, match3d_runtime_run, match3d_work_profile,
 };
@@ -234,6 +237,10 @@ macro_rules! migration_tables {
             match3d_agent_message,
             match3d_work_profile,
             match3d_runtime_run,
+            jump_hop_agent_session,
+            jump_hop_work_profile,
+            jump_hop_runtime_run,
+            jump_hop_event,
             square_hole_agent_session,
             square_hole_agent_message,
             square_hole_work_profile,