@tryinget/pi-activity-strip 0.8.0 → 0.9.0

package/native/panel/src/directory_view.rs

@@ -0,0 +1,409 @@
+use crate::app::AppMsg;
+use crate::protocol::WindowEntry;
+use relm4::Sender;
+use relm4::gtk;
+use relm4::gtk::prelude::*;
+
+/// Enough digits for any Niri window id; a longer number is a typo, not a window.
+const MAX_WINDOW_DIGITS: usize = 9;
+/// A search is a few letters of a project name, never a sentence.
+const MAX_QUERY_CHARS: usize = 32;
+
+/// What Enter does with the typed query.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum JumpChoice {
+    /// A number: exactly that Niri window, listed or not.
+    Window(i64),
+    /// A name: the first listed match, opened like clicking its row.
+    Card(String),
+}
+
+/// The brand block's window list: every agent window on every workspace, as its card's first line
+/// and its Niri window number. The typed query narrows it by name or number; Enter goes to the
+/// typed window number, or to the first match of a name.
+pub struct DirectoryView {
+    pub root: gtk::Box,
+    status: gtk::Label,
+    rows: gtk::Box,
+    sender: Sender<AppMsg>,
+}
+
+impl DirectoryView {
+    pub fn new(sender: &Sender<AppMsg>) -> Self {
+        let root = gtk::Box::new(gtk::Orientation::Vertical, 6);
+        root.add_css_class("directory");
+        root.set_visible(false);
+        root.set_vexpand(true);
+        root.set_margin_top(8);
+
+        let status = gtk::Label::new(None);
+        status.add_css_class("jump-line");
+        status.set_halign(gtk::Align::Fill);
+        status.set_xalign(0.0);
+
+        let rows = gtk::Box::new(gtk::Orientation::Vertical, 1);
+        let scroller = gtk::ScrolledWindow::new();
+        scroller.add_css_class("directory-scroller");
+        scroller.set_policy(gtk::PolicyType::Never, gtk::PolicyType::Automatic);
+        // Fill the brand column's height; rows beyond it scroll (wheel or touchpad, no bar).
+        scroller.set_vexpand(true);
+        scroller.set_child(Some(&rows));
+
+        root.append(&status);
+        root.append(&scroller);
+        Self {
+            root,
+            status,
+            rows,
+            sender: sender.clone(),
+        }
+    }
+
+    pub fn set_visible(&self, visible: bool) {
+        self.root.set_visible(visible);
+    }
+
+    /// Rebuild the rows for the current list and query. Clicking a row activates its card, so a
+    /// hidden tab is presented exactly as clicking its card would. The row Enter would open is
+    /// marked, so a typed name always shows where it leads.
+    pub fn render(
+        &self,
+        windows: &[WindowEntry],
+        query: &str,
+        can_type: bool,
+        allow_unlisted: bool,
+    ) {
+        while let Some(child) = self.rows.first_child() {
+            self.rows.remove(&child);
+        }
+        let shown = filter_entries(windows, query);
+        let choice = jump_choice(windows, query, allow_unlisted);
+        // Alphabetical from the controller, so workspace headings would repeat; each row names
+        // its workspace instead.
+        for entry in &shown {
+            let chosen = match &choice {
+                Some(JumpChoice::Window(id)) => entry.window_id == *id,
+                Some(JumpChoice::Card(card_id)) => &entry.card_id == card_id,
+                None => false,
+            };
+            self.rows.append(&self.row(entry, chosen));
+        }
+        if shown.is_empty() {
+            let empty = gtk::Label::new(Some(if windows.is_empty() {
+                "No agent windows"
+            } else {
+                "No listed window matches"
+            }));
+            empty.add_css_class("directory-empty");
+            empty.set_xalign(0.0);
+            self.rows.append(&empty);
+        }
+        self.status
+            .set_text(&status_text(windows, query, can_type, allow_unlisted));
+    }
+
+    /// The typing hint alone, leaving the rows (and any click in progress on them) untouched.
+    pub fn set_prompt(
+        &self,
+        windows: &[WindowEntry],
+        query: &str,
+        can_type: bool,
+        allow_unlisted: bool,
+    ) {
+        self.status
+            .set_text(&status_text(windows, query, can_type, allow_unlisted));
+    }
+
+    /// A transient message after a jump or activation, until the next keystroke re-renders.
+    pub fn set_status(&self, message: &str) {
+        self.status.set_text(message);
+    }
+
+    fn row(&self, entry: &WindowEntry, chosen: bool) -> gtk::Button {
+        let row = gtk::Button::new();
+        row.add_css_class("directory-row");
+        if entry.current {
+            row.add_css_class("current");
+        }
+        if chosen {
+            row.add_css_class("chosen");
+        }
+        let line = gtk::Box::new(gtk::Orientation::Horizontal, 8);
+        let label = gtk::Label::new(Some(&format!(
+            "{}{}",
+            if entry.hidden_tab { "⧉ " } else { "" },
+            entry.label
+        )));
+        label.add_css_class("directory-label");
+        label.set_xalign(0.0);
+        label.set_hexpand(true);
+        label.set_ellipsize(relm4::gtk::pango::EllipsizeMode::End);
+        label.set_max_width_chars(1);
+        let workspace = gtk::Label::new(Some(&workspace_tag(entry)));
+        workspace.add_css_class("directory-workspace");
+        let id = gtk::Label::new(Some(&format!("#{}", entry.window_id)));
+        id.add_css_class("directory-id");
+        line.append(&label);
+        line.append(&workspace);
+        line.append(&id);
+        row.set_child(Some(&line));
+        row.set_tooltip_text(Some(&format!(
+            "{} — window #{}, {}{}",
+            entry.label,
+            entry.window_id,
+            workspace_title(entry),
+            if entry.hidden_tab { ", hidden tab" } else { "" }
+        )));
+        let tx = self.sender.clone();
+        let card_id = entry.card_id.clone();
+        row.connect_clicked(move |_| {
+            let _ = tx.send(AppMsg::DirectoryActivate(card_id.clone()));
+        });
+        row
+    }
+}
+
+/// Entries whose project name contains the query (ignoring case) or whose window number starts
+/// with it; all of them when nothing is typed.
+pub fn filter_entries<'a>(windows: &'a [WindowEntry], query: &str) -> Vec<&'a WindowEntry> {
+    let needle = query.to_lowercase();
+    windows
+        .iter()
+        .filter(|entry| {
+            entry.window_id.to_string().starts_with(&needle)
+                || entry.label.to_lowercase().contains(&needle)
+        })
+        .collect()
+}
+
+fn is_window_number(query: &str) -> bool {
+    !query.is_empty() && query.chars().all(|character| character.is_ascii_digit())
+}
+
+/// What Enter does. Digits go to the listed window with exactly that number; failing that, to a
+/// project whose name contains them (`0844` finds `pi-0844-…`); failing that, when
+/// `allow_unlisted`, to exactly that number, listed or not, never a guessed completion. Anything
+/// else goes to the first project whose name contains it. Nothing typed, or nothing matching,
+/// does nothing. Typing held only by hover passes `allow_unlisted = false`, so a digit typed at a
+/// terminal prompt cannot reach an arbitrary window.
+pub fn jump_choice(
+    windows: &[WindowEntry],
+    query: &str,
+    allow_unlisted: bool,
+) -> Option<JumpChoice> {
+    if query.is_empty() {
+        return None;
+    }
+    let needle = query.to_lowercase();
+    let named = || {
+        windows
+            .iter()
+            .find(|entry| entry.label.to_lowercase().contains(&needle))
+            .map(|entry| JumpChoice::Card(entry.card_id.clone()))
+    };
+    if !is_window_number(query) {
+        return named();
+    }
+    let number = (query.len() <= MAX_WINDOW_DIGITS)
+        .then(|| query.parse::<i64>().ok())
+        .flatten();
+    if let Some(id) = number
+        && windows.iter().any(|entry| entry.window_id == id)
+    {
+        return Some(JumpChoice::Window(id));
+    }
+    named().or(number.filter(|_| allow_unlisted).map(JumpChoice::Window))
+}
+
+/// Append a typed character: letters and digits, and the `-`, `_` and `.` of project names.
+pub fn push_query_char(query: &mut String, character: char) -> bool {
+    if !is_query_char(character) || query.chars().count() >= MAX_QUERY_CHARS {
+        return false;
+    }
+    query.push(character);
+    true
+}
+
+pub fn is_query_char(character: char) -> bool {
+    character.is_alphanumeric() || matches!(character, '-' | '_' | '.')
+}
+
+/// The short workspace marker on each row: the number the operator sees in Niri.
+fn workspace_tag(entry: &WindowEntry) -> String {
+    entry
+        .workspace_idx
+        .map(|idx| format!("ws{idx}"))
+        .unwrap_or_default()
+}
+
+/// The workspace in full, for the row's tooltip: its number and any name.
+fn workspace_title(entry: &WindowEntry) -> String {
+    let number = entry
+        .workspace_idx
+        .map(|idx| format!("workspace {idx}"))
+        .unwrap_or_else(|| "workspace".to_owned());
+    match entry
+        .workspace_name
+        .as_deref()
+        .filter(|name| !name.is_empty())
+    {
+        Some(name) => format!("{number} · {name}"),
+        None => number,
+    }
+}
+
+fn status_text(
+    windows: &[WindowEntry],
+    query: &str,
+    can_type: bool,
+    allow_unlisted: bool,
+) -> String {
+    if !can_type {
+        // The keyboard was handed back (hover timeout); a click takes it again.
+        return "Click, then type a name or number".to_owned();
+    }
+    match jump_choice(windows, query, allow_unlisted) {
+        _ if query.is_empty() => "Type a name or number · ⏎ go".to_owned(),
+        Some(JumpChoice::Window(_)) => format!("#{query}▏ ⏎ jump · ⌫ edit"),
+        Some(JumpChoice::Card(card_id)) => {
+            let label = windows
+                .iter()
+                .find(|entry| entry.card_id == card_id)
+                .map(|entry| entry.label.as_str())
+                .unwrap_or("match");
+            format!("{query}▏ ⏎ {label}")
+        }
+        None => format!("{query}▏ no match"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn jump_choice_open(windows: &[WindowEntry], query: &str) -> Option<JumpChoice> {
+        jump_choice(windows, query, true)
+    }
+
+    fn entry(label: &str, window_id: i64, workspace_idx: i64) -> WindowEntry {
+        WindowEntry {
+            card_id: format!("card-{window_id}"),
+            label: label.into(),
+            window_id,
+            workspace_id: Some(workspace_idx + 100),
+            workspace_idx: Some(workspace_idx),
+            workspace_name: None,
+            hidden_tab: false,
+            current: false,
+        }
+    }
+
+    #[test]
+    fn the_status_line_says_what_enter_will_do() {
+        let windows = vec![entry("pi-extensions", 432, 2)];
+        assert_eq!(
+            status_text(&windows, "", false, true),
+            "Click, then type a name or number"
+        );
+        assert_eq!(
+            status_text(&windows, "", true, true),
+            "Type a name or number · ⏎ go"
+        );
+        assert!(status_text(&windows, "43", true, true).starts_with("#43"));
+        assert_eq!(
+            status_text(&windows, "ext", true, true),
+            "ext▏ ⏎ pi-extensions"
+        );
+        assert_eq!(status_text(&windows, "zzz", true, true), "zzz▏ no match");
+    }
+
+    #[test]
+    fn the_query_matches_names_anywhere_and_numbers_from_the_start() {
+        let windows = vec![
+            entry("pi-extensions", 43, 2),
+            entry("dep-diet", 432, 2),
+            entry("Text-Tools", 344, 3),
+        ];
+        let labels = |query: &str| -> Vec<String> {
+            filter_entries(&windows, query)
+                .iter()
+                .map(|entry| entry.label.clone())
+                .collect()
+        };
+        assert_eq!(labels("").len(), 3);
+        assert_eq!(
+            labels("ext"),
+            ["pi-extensions", "Text-Tools"],
+            "any case, anywhere"
+        );
+        assert_eq!(labels("43"), ["pi-extensions", "dep-diet"]);
+        assert_eq!(labels("432"), ["dep-diet"]);
+        assert!(labels("9").is_empty());
+    }
+
+    #[test]
+    fn enter_goes_to_the_typed_number_or_the_first_named_match() {
+        let windows = vec![entry("dep-diet", 432, 2), entry("pi-extensions", 43, 2)];
+        assert_eq!(
+            jump_choice_open(&windows, "43"),
+            Some(JumpChoice::Window(43))
+        );
+        assert_eq!(
+            jump_choice_open(&windows, "007"),
+            Some(JumpChoice::Window(7)),
+            "a number need not be listed"
+        );
+        assert_eq!(jump_choice_open(&windows, "1234567890"), None);
+        assert_eq!(
+            jump_choice_open(&windows, "d"),
+            Some(JumpChoice::Card("card-432".into())),
+            "the first listed match"
+        );
+        assert_eq!(jump_choice_open(&windows, "nothing"), None);
+        let numbered = vec![entry("pi-0844-qualification", 12, 2), entry("x", 844, 2)];
+        assert_eq!(
+            jump_choice_open(&numbered, "844"),
+            Some(JumpChoice::Window(844)),
+            "a listed window number wins"
+        );
+        assert_eq!(
+            jump_choice_open(&numbered[..1], "0844"),
+            Some(JumpChoice::Card("card-12".into())),
+            "digits inside a name, with no such window listed, go to that project"
+        );
+        assert_eq!(jump_choice_open(&windows, ""), None);
+        assert_eq!(
+            jump_choice(&windows, "1", false),
+            None,
+            "held only by hover, an unlisted number goes nowhere"
+        );
+        assert_eq!(
+            jump_choice(&windows, "43", false),
+            Some(JumpChoice::Window(43)),
+            "a listed number still jumps"
+        );
+    }
+
+    #[test]
+    fn the_query_takes_name_characters_up_to_a_bound() {
+        let mut query = String::new();
+        assert!(push_query_char(&mut query, 'e'));
+        assert!(push_query_char(&mut query, '-'));
+        assert!(push_query_char(&mut query, '4'));
+        assert!(!push_query_char(&mut query, ' '));
+        assert!(!push_query_char(&mut query, '/'));
+        for _ in 0..50 {
+            push_query_char(&mut query, 'x');
+        }
+        assert_eq!(query.chars().count(), MAX_QUERY_CHARS);
+    }
+
+    #[test]
+    fn each_row_names_its_workspace() {
+        let mut named = entry("a", 1, 3);
+        named.workspace_name = Some("claude-recovery".into());
+        assert_eq!(workspace_tag(&named), "ws3");
+        assert_eq!(workspace_title(&named), "workspace 3 · claude-recovery");
+        assert_eq!(workspace_title(&entry("a", 1, 2)), "workspace 2");
+    }
+}

package/native/panel/src/main.rs

@@ -1,5 +1,6 @@
 mod app;
 mod card_view;
+mod directory_view;
 mod protocol;
 mod runtime;
 

package/native/panel/src/protocol.rs

@@ -140,6 +140,31 @@ pub struct ViewMessage {
     pub focused_card_id: Option<String>,
     #[serde(default)]
     pub sessions: Vec<Card>,
+    /// Every agent window on every workspace, for the brand block's window list.
+    #[serde(default)]
+    pub windows: Vec<WindowEntry>,
+}
+
+/// One entry of the window list: the card's first line and the Niri window number to jump to.
+#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct WindowEntry {
+    #[serde(default)]
+    pub card_id: String,
+    #[serde(default)]
+    pub label: String,
+    pub window_id: i64,
+    /// Niri's workspace id: the grouping key, since workspace numbers repeat across monitors.
+    #[serde(default, deserialize_with = "lenient_integer")]
+    pub workspace_id: Option<i64>,
+    #[serde(default, deserialize_with = "lenient_integer")]
+    pub workspace_idx: Option<i64>,
+    #[serde(default)]
+    pub workspace_name: Option<String>,
+    #[serde(default)]
+    pub hidden_tab: bool,
+    #[serde(default)]
+    pub current: bool,
 }
 
 fn protocol_version() -> u8 {
@@ -252,6 +277,33 @@ pub fn demo_view() -> ViewMessage {
                 ..empty_card()
             },
         ],
+        windows: vec![
+            demo_window("demo-monitor", "activity-strip", 36, 2, false, false),
+            demo_window("demo-tool", "native-dogfood", 43, 2, false, true),
+            demo_window("demo-hidden", "pi-extensions", 43, 2, true, false),
+            demo_window("demo-other", "dep-surgeon", 344, 3, false, false),
+            demo_window("demo-far", "niri-desktop-continuity", 1048, 5, false, false),
+        ],
+    }
+}
+
+fn demo_window(
+    card_id: &str,
+    label: &str,
+    window_id: i64,
+    workspace_idx: i64,
+    hidden_tab: bool,
+    current: bool,
+) -> WindowEntry {
+    WindowEntry {
+        card_id: card_id.into(),
+        label: label.into(),
+        window_id,
+        workspace_id: Some(workspace_idx + 100),
+        workspace_idx: Some(workspace_idx),
+        workspace_name: None,
+        hidden_tab,
+        current,
     }
 }
 
