[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7C3WQH8X8S7GR2YXZQW94HT":3,"skill-same:01M7C3WQH8X8S7GR2YXZQW94HT":50},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":27,"commitSha":28,"skillDirectory":29,"forksCount":30,"repositoryHtmlUrl":31,"repositoryHomepageUrl":32,"ownerHtmlUrl":33,"ownerBlogUrl":6,"ownerDescription":34,"updatedAt":35,"install":36,"resources":49},"01M7C3WQH8X8S7GR2YXZQW94HT","robius-app-architecture",null,"CRITICAL: Use for Robius app architecture patterns. Triggers on:\nTokio, async, submit_async_request, 异步, 架构,\nSignalToUI, Cx::post_action, worker task,\napp structure, MatchEvent, handle_startup","YYC-Cube\u002FYYC3-Knowledge-Base","YYC-Cube","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F235006543?v=4","01M79J2PH4SWD2X0825X6PN748","yyc3","01M79J2PHVK3F6ZBYT8K2SCZCW",1,"MIT","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fplugins\u002Fantigravity-awesome-skills-claude\u002Fskills\u002Frobius-app-architecture\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: robius-app-architecture\ndescription: |\n  CRITICAL: Use for Robius app architecture patterns. Triggers on:\n  Tokio, async, submit_async_request, 异步, 架构,\n  SignalToUI, Cx::post_action, worker task,\n  app structure, MatchEvent, handle_startup\nrisk: unknown\nsource: community\n---\n\n# Robius App Architecture Skill\n\nBest practices for structuring Makepad applications based on the Robrix and Moly codebases - production applications built with Makepad and Robius framework.\n\n**Source codebases:**\n- **Robrix**: Matrix chat client - complex sync\u002Fasync with background subscriptions\n- **Moly**: AI chat application - cross-platform (native + WASM) with streaming APIs\n\n## When to Use\nUse this skill when:\n- Building a Makepad application with async backend integration\n- Designing sync\u002Fasync communication patterns in Makepad\n- Structuring a Robius-style application\n- Keywords: robrix, robius, makepad app structure, async makepad, tokio makepad\n\n## Production Patterns\n\nFor production-ready async patterns, see the `_base\u002F` directory:\n\n| Pattern | Description |\n|---------|-------------|\n| 08-async-loading | Async data loading with loading states |\n| 09-streaming-results | Incremental results with SignalToUI |\n| 13-tokio-integration | Full tokio runtime integration |\n\n## Core Architecture Pattern\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│                     UI Thread (Makepad)                     │\n│  ┌─────────┐     ┌──────────┐     ┌──────────────────────┐ │\n│  │   App   │────▶│ WidgetRef │────▶│ Widget Tree (View)  │ │\n│  │ State   │     │    ui     │     │ Scope::with_data()  │ │\n│  └────┬────┘     └──────────┘     └──────────────────────┘ │\n│       │                                                     │\n│       │ submit_async_request()                              │\n│       ▼                                                     │\n│  ┌─────────────────┐          ┌─────────────────────────┐  │\n│  │ REQUEST_SENDER  │─────────▶│  Crossbeam SegQueue     │  │\n│  │ (MPSC Channel)  │          │  (Lock-free Updates)    │  │\n│  └─────────────────┘          └─────────────────────────┘  │\n└───────────────────────────────────┬─────────────────────────┘\n                                    │\n                    SignalToUI::set_ui_signal()\n                                    │\n┌───────────────────────────────────┴─────────────────────────┐\n│                   Tokio Runtime (Async)                      │\n│  ┌──────────────────────────────────────────────────────┐   │\n│  │           worker_task (Request Handler)               │   │\n│  │  - Receives Request from UI                           │   │\n│  │  - Spawns async tasks per request                     │   │\n│  │  - Posts actions back via Cx::post_action()           │   │\n│  └──────────────────────────────────────────────────────┘   │\n│  ┌──────────────────────────────────────────────────────┐   │\n│  │         Per-Item Subscriber Tasks                     │   │\n│  │  - Listens to external data stream                    │   │\n│  │  - Sends Update via crossbeam channel                 │   │\n│  │  - Calls SignalToUI::set_ui_signal() to wake UI       │   │\n│  └──────────────────────────────────────────────────────┘   │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## App Structure\n\n### Top-Level App Definition\n\n```rust\nuse makepad_widgets::*;\n\nlive_design! {\n    use link::theme::*;\n    use link::widgets::*;\n\n    App = {{App}} {\n        ui: \u003CRoot>{\n            main_window = \u003CWindow> {\n                window: {inner_size: vec2(1280, 800), title: \"MyApp\"},\n                body = {\n                    \u002F\u002F Main content here\n                }\n            }\n        }\n    }\n}\n\napp_main!(App);\n\n#[derive(Live)]\npub struct App {\n    #[live] ui: WidgetRef,\n    #[rust] app_state: AppState,\n}\n\nimpl LiveRegister for App {\n    fn live_register(cx: &mut Cx) {\n        \u002F\u002F Order matters: register base widgets first\n        makepad_widgets::live_design(cx);\n        \u002F\u002F Then shared\u002Fcommon widgets\n        crate::shared::live_design(cx);\n        \u002F\u002F Then feature modules\n        crate::home::live_design(cx);\n    }\n}\n\nimpl LiveHook for App {\n    fn after_new_from_doc(&mut self, cx: &mut Cx) {\n        \u002F\u002F One-time initialization after widget tree is created\n    }\n}\n```\n\n### AppMain Implementation\n\n```rust\nimpl AppMain for App {\n    fn handle_event(&mut self, cx: &mut Cx, event: &Event) {\n        \u002F\u002F Forward to MatchEvent trait\n        self.match_event(cx, event);\n\n        \u002F\u002F Pass AppState through widget tree via Scope\n        let scope = &mut Scope::with_data(&mut self.app_state);\n        self.ui.handle_event(cx, event, scope);\n    }\n}\n```\n\n## Tokio Runtime Integration\n\n### Static Runtime Initialization\n\n```rust\nuse std::sync::Mutex;\nuse tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};\n\nstatic TOKIO_RUNTIME: Mutex\u003COption\u003Ctokio::runtime::Runtime>> = Mutex::new(None);\nstatic REQUEST_SENDER: Mutex\u003COption\u003CUnboundedSender\u003CAppRequest>>> = Mutex::new(None);\n\npub fn start_async_runtime() -> Result\u003Ctokio::runtime::Handle> {\n    let (request_sender, request_receiver) = tokio::sync::mpsc::unbounded_channel();\n\n    let rt_handle = TOKIO_RUNTIME.lock().unwrap()\n        .get_or_insert_with(|| {\n            tokio::runtime::Runtime::new()\n                .expect(\"Failed to create Tokio runtime\")\n        })\n        .handle()\n        .clone();\n\n    \u002F\u002F Store sender for UI thread to use\n    *REQUEST_SENDER.lock().unwrap() = Some(request_sender);\n\n    \u002F\u002F Spawn the main worker task\n    rt_handle.spawn(worker_task(request_receiver));\n\n    Ok(rt_handle)\n}\n```\n\n### Request Submission Pattern\n\n```rust\npub enum AppRequest {\n    FetchData { id: String },\n    SendMessage { content: String },\n    \u002F\u002F ... other request types\n}\n\n\u002F\u002F\u002F Submit a request from UI thread to async runtime\npub fn submit_async_request(req: AppRequest) {\n    if let Some(sender) = REQUEST_SENDER.lock().unwrap().as_ref() {\n        sender.send(req)\n            .expect(\"BUG: worker task receiver has died!\");\n    }\n}\n```\n\n### Worker Task Pattern\n\n```rust\nasync fn worker_task(mut request_receiver: UnboundedReceiver\u003CAppRequest>) -> Result\u003C()> {\n    while let Some(request) = request_receiver.recv().await {\n        match request {\n            AppRequest::FetchData { id } => {\n                \u002F\u002F Spawn a new task for each request\n                let _task = tokio::spawn(async move {\n                    let result = fetch_data(&id).await;\n                    \u002F\u002F Post result back to UI thread\n                    Cx::post_action(DataFetchedAction { id, result });\n                });\n            }\n            AppRequest::SendMessage { content } => {\n                let _task = tokio::spawn(async move {\n                    match send_message(&content).await {\n                        Ok(()) => Cx::post_action(MessageSentAction::Success),\n                        Err(e) => Cx::post_action(MessageSentAction::Failed(e)),\n                    }\n                });\n            }\n        }\n    }\n    Ok(())\n}\n```\n\n## Lock-Free Update Queue Pattern\n\nFor high-frequency updates from background tasks:\n\n```rust\nuse crossbeam_queue::SegQueue;\nuse makepad_widgets::SignalToUI;\n\npub enum DataUpdate {\n    NewItem { item: Item },\n    ItemChanged { id: String, changes: Changes },\n    Status { message: String },\n}\n\nstatic PENDING_UPDATES: SegQueue\u003CDataUpdate> = SegQueue::new();\n\n\u002F\u002F\u002F Called from background async tasks\npub fn enqueue_update(update: DataUpdate) {\n    PENDING_UPDATES.push(update);\n    SignalToUI::set_ui_signal();  \u002F\u002F Wake UI thread\n}\n\n\u002F\u002F In widget's handle_event:\nimpl Widget for MyWidget {\n    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {\n        \u002F\u002F Poll for updates on Signal events\n        if let Event::Signal = event {\n            while let Some(update) = PENDING_UPDATES.pop() {\n                match update {\n                    DataUpdate::NewItem { item } => {\n                        self.items.push(item);\n                        self.redraw(cx);\n                    }\n                    \u002F\u002F ... handle other updates\n                }\n            }\n        }\n    }\n}\n```\n\n## Startup Sequence\n\n```rust\nimpl MatchEvent for App {\n    fn handle_startup(&mut self, cx: &mut Cx) {\n        \u002F\u002F 1. Initialize logging\n        let _ = tracing_subscriber::fmt::try_init();\n\n        \u002F\u002F 2. Initialize app data directory\n        let _app_data_dir = crate::app_data_dir();\n\n        \u002F\u002F 3. Load persisted state\n        if let Err(e) = persistence::load_window_state(\n            self.ui.window(ids!(main_window)), cx\n        ) {\n            error!(\"Failed to load window state: {}\", e);\n        }\n\n        \u002F\u002F 4. Update UI based on loaded state\n        self.update_ui_visibility(cx);\n\n        \u002F\u002F 5. Start async runtime\n        let _rt_handle = crate::start_async_runtime().unwrap();\n    }\n}\n```\n\n## Shutdown Sequence\n\n```rust\nimpl AppMain for App {\n    fn handle_event(&mut self, cx: &mut Cx, event: &Event) {\n        if let Event::Shutdown = event {\n            \u002F\u002F Save window geometry\n            let window_ref = self.ui.window(ids!(main_window));\n            if let Err(e) = persistence::save_window_state(window_ref, cx) {\n                error!(\"Failed to save window state: {e}\");\n            }\n\n            \u002F\u002F Save app state\n            if let Some(user_id) = current_user_id() {\n                if let Err(e) = persistence::save_app_state(\n                    self.app_state.clone(), user_id\n                ) {\n                    error!(\"Failed to save app state: {e}\");\n                }\n            }\n        }\n        \u002F\u002F ... rest of event handling\n    }\n}\n```\n\n## Best Practices\n\n1. **Separation of Concerns**: Keep UI logic on the main thread, async operations in Tokio runtime\n2. **Request\u002FResponse Pattern**: Use typed enums for requests and actions\n3. **Lock-Free Updates**: Use `crossbeam::SegQueue` for high-frequency background updates\n4. **SignalToUI**: Always call `SignalToUI::set_ui_signal()` after enqueueing updates\n5. **Cx::post_action()**: Use for async task results that need action handling\n6. **Scope::with_data()**: Pass shared state through widget tree\n7. **Module Registration Order**: Register base widgets before dependent modules in `live_register()`\n\n## Reference Files\n\n- `references\u002Ftokio-integration.md` - Detailed Tokio runtime patterns (Robrix)\n- `references\u002Fchannel-patterns.md` - Channel communication patterns (Robrix)\n- `references\u002Fmoly-async-patterns.md` - Cross-platform async patterns (Moly)\n  - `PlatformSend` trait for native\u002FWASM compatibility\n  - `UiRunner` for async defer operations\n  - `AbortOnDropHandle` for task cancellation\n  - `ThreadToken` for non-Send types on WASM\n  - `spawn()` platform-agnostic function\n\n## Limitations\n- Use this skill only when the task clearly matches the scope described above.\n- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.\n- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.\n","# Robius App Architecture Skill\n\nBest practices for structuring Makepad applications based on the Robrix and Moly codebases - production applications built with Makepad and Robius framework.\n\n**Source codebases:**\n- **Robrix**: Matrix chat client - complex sync\u002Fasync with background subscriptions\n- **Moly**: AI chat application - cross-platform (native + WASM) with streaming APIs\n\n## When to Use\nUse this skill when:\n- Building a Makepad application with async backend integration\n- Designing sync\u002Fasync communication patterns in Makepad\n- Structuring a Robius-style application\n- Keywords: robrix, robius, makepad app structure, async makepad, tokio makepad\n\n## Production Patterns\n\nFor production-ready async patterns, see the `_base\u002F` directory:\n\n| Pattern | Description |\n|---------|-------------|\n| 08-async-loading | Async data loading with loading states |\n| 09-streaming-results | Incremental results with SignalToUI |\n| 13-tokio-integration | Full tokio runtime integration |\n\n## Core Architecture Pattern\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│                     UI Thread (Makepad)                     │\n│  ┌─────────┐     ┌──────────┐     ┌──────────────────────┐ │\n│  │   App   │────▶│ WidgetRef │────▶│ Widget Tree (View)  │ │\n│  │ State   │     │    ui     │     │ Scope::with_data()  │ │\n│  └────┬────┘     └──────────┘     └──────────────────────┘ │\n│       │                                                     │\n│       │ submit_async_request()                              │\n│       ▼                                                     │\n│  ┌─────────────────┐          ┌─────────────────────────┐  │\n│  │ REQUEST_SENDER  │─────────▶│  Crossbeam SegQueue     │  │\n│  │ (MPSC Channel)  │          │  (Lock-free Updates)    │  │\n│  └─────────────────┘          └─────────────────────────┘  │\n└───────────────────────────────────┬─────────────────────────┘\n                                    │\n                    SignalToUI::set_ui_signal()\n                                    │\n┌───────────────────────────────────┴─────────────────────────┐\n│                   Tokio Runtime (Async)                      │\n│  ┌──────────────────────────────────────────────────────┐   │\n│  │           worker_task (Request Handler)               │   │\n│  │  - Receives Request from UI                           │   │\n│  │  - Spawns async tasks per request                     │   │\n│  │  - Posts actions back via Cx::post_action()           │   │\n│  └──────────────────────────────────────────────────────┘   │\n│  ┌──────────────────────────────────────────────────────┐   │\n│  │         Per-Item Subscriber Tasks                     │   │\n│  │  - Listens to external data stream                    │   │\n│  │  - Sends Update via crossbeam channel                 │   │\n│  │  - Calls SignalToUI::set_ui_signal() to wake UI       │   │\n│  └──────────────────────────────────────────────────────┘   │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## App Structure\n\n### Top-Level App Definition\n\n```rust\nuse makepad_widgets::*;\n\nlive_design! {\n    use link::theme::*;\n    use link::widgets::*;\n\n    App = {{App}} {\n        ui: \u003CRoot>{\n            main_window = \u003CWindow> {\n                window: {inner_size: vec2(1280, 800), title: \"MyApp\"},\n                body = {\n                    \u002F\u002F Main content here\n                }\n            }\n        }\n    }\n}\n\napp_main!(App);\n\n#[derive(Live)]\npub struct App {\n    #[live] ui: WidgetRef,\n    #[rust] app_state: AppState,\n}\n\nimpl LiveRegister for App {\n    fn live_register(cx: &mut Cx) {\n        \u002F\u002F Order matters: register base widgets first\n        makepad_widgets::live_design(cx);\n        \u002F\u002F Then shared\u002Fcommon widgets\n        crate::shared::live_design(cx);\n        \u002F\u002F Then feature modules\n        crate::home::live_design(cx);\n    }\n}\n\nimpl LiveHook for App {\n    fn after_new_from_doc(&mut self, cx: &mut Cx) {\n        \u002F\u002F One-time initialization after widget tree is created\n    }\n}\n```\n\n### AppMain Implementation\n\n```rust\nimpl AppMain for App {\n    fn handle_event(&mut self, cx: &mut Cx, event: &Event) {\n        \u002F\u002F Forward to MatchEvent trait\n        self.match_event(cx, event);\n\n        \u002F\u002F Pass AppState through widget tree via Scope\n        let scope = &mut Scope::with_data(&mut self.app_state);\n        self.ui.handle_event(cx, event, scope);\n    }\n}\n```\n\n## Tokio Runtime Integration\n\n### Static Runtime Initialization\n\n```rust\nuse std::sync::Mutex;\nuse tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};\n\nstatic TOKIO_RUNTIME: Mutex\u003COption\u003Ctokio::runtime::Runtime>> = Mutex::new(None);\nstatic REQUEST_SENDER: Mutex\u003COption\u003CUnboundedSender\u003CAppRequest>>> = Mutex::new(None);\n\npub fn start_async_runtime() -> Result\u003Ctokio::runtime::Handle> {\n    let (request_sender, request_receiver) = tokio::sync::mpsc::unbounded_channel();\n\n    let rt_handle = TOKIO_RUNTIME.lock().unwrap()\n        .get_or_insert_with(|| {\n            tokio::runtime::Runtime::new()\n                .expect(\"Failed to create Tokio runtime\")\n        })\n        .handle()\n        .clone();\n\n    \u002F\u002F Store sender for UI thread to use\n    *REQUEST_SENDER.lock().unwrap() = Some(request_sender);\n\n    \u002F\u002F Spawn the main worker task\n    rt_handle.spawn(worker_task(request_receiver));\n\n    Ok(rt_handle)\n}\n```\n\n### Request Submission Pattern\n\n```rust\npub enum AppRequest {\n    FetchData { id: String },\n    SendMessage { content: String },\n    \u002F\u002F ... other request types\n}\n\n\u002F\u002F\u002F Submit a request from UI thread to async runtime\npub fn submit_async_request(req: AppRequest) {\n    if let Some(sender) = REQUEST_SENDER.lock().unwrap().as_ref() {\n        sender.send(req)\n            .expect(\"BUG: worker task receiver has died!\");\n    }\n}\n```\n\n### Worker Task Pattern\n\n```rust\nasync fn worker_task(mut request_receiver: UnboundedReceiver\u003CAppRequest>) -> Result\u003C()> {\n    while let Some(request) = request_receiver.recv().await {\n        match request {\n            AppRequest::FetchData { id } => {\n                \u002F\u002F Spawn a new task for each request\n                let _task = tokio::spawn(async move {\n                    let result = fetch_data(&id).await;\n                    \u002F\u002F Post result back to UI thread\n                    Cx::post_action(DataFetchedAction { id, result });\n                });\n            }\n            AppRequest::SendMessage { content } => {\n                let _task = tokio::spawn(async move {\n                    match send_message(&content).await {\n                        Ok(()) => Cx::post_action(MessageSentAction::Success),\n                        Err(e) => Cx::post_action(MessageSentAction::Failed(e)),\n                    }\n                });\n            }\n        }\n    }\n    Ok(())\n}\n```\n\n## Lock-Free Update Queue Pattern\n\nFor high-frequency updates from background tasks:\n\n```rust\nuse crossbeam_queue::SegQueue;\nuse makepad_widgets::SignalToUI;\n\npub enum DataUpdate {\n    NewItem { item: Item },\n    ItemChanged { id: String, changes: Changes },\n    Status { message: String },\n}\n\nstatic PENDING_UPDATES: SegQueue\u003CDataUpdate> = SegQueue::new();\n\n\u002F\u002F\u002F Called from background async tasks\npub fn enqueue_update(update: DataUpdate) {\n    PENDING_UPDATES.push(update);\n    SignalToUI::set_ui_signal();  \u002F\u002F Wake UI thread\n}\n\n\u002F\u002F In widget's handle_event:\nimpl Widget for MyWidget {\n    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {\n        \u002F\u002F Poll for updates on Signal events\n        if let Event::Signal = event {\n            while let Some(update) = PENDING_UPDATES.pop() {\n                match update {\n                    DataUpdate::NewItem { item } => {\n                        self.items.push(item);\n                        self.redraw(cx);\n                    }\n                    \u002F\u002F ... handle other updates\n                }\n            }\n        }\n    }\n}\n```\n\n## Startup Sequence\n\n```rust\nimpl MatchEvent for App {\n    fn handle_startup(&mut self, cx: &mut Cx) {\n        \u002F\u002F 1. Initialize logging\n        let _ = tracing_subscriber::fmt::try_init();\n\n        \u002F\u002F 2. Initialize app data directory\n        let _app_data_dir = crate::app_data_dir();\n\n        \u002F\u002F 3. Load persisted state\n        if let Err(e) = persistence::load_window_state(\n            self.ui.window(ids!(main_window)), cx\n        ) {\n            error!(\"Failed to load window state: {}\", e);\n        }\n\n        \u002F\u002F 4. Update UI based on loaded state\n        self.update_ui_visibility(cx);\n\n        \u002F\u002F 5. Start async runtime\n        let _rt_handle = crate::start_async_runtime().unwrap();\n    }\n}\n```\n\n## Shutdown Sequence\n\n```rust\nimpl AppMain for App {\n    fn handle_event(&mut self, cx: &mut Cx, event: &Event) {\n        if let Event::Shutdown = event {\n            \u002F\u002F Save window geometry\n            let window_ref = self.ui.window(ids!(main_window));\n            if let Err(e) = persistence::save_window_state(window_ref, cx) {\n                error!(\"Failed to save window state: {e}\");\n            }\n\n            \u002F\u002F Save app state\n            if let Some(user_id) = current_user_id() {\n                if let Err(e) = persistence::save_app_state(\n                    self.app_state.clone(), user_id\n                ) {\n                    error!(\"Failed to save app state: {e}\");\n                }\n            }\n        }\n        \u002F\u002F ... rest of event handling\n    }\n}\n```\n\n## Best Practices\n\n1. **Separation of Concerns**: Keep UI logic on the main thread, async operations in Tokio runtime\n2. **Request\u002FResponse Pattern**: Use typed enums for requests and actions\n3. **Lock-Free Updates**: Use `crossbeam::SegQueue` for high-frequency background updates\n4. **SignalToUI**: Always call `SignalToUI::set_ui_signal()` after enqueueing updates\n5. **Cx::post_action()**: Use for async task results that need action handling\n6. **Scope::with_data()**: Pass shared state through widget tree\n7. **Module Registration Order**: Register base widgets before dependent modules in `live_register()`\n\n## Reference Files\n\n- `references\u002Ftokio-integration.md` - Detailed Tokio runtime patterns (Robrix)\n- `references\u002Fchannel-patterns.md` - Channel communication patterns (Robrix)\n- `references\u002Fmoly-async-patterns.md` - Cross-platform async patterns (Moly)\n  - `PlatformSend` trait for native\u002FWASM compatibility\n  - `UiRunner` for async defer operations\n  - `AbortOnDropHandle` for task cancellation\n  - `ThreadToken` for non-Send types on WASM\n  - `spawn()` platform-agnostic function\n\n## Limitations\n- Use this skill only when the task clearly matches the scope described above.\n- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.\n- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.\n",{"name":5,"risk":24,"source":25,"description":26},"unknown","community","CRITICAL: Use for Robius app architecture patterns. Triggers on:\nTokio, async, submit_async_request, 异步, 架构,\nSignalToUI, Cx::post_action, worker task,\napp structure, MatchEvent, handle_startup\n","main","87afe6ce96220accf50a345dea46784c8c9f210e","YYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fplugins\u002Fantigravity-awesome-skills-claude\u002Fskills\u002Frobius-app-architecture",0,"https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base","https:\u002F\u002Fkb.yyc3.top\u002F","https:\u002F\u002Fgithub.com\u002FYYC-Cube","万象归元于云枢 | 深栈智启新纪元","2026-11-10 10:37:32",{"source":8,"skillName":5,"commands":37,"prompt":47,"zipAvailable":48},[38,41,44],{"tool":39,"command":40},"npx","npx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill robius-app-architecture",{"tool":42,"command":43},"bunx","bunx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill robius-app-architecture",{"tool":45,"command":46},"pnpm","pnpm dlx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill robius-app-architecture","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Skills-技能包\u002FYYC3-Skills-技能包-antigravity-awesome-skills\u002Fplugins\u002Fantigravity-awesome-skills-claude\u002Fskills\u002Frobius-app-architecture\u002FSKILL.md",true,[],[51,58,65,72,79,86],{"skillNo":52,"name":53,"nameZh":6,"description":54,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":19},"01M7CTDWHERCXPQCP0K03A86AS","vercel-sandbox","Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include \"Vercel Sandbox browser\", \"microVM Chrome\", \"agent-browser in sandbox\", \"browser automation on Vercel\", or any task requiring Chrome in a Vercel Sandbox.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fvercel-sandbox\u002FSKILL.md",[],[],{"skillNo":59,"name":60,"nameZh":6,"description":61,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":62,"categories":63,"keywords":64,"publishedAt":19},"01M7CTD8D2BNJY54S65M47HEJA","slack","Interact with Slack workspaces using browser automation. Use when the user needs to check unread channels, navigate Slack, send messages, extract data, find information, search conversations, or automate any Slack task. Triggers include \"check my Slack\", \"what channels have unreads\", \"send a message to\", \"search Slack for\", \"extract from Slack\", \"find who said\", or any task requiring programmatic Slack interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fslack\u002FSKILL.md",[],[],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7CTCSSB8ZP3Q58C3YZDZK1W","electron","Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include \"automate Slack app\", \"control VS Code\", \"interact with Discord app\", \"test this Electron app\", \"connect to desktop app\", or any task requiring automation of a native Electron application.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Felectron\u002FSKILL.md",[],[],{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M7CTCBJY76688V4DCZGWFHGQ","dogfood","Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to \"dogfood\", \"QA\", \"exploratory test\", \"find issues\", \"bug hunt\", \"test this app\u002Fsite\u002Fplatform\", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fdogfood\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M7CTC4H0FFGVEAQR9PA4GA1A","agent-browser","Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to \"open a website\", \"fill out a form\", \"click a button\", \"take a screenshot\", \"scrape data from a page\", \"test this web app\", \"login to a site\", \"automate browser actions\", or any task requiring programmatic web interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fagent-browser\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M7CTBKVFYBG78FDSABSDJTTQ","shadcn","Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI, including chat interfaces. Provides project context, component docs, and usage examples. Applies when working with shadcn\u002Fui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for \"shadcn init\", \"create an app with --preset\", \"switch to --preset\", and for building a design system or applying a DESIGN.md or brand spec to shadcn\u002Fui.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-UI-界面组件\u002FYYC3-UI-界面组件-ui\u002Fskills\u002Fshadcn\u002FSKILL.md",[],[]]