@@ -300,6 +352,25 @@ mod tests {
         assert_eq!(view.sessions[0].pid, 4242);
         assert!(view.sessions[0].ak_tasks.is_empty());
         assert_eq!(view.sessions[0].ak_task_overflow, 0);
+        assert!(
+            view.windows.is_empty(),
+            "controllers without a window list still parse"
+        );
+    }
+
+    #[test]
+    fn view_messages_carry_the_window_list() {
+        let view: ViewMessage = serde_json::from_str(
+            r#"{"type":"view","revision":1,"windows":[{"cardId":"terminal:a","label":"pi-extensions","windowId":432,"workspaceIdx":"x","workspaceName":null,"hiddenTab":true,"current":false}]}"#,
+        )
+        .expect("view should parse");
+        assert_eq!(view.windows.len(), 1);
+        assert_eq!(view.windows[0].window_id, 432);
+        assert_eq!(
+            view.windows[0].workspace_idx, None,
+            "a malformed workspace number drops only that field"
+        );
+        assert!(view.windows[0].hidden_tab);
     }
 
     #[test]

package/native/panel/src/runtime.rs

@@ -45,20 +45,36 @@ pub fn apply_theme(definitions: &str) {
     THEME_PROVIDER.with(|provider| provider.load_from_data(&css));
 }
 
+/// Read controller messages from stdin on their own thread. The thread is detached on purpose: it
+/// lives exactly as long as stdin, and on EOF it reports the parent gone, which closes the panel.
 pub fn start_input_reader(sender: relm4::Sender<AppMsg>) {
-    std::thread::spawn(move || {
-        for line in BufReader::new(std::io::stdin()).lines() {
-            match line {
-                Ok(line) if !line.trim().is_empty() => consume_line(&sender, &line),
-                Ok(_) => {}
-                Err(error) => {
-                    let _ = sender.send(AppMsg::InputError(format!("panel input failed: {error}")));
-                    break;
-                }
+    let reader_sender = sender.clone();
+    let spawned = std::thread::Builder::new()
+        .name("panel-input".into())
+        .spawn(move || read_input(reader_sender));
+    match spawned {
+        Ok(handle) => drop(handle),
+        Err(error) => {
+            let _ = sender.send(AppMsg::InputError(format!(
+                "could not start the panel input reader: {error}"
+            )));
+            let _ = sender.send(AppMsg::ParentGone);
+        }
+    }
+}
+
+fn read_input(sender: relm4::Sender<AppMsg>) {
+    for line in BufReader::new(std::io::stdin()).lines() {
+        match line {
+            Ok(line) if !line.trim().is_empty() => consume_line(&sender, &line),
+            Ok(_) => {}
+            Err(error) => {
+                let _ = sender.send(AppMsg::InputError(format!("panel input failed: {error}")));
+                break;
             }
         }
-        let _ = sender.send(AppMsg::ParentGone);
-    });
+    }
+    let _ = sender.send(AppMsg::ParentGone);
 }
 
 fn consume_line(sender: &relm4::Sender<AppMsg>, line: &str) {
@@ -121,6 +137,22 @@ fn consume_line(sender: &relm4::Sender<AppMsg>, line: &str) {
                 .to_owned();
             let _ = sender.send(AppMsg::ActivationResult(card_id, ok, message));
         }
+        Some("jump-result") => {
+            let ok = value
+                .get("ok")
+                .and_then(|item| item.as_bool())
+                .unwrap_or(false);
+            let message = value
+                .get("message")
+                .and_then(|item| item.as_str())
+                .unwrap_or(if ok { "Jumped." } else { "Nothing moved." })
+                .to_owned();
+            let window_id = value
+                .get("windowId")
+                .and_then(|item| item.as_i64())
+                .unwrap_or(-1);
+            let _ = sender.send(AppMsg::JumpResult(window_id, ok, message));
+        }
         Some(kind) => {
             let _ = sender.send(AppMsg::InputError(format!(
                 "unsupported panel message: {kind}"

package/native/panel/src/style.css

@@ -265,3 +265,88 @@ window {
   font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
   font-size: 8px;
 }
+
+/*
+ * The brand block's window list: every agent window on every workspace, as its card's first line
+ * and its Niri window number. The number is the thing you type, so it carries the accent.
+ */
+.directory {
+  border-top: 1px solid alpha(@pi_foreground, 0.12);
+  padding-top: 7px;
+}
+
+.jump-line {
+  color: @pi_accent;
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 10px;
+  font-weight: 600;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.directory-scroller,
+.directory-scroller > viewport {
+  background: transparent;
+}
+
+/* Same as the card row: scrolls by wheel or touchpad without a visible bar. */
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.directory-scroller scrollbar {
+  opacity: 0;
+  min-width: 0;
+  min-height: 0;
+}
+
+.directory-header {
+  color: alpha(@pi_foreground, 0.5);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
+  letter-spacing: 1px;
+  margin-top: 5px;
+}
+
+.directory-row {
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: 6px;
+  color: @pi_foreground;
+  min-height: 0;
+  padding: 2px 6px;
+}
+
+.directory-row:hover,
+.directory-row:focus-visible {
+  background: mix(@pi_background, @pi_foreground, 0.1);
+}
+
+/* The window you are in: the same accent ring as its card. */
+.directory-row.current {
+  border-color: @pi_accent;
+}
+
+.directory-label {
+  font-size: 11px;
+}
+
+.directory-id {
+  color: @pi_accent;
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 10px;
+  font-weight: 600;
+}
+
+.directory-empty {
+  color: alpha(@pi_foreground, 0.5);
+  font-size: 10px;
+}
+
+/* Which workspace a row's window is on; quieter than the number you type. */
+.directory-workspace {
+  color: alpha(@pi_foreground, 0.5);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 9px;
+}
+
+/* The row Enter would open: a typed name always shows where it leads. */
+.directory-row.chosen {
+  background: alpha(@pi_accent, 0.16);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -92,9 +92,8 @@
     "@earendil-works/pi-ai": "0.84.4",
     "@earendil-works/pi-coding-agent": "0.84.4",
     "@types/node": "22.14.0",
-    "@typescript/native-preview": "7.0.0-dev.20260417.1",
     "typebox": "1.3.7",
-    "typescript": "5.9.2"
+    "typescript": "7.0.2"
   },
   "overrides": {
     "fast-xml-parser": "5.7.0"

package/src/common/contracts.d.ts

@@ -99,6 +99,7 @@ export interface ActivityStripRuntimeStatus {
   clickThrough?: boolean;
   panelMoveCount?: number;
   panelActivationCount?: number;
+  panelJumpCount?: number;
   panelRestartCount?: number;
   lastMovedCardId?: string | null;
   warnings?: string[];