From 621bee90975b2a2f8897ad923f7cd51a772ff7b4 Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Fri, 30 Jan 2026 12:32:02 +0000
Subject: [PATCH 1/6] Add TinyBase schema generation to specta-zod and create
 store-types crate

- Add TinyBase exporter module to specta-zod for generating TinyBase table schemas
- Fix double z.preprocess issue for optional fields that are already nullable
- Create store-types crate with Rust type definitions matching packages/store schemas
- Add generator binary to output both Zod and TinyBase schemas from Rust types
- Include snapshot tests for TinyBase schema generation

Co-Authored-By: yujonglee <yujonglee.dev@gmail.com>
---
 Cargo.lock                                    |  10 +
 crates/specta-zod/src/lib.rs                  |   2 +
 ...a_zod__tinybase__tests__simple_struct.snap |  10 +
 ...ecta_zod__tinybase__tests__with_array.snap |   9 +
 ...a_zod__tinybase__tests__with_optional.snap |  10 +
 crates/specta-zod/src/tinybase.rs             | 195 +++++++++++++
 crates/specta-zod/src/zod.rs                  |   4 +-
 crates/store-types/Cargo.toml                 |  14 +
 crates/store-types/src/bin/generate.rs        |  35 +++
 crates/store-types/src/lib.rs                 | 268 ++++++++++++++++++
 10 files changed, 556 insertions(+), 1 deletion(-)
 create mode 100644 crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__simple_struct.snap
 create mode 100644 crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_array.snap
 create mode 100644 crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_optional.snap
 create mode 100644 crates/specta-zod/src/tinybase.rs
 create mode 100644 crates/store-types/Cargo.toml
 create mode 100644 crates/store-types/src/bin/generate.rs
 create mode 100644 crates/store-types/src/lib.rs

diff --git a/Cargo.lock b/Cargo.lock
index ba49997d2f..19349414b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -15385,6 +15385,16 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
+[[package]]
+name = "store-types"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "specta",
+ "specta-zod",
+]
+
 [[package]]
 name = "str_inflector"
 version = "0.12.0"
diff --git a/crates/specta-zod/src/lib.rs b/crates/specta-zod/src/lib.rs
index 3b0b1a1f1d..1eed204f4d 100644
--- a/crates/specta-zod/src/lib.rs
+++ b/crates/specta-zod/src/lib.rs
@@ -1,5 +1,7 @@
 mod error;
+mod tinybase;
 mod zod;
 
 pub use error::Error;
+pub use tinybase::TinyBase;
 pub use zod::Zod;
diff --git a/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__simple_struct.snap b/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__simple_struct.snap
new file mode 100644
index 0000000000..cf821a34c3
--- /dev/null
+++ b/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__simple_struct.snap
@@ -0,0 +1,10 @@
+---
+source: crates/specta-zod/src/tinybase.rs
+assertion_line: 165
+expression: output
+---
+export const simple_structTinybaseSchema = {
+  name: { type: "string" },
+  age: { type: "number" },
+  active: { type: "boolean" },
+};
diff --git a/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_array.snap b/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_array.snap
new file mode 100644
index 0000000000..1b159f94ac
--- /dev/null
+++ b/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_array.snap
@@ -0,0 +1,9 @@
+---
+source: crates/specta-zod/src/tinybase.rs
+assertion_line: 181
+expression: output
+---
+export const with_arrayTinybaseSchema = {
+  tags: { type: "string" },
+  scores: { type: "string" },
+};
diff --git a/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_optional.snap b/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_optional.snap
new file mode 100644
index 0000000000..292f77e4d0
--- /dev/null
+++ b/crates/specta-zod/src/snapshots/specta_zod__tinybase__tests__with_optional.snap
@@ -0,0 +1,10 @@
+---
+source: crates/specta-zod/src/tinybase.rs
+assertion_line: 173
+expression: output
+---
+export const with_optionalTinybaseSchema = {
+  required: { type: "string" },
+  optional: { type: "string" },
+  optional_num: { type: "number" },
+};
diff --git a/crates/specta-zod/src/tinybase.rs b/crates/specta-zod/src/tinybase.rs
new file mode 100644
index 0000000000..6302dd4d95
--- /dev/null
+++ b/crates/specta-zod/src/tinybase.rs
@@ -0,0 +1,195 @@
+use std::{borrow::Cow, fmt::Write, path::Path};
+
+use specta::{
+    TypeCollection,
+    datatype::{DataType, NamedDataType, PrimitiveType, StructFields},
+};
+
+use crate::Error;
+
+pub struct TinyBase {
+    pub header: Cow<'static, str>,
+}
+
+impl Default for TinyBase {
+    fn default() -> Self {
+        Self {
+            header: r#"import type { TablesSchema, ValuesSchema } from "tinybase/with-schemas";
+
+import type { InferTinyBaseSchema } from "./shared";
+
+"#
+            .into(),
+        }
+    }
+}
+
+impl TinyBase {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn header(mut self, header: impl Into<Cow<'static, str>>) -> Self {
+        self.header = header.into();
+        self
+    }
+
+    pub fn export(&self, types: &TypeCollection) -> Result<String, Error> {
+        let mut output = self.header.to_string();
+
+        for (_, ndt) in types {
+            export_named_datatype(&mut output, ndt)?;
+            output.push('\n');
+        }
+
+        Ok(output)
+    }
+
+    pub fn export_to(&self, path: impl AsRef<Path>, types: &TypeCollection) -> Result<(), Error> {
+        let content = self.export(types)?;
+        std::fs::write(path, content)?;
+        Ok(())
+    }
+}
+
+fn export_named_datatype(s: &mut String, ndt: &NamedDataType) -> Result<(), Error> {
+    let name = ndt.name();
+
+    match &ndt.inner {
+        DataType::Struct(st) => {
+            if let StructFields::Named(named) = st.fields() {
+                let fields: Vec<_> = named
+                    .fields()
+                    .iter()
+                    .filter(|(_, f)| f.ty().is_some())
+                    .collect();
+
+                write!(
+                    s,
+                    "export const {}TinybaseSchema = {{\n",
+                    to_snake_case(name)
+                )?;
+
+                for (i, (field_name, field)) in fields.iter().enumerate() {
+                    let ty = field.ty().unwrap();
+                    let tinybase_type = datatype_to_tinybase_type(ty);
+
+                    if i > 0 {
+                        s.push_str(",\n");
+                    }
+                    write!(s, "  {}: {{ type: \"{}\" }}", field_name, tinybase_type)?;
+                }
+
+                if !fields.is_empty() {
+                    s.push(',');
+                }
+                s.push_str("\n};\n");
+            }
+        }
+        _ => {}
+    }
+
+    Ok(())
+}
+
+fn datatype_to_tinybase_type(dt: &DataType) -> &'static str {
+    match dt {
+        DataType::Primitive(p) => primitive_to_tinybase_type(p),
+        DataType::Nullable(inner) => datatype_to_tinybase_type(inner),
+        DataType::List(_) => "string",
+        DataType::Map(_) => "string",
+        DataType::Struct(_) => "string",
+        DataType::Enum(_) => "string",
+        DataType::Tuple(_) => "string",
+        DataType::Reference(_) => "string",
+        _ => "string",
+    }
+}
+
+fn primitive_to_tinybase_type(p: &PrimitiveType) -> &'static str {
+    use PrimitiveType::*;
+
+    match p {
+        i8 | i16 | i32 | u8 | u16 | u32 | f32 | f64 | usize | isize | i64 | u64 | i128 | u128 => {
+            "number"
+        }
+        bool => "boolean",
+        String | char => "string",
+    }
+}
+
+fn to_snake_case(name: &str) -> String {
+    let mut result = String::new();
+
+    for (i, c) in name.chars().enumerate() {
+        if c.is_uppercase() {
+            if i > 0 {
+                result.push('_');
+            }
+            result.push(c.to_ascii_lowercase());
+        } else {
+            result.push(c);
+        }
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+    use specta::Type;
+
+    #[derive(Type, Serialize, Deserialize)]
+    struct SimpleStruct {
+        name: String,
+        age: i32,
+        active: bool,
+    }
+
+    #[derive(Type, Serialize, Deserialize)]
+    struct WithOptional {
+        required: String,
+        optional: Option<String>,
+        optional_num: Option<i32>,
+    }
+
+    #[derive(Type, Serialize, Deserialize)]
+    struct WithArray {
+        tags: Vec<String>,
+        scores: Vec<i32>,
+    }
+
+    #[test]
+    fn test_simple_struct() {
+        let mut types = TypeCollection::default();
+        types.register::<SimpleStruct>();
+        let output = TinyBase::new().header("").export(&types).unwrap();
+        insta::assert_snapshot!(output);
+    }
+
+    #[test]
+    fn test_with_optional() {
+        let mut types = TypeCollection::default();
+        types.register::<WithOptional>();
+        let output = TinyBase::new().header("").export(&types).unwrap();
+        insta::assert_snapshot!(output);
+    }
+
+    #[test]
+    fn test_with_array() {
+        let mut types = TypeCollection::default();
+        types.register::<WithArray>();
+        let output = TinyBase::new().header("").export(&types).unwrap();
+        insta::assert_snapshot!(output);
+    }
+
+    #[test]
+    fn test_snake_case_conversion() {
+        assert_eq!(to_snake_case("SimpleStruct"), "simple_struct");
+        assert_eq!(to_snake_case("MyStruct"), "my_struct");
+        assert_eq!(to_snake_case("ABC"), "a_b_c");
+        assert_eq!(to_snake_case("already_snake"), "already_snake");
+    }
+}
diff --git a/crates/specta-zod/src/zod.rs b/crates/specta-zod/src/zod.rs
index 95504bb56f..9f38fbbdd9 100644
--- a/crates/specta-zod/src/zod.rs
+++ b/crates/specta-zod/src/zod.rs
@@ -237,7 +237,9 @@ fn field_type(s: &mut String, types: &TypeCollection, field: &Field) -> Result<(
         return Ok(());
     };
 
-    if field.optional() {
+    let is_nullable = matches!(ty, DataType::Nullable(_));
+
+    if field.optional() && !is_nullable {
         s.push_str("z.preprocess((val) => val ?? undefined, ");
         datatype(s, types, ty, false)?;
         s.push_str(".optional())");
diff --git a/crates/store-types/Cargo.toml b/crates/store-types/Cargo.toml
new file mode 100644
index 0000000000..b5fb26c7e8
--- /dev/null
+++ b/crates/store-types/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "store-types"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+specta = { workspace = true, features = ["derive"] }
+specta-zod = { path = "../specta-zod" }
+
+[[bin]]
+name = "generate-store-types"
+path = "src/bin/generate.rs"
diff --git a/crates/store-types/src/bin/generate.rs b/crates/store-types/src/bin/generate.rs
new file mode 100644
index 0000000000..9d7796b42d
--- /dev/null
+++ b/crates/store-types/src/bin/generate.rs
@@ -0,0 +1,35 @@
+use specta::TypeCollection;
+use specta_zod::{TinyBase, Zod};
+use store_types::*;
+
+fn main() {
+    let mut types = TypeCollection::default();
+    types.register::<Human>();
+    types.register::<Event>();
+    types.register::<Calendar>();
+    types.register::<Organization>();
+    types.register::<Session>();
+    types.register::<Transcript>();
+    types.register::<MappingSessionParticipant>();
+    types.register::<Tag>();
+    types.register::<MappingTagSession>();
+    types.register::<Template>();
+    types.register::<TemplateSection>();
+    types.register::<ChatGroup>();
+    types.register::<ChatMessage>();
+    types.register::<ChatShortcut>();
+    types.register::<EnhancedNote>();
+    types.register::<Prompt>();
+    types.register::<Word>();
+    types.register::<SpeakerHint>();
+    types.register::<General>();
+
+    let zod_output = Zod::new().export(&types).unwrap();
+    let tinybase_output = TinyBase::new().export(&types).unwrap();
+
+    println!("// Generated by store-types crate");
+    println!("// Do not edit manually");
+    println!();
+    println!("{}", zod_output);
+    println!("{}", tinybase_output);
+}
diff --git a/crates/store-types/src/lib.rs b/crates/store-types/src/lib.rs
new file mode 100644
index 0000000000..25abe17efc
--- /dev/null
+++ b/crates/store-types/src/lib.rs
@@ -0,0 +1,268 @@
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Human {
+    pub user_id: String,
+    pub name: String,
+    pub email: String,
+    pub org_id: String,
+    #[specta(optional)]
+    pub job_title: Option<String>,
+    #[specta(optional)]
+    pub linkedin_username: Option<String>,
+    #[specta(optional)]
+    pub memo: Option<String>,
+    pub pinned: bool,
+    #[specta(optional)]
+    pub pin_order: Option<i32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Event {
+    pub user_id: String,
+    pub created_at: String,
+    pub tracking_id_event: String,
+    pub calendar_id: String,
+    pub title: String,
+    pub started_at: String,
+    pub ended_at: String,
+    #[specta(optional)]
+    pub location: Option<String>,
+    #[specta(optional)]
+    pub meeting_link: Option<String>,
+    #[specta(optional)]
+    pub description: Option<String>,
+    #[specta(optional)]
+    pub note: Option<String>,
+    #[specta(optional)]
+    pub ignored: Option<bool>,
+    #[specta(optional)]
+    pub recurrence_series_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Calendar {
+    pub user_id: String,
+    pub created_at: String,
+    pub tracking_id_calendar: String,
+    pub name: String,
+    pub enabled: bool,
+    pub provider: String,
+    #[specta(optional)]
+    pub source: Option<String>,
+    #[specta(optional)]
+    pub color: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Organization {
+    pub user_id: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Session {
+    pub user_id: String,
+    pub created_at: String,
+    #[specta(optional)]
+    pub folder_id: Option<String>,
+    #[specta(optional)]
+    pub event_id: Option<String>,
+    pub title: String,
+    pub raw_md: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Transcript {
+    pub user_id: String,
+    pub created_at: String,
+    pub session_id: String,
+    pub started_at: i64,
+    #[specta(optional)]
+    pub ended_at: Option<i64>,
+    pub words: String,
+    pub speaker_hints: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct MappingSessionParticipant {
+    pub user_id: String,
+    pub session_id: String,
+    pub human_id: String,
+    #[specta(optional)]
+    pub source: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Tag {
+    pub user_id: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct MappingTagSession {
+    pub user_id: String,
+    pub tag_id: String,
+    pub session_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Template {
+    pub user_id: String,
+    pub title: String,
+    pub description: String,
+    #[specta(optional)]
+    pub category: Option<String>,
+    #[specta(optional)]
+    pub targets: Option<Vec<String>>,
+    pub sections: Vec<TemplateSection>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct TemplateSection {
+    pub title: String,
+    pub description: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct ChatGroup {
+    pub user_id: String,
+    pub created_at: String,
+    pub title: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct ChatMessage {
+    pub user_id: String,
+    pub created_at: String,
+    pub chat_group_id: String,
+    pub role: String,
+    pub content: String,
+    pub metadata: String,
+    pub parts: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct ChatShortcut {
+    pub user_id: String,
+    pub title: String,
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct EnhancedNote {
+    pub user_id: String,
+    pub session_id: String,
+    pub content: String,
+    #[specta(optional)]
+    pub template_id: Option<String>,
+    pub position: i32,
+    #[specta(optional)]
+    pub title: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Prompt {
+    pub user_id: String,
+    pub task_type: String,
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Word {
+    pub user_id: String,
+    pub created_at: String,
+    pub transcript_id: String,
+    pub text: String,
+    pub start_ms: i64,
+    pub end_ms: i64,
+    pub channel: i32,
+    #[specta(optional)]
+    pub speaker: Option<String>,
+    #[specta(optional)]
+    pub metadata: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct SpeakerHint {
+    pub user_id: String,
+    pub created_at: String,
+    pub transcript_id: String,
+    pub word_id: String,
+    pub r#type: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct General {
+    pub user_id: String,
+    pub autostart: bool,
+    pub telemetry_consent: bool,
+    pub save_recordings: bool,
+    pub notification_event: bool,
+    pub notification_detect: bool,
+    pub respect_dnd: bool,
+    pub quit_intercept: bool,
+    pub ai_language: String,
+    pub spoken_languages: Vec<String>,
+    pub ignored_platforms: Vec<String>,
+    pub ignored_recurring_series: Vec<String>,
+    #[specta(optional)]
+    pub current_llm_provider: Option<String>,
+    #[specta(optional)]
+    pub current_llm_model: Option<String>,
+    #[specta(optional)]
+    pub current_stt_provider: Option<String>,
+    #[specta(optional)]
+    pub current_stt_model: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use specta::TypeCollection;
+    use specta_zod::{TinyBase, Zod};
+
+    #[test]
+    fn test_generate_zod_schemas() {
+        let mut types = TypeCollection::default();
+        types.register::<Human>();
+        types.register::<Event>();
+        types.register::<Calendar>();
+        types.register::<Organization>();
+        types.register::<Session>();
+        types.register::<Transcript>();
+        types.register::<MappingSessionParticipant>();
+        types.register::<Tag>();
+        types.register::<MappingTagSession>();
+        types.register::<Template>();
+        types.register::<TemplateSection>();
+        types.register::<ChatGroup>();
+        types.register::<ChatMessage>();
+        types.register::<ChatShortcut>();
+        types.register::<EnhancedNote>();
+        types.register::<Prompt>();
+        types.register::<Word>();
+        types.register::<SpeakerHint>();
+        types.register::<General>();
+
+        let output = Zod::new().export(&types).unwrap();
+        println!("{}", output);
+        assert!(output.contains("humanSchema"));
+        assert!(output.contains("sessionSchema"));
+    }
+
+    #[test]
+    fn test_generate_tinybase_schemas() {
+        let mut types = TypeCollection::default();
+        types.register::<Human>();
+        types.register::<Session>();
+        types.register::<Transcript>();
+
+        let output = TinyBase::new().export(&types).unwrap();
+        println!("{}", output);
+        assert!(output.contains("humanTinybaseSchema"));
+        assert!(output.contains("sessionTinybaseSchema"));
+    }
+}

From 3859a3fc6c1c7d1e2c7ca11e722c33ffb767bfed Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Fri, 30 Jan 2026 12:53:48 +0000
Subject: [PATCH 2/6] Update generator to produce complete schema.ts
 replacement

- Add enum schemas (calendarProviderSchema, participantSourceSchema)
- Add providerSpeakerIndexSchema and aiProviderSchema
- Generate tableSchemaForTinybase as combined object
- Generate valueSchemaForTinybase for General values
- Add all type exports and Storage type exports
- Handle special cases: defaults, JSON fields, enum references

Co-Authored-By: yujonglee <yujonglee.dev@gmail.com>
---
 crates/store-types/src/bin/generate.rs | 363 ++++++++++++++++++++++++-
 1 file changed, 358 insertions(+), 5 deletions(-)

diff --git a/crates/store-types/src/bin/generate.rs b/crates/store-types/src/bin/generate.rs
index 9d7796b42d..e7ca2e60b1 100644
--- a/crates/store-types/src/bin/generate.rs
+++ b/crates/store-types/src/bin/generate.rs
@@ -24,12 +24,365 @@ fn main() {
     types.register::<SpeakerHint>();
     types.register::<General>();
 
+    // Generate Zod schemas
     let zod_output = Zod::new().export(&types).unwrap();
-    let tinybase_output = TinyBase::new().export(&types).unwrap();
 
-    println!("// Generated by store-types crate");
-    println!("// Do not edit manually");
+    // Generate TinyBase schemas
+    let tinybase_output = TinyBase::new()
+        .header("")
+        .export(&types)
+        .unwrap();
+
+    // Print the complete schema.ts file
+    print_schema_file(&zod_output, &tinybase_output);
+}
+
+fn print_schema_file(zod_output: &str, tinybase_output: &str) {
+    // Header
+    println!(
+        r#"import type {{ TablesSchema }} from "tinybase/with-schemas";
+import {{ z }} from "zod";
+
+import {{ InferTinyBaseSchema, jsonObject, type ToStorageType }} from "./shared";
+"#
+    );
+
+    // Enum schemas (these need to be defined before they're used)
+    println!(
+        r#"export const calendarProviderSchema = z.enum(["apple", "google", "outlook"]);
+export type CalendarProvider = z.infer<typeof calendarProviderSchema>;
+"#
+    );
+
+    println!(
+        r#"export const participantSourceSchema = z.enum(["manual", "auto", "excluded"]);
+export type ParticipantSource = z.infer<typeof participantSourceSchema>;
+"#
+    );
+
+    // Remove the header from zod_output since we already printed our own
+    let zod_without_header = zod_output
+        .replace(
+            "import { z } from \"zod\";\nimport { jsonObject } from \"./shared\";\n\n",
+            "",
+        );
+
+    // Print Zod schemas (modified to use enum references where needed)
+    let modified_zod = zod_without_header
+        // Calendar provider should use the enum
+        .replace("provider: z.string()", "provider: calendarProviderSchema")
+        // MappingSessionParticipant.source should use participantSourceSchema
+        .replace(
+            "export const mappingSessionParticipantSchema = z.object({\n  user_id: z.string(),\n  session_id: z.string(),\n  human_id: z.string(),\n  source: z.preprocess((val) => val ?? undefined, z.string().optional()),\n});",
+            "export const mappingSessionParticipantSchema = z.object({\n  user_id: z.string(),\n  session_id: z.string(),\n  human_id: z.string(),\n  source: z.preprocess(\n    (val) => val ?? undefined,\n    participantSourceSchema.optional(),\n  ),\n});",
+        )
+        // Human.pinned should have default false
+        .replace(
+            "pinned: z.boolean()",
+            "pinned: z.preprocess((val) => val ?? false, z.boolean())",
+        )
+        // Calendar.enabled should have default false
+        .replace(
+            "enabled: z.boolean()",
+            "enabled: z.preprocess((val) => val ?? false, z.boolean())",
+        )
+        // General booleans should have defaults
+        .replace(
+            "autostart: z.boolean()",
+            "autostart: z.boolean().default(false)",
+        )
+        .replace(
+            "telemetry_consent: z.boolean()",
+            "telemetry_consent: z.boolean().default(true)",
+        )
+        .replace(
+            "save_recordings: z.boolean()",
+            "save_recordings: z.boolean().default(true)",
+        )
+        .replace(
+            "notification_event: z.boolean()",
+            "notification_event: z.boolean().default(true)",
+        )
+        .replace(
+            "notification_detect: z.boolean()",
+            "notification_detect: z.boolean().default(true)",
+        )
+        .replace(
+            "respect_dnd: z.boolean()",
+            "respect_dnd: z.boolean().default(false)",
+        )
+        .replace(
+            "quit_intercept: z.boolean()",
+            "quit_intercept: z.boolean().default(false)",
+        )
+        .replace(
+            "ai_language: z.string()",
+            r#"ai_language: z.string().default("en")"#,
+        )
+        // General arrays should have defaults
+        .replace(
+            "spoken_languages: jsonObject(z.array(z.string()))",
+            r#"spoken_languages: jsonObject(z.array(z.string()).default(["en"]))"#,
+        )
+        .replace(
+            "ignored_platforms: jsonObject(z.array(z.string()))",
+            "ignored_platforms: jsonObject(z.array(z.string()).default([]))",
+        )
+        .replace(
+            "ignored_recurring_series: jsonObject(z.array(z.string()))",
+            "ignored_recurring_series: jsonObject(z.array(z.string()).default([]))",
+        )
+        // General optional fields should not use preprocess
+        .replace(
+            "current_llm_provider: z.preprocess((val) => val ?? undefined, z.string().optional())",
+            "current_llm_provider: z.string().optional()",
+        )
+        .replace(
+            "current_llm_model: z.preprocess((val) => val ?? undefined, z.string().optional())",
+            "current_llm_model: z.string().optional()",
+        )
+        .replace(
+            "current_stt_provider: z.preprocess((val) => val ?? undefined, z.string().optional())",
+            "current_stt_provider: z.string().optional()",
+        )
+        .replace(
+            "current_stt_model: z.preprocess((val) => val ?? undefined, z.string().optional())",
+            "current_stt_model: z.string().optional()",
+        )
+        // Transcript words/speaker_hints should have default "[]"
+        .replace(
+            "words: z.string()",
+            r#"words: z.preprocess((val) => val ?? "[]", z.string())"#,
+        )
+        .replace(
+            "speaker_hints: z.string()",
+            r#"speaker_hints: z.preprocess((val) => val ?? "[]", z.string())"#,
+        )
+        // ChatMessage metadata/parts should use jsonObject(z.any())
+        .replace("metadata: z.string()", "metadata: jsonObject(z.any())")
+        .replace("parts: z.string()", "parts: jsonObject(z.any())")
+        // Word metadata should use jsonObject with record
+        .replace(
+            "metadata: z.preprocess((val) => val ?? undefined, z.string().optional())",
+            "metadata: z.preprocess(\n    (val) => val ?? undefined,\n    jsonObject(z.record(z.string(), z.unknown())).optional(),\n  )",
+        )
+        // SpeakerHint value should use jsonObject with record
+        .replace(
+            "value: z.string()",
+            "value: jsonObject(z.record(z.string(), z.unknown()))",
+        );
+
+    println!("{}", modified_zod);
+
+    // Add providerSpeakerIndexSchema
+    println!(
+        r#"export const providerSpeakerIndexSchema = z.object({{
+  speaker_index: z.number(),
+  provider: z.string().optional(),
+  channel: z.number().optional(),
+}});
+"#
+    );
+
+    // Add aiProviderSchema
+    println!(
+        r#"export const aiProviderSchema = z
+  .object({{
+    type: z.enum(["stt", "llm"]),
+    base_url: z.url().min(1),
+    api_key: z.string(),
+  }})
+  .refine(
+    (data) => !data.base_url.startsWith("https:") || data.api_key.length > 0,
+    {{
+      message: "API key is required for HTTPS URLs",
+      path: ["api_key"],
+    }},
+  );
+"#
+    );
+
+    // Type exports
+    println!(
+        r#"export type ProviderSpeakerIndexHint = z.infer<
+  typeof providerSpeakerIndexSchema
+>;
+
+export type Human = z.infer<typeof humanSchema>;
+export type Event = z.infer<typeof eventSchema>;
+export type Calendar = z.infer<typeof calendarSchema>;
+export type CalendarStorage = ToStorageType<typeof calendarSchema>;
+export type Organization = z.infer<typeof organizationSchema>;
+export type Session = z.infer<typeof sessionSchema>;
+export type Transcript = z.infer<typeof transcriptSchema>;
+export type Word = z.infer<typeof wordSchema>;
+export type SpeakerHint = z.infer<typeof speakerHintSchema>;
+export type MappingSessionParticipant = z.infer<
+  typeof mappingSessionParticipantSchema
+>;
+export type Tag = z.infer<typeof tagSchema>;
+export type MappingTagSession = z.infer<typeof mappingTagSessionSchema>;
+export type Template = z.infer<typeof templateSchema>;
+export type TemplateSection = z.infer<typeof templateSectionSchema>;
+export type ChatGroup = z.infer<typeof chatGroupSchema>;
+export type ChatMessage = z.infer<typeof chatMessageSchema>;
+export type ChatShortcut = z.infer<typeof chatShortcutSchema>;
+export type EnhancedNote = z.infer<typeof enhancedNoteSchema>;
+export type Prompt = z.infer<typeof promptSchema>;
+export type AIProvider = z.infer<typeof aiProviderSchema>;
+export type General = z.infer<typeof generalSchema>;
+
+export type SessionStorage = ToStorageType<typeof sessionSchema>;
+export type TranscriptStorage = ToStorageType<typeof transcriptSchema>;
+export type WordStorage = ToStorageType<typeof wordSchema>;
+export type SpeakerHintStorage = ToStorageType<typeof speakerHintSchema>;
+export type TemplateStorage = ToStorageType<typeof templateSchema>;
+export type ChatMessageStorage = ToStorageType<typeof chatMessageSchema>;
+export type EnhancedNoteStorage = ToStorageType<typeof enhancedNoteSchema>;
+export type HumanStorage = ToStorageType<typeof humanSchema>;
+export type OrganizationStorage = ToStorageType<typeof organizationSchema>;
+export type PromptStorage = ToStorageType<typeof promptSchema>;
+export type ChatShortcutStorage = ToStorageType<typeof chatShortcutSchema>;
+export type EventStorage = ToStorageType<typeof eventSchema>;
+export type MappingSessionParticipantStorage = ToStorageType<
+  typeof mappingSessionParticipantSchema
+>;
+export type AIProviderStorage = ToStorageType<typeof aiProviderSchema>;
+export type GeneralStorage = ToStorageType<typeof generalSchema>;
+"#
+    );
+
+    // Generate tableSchemaForTinybase
+    println!("export const tableSchemaForTinybase = {{");
+
+    // Parse tinybase_output and reorganize into table format
+    let table_schemas = [
+        ("sessions", "sessionTinybaseSchema", "sessionSchema"),
+        (
+            "transcripts",
+            "transcriptTinybaseSchema",
+            "transcriptSchema",
+        ),
+        ("words", "wordTinybaseSchema", "wordSchema"),
+        (
+            "speaker_hints",
+            "speaker_hintTinybaseSchema",
+            "speakerHintSchema",
+        ),
+        ("humans", "humanTinybaseSchema", "humanSchema"),
+        (
+            "organizations",
+            "organizationTinybaseSchema",
+            "organizationSchema",
+        ),
+        ("calendars", "calendarTinybaseSchema", "calendarSchema"),
+        ("events", "eventTinybaseSchema", "eventSchema"),
+        (
+            "mapping_session_participant",
+            "mapping_session_participantTinybaseSchema",
+            "mappingSessionParticipantSchema",
+        ),
+        ("tags", "tagTinybaseSchema", "tagSchema"),
+        (
+            "mapping_tag_session",
+            "mapping_tag_sessionTinybaseSchema",
+            "mappingTagSessionSchema",
+        ),
+        ("templates", "templateTinybaseSchema", "templateSchema"),
+        ("chat_groups", "chat_groupTinybaseSchema", "chatGroupSchema"),
+        (
+            "chat_messages",
+            "chat_messageTinybaseSchema",
+            "chatMessageSchema",
+        ),
+        (
+            "enhanced_notes",
+            "enhanced_noteTinybaseSchema",
+            "enhancedNoteSchema",
+        ),
+        ("prompts", "promptTinybaseSchema", "promptSchema"),
+        (
+            "chat_shortcuts",
+            "chat_shortcutTinybaseSchema",
+            "chatShortcutSchema",
+        ),
+    ];
+
+    for (table_name, _, zod_schema) in table_schemas.iter() {
+        let schema_content = extract_tinybase_schema(tinybase_output, table_name);
+        if let Some(content) = schema_content {
+            println!(
+                "  {}: {{\n{}  }} as const satisfies InferTinyBaseSchema<typeof {}>,",
+                table_name, content, zod_schema
+            );
+        }
+    }
+
+    println!("}} as const satisfies TablesSchema;");
     println!();
-    println!("{}", zod_output);
-    println!("{}", tinybase_output);
+
+    // Generate valueSchemaForTinybase (General fields)
+    println!(
+        r#"export const valueSchemaForTinybase = {{
+  user_id: {{ type: "string" }},
+  autostart: {{ type: "boolean" }},
+  save_recordings: {{ type: "boolean" }},
+  notification_event: {{ type: "boolean" }},
+  notification_detect: {{ type: "boolean" }},
+  respect_dnd: {{ type: "boolean" }},
+  quit_intercept: {{ type: "boolean" }},
+  telemetry_consent: {{ type: "boolean" }},
+  ai_language: {{ type: "string" }},
+  spoken_languages: {{ type: "string" }},
+  ignored_platforms: {{ type: "string" }},
+  ignored_recurring_series: {{ type: "string" }},
+  current_llm_provider: {{ type: "string" }},
+  current_llm_model: {{ type: "string" }},
+  current_stt_provider: {{ type: "string" }},
+  current_stt_model: {{ type: "string" }},
+}} as const satisfies InferTinyBaseSchema<typeof generalSchema>;
+"#
+    );
+}
+
+fn extract_tinybase_schema(tinybase_output: &str, table_name: &str) -> Option<String> {
+    // Map table names to their TinyBase schema variable names
+    let var_name = match table_name {
+        "sessions" => "sessionTinybaseSchema",
+        "transcripts" => "transcriptTinybaseSchema",
+        "words" => "wordTinybaseSchema",
+        "speaker_hints" => "speaker_hintTinybaseSchema",
+        "humans" => "humanTinybaseSchema",
+        "organizations" => "organizationTinybaseSchema",
+        "calendars" => "calendarTinybaseSchema",
+        "events" => "eventTinybaseSchema",
+        "mapping_session_participant" => "mapping_session_participantTinybaseSchema",
+        "tags" => "tagTinybaseSchema",
+        "mapping_tag_session" => "mapping_tag_sessionTinybaseSchema",
+        "templates" => "templateTinybaseSchema",
+        "chat_groups" => "chat_groupTinybaseSchema",
+        "chat_messages" => "chat_messageTinybaseSchema",
+        "enhanced_notes" => "enhanced_noteTinybaseSchema",
+        "prompts" => "promptTinybaseSchema",
+        "chat_shortcuts" => "chat_shortcutTinybaseSchema",
+        _ => return None,
+    };
+
+    // Find the schema in the output
+    let search_pattern = format!("export const {} = {{", var_name);
+    if let Some(start_idx) = tinybase_output.find(&search_pattern) {
+        let content_start = start_idx + search_pattern.len();
+        if let Some(end_idx) = tinybase_output[content_start..].find("};") {
+            let content = &tinybase_output[content_start..content_start + end_idx];
+            // Reformat the content with proper indentation
+            let formatted = content
+                .lines()
+                .filter(|line| !line.trim().is_empty())
+                .map(|line| format!("    {}", line.trim()))
+                .collect::<Vec<_>>()
+                .join("\n");
+            return Some(formatted + "\n");
+        }
+    }
+    None
 }

From 79073318a1b7b257225613573dbc95546bf2be50 Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Fri, 30 Jan 2026 13:00:20 +0000
Subject: [PATCH 3/6] Fix formatting in generate.rs

Co-Authored-By: yujonglee <yujonglee.dev@gmail.com>
---
 crates/store-types/src/bin/generate.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/crates/store-types/src/bin/generate.rs b/crates/store-types/src/bin/generate.rs
index e7ca2e60b1..e610731e22 100644
--- a/crates/store-types/src/bin/generate.rs
+++ b/crates/store-types/src/bin/generate.rs
@@ -28,10 +28,7 @@ fn main() {
     let zod_output = Zod::new().export(&types).unwrap();
 
     // Generate TinyBase schemas
-    let tinybase_output = TinyBase::new()
-        .header("")
-        .export(&types)
-        .unwrap();
+    let tinybase_output = TinyBase::new().header("").export(&types).unwrap();
 
     // Print the complete schema.ts file
     print_schema_file(&zod_output, &tinybase_output);
@@ -61,11 +58,10 @@ export type ParticipantSource = z.infer<typeof participantSourceSchema>;
     );
 
     // Remove the header from zod_output since we already printed our own
-    let zod_without_header = zod_output
-        .replace(
-            "import { z } from \"zod\";\nimport { jsonObject } from \"./shared\";\n\n",
-            "",
-        );
+    let zod_without_header = zod_output.replace(
+        "import { z } from \"zod\";\nimport { jsonObject } from \"./shared\";\n\n",
+        "",
+    );
 
     // Print Zod schemas (modified to use enum references where needed)
     let modified_zod = zod_without_header

From 6dad2b9d680eccb602cbf547e6b323219b0ba4a0 Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Fri, 30 Jan 2026 13:04:03 +0000
Subject: [PATCH 4/6] Replace packages/store/src/schema.ts with generated
 output

- Add auto-generated header comment to indicate file is generated
- Run generator to produce complete schema.ts replacement
- Format with dprint

The schema.ts file is now generated from Rust types defined in
crates/store-types/src/lib.rs. To regenerate:
  cargo run -p store-types --bin generate-store-types > packages/store/src/schema.ts

Co-Authored-By: yujonglee <yujonglee.dev@gmail.com>
---
 crates/store-types/src/bin/generate.rs |   8 +
 packages/store/src/schema.ts           | 242 ++++++++++++++-----------
 2 files changed, 142 insertions(+), 108 deletions(-)

diff --git a/crates/store-types/src/bin/generate.rs b/crates/store-types/src/bin/generate.rs
index e610731e22..4325d7a5a0 100644
--- a/crates/store-types/src/bin/generate.rs
+++ b/crates/store-types/src/bin/generate.rs
@@ -35,6 +35,14 @@ fn main() {
 }
 
 fn print_schema_file(zod_output: &str, tinybase_output: &str) {
+    // Auto-generated header comment
+    println!(
+        r#"// This file is auto-generated by `cargo run -p store-types --bin generate-store-types`
+// Do not edit this file manually. Instead, edit the Rust types in crates/store-types/src/lib.rs
+// and run the generator to update this file.
+"#
+    );
+
     // Header
     println!(
         r#"import type {{ TablesSchema }} from "tinybase/with-schemas";
diff --git a/packages/store/src/schema.ts b/packages/store/src/schema.ts
index 7ec0589c9e..09bc1044f4 100644
--- a/packages/store/src/schema.ts
+++ b/packages/store/src/schema.ts
@@ -1,22 +1,63 @@
+// This file is auto-generated by `cargo run -p store-types --bin generate-store-types`
+// Do not edit this file manually. Instead, edit the Rust types in crates/store-types/src/lib.rs
+// and run the generator to update this file.
 import type { TablesSchema } from "tinybase/with-schemas";
 import { z } from "zod";
 
 import { InferTinyBaseSchema, jsonObject, type ToStorageType } from "./shared";
 
-export const humanSchema = z.object({
+export const calendarProviderSchema = z.enum(["apple", "google", "outlook"]);
+export type CalendarProvider = z.infer<typeof calendarProviderSchema>;
+
+export const participantSourceSchema = z.enum(["manual", "auto", "excluded"]);
+export type ParticipantSource = z.infer<typeof participantSourceSchema>;
+
+export const calendarSchema = z.object({
   user_id: z.string(),
+  created_at: z.string(),
+  tracking_id_calendar: z.string(),
   name: z.string(),
-  email: z.string(),
-  org_id: z.string(),
-  job_title: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  linkedin_username: z.preprocess(
-    (val) => val ?? undefined,
-    z.string().optional(),
-  ),
-  memo: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  pinned: z.preprocess((val) => val ?? false, z.boolean()),
-  pin_order: z.preprocess((val) => val ?? undefined, z.number().optional()),
+  enabled: z.preprocess((val) => val ?? false, z.boolean()),
+  provider: calendarProviderSchema,
+  source: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  color: z.preprocess((val) => val ?? undefined, z.string().optional()),
+});
+export type Calendar = z.infer<typeof calendarSchema>;
+
+export const chatGroupSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  title: z.string(),
+});
+export type ChatGroup = z.infer<typeof chatGroupSchema>;
+
+export const chatMessageSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  chat_group_id: z.string(),
+  role: z.string(),
+  content: z.string(),
+  metadata: jsonObject(z.any()),
+  parts: jsonObject(z.any()),
+});
+export type ChatMessage = z.infer<typeof chatMessageSchema>;
+
+export const chatShortcutSchema = z.object({
+  user_id: z.string(),
+  title: z.string(),
+  content: z.string(),
 });
+export type ChatShortcut = z.infer<typeof chatShortcutSchema>;
+
+export const enhancedNoteSchema = z.object({
+  user_id: z.string(),
+  session_id: z.string(),
+  content: z.string(),
+  template_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  position: z.number(),
+  title: z.preprocess((val) => val ?? undefined, z.string().optional()),
+});
+export type EnhancedNote = z.infer<typeof enhancedNoteSchema>;
 
 export const eventSchema = z.object({
   user_id: z.string(),
@@ -36,25 +77,76 @@ export const eventSchema = z.object({
     z.string().optional(),
   ),
 });
+export type Event = z.infer<typeof eventSchema>;
 
-export const calendarProviderSchema = z.enum(["apple", "google", "outlook"]);
-export type CalendarProvider = z.infer<typeof calendarProviderSchema>;
+export const generalSchema = z.object({
+  user_id: z.string(),
+  autostart: z.boolean().default(false),
+  telemetry_consent: z.boolean().default(true),
+  save_recordings: z.boolean().default(true),
+  notification_event: z.boolean().default(true),
+  notification_detect: z.boolean().default(true),
+  respect_dnd: z.boolean().default(false),
+  quit_intercept: z.boolean().default(false),
+  ai_language: z.string().default("en"),
+  spoken_languages: jsonObject(z.array(z.string()).default(["en"])),
+  ignored_platforms: jsonObject(z.array(z.string()).default([])),
+  ignored_recurring_series: jsonObject(z.array(z.string()).default([])),
+  current_llm_provider: z.string().optional(),
+  current_llm_model: z.string().optional(),
+  current_stt_provider: z.string().optional(),
+  current_stt_model: z.string().optional(),
+});
+export type General = z.infer<typeof generalSchema>;
 
-export const calendarSchema = z.object({
+export const humanSchema = z.object({
   user_id: z.string(),
-  created_at: z.string(),
-  tracking_id_calendar: z.string(),
   name: z.string(),
-  enabled: z.preprocess((val) => val ?? false, z.boolean()),
-  provider: calendarProviderSchema,
-  source: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  color: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  email: z.string(),
+  org_id: z.string(),
+  job_title: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  linkedin_username: z.preprocess(
+    (val) => val ?? undefined,
+    z.string().optional(),
+  ),
+  memo: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  pinned: z.preprocess((val) => val ?? false, z.boolean()),
+  pin_order: z.preprocess((val) => val ?? undefined, z.number().optional()),
 });
+export type Human = z.infer<typeof humanSchema>;
+
+export const mappingSessionParticipantSchema = z.object({
+  user_id: z.string(),
+  session_id: z.string(),
+  human_id: z.string(),
+  source: z.preprocess(
+    (val) => val ?? undefined,
+    participantSourceSchema.optional(),
+  ),
+});
+export type MappingSessionParticipant = z.infer<
+  typeof mappingSessionParticipantSchema
+>;
+
+export const mappingTagSessionSchema = z.object({
+  user_id: z.string(),
+  tag_id: z.string(),
+  session_id: z.string(),
+});
+export type MappingTagSession = z.infer<typeof mappingTagSessionSchema>;
 
 export const organizationSchema = z.object({
   user_id: z.string(),
   name: z.string(),
 });
+export type Organization = z.infer<typeof organizationSchema>;
+
+export const promptSchema = z.object({
+  user_id: z.string(),
+  task_type: z.string(),
+  content: z.string(),
+});
+export type Prompt = z.infer<typeof promptSchema>;
 
 export const sessionSchema = z.object({
   user_id: z.string(),
@@ -64,45 +156,23 @@ export const sessionSchema = z.object({
   title: z.string(),
   raw_md: z.string(),
 });
+export type Session = z.infer<typeof sessionSchema>;
 
-export const transcriptSchema = z.object({
+export const speakerHintSchema = z.object({
   user_id: z.string(),
   created_at: z.string(),
-  session_id: z.string(),
-  started_at: z.number(),
-  ended_at: z.preprocess((val) => val ?? undefined, z.number().optional()),
-  words: z.preprocess((val) => val ?? "[]", z.string()),
-  speaker_hints: z.preprocess((val) => val ?? "[]", z.string()),
-});
-
-export const participantSourceSchema = z.enum(["manual", "auto", "excluded"]);
-export type ParticipantSource = z.infer<typeof participantSourceSchema>;
-
-export const mappingSessionParticipantSchema = z.object({
-  user_id: z.string(),
-  session_id: z.string(),
-  human_id: z.string(),
-  source: z.preprocess(
-    (val) => val ?? undefined,
-    participantSourceSchema.optional(),
-  ),
+  transcript_id: z.string(),
+  word_id: z.string(),
+  type: z.string(),
+  value: jsonObject(z.record(z.string(), z.unknown())),
 });
+export type SpeakerHint = z.infer<typeof speakerHintSchema>;
 
 export const tagSchema = z.object({
   user_id: z.string(),
   name: z.string(),
 });
-
-export const mappingTagSessionSchema = z.object({
-  user_id: z.string(),
-  tag_id: z.string(),
-  session_id: z.string(),
-});
-
-export const templateSectionSchema = z.object({
-  title: z.string(),
-  description: z.string(),
-});
+export type Tag = z.infer<typeof tagSchema>;
 
 export const templateSchema = z.object({
   user_id: z.string(),
@@ -115,43 +185,24 @@ export const templateSchema = z.object({
   ),
   sections: jsonObject(z.array(templateSectionSchema)),
 });
+export type Template = z.infer<typeof templateSchema>;
 
-export const chatGroupSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
+export const templateSectionSchema = z.object({
   title: z.string(),
+  description: z.string(),
 });
+export type TemplateSection = z.infer<typeof templateSectionSchema>;
 
-export const chatMessageSchema = z.object({
+export const transcriptSchema = z.object({
   user_id: z.string(),
   created_at: z.string(),
-  chat_group_id: z.string(),
-  role: z.string(),
-  content: z.string(),
-  metadata: jsonObject(z.any()),
-  parts: jsonObject(z.any()),
-});
-
-export const chatShortcutSchema = z.object({
-  user_id: z.string(),
-  title: z.string(),
-  content: z.string(),
-});
-
-export const enhancedNoteSchema = z.object({
-  user_id: z.string(),
   session_id: z.string(),
-  content: z.string(),
-  template_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  position: z.number(),
-  title: z.preprocess((val) => val ?? undefined, z.string().optional()),
-});
-
-export const promptSchema = z.object({
-  user_id: z.string(),
-  task_type: z.string(),
-  content: z.string(),
+  started_at: z.number(),
+  ended_at: z.preprocess((val) => val ?? undefined, z.number().optional()),
+  words: z.preprocess((val) => val ?? "[]", z.string()),
+  speaker_hints: z.preprocess((val) => val ?? "[]", z.string()),
 });
+export type Transcript = z.infer<typeof transcriptSchema>;
 
 export const wordSchema = z.object({
   user_id: z.string(),
@@ -167,15 +218,7 @@ export const wordSchema = z.object({
     jsonObject(z.record(z.string(), z.unknown())).optional(),
   ),
 });
-
-export const speakerHintSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  transcript_id: z.string(),
-  word_id: z.string(),
-  type: z.string(),
-  value: jsonObject(z.record(z.string(), z.unknown())),
-});
+export type Word = z.infer<typeof wordSchema>;
 
 export const providerSpeakerIndexSchema = z.object({
   speaker_index: z.number(),
@@ -183,25 +226,6 @@ export const providerSpeakerIndexSchema = z.object({
   channel: z.number().optional(),
 });
 
-export const generalSchema = z.object({
-  user_id: z.string(),
-  autostart: z.boolean().default(false),
-  telemetry_consent: z.boolean().default(true),
-  save_recordings: z.boolean().default(true),
-  notification_event: z.boolean().default(true),
-  notification_detect: z.boolean().default(true),
-  respect_dnd: z.boolean().default(false),
-  quit_intercept: z.boolean().default(false),
-  ai_language: z.string().default("en"),
-  spoken_languages: jsonObject(z.array(z.string()).default(["en"])),
-  ignored_platforms: jsonObject(z.array(z.string()).default([])),
-  ignored_recurring_series: jsonObject(z.array(z.string()).default([])),
-  current_llm_provider: z.string().optional(),
-  current_llm_model: z.string().optional(),
-  current_stt_provider: z.string().optional(),
-  current_stt_model: z.string().optional(),
-});
-
 export const aiProviderSchema = z
   .object({
     type: z.enum(["stt", "llm"]),
@@ -283,8 +307,8 @@ export const tableSchemaForTinybase = {
   words: {
     user_id: { type: "string" },
     created_at: { type: "string" },
-    text: { type: "string" },
     transcript_id: { type: "string" },
+    text: { type: "string" },
     start_ms: { type: "number" },
     end_ms: { type: "number" },
     channel: { type: "number" },
@@ -360,6 +384,8 @@ export const tableSchemaForTinybase = {
     user_id: { type: "string" },
     title: { type: "string" },
     description: { type: "string" },
+    category: { type: "string" },
+    targets: { type: "string" },
     sections: { type: "string" },
   } as const satisfies InferTinyBaseSchema<typeof templateSchema>,
   chat_groups: {

From fd2dc27a2b303d1c35aae704684ea24cfe4153a4 Mon Sep 17 00:00:00 2001
From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Date: Fri, 30 Jan 2026 13:08:06 +0000
Subject: [PATCH 5/6] Fix duplicate type exports and templateSectionSchema
 ordering

- Remove duplicate type exports (Zod exporter already generates inline types)
- Add reorder_template_schemas function to ensure templateSectionSchema
  is defined before templateSchema (which references it)
- Typecheck now passes

Co-Authored-By: yujonglee <yujonglee.dev@gmail.com>
---
 crates/store-types/src/bin/generate.rs | 103 +++++++++++++++++++------
 packages/store/src/schema.ts           |  36 ++-------
 2 files changed, 85 insertions(+), 54 deletions(-)

diff --git a/crates/store-types/src/bin/generate.rs b/crates/store-types/src/bin/generate.rs
index 4325d7a5a0..c2468935c0 100644
--- a/crates/store-types/src/bin/generate.rs
+++ b/crates/store-types/src/bin/generate.rs
@@ -71,8 +71,12 @@ export type ParticipantSource = z.infer<typeof participantSourceSchema>;
         "",
     );
 
+    // Reorder schemas so templateSectionSchema comes before templateSchema
+    // (templateSchema references templateSectionSchema)
+    let reordered_zod = reorder_template_schemas(&zod_without_header);
+
     // Print Zod schemas (modified to use enum references where needed)
-    let modified_zod = zod_without_header
+    let modified_zod = reordered_zod
         // Calendar provider should use the enum
         .replace("provider: z.string()", "provider: calendarProviderSchema")
         // MappingSessionParticipant.source should use participantSourceSchema
@@ -206,36 +210,15 @@ export type ParticipantSource = z.infer<typeof participantSourceSchema>;
 "#
     );
 
-    // Type exports
+    // Type exports - only the ones not already generated by Zod exporter
+    // The Zod exporter generates inline type exports after each schema
     println!(
         r#"export type ProviderSpeakerIndexHint = z.infer<
   typeof providerSpeakerIndexSchema
 >;
-
-export type Human = z.infer<typeof humanSchema>;
-export type Event = z.infer<typeof eventSchema>;
-export type Calendar = z.infer<typeof calendarSchema>;
-export type CalendarStorage = ToStorageType<typeof calendarSchema>;
-export type Organization = z.infer<typeof organizationSchema>;
-export type Session = z.infer<typeof sessionSchema>;
-export type Transcript = z.infer<typeof transcriptSchema>;
-export type Word = z.infer<typeof wordSchema>;
-export type SpeakerHint = z.infer<typeof speakerHintSchema>;
-export type MappingSessionParticipant = z.infer<
-  typeof mappingSessionParticipantSchema
->;
-export type Tag = z.infer<typeof tagSchema>;
-export type MappingTagSession = z.infer<typeof mappingTagSessionSchema>;
-export type Template = z.infer<typeof templateSchema>;
-export type TemplateSection = z.infer<typeof templateSectionSchema>;
-export type ChatGroup = z.infer<typeof chatGroupSchema>;
-export type ChatMessage = z.infer<typeof chatMessageSchema>;
-export type ChatShortcut = z.infer<typeof chatShortcutSchema>;
-export type EnhancedNote = z.infer<typeof enhancedNoteSchema>;
-export type Prompt = z.infer<typeof promptSchema>;
 export type AIProvider = z.infer<typeof aiProviderSchema>;
-export type General = z.infer<typeof generalSchema>;
 
+export type CalendarStorage = ToStorageType<typeof calendarSchema>;
 export type SessionStorage = ToStorageType<typeof sessionSchema>;
 export type TranscriptStorage = ToStorageType<typeof transcriptSchema>;
 export type WordStorage = ToStorageType<typeof wordSchema>;
@@ -349,6 +332,76 @@ export type GeneralStorage = ToStorageType<typeof generalSchema>;
     );
 }
 
+fn reorder_template_schemas(zod_output: &str) -> String {
+    // Find templateSchema and templateSectionSchema blocks
+    let template_schema_start = "export const templateSchema = z.object({";
+    let template_section_start = "export const templateSectionSchema = z.object({";
+
+    if let (Some(template_idx), Some(section_idx)) = (
+        zod_output.find(template_schema_start),
+        zod_output.find(template_section_start),
+    ) {
+        // Only reorder if templateSchema comes before templateSectionSchema
+        if template_idx < section_idx {
+            // Find the end of each schema block (});)
+            let template_end = find_schema_end(zod_output, template_idx);
+            let section_end = find_schema_end(zod_output, section_idx);
+
+            if let (Some(t_end), Some(s_end)) = (template_end, section_end) {
+                // Extract the blocks
+                let template_block = &zod_output[template_idx..t_end];
+                let section_block = &zod_output[section_idx..s_end];
+
+                // Build the reordered output
+                let before_template = &zod_output[..template_idx];
+                let between = &zod_output[t_end..section_idx];
+                let after_section = &zod_output[s_end..];
+
+                return format!(
+                    "{}{}{}{}{}",
+                    before_template, section_block, between, template_block, after_section
+                );
+            }
+        }
+    }
+    zod_output.to_string()
+}
+
+fn find_schema_end(content: &str, start_idx: usize) -> Option<usize> {
+    // Find the end of a schema block, accounting for the type export line
+    let from_start = &content[start_idx..];
+
+    // Find the closing }); of the z.object
+    let mut depth = 0;
+    let mut in_object = false;
+    let mut chars = from_start.char_indices();
+
+    while let Some((i, c)) = chars.next() {
+        match c {
+            '{' => {
+                depth += 1;
+                in_object = true;
+            }
+            '}' => {
+                depth -= 1;
+                if in_object && depth == 0 {
+                    // Found the closing brace, now find the end of the line with type export
+                    let rest = &from_start[i..];
+                    // Look for the next "export const" or end of string
+                    if let Some(next_export) = rest.find("\nexport const ") {
+                        return Some(start_idx + i + next_export + 1);
+                    } else {
+                        // No more exports, return to end
+                        return Some(content.len());
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
 fn extract_tinybase_schema(tinybase_output: &str, table_name: &str) -> Option<String> {
     // Map table names to their TinyBase schema variable names
     let var_name = match table_name {
diff --git a/packages/store/src/schema.ts b/packages/store/src/schema.ts
index 09bc1044f4..80ad490290 100644
--- a/packages/store/src/schema.ts
+++ b/packages/store/src/schema.ts
@@ -174,6 +174,12 @@ export const tagSchema = z.object({
 });
 export type Tag = z.infer<typeof tagSchema>;
 
+export const templateSectionSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+});
+export type TemplateSection = z.infer<typeof templateSectionSchema>;
+
 export const templateSchema = z.object({
   user_id: z.string(),
   title: z.string(),
@@ -187,12 +193,6 @@ export const templateSchema = z.object({
 });
 export type Template = z.infer<typeof templateSchema>;
 
-export const templateSectionSchema = z.object({
-  title: z.string(),
-  description: z.string(),
-});
-export type TemplateSection = z.infer<typeof templateSectionSchema>;
-
 export const transcriptSchema = z.object({
   user_id: z.string(),
   created_at: z.string(),
@@ -243,31 +243,9 @@ export const aiProviderSchema = z
 export type ProviderSpeakerIndexHint = z.infer<
   typeof providerSpeakerIndexSchema
 >;
-
-export type Human = z.infer<typeof humanSchema>;
-export type Event = z.infer<typeof eventSchema>;
-export type Calendar = z.infer<typeof calendarSchema>;
-export type CalendarStorage = ToStorageType<typeof calendarSchema>;
-export type Organization = z.infer<typeof organizationSchema>;
-export type Session = z.infer<typeof sessionSchema>;
-export type Transcript = z.infer<typeof transcriptSchema>;
-export type Word = z.infer<typeof wordSchema>;
-export type SpeakerHint = z.infer<typeof speakerHintSchema>;
-export type MappingSessionParticipant = z.infer<
-  typeof mappingSessionParticipantSchema
->;
-export type Tag = z.infer<typeof tagSchema>;
-export type MappingTagSession = z.infer<typeof mappingTagSessionSchema>;
-export type Template = z.infer<typeof templateSchema>;
-export type TemplateSection = z.infer<typeof templateSectionSchema>;
-export type ChatGroup = z.infer<typeof chatGroupSchema>;
-export type ChatMessage = z.infer<typeof chatMessageSchema>;
-export type ChatShortcut = z.infer<typeof chatShortcutSchema>;
-export type EnhancedNote = z.infer<typeof enhancedNoteSchema>;
-export type Prompt = z.infer<typeof promptSchema>;
 export type AIProvider = z.infer<typeof aiProviderSchema>;
-export type General = z.infer<typeof generalSchema>;
 
+export type CalendarStorage = ToStorageType<typeof calendarSchema>;
 export type SessionStorage = ToStorageType<typeof sessionSchema>;
 export type TranscriptStorage = ToStorageType<typeof transcriptSchema>;
 export type WordStorage = ToStorageType<typeof wordSchema>;

From 012042ced02bcd967ab34fbbdd790b589143595c Mon Sep 17 00:00:00 2001
From: Yujong Lee <yujonglee.dev@gmail.com>
Date: Sat, 31 Jan 2026 18:07:53 +0900
Subject: [PATCH 6/6] wip

---
 crates/specta-zod/src/zod.rs           |  86 +++++
 crates/store-types/Cargo.toml          |   7 +-
 crates/store-types/build.rs            | 118 +++++++
 crates/store-types/src/bin/generate.rs | 445 -------------------------
 crates/store-types/src/lib.rs          | 221 +-----------
 crates/store-types/src/types.rs        | 240 +++++++++++++
 packages/store/src/schema.ts           | 422 +----------------------
 packages/store/src/tinybase.ts         | 198 +++++++++++
 packages/store/src/zod.ts              | 253 ++++++++++++++
 9 files changed, 903 insertions(+), 1087 deletions(-)
 create mode 100644 crates/store-types/build.rs
 delete mode 100644 crates/store-types/src/bin/generate.rs
 create mode 100644 crates/store-types/src/types.rs
 create mode 100644 packages/store/src/tinybase.ts
 create mode 100644 packages/store/src/zod.ts

diff --git a/crates/specta-zod/src/zod.rs b/crates/specta-zod/src/zod.rs
index 9f38fbbdd9..70ff2a3e88 100644
--- a/crates/specta-zod/src/zod.rs
+++ b/crates/specta-zod/src/zod.rs
@@ -10,6 +10,41 @@ use specta::{
 
 use crate::Error;
 
+#[derive(Debug, Default)]
+struct ZodFieldAttrs {
+    default: Option<String>,
+    schema: Option<String>,
+    json: Option<String>,
+}
+
+fn parse_zod_attrs(docs: &str) -> ZodFieldAttrs {
+    let mut attrs = ZodFieldAttrs::default();
+
+    for line in docs.lines() {
+        let line = line.trim();
+        if let Some(rest) = line.strip_prefix("@zod.") {
+            if let Some(value) = rest
+                .strip_prefix("default(")
+                .and_then(|s| s.strip_suffix(")"))
+            {
+                attrs.default = Some(value.to_string());
+            } else if let Some(value) = rest
+                .strip_prefix("schema(")
+                .and_then(|s| s.strip_suffix(")"))
+            {
+                attrs.schema = Some(value.to_string());
+            } else if let Some(value) = rest.strip_prefix("json(").and_then(|s| s.strip_suffix(")"))
+            {
+                attrs.json = Some(value.to_string());
+            } else if rest == "json" {
+                attrs.json = Some(String::new());
+            }
+        }
+    }
+
+    attrs
+}
+
 pub struct Zod {
     pub header: Cow<'static, str>,
 }
@@ -237,12 +272,63 @@ fn field_type(s: &mut String, types: &TypeCollection, field: &Field) -> Result<(
         return Ok(());
     };
 
+    let attrs = parse_zod_attrs(field.docs());
     let is_nullable = matches!(ty, DataType::Nullable(_));
 
+    if let Some(schema) = &attrs.schema {
+        s.push_str(schema);
+        if let Some(default) = &attrs.default {
+            write!(s, ".default({})", default)?;
+        }
+        return Ok(());
+    }
+
+    if let Some(json_inner) = &attrs.json {
+        let is_optional = field.optional() || is_nullable;
+        if is_optional {
+            s.push_str("z.preprocess((val) => val ?? undefined, jsonObject(");
+            if json_inner.is_empty() {
+                if is_nullable {
+                    if let DataType::Nullable(inner) = ty {
+                        datatype(s, types, inner, true)?;
+                    }
+                } else {
+                    datatype(s, types, ty, true)?;
+                }
+            } else {
+                s.push_str(json_inner);
+            }
+            s.push_str(").optional())");
+        } else {
+            s.push_str("jsonObject(");
+            if json_inner.is_empty() {
+                datatype(s, types, ty, true)?;
+            } else {
+                s.push_str(json_inner);
+            }
+            s.push(')');
+        }
+        if let Some(default) = &attrs.default {
+            write!(s, ".default({})", default)?;
+        }
+        return Ok(());
+    }
+
     if field.optional() && !is_nullable {
         s.push_str("z.preprocess((val) => val ?? undefined, ");
         datatype(s, types, ty, false)?;
         s.push_str(".optional())");
+    } else if let Some(default) = &attrs.default {
+        if is_nullable {
+            write!(s, "z.preprocess((val) => val ?? {}, ", default)?;
+            if let DataType::Nullable(inner) = ty {
+                datatype(s, types, inner, false)?;
+            }
+            s.push(')');
+        } else {
+            datatype(s, types, ty, false)?;
+            write!(s, ".default({})", default)?;
+        }
     } else {
         datatype(s, types, ty, false)?;
     }
diff --git a/crates/store-types/Cargo.toml b/crates/store-types/Cargo.toml
index b5fb26c7e8..11b32c690e 100644
--- a/crates/store-types/Cargo.toml
+++ b/crates/store-types/Cargo.toml
@@ -9,6 +9,7 @@ serde_json = { workspace = true }
 specta = { workspace = true, features = ["derive"] }
 specta-zod = { path = "../specta-zod" }
 
-[[bin]]
-name = "generate-store-types"
-path = "src/bin/generate.rs"
+[build-dependencies]
+serde = { workspace = true, features = ["derive"] }
+specta = { workspace = true, features = ["derive"] }
+specta-zod = { path = "../specta-zod" }
diff --git a/crates/store-types/build.rs b/crates/store-types/build.rs
new file mode 100644
index 0000000000..414493f23d
--- /dev/null
+++ b/crates/store-types/build.rs
@@ -0,0 +1,118 @@
+use specta::TypeCollection;
+use specta_zod::Zod;
+
+include!("src/types.rs");
+
+fn main() {
+    let mut types = TypeCollection::default();
+    types.register::<Human>();
+    types.register::<Event>();
+    types.register::<Calendar>();
+    types.register::<Organization>();
+    types.register::<Session>();
+    types.register::<Transcript>();
+    types.register::<MappingSessionParticipant>();
+    types.register::<Tag>();
+    types.register::<MappingTagSession>();
+    types.register::<TemplateSection>();
+    types.register::<Template>();
+    types.register::<ChatGroup>();
+    types.register::<ChatMessage>();
+    types.register::<ChatShortcut>();
+    types.register::<EnhancedNote>();
+    types.register::<Prompt>();
+    types.register::<Word>();
+    types.register::<SpeakerHint>();
+    types.register::<General>();
+
+    let header = r#"// This file is auto-generated by building store-types crate.
+// Do not edit this file manually. Instead, edit the Rust types in
+// crates/store-types/src/types.rs and run `cargo build -p store-types`.
+
+import { z } from "zod";
+
+import { jsonObject } from "./shared";
+
+export const calendarProviderSchema = z.enum(["apple", "google", "outlook"]);
+export type CalendarProvider = z.infer<typeof calendarProviderSchema>;
+
+export const participantSourceSchema = z.enum(["manual", "auto", "excluded"]);
+export type ParticipantSource = z.infer<typeof participantSourceSchema>;
+
+"#;
+
+    let zod_output = Zod::new().header(header).export(&types).unwrap();
+    let zod_output = reorder_template_schemas(&zod_output);
+
+    let footer = r#"
+export const providerSpeakerIndexSchema = z.object({
+  speaker_index: z.number(),
+  provider: z.string().optional(),
+  channel: z.number().optional(),
+});
+export type ProviderSpeakerIndexHint = z.infer<typeof providerSpeakerIndexSchema>;
+
+export const aiProviderSchema = z
+  .object({
+    type: z.enum(["stt", "llm"]),
+    base_url: z.url().min(1),
+    api_key: z.string(),
+  })
+  .refine(
+    (data) => !data.base_url.startsWith("https:") || data.api_key.length > 0,
+    {
+      message: "API key is required for HTTPS URLs",
+      path: ["api_key"],
+    },
+  );
+export type AIProvider = z.infer<typeof aiProviderSchema>;
+"#;
+
+    let output = format!("{}{}", zod_output, footer);
+
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let output_path = std::path::Path::new(&manifest_dir).join("../../packages/store/src/zod.ts");
+    std::fs::write(&output_path, output).expect("Failed to write zod.ts");
+
+    println!("cargo::rerun-if-changed=src/types.rs");
+}
+
+fn reorder_template_schemas(output: &str) -> String {
+    let template_marker = "export const templateSchema = z.object({";
+    let section_marker = "export const templateSectionSchema = z.object({";
+
+    let Some(template_start) = output.find(template_marker) else {
+        return output.to_string();
+    };
+    let Some(section_start) = output.find(section_marker) else {
+        return output.to_string();
+    };
+
+    if template_start > section_start {
+        return output.to_string();
+    }
+
+    let template_end = find_type_block_end(output, template_start);
+    let section_end = find_type_block_end(output, section_start);
+
+    let template_block = &output[template_start..template_end];
+    let section_block = &output[section_start..section_end];
+
+    let before = &output[..template_start];
+    let between = &output[template_end..section_start];
+    let after = &output[section_end..];
+
+    format!(
+        "{}{}{}{}{}",
+        before, section_block, between, template_block, after
+    )
+}
+
+fn find_type_block_end(content: &str, start: usize) -> usize {
+    let from_start = &content[start..];
+    if let Some(next) = from_start[1..].find("\nexport const ") {
+        start + 1 + next + 1
+    } else {
+        content.len()
+    }
+}
diff --git a/crates/store-types/src/bin/generate.rs b/crates/store-types/src/bin/generate.rs
deleted file mode 100644
index c2468935c0..0000000000
--- a/crates/store-types/src/bin/generate.rs
+++ /dev/null
@@ -1,445 +0,0 @@
-use specta::TypeCollection;
-use specta_zod::{TinyBase, Zod};
-use store_types::*;
-
-fn main() {
-    let mut types = TypeCollection::default();
-    types.register::<Human>();
-    types.register::<Event>();
-    types.register::<Calendar>();
-    types.register::<Organization>();
-    types.register::<Session>();
-    types.register::<Transcript>();
-    types.register::<MappingSessionParticipant>();
-    types.register::<Tag>();
-    types.register::<MappingTagSession>();
-    types.register::<Template>();
-    types.register::<TemplateSection>();
-    types.register::<ChatGroup>();
-    types.register::<ChatMessage>();
-    types.register::<ChatShortcut>();
-    types.register::<EnhancedNote>();
-    types.register::<Prompt>();
-    types.register::<Word>();
-    types.register::<SpeakerHint>();
-    types.register::<General>();
-
-    // Generate Zod schemas
-    let zod_output = Zod::new().export(&types).unwrap();
-
-    // Generate TinyBase schemas
-    let tinybase_output = TinyBase::new().header("").export(&types).unwrap();
-
-    // Print the complete schema.ts file
-    print_schema_file(&zod_output, &tinybase_output);
-}
-
-fn print_schema_file(zod_output: &str, tinybase_output: &str) {
-    // Auto-generated header comment
-    println!(
-        r#"// This file is auto-generated by `cargo run -p store-types --bin generate-store-types`
-// Do not edit this file manually. Instead, edit the Rust types in crates/store-types/src/lib.rs
-// and run the generator to update this file.
-"#
-    );
-
-    // Header
-    println!(
-        r#"import type {{ TablesSchema }} from "tinybase/with-schemas";
-import {{ z }} from "zod";
-
-import {{ InferTinyBaseSchema, jsonObject, type ToStorageType }} from "./shared";
-"#
-    );
-
-    // Enum schemas (these need to be defined before they're used)
-    println!(
-        r#"export const calendarProviderSchema = z.enum(["apple", "google", "outlook"]);
-export type CalendarProvider = z.infer<typeof calendarProviderSchema>;
-"#
-    );
-
-    println!(
-        r#"export const participantSourceSchema = z.enum(["manual", "auto", "excluded"]);
-export type ParticipantSource = z.infer<typeof participantSourceSchema>;
-"#
-    );
-
-    // Remove the header from zod_output since we already printed our own
-    let zod_without_header = zod_output.replace(
-        "import { z } from \"zod\";\nimport { jsonObject } from \"./shared\";\n\n",
-        "",
-    );
-
-    // Reorder schemas so templateSectionSchema comes before templateSchema
-    // (templateSchema references templateSectionSchema)
-    let reordered_zod = reorder_template_schemas(&zod_without_header);
-
-    // Print Zod schemas (modified to use enum references where needed)
-    let modified_zod = reordered_zod
-        // Calendar provider should use the enum
-        .replace("provider: z.string()", "provider: calendarProviderSchema")
-        // MappingSessionParticipant.source should use participantSourceSchema
-        .replace(
-            "export const mappingSessionParticipantSchema = z.object({\n  user_id: z.string(),\n  session_id: z.string(),\n  human_id: z.string(),\n  source: z.preprocess((val) => val ?? undefined, z.string().optional()),\n});",
-            "export const mappingSessionParticipantSchema = z.object({\n  user_id: z.string(),\n  session_id: z.string(),\n  human_id: z.string(),\n  source: z.preprocess(\n    (val) => val ?? undefined,\n    participantSourceSchema.optional(),\n  ),\n});",
-        )
-        // Human.pinned should have default false
-        .replace(
-            "pinned: z.boolean()",
-            "pinned: z.preprocess((val) => val ?? false, z.boolean())",
-        )
-        // Calendar.enabled should have default false
-        .replace(
-            "enabled: z.boolean()",
-            "enabled: z.preprocess((val) => val ?? false, z.boolean())",
-        )
-        // General booleans should have defaults
-        .replace(
-            "autostart: z.boolean()",
-            "autostart: z.boolean().default(false)",
-        )
-        .replace(
-            "telemetry_consent: z.boolean()",
-            "telemetry_consent: z.boolean().default(true)",
-        )
-        .replace(
-            "save_recordings: z.boolean()",
-            "save_recordings: z.boolean().default(true)",
-        )
-        .replace(
-            "notification_event: z.boolean()",
-            "notification_event: z.boolean().default(true)",
-        )
-        .replace(
-            "notification_detect: z.boolean()",
-            "notification_detect: z.boolean().default(true)",
-        )
-        .replace(
-            "respect_dnd: z.boolean()",
-            "respect_dnd: z.boolean().default(false)",
-        )
-        .replace(
-            "quit_intercept: z.boolean()",
-            "quit_intercept: z.boolean().default(false)",
-        )
-        .replace(
-            "ai_language: z.string()",
-            r#"ai_language: z.string().default("en")"#,
-        )
-        // General arrays should have defaults
-        .replace(
-            "spoken_languages: jsonObject(z.array(z.string()))",
-            r#"spoken_languages: jsonObject(z.array(z.string()).default(["en"]))"#,
-        )
-        .replace(
-            "ignored_platforms: jsonObject(z.array(z.string()))",
-            "ignored_platforms: jsonObject(z.array(z.string()).default([]))",
-        )
-        .replace(
-            "ignored_recurring_series: jsonObject(z.array(z.string()))",
-            "ignored_recurring_series: jsonObject(z.array(z.string()).default([]))",
-        )
-        // General optional fields should not use preprocess
-        .replace(
-            "current_llm_provider: z.preprocess((val) => val ?? undefined, z.string().optional())",
-            "current_llm_provider: z.string().optional()",
-        )
-        .replace(
-            "current_llm_model: z.preprocess((val) => val ?? undefined, z.string().optional())",
-            "current_llm_model: z.string().optional()",
-        )
-        .replace(
-            "current_stt_provider: z.preprocess((val) => val ?? undefined, z.string().optional())",
-            "current_stt_provider: z.string().optional()",
-        )
-        .replace(
-            "current_stt_model: z.preprocess((val) => val ?? undefined, z.string().optional())",
-            "current_stt_model: z.string().optional()",
-        )
-        // Transcript words/speaker_hints should have default "[]"
-        .replace(
-            "words: z.string()",
-            r#"words: z.preprocess((val) => val ?? "[]", z.string())"#,
-        )
-        .replace(
-            "speaker_hints: z.string()",
-            r#"speaker_hints: z.preprocess((val) => val ?? "[]", z.string())"#,
-        )
-        // ChatMessage metadata/parts should use jsonObject(z.any())
-        .replace("metadata: z.string()", "metadata: jsonObject(z.any())")
-        .replace("parts: z.string()", "parts: jsonObject(z.any())")
-        // Word metadata should use jsonObject with record
-        .replace(
-            "metadata: z.preprocess((val) => val ?? undefined, z.string().optional())",
-            "metadata: z.preprocess(\n    (val) => val ?? undefined,\n    jsonObject(z.record(z.string(), z.unknown())).optional(),\n  )",
-        )
-        // SpeakerHint value should use jsonObject with record
-        .replace(
-            "value: z.string()",
-            "value: jsonObject(z.record(z.string(), z.unknown()))",
-        );
-
-    println!("{}", modified_zod);
-
-    // Add providerSpeakerIndexSchema
-    println!(
-        r#"export const providerSpeakerIndexSchema = z.object({{
-  speaker_index: z.number(),
-  provider: z.string().optional(),
-  channel: z.number().optional(),
-}});
-"#
-    );
-
-    // Add aiProviderSchema
-    println!(
-        r#"export const aiProviderSchema = z
-  .object({{
-    type: z.enum(["stt", "llm"]),
-    base_url: z.url().min(1),
-    api_key: z.string(),
-  }})
-  .refine(
-    (data) => !data.base_url.startsWith("https:") || data.api_key.length > 0,
-    {{
-      message: "API key is required for HTTPS URLs",
-      path: ["api_key"],
-    }},
-  );
-"#
-    );
-
-    // Type exports - only the ones not already generated by Zod exporter
-    // The Zod exporter generates inline type exports after each schema
-    println!(
-        r#"export type ProviderSpeakerIndexHint = z.infer<
-  typeof providerSpeakerIndexSchema
->;
-export type AIProvider = z.infer<typeof aiProviderSchema>;
-
-export type CalendarStorage = ToStorageType<typeof calendarSchema>;
-export type SessionStorage = ToStorageType<typeof sessionSchema>;
-export type TranscriptStorage = ToStorageType<typeof transcriptSchema>;
-export type WordStorage = ToStorageType<typeof wordSchema>;
-export type SpeakerHintStorage = ToStorageType<typeof speakerHintSchema>;
-export type TemplateStorage = ToStorageType<typeof templateSchema>;
-export type ChatMessageStorage = ToStorageType<typeof chatMessageSchema>;
-export type EnhancedNoteStorage = ToStorageType<typeof enhancedNoteSchema>;
-export type HumanStorage = ToStorageType<typeof humanSchema>;
-export type OrganizationStorage = ToStorageType<typeof organizationSchema>;
-export type PromptStorage = ToStorageType<typeof promptSchema>;
-export type ChatShortcutStorage = ToStorageType<typeof chatShortcutSchema>;
-export type EventStorage = ToStorageType<typeof eventSchema>;
-export type MappingSessionParticipantStorage = ToStorageType<
-  typeof mappingSessionParticipantSchema
->;
-export type AIProviderStorage = ToStorageType<typeof aiProviderSchema>;
-export type GeneralStorage = ToStorageType<typeof generalSchema>;
-"#
-    );
-
-    // Generate tableSchemaForTinybase
-    println!("export const tableSchemaForTinybase = {{");
-
-    // Parse tinybase_output and reorganize into table format
-    let table_schemas = [
-        ("sessions", "sessionTinybaseSchema", "sessionSchema"),
-        (
-            "transcripts",
-            "transcriptTinybaseSchema",
-            "transcriptSchema",
-        ),
-        ("words", "wordTinybaseSchema", "wordSchema"),
-        (
-            "speaker_hints",
-            "speaker_hintTinybaseSchema",
-            "speakerHintSchema",
-        ),
-        ("humans", "humanTinybaseSchema", "humanSchema"),
-        (
-            "organizations",
-            "organizationTinybaseSchema",
-            "organizationSchema",
-        ),
-        ("calendars", "calendarTinybaseSchema", "calendarSchema"),
-        ("events", "eventTinybaseSchema", "eventSchema"),
-        (
-            "mapping_session_participant",
-            "mapping_session_participantTinybaseSchema",
-            "mappingSessionParticipantSchema",
-        ),
-        ("tags", "tagTinybaseSchema", "tagSchema"),
-        (
-            "mapping_tag_session",
-            "mapping_tag_sessionTinybaseSchema",
-            "mappingTagSessionSchema",
-        ),
-        ("templates", "templateTinybaseSchema", "templateSchema"),
-        ("chat_groups", "chat_groupTinybaseSchema", "chatGroupSchema"),
-        (
-            "chat_messages",
-            "chat_messageTinybaseSchema",
-            "chatMessageSchema",
-        ),
-        (
-            "enhanced_notes",
-            "enhanced_noteTinybaseSchema",
-            "enhancedNoteSchema",
-        ),
-        ("prompts", "promptTinybaseSchema", "promptSchema"),
-        (
-            "chat_shortcuts",
-            "chat_shortcutTinybaseSchema",
-            "chatShortcutSchema",
-        ),
-    ];
-
-    for (table_name, _, zod_schema) in table_schemas.iter() {
-        let schema_content = extract_tinybase_schema(tinybase_output, table_name);
-        if let Some(content) = schema_content {
-            println!(
-                "  {}: {{\n{}  }} as const satisfies InferTinyBaseSchema<typeof {}>,",
-                table_name, content, zod_schema
-            );
-        }
-    }
-
-    println!("}} as const satisfies TablesSchema;");
-    println!();
-
-    // Generate valueSchemaForTinybase (General fields)
-    println!(
-        r#"export const valueSchemaForTinybase = {{
-  user_id: {{ type: "string" }},
-  autostart: {{ type: "boolean" }},
-  save_recordings: {{ type: "boolean" }},
-  notification_event: {{ type: "boolean" }},
-  notification_detect: {{ type: "boolean" }},
-  respect_dnd: {{ type: "boolean" }},
-  quit_intercept: {{ type: "boolean" }},
-  telemetry_consent: {{ type: "boolean" }},
-  ai_language: {{ type: "string" }},
-  spoken_languages: {{ type: "string" }},
-  ignored_platforms: {{ type: "string" }},
-  ignored_recurring_series: {{ type: "string" }},
-  current_llm_provider: {{ type: "string" }},
-  current_llm_model: {{ type: "string" }},
-  current_stt_provider: {{ type: "string" }},
-  current_stt_model: {{ type: "string" }},
-}} as const satisfies InferTinyBaseSchema<typeof generalSchema>;
-"#
-    );
-}
-
-fn reorder_template_schemas(zod_output: &str) -> String {
-    // Find templateSchema and templateSectionSchema blocks
-    let template_schema_start = "export const templateSchema = z.object({";
-    let template_section_start = "export const templateSectionSchema = z.object({";
-
-    if let (Some(template_idx), Some(section_idx)) = (
-        zod_output.find(template_schema_start),
-        zod_output.find(template_section_start),
-    ) {
-        // Only reorder if templateSchema comes before templateSectionSchema
-        if template_idx < section_idx {
-            // Find the end of each schema block (});)
-            let template_end = find_schema_end(zod_output, template_idx);
-            let section_end = find_schema_end(zod_output, section_idx);
-
-            if let (Some(t_end), Some(s_end)) = (template_end, section_end) {
-                // Extract the blocks
-                let template_block = &zod_output[template_idx..t_end];
-                let section_block = &zod_output[section_idx..s_end];
-
-                // Build the reordered output
-                let before_template = &zod_output[..template_idx];
-                let between = &zod_output[t_end..section_idx];
-                let after_section = &zod_output[s_end..];
-
-                return format!(
-                    "{}{}{}{}{}",
-                    before_template, section_block, between, template_block, after_section
-                );
-            }
-        }
-    }
-    zod_output.to_string()
-}
-
-fn find_schema_end(content: &str, start_idx: usize) -> Option<usize> {
-    // Find the end of a schema block, accounting for the type export line
-    let from_start = &content[start_idx..];
-
-    // Find the closing }); of the z.object
-    let mut depth = 0;
-    let mut in_object = false;
-    let mut chars = from_start.char_indices();
-
-    while let Some((i, c)) = chars.next() {
-        match c {
-            '{' => {
-                depth += 1;
-                in_object = true;
-            }
-            '}' => {
-                depth -= 1;
-                if in_object && depth == 0 {
-                    // Found the closing brace, now find the end of the line with type export
-                    let rest = &from_start[i..];
-                    // Look for the next "export const" or end of string
-                    if let Some(next_export) = rest.find("\nexport const ") {
-                        return Some(start_idx + i + next_export + 1);
-                    } else {
-                        // No more exports, return to end
-                        return Some(content.len());
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-    None
-}
-
-fn extract_tinybase_schema(tinybase_output: &str, table_name: &str) -> Option<String> {
-    // Map table names to their TinyBase schema variable names
-    let var_name = match table_name {
-        "sessions" => "sessionTinybaseSchema",
-        "transcripts" => "transcriptTinybaseSchema",
-        "words" => "wordTinybaseSchema",
-        "speaker_hints" => "speaker_hintTinybaseSchema",
-        "humans" => "humanTinybaseSchema",
-        "organizations" => "organizationTinybaseSchema",
-        "calendars" => "calendarTinybaseSchema",
-        "events" => "eventTinybaseSchema",
-        "mapping_session_participant" => "mapping_session_participantTinybaseSchema",
-        "tags" => "tagTinybaseSchema",
-        "mapping_tag_session" => "mapping_tag_sessionTinybaseSchema",
-        "templates" => "templateTinybaseSchema",
-        "chat_groups" => "chat_groupTinybaseSchema",
-        "chat_messages" => "chat_messageTinybaseSchema",
-        "enhanced_notes" => "enhanced_noteTinybaseSchema",
-        "prompts" => "promptTinybaseSchema",
-        "chat_shortcuts" => "chat_shortcutTinybaseSchema",
-        _ => return None,
-    };
-
-    // Find the schema in the output
-    let search_pattern = format!("export const {} = {{", var_name);
-    if let Some(start_idx) = tinybase_output.find(&search_pattern) {
-        let content_start = start_idx + search_pattern.len();
-        if let Some(end_idx) = tinybase_output[content_start..].find("};") {
-            let content = &tinybase_output[content_start..content_start + end_idx];
-            // Reformat the content with proper indentation
-            let formatted = content
-                .lines()
-                .filter(|line| !line.trim().is_empty())
-                .map(|line| format!("    {}", line.trim()))
-                .collect::<Vec<_>>()
-                .join("\n");
-            return Some(formatted + "\n");
-        }
-    }
-    None
-}
diff --git a/crates/store-types/src/lib.rs b/crates/store-types/src/lib.rs
index 25abe17efc..5d9c978004 100644
--- a/crates/store-types/src/lib.rs
+++ b/crates/store-types/src/lib.rs
@@ -1,222 +1,5 @@
-use serde::{Deserialize, Serialize};
-use specta::Type;
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Human {
-    pub user_id: String,
-    pub name: String,
-    pub email: String,
-    pub org_id: String,
-    #[specta(optional)]
-    pub job_title: Option<String>,
-    #[specta(optional)]
-    pub linkedin_username: Option<String>,
-    #[specta(optional)]
-    pub memo: Option<String>,
-    pub pinned: bool,
-    #[specta(optional)]
-    pub pin_order: Option<i32>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Event {
-    pub user_id: String,
-    pub created_at: String,
-    pub tracking_id_event: String,
-    pub calendar_id: String,
-    pub title: String,
-    pub started_at: String,
-    pub ended_at: String,
-    #[specta(optional)]
-    pub location: Option<String>,
-    #[specta(optional)]
-    pub meeting_link: Option<String>,
-    #[specta(optional)]
-    pub description: Option<String>,
-    #[specta(optional)]
-    pub note: Option<String>,
-    #[specta(optional)]
-    pub ignored: Option<bool>,
-    #[specta(optional)]
-    pub recurrence_series_id: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Calendar {
-    pub user_id: String,
-    pub created_at: String,
-    pub tracking_id_calendar: String,
-    pub name: String,
-    pub enabled: bool,
-    pub provider: String,
-    #[specta(optional)]
-    pub source: Option<String>,
-    #[specta(optional)]
-    pub color: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Organization {
-    pub user_id: String,
-    pub name: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Session {
-    pub user_id: String,
-    pub created_at: String,
-    #[specta(optional)]
-    pub folder_id: Option<String>,
-    #[specta(optional)]
-    pub event_id: Option<String>,
-    pub title: String,
-    pub raw_md: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Transcript {
-    pub user_id: String,
-    pub created_at: String,
-    pub session_id: String,
-    pub started_at: i64,
-    #[specta(optional)]
-    pub ended_at: Option<i64>,
-    pub words: String,
-    pub speaker_hints: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct MappingSessionParticipant {
-    pub user_id: String,
-    pub session_id: String,
-    pub human_id: String,
-    #[specta(optional)]
-    pub source: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Tag {
-    pub user_id: String,
-    pub name: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct MappingTagSession {
-    pub user_id: String,
-    pub tag_id: String,
-    pub session_id: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Template {
-    pub user_id: String,
-    pub title: String,
-    pub description: String,
-    #[specta(optional)]
-    pub category: Option<String>,
-    #[specta(optional)]
-    pub targets: Option<Vec<String>>,
-    pub sections: Vec<TemplateSection>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct TemplateSection {
-    pub title: String,
-    pub description: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct ChatGroup {
-    pub user_id: String,
-    pub created_at: String,
-    pub title: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct ChatMessage {
-    pub user_id: String,
-    pub created_at: String,
-    pub chat_group_id: String,
-    pub role: String,
-    pub content: String,
-    pub metadata: String,
-    pub parts: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct ChatShortcut {
-    pub user_id: String,
-    pub title: String,
-    pub content: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct EnhancedNote {
-    pub user_id: String,
-    pub session_id: String,
-    pub content: String,
-    #[specta(optional)]
-    pub template_id: Option<String>,
-    pub position: i32,
-    #[specta(optional)]
-    pub title: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Prompt {
-    pub user_id: String,
-    pub task_type: String,
-    pub content: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct Word {
-    pub user_id: String,
-    pub created_at: String,
-    pub transcript_id: String,
-    pub text: String,
-    pub start_ms: i64,
-    pub end_ms: i64,
-    pub channel: i32,
-    #[specta(optional)]
-    pub speaker: Option<String>,
-    #[specta(optional)]
-    pub metadata: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct SpeakerHint {
-    pub user_id: String,
-    pub created_at: String,
-    pub transcript_id: String,
-    pub word_id: String,
-    pub r#type: String,
-    pub value: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, Type)]
-pub struct General {
-    pub user_id: String,
-    pub autostart: bool,
-    pub telemetry_consent: bool,
-    pub save_recordings: bool,
-    pub notification_event: bool,
-    pub notification_detect: bool,
-    pub respect_dnd: bool,
-    pub quit_intercept: bool,
-    pub ai_language: String,
-    pub spoken_languages: Vec<String>,
-    pub ignored_platforms: Vec<String>,
-    pub ignored_recurring_series: Vec<String>,
-    #[specta(optional)]
-    pub current_llm_provider: Option<String>,
-    #[specta(optional)]
-    pub current_llm_model: Option<String>,
-    #[specta(optional)]
-    pub current_stt_provider: Option<String>,
-    #[specta(optional)]
-    pub current_stt_model: Option<String>,
-}
+mod types;
+pub use types::*;
 
 #[cfg(test)]
 mod tests {
diff --git a/crates/store-types/src/types.rs b/crates/store-types/src/types.rs
new file mode 100644
index 0000000000..785b51082f
--- /dev/null
+++ b/crates/store-types/src/types.rs
@@ -0,0 +1,240 @@
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Human {
+    pub user_id: String,
+    pub name: String,
+    pub email: String,
+    pub org_id: String,
+    #[specta(optional)]
+    pub job_title: Option<String>,
+    #[specta(optional)]
+    pub linkedin_username: Option<String>,
+    #[specta(optional)]
+    pub memo: Option<String>,
+    /// @zod.default(false)
+    pub pinned: bool,
+    #[specta(optional)]
+    pub pin_order: Option<i32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Event {
+    pub user_id: String,
+    pub created_at: String,
+    pub tracking_id_event: String,
+    pub calendar_id: String,
+    pub title: String,
+    pub started_at: String,
+    pub ended_at: String,
+    #[specta(optional)]
+    pub location: Option<String>,
+    #[specta(optional)]
+    pub meeting_link: Option<String>,
+    #[specta(optional)]
+    pub description: Option<String>,
+    #[specta(optional)]
+    pub note: Option<String>,
+    #[specta(optional)]
+    pub ignored: Option<bool>,
+    #[specta(optional)]
+    pub recurrence_series_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Calendar {
+    pub user_id: String,
+    pub created_at: String,
+    pub tracking_id_calendar: String,
+    pub name: String,
+    /// @zod.default(false)
+    pub enabled: bool,
+    /// @zod.schema(calendarProviderSchema)
+    pub provider: String,
+    #[specta(optional)]
+    pub source: Option<String>,
+    #[specta(optional)]
+    pub color: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Organization {
+    pub user_id: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Session {
+    pub user_id: String,
+    pub created_at: String,
+    #[specta(optional)]
+    pub folder_id: Option<String>,
+    #[specta(optional)]
+    pub event_id: Option<String>,
+    pub title: String,
+    pub raw_md: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Transcript {
+    pub user_id: String,
+    pub created_at: String,
+    pub session_id: String,
+    pub started_at: i64,
+    #[specta(optional)]
+    pub ended_at: Option<i64>,
+    /// @zod.default("[]")
+    pub words: String,
+    /// @zod.default("[]")
+    pub speaker_hints: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct MappingSessionParticipant {
+    pub user_id: String,
+    pub session_id: String,
+    pub human_id: String,
+    /// @zod.schema(participantSourceSchema.optional())
+    #[specta(optional)]
+    pub source: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Tag {
+    pub user_id: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct MappingTagSession {
+    pub user_id: String,
+    pub tag_id: String,
+    pub session_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Template {
+    pub user_id: String,
+    pub title: String,
+    pub description: String,
+    #[specta(optional)]
+    pub category: Option<String>,
+    #[specta(optional)]
+    pub targets: Option<Vec<String>>,
+    pub sections: Vec<TemplateSection>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct TemplateSection {
+    pub title: String,
+    pub description: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct ChatGroup {
+    pub user_id: String,
+    pub created_at: String,
+    pub title: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct ChatMessage {
+    pub user_id: String,
+    pub created_at: String,
+    pub chat_group_id: String,
+    pub role: String,
+    pub content: String,
+    /// @zod.json(z.any())
+    pub metadata: String,
+    /// @zod.json(z.any())
+    pub parts: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct ChatShortcut {
+    pub user_id: String,
+    pub title: String,
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct EnhancedNote {
+    pub user_id: String,
+    pub session_id: String,
+    pub content: String,
+    #[specta(optional)]
+    pub template_id: Option<String>,
+    pub position: i32,
+    #[specta(optional)]
+    pub title: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Prompt {
+    pub user_id: String,
+    pub task_type: String,
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct Word {
+    pub user_id: String,
+    pub created_at: String,
+    pub transcript_id: String,
+    pub text: String,
+    pub start_ms: i64,
+    pub end_ms: i64,
+    pub channel: i32,
+    #[specta(optional)]
+    pub speaker: Option<String>,
+    /// @zod.json(z.record(z.string(), z.unknown()))
+    #[specta(optional)]
+    pub metadata: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct SpeakerHint {
+    pub user_id: String,
+    pub created_at: String,
+    pub transcript_id: String,
+    pub word_id: String,
+    pub r#type: String,
+    /// @zod.json(z.record(z.string(), z.unknown()))
+    pub value: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct General {
+    pub user_id: String,
+    /// @zod.default(false)
+    pub autostart: bool,
+    /// @zod.default(true)
+    pub telemetry_consent: bool,
+    /// @zod.default(true)
+    pub save_recordings: bool,
+    /// @zod.default(true)
+    pub notification_event: bool,
+    /// @zod.default(true)
+    pub notification_detect: bool,
+    /// @zod.default(false)
+    pub respect_dnd: bool,
+    /// @zod.default(false)
+    pub quit_intercept: bool,
+    /// @zod.default("en")
+    pub ai_language: String,
+    /// @zod.default(["en"])
+    pub spoken_languages: Vec<String>,
+    /// @zod.default([])
+    pub ignored_platforms: Vec<String>,
+    /// @zod.default([])
+    pub ignored_recurring_series: Vec<String>,
+    #[specta(optional)]
+    pub current_llm_provider: Option<String>,
+    #[specta(optional)]
+    pub current_llm_model: Option<String>,
+    #[specta(optional)]
+    pub current_stt_provider: Option<String>,
+    #[specta(optional)]
+    pub current_stt_model: Option<String>,
+}
diff --git a/packages/store/src/schema.ts b/packages/store/src/schema.ts
index 80ad490290..da050c6f8a 100644
--- a/packages/store/src/schema.ts
+++ b/packages/store/src/schema.ts
@@ -1,420 +1,2 @@
-// This file is auto-generated by `cargo run -p store-types --bin generate-store-types`
-// Do not edit this file manually. Instead, edit the Rust types in crates/store-types/src/lib.rs
-// and run the generator to update this file.
-import type { TablesSchema } from "tinybase/with-schemas";
-import { z } from "zod";
-
-import { InferTinyBaseSchema, jsonObject, type ToStorageType } from "./shared";
-
-export const calendarProviderSchema = z.enum(["apple", "google", "outlook"]);
-export type CalendarProvider = z.infer<typeof calendarProviderSchema>;
-
-export const participantSourceSchema = z.enum(["manual", "auto", "excluded"]);
-export type ParticipantSource = z.infer<typeof participantSourceSchema>;
-
-export const calendarSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  tracking_id_calendar: z.string(),
-  name: z.string(),
-  enabled: z.preprocess((val) => val ?? false, z.boolean()),
-  provider: calendarProviderSchema,
-  source: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  color: z.preprocess((val) => val ?? undefined, z.string().optional()),
-});
-export type Calendar = z.infer<typeof calendarSchema>;
-
-export const chatGroupSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  title: z.string(),
-});
-export type ChatGroup = z.infer<typeof chatGroupSchema>;
-
-export const chatMessageSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  chat_group_id: z.string(),
-  role: z.string(),
-  content: z.string(),
-  metadata: jsonObject(z.any()),
-  parts: jsonObject(z.any()),
-});
-export type ChatMessage = z.infer<typeof chatMessageSchema>;
-
-export const chatShortcutSchema = z.object({
-  user_id: z.string(),
-  title: z.string(),
-  content: z.string(),
-});
-export type ChatShortcut = z.infer<typeof chatShortcutSchema>;
-
-export const enhancedNoteSchema = z.object({
-  user_id: z.string(),
-  session_id: z.string(),
-  content: z.string(),
-  template_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  position: z.number(),
-  title: z.preprocess((val) => val ?? undefined, z.string().optional()),
-});
-export type EnhancedNote = z.infer<typeof enhancedNoteSchema>;
-
-export const eventSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  tracking_id_event: z.string(),
-  calendar_id: z.string(),
-  title: z.string(),
-  started_at: z.string(),
-  ended_at: z.string(),
-  location: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  meeting_link: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  description: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  note: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  ignored: z.preprocess((val) => val ?? undefined, z.boolean().optional()),
-  recurrence_series_id: z.preprocess(
-    (val) => val ?? undefined,
-    z.string().optional(),
-  ),
-});
-export type Event = z.infer<typeof eventSchema>;
-
-export const generalSchema = z.object({
-  user_id: z.string(),
-  autostart: z.boolean().default(false),
-  telemetry_consent: z.boolean().default(true),
-  save_recordings: z.boolean().default(true),
-  notification_event: z.boolean().default(true),
-  notification_detect: z.boolean().default(true),
-  respect_dnd: z.boolean().default(false),
-  quit_intercept: z.boolean().default(false),
-  ai_language: z.string().default("en"),
-  spoken_languages: jsonObject(z.array(z.string()).default(["en"])),
-  ignored_platforms: jsonObject(z.array(z.string()).default([])),
-  ignored_recurring_series: jsonObject(z.array(z.string()).default([])),
-  current_llm_provider: z.string().optional(),
-  current_llm_model: z.string().optional(),
-  current_stt_provider: z.string().optional(),
-  current_stt_model: z.string().optional(),
-});
-export type General = z.infer<typeof generalSchema>;
-
-export const humanSchema = z.object({
-  user_id: z.string(),
-  name: z.string(),
-  email: z.string(),
-  org_id: z.string(),
-  job_title: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  linkedin_username: z.preprocess(
-    (val) => val ?? undefined,
-    z.string().optional(),
-  ),
-  memo: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  pinned: z.preprocess((val) => val ?? false, z.boolean()),
-  pin_order: z.preprocess((val) => val ?? undefined, z.number().optional()),
-});
-export type Human = z.infer<typeof humanSchema>;
-
-export const mappingSessionParticipantSchema = z.object({
-  user_id: z.string(),
-  session_id: z.string(),
-  human_id: z.string(),
-  source: z.preprocess(
-    (val) => val ?? undefined,
-    participantSourceSchema.optional(),
-  ),
-});
-export type MappingSessionParticipant = z.infer<
-  typeof mappingSessionParticipantSchema
->;
-
-export const mappingTagSessionSchema = z.object({
-  user_id: z.string(),
-  tag_id: z.string(),
-  session_id: z.string(),
-});
-export type MappingTagSession = z.infer<typeof mappingTagSessionSchema>;
-
-export const organizationSchema = z.object({
-  user_id: z.string(),
-  name: z.string(),
-});
-export type Organization = z.infer<typeof organizationSchema>;
-
-export const promptSchema = z.object({
-  user_id: z.string(),
-  task_type: z.string(),
-  content: z.string(),
-});
-export type Prompt = z.infer<typeof promptSchema>;
-
-export const sessionSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  folder_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  event_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  title: z.string(),
-  raw_md: z.string(),
-});
-export type Session = z.infer<typeof sessionSchema>;
-
-export const speakerHintSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  transcript_id: z.string(),
-  word_id: z.string(),
-  type: z.string(),
-  value: jsonObject(z.record(z.string(), z.unknown())),
-});
-export type SpeakerHint = z.infer<typeof speakerHintSchema>;
-
-export const tagSchema = z.object({
-  user_id: z.string(),
-  name: z.string(),
-});
-export type Tag = z.infer<typeof tagSchema>;
-
-export const templateSectionSchema = z.object({
-  title: z.string(),
-  description: z.string(),
-});
-export type TemplateSection = z.infer<typeof templateSectionSchema>;
-
-export const templateSchema = z.object({
-  user_id: z.string(),
-  title: z.string(),
-  description: z.string(),
-  category: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  targets: z.preprocess(
-    (val) => val ?? undefined,
-    jsonObject(z.array(z.string())).optional(),
-  ),
-  sections: jsonObject(z.array(templateSectionSchema)),
-});
-export type Template = z.infer<typeof templateSchema>;
-
-export const transcriptSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  session_id: z.string(),
-  started_at: z.number(),
-  ended_at: z.preprocess((val) => val ?? undefined, z.number().optional()),
-  words: z.preprocess((val) => val ?? "[]", z.string()),
-  speaker_hints: z.preprocess((val) => val ?? "[]", z.string()),
-});
-export type Transcript = z.infer<typeof transcriptSchema>;
-
-export const wordSchema = z.object({
-  user_id: z.string(),
-  created_at: z.string(),
-  transcript_id: z.string(),
-  text: z.string(),
-  start_ms: z.number(),
-  end_ms: z.number(),
-  channel: z.number(),
-  speaker: z.preprocess((val) => val ?? undefined, z.string().optional()),
-  metadata: z.preprocess(
-    (val) => val ?? undefined,
-    jsonObject(z.record(z.string(), z.unknown())).optional(),
-  ),
-});
-export type Word = z.infer<typeof wordSchema>;
-
-export const providerSpeakerIndexSchema = z.object({
-  speaker_index: z.number(),
-  provider: z.string().optional(),
-  channel: z.number().optional(),
-});
-
-export const aiProviderSchema = z
-  .object({
-    type: z.enum(["stt", "llm"]),
-    base_url: z.url().min(1),
-    api_key: z.string(),
-  })
-  .refine(
-    (data) => !data.base_url.startsWith("https:") || data.api_key.length > 0,
-    {
-      message: "API key is required for HTTPS URLs",
-      path: ["api_key"],
-    },
-  );
-
-export type ProviderSpeakerIndexHint = z.infer<
-  typeof providerSpeakerIndexSchema
->;
-export type AIProvider = z.infer<typeof aiProviderSchema>;
-
-export type CalendarStorage = ToStorageType<typeof calendarSchema>;
-export type SessionStorage = ToStorageType<typeof sessionSchema>;
-export type TranscriptStorage = ToStorageType<typeof transcriptSchema>;
-export type WordStorage = ToStorageType<typeof wordSchema>;
-export type SpeakerHintStorage = ToStorageType<typeof speakerHintSchema>;
-export type TemplateStorage = ToStorageType<typeof templateSchema>;
-export type ChatMessageStorage = ToStorageType<typeof chatMessageSchema>;
-export type EnhancedNoteStorage = ToStorageType<typeof enhancedNoteSchema>;
-export type HumanStorage = ToStorageType<typeof humanSchema>;
-export type OrganizationStorage = ToStorageType<typeof organizationSchema>;
-export type PromptStorage = ToStorageType<typeof promptSchema>;
-export type ChatShortcutStorage = ToStorageType<typeof chatShortcutSchema>;
-export type EventStorage = ToStorageType<typeof eventSchema>;
-export type MappingSessionParticipantStorage = ToStorageType<
-  typeof mappingSessionParticipantSchema
->;
-export type AIProviderStorage = ToStorageType<typeof aiProviderSchema>;
-export type GeneralStorage = ToStorageType<typeof generalSchema>;
-
-export const tableSchemaForTinybase = {
-  sessions: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    folder_id: { type: "string" },
-    event_id: { type: "string" },
-    title: { type: "string" },
-    raw_md: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof sessionSchema>,
-  transcripts: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    session_id: { type: "string" },
-    started_at: { type: "number" },
-    ended_at: { type: "number" },
-    words: { type: "string" },
-    speaker_hints: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof transcriptSchema>,
-  words: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    transcript_id: { type: "string" },
-    text: { type: "string" },
-    start_ms: { type: "number" },
-    end_ms: { type: "number" },
-    channel: { type: "number" },
-    speaker: { type: "string" },
-    metadata: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof wordSchema>,
-  speaker_hints: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    transcript_id: { type: "string" },
-    word_id: { type: "string" },
-    type: { type: "string" },
-    value: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof speakerHintSchema>,
-  humans: {
-    user_id: { type: "string" },
-    name: { type: "string" },
-    email: { type: "string" },
-    org_id: { type: "string" },
-    job_title: { type: "string" },
-    linkedin_username: { type: "string" },
-    memo: { type: "string" },
-    pinned: { type: "boolean" },
-    pin_order: { type: "number" },
-  } as const satisfies InferTinyBaseSchema<typeof humanSchema>,
-  organizations: {
-    user_id: { type: "string" },
-    name: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof organizationSchema>,
-  calendars: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    tracking_id_calendar: { type: "string" },
-    name: { type: "string" },
-    enabled: { type: "boolean" },
-    provider: { type: "string" },
-    source: { type: "string" },
-    color: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof calendarSchema>,
-  events: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    tracking_id_event: { type: "string" },
-    calendar_id: { type: "string" },
-    title: { type: "string" },
-    started_at: { type: "string" },
-    ended_at: { type: "string" },
-    location: { type: "string" },
-    meeting_link: { type: "string" },
-    description: { type: "string" },
-    note: { type: "string" },
-    ignored: { type: "boolean" },
-    recurrence_series_id: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof eventSchema>,
-  mapping_session_participant: {
-    user_id: { type: "string" },
-    session_id: { type: "string" },
-    human_id: { type: "string" },
-    source: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<
-    typeof mappingSessionParticipantSchema
-  >,
-  tags: {
-    user_id: { type: "string" },
-    name: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof tagSchema>,
-  mapping_tag_session: {
-    user_id: { type: "string" },
-    tag_id: { type: "string" },
-    session_id: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof mappingTagSessionSchema>,
-  templates: {
-    user_id: { type: "string" },
-    title: { type: "string" },
-    description: { type: "string" },
-    category: { type: "string" },
-    targets: { type: "string" },
-    sections: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof templateSchema>,
-  chat_groups: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    title: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof chatGroupSchema>,
-  chat_messages: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    chat_group_id: { type: "string" },
-    role: { type: "string" },
-    content: { type: "string" },
-    metadata: { type: "string" },
-    parts: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof chatMessageSchema>,
-  enhanced_notes: {
-    user_id: { type: "string" },
-    session_id: { type: "string" },
-    content: { type: "string" },
-    template_id: { type: "string" },
-    position: { type: "number" },
-    title: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof enhancedNoteSchema>,
-  prompts: {
-    user_id: { type: "string" },
-    task_type: { type: "string" },
-    content: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof promptSchema>,
-  chat_shortcuts: {
-    user_id: { type: "string" },
-    title: { type: "string" },
-    content: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof chatShortcutSchema>,
-} as const satisfies TablesSchema;
-
-export const valueSchemaForTinybase = {
-  user_id: { type: "string" },
-  autostart: { type: "boolean" },
-  save_recordings: { type: "boolean" },
-  notification_event: { type: "boolean" },
-  notification_detect: { type: "boolean" },
-  respect_dnd: { type: "boolean" },
-  quit_intercept: { type: "boolean" },
-  telemetry_consent: { type: "boolean" },
-  ai_language: { type: "string" },
-  spoken_languages: { type: "string" },
-  ignored_platforms: { type: "string" },
-  ignored_recurring_series: { type: "string" },
-  current_llm_provider: { type: "string" },
-  current_llm_model: { type: "string" },
-  current_stt_provider: { type: "string" },
-  current_stt_model: { type: "string" },
-} as const satisfies InferTinyBaseSchema<typeof generalSchema>;
+export * from "./zod";
+export * from "./tinybase";
diff --git a/packages/store/src/tinybase.ts b/packages/store/src/tinybase.ts
new file mode 100644
index 0000000000..dcc6e2cd0a
--- /dev/null
+++ b/packages/store/src/tinybase.ts
@@ -0,0 +1,198 @@
+import type { TablesSchema } from "tinybase/with-schemas";
+
+import { InferTinyBaseSchema, type ToStorageType } from "./shared";
+import {
+  aiProviderSchema,
+  calendarSchema,
+  chatGroupSchema,
+  chatMessageSchema,
+  chatShortcutSchema,
+  enhancedNoteSchema,
+  eventSchema,
+  generalSchema,
+  humanSchema,
+  mappingSessionParticipantSchema,
+  mappingTagSessionSchema,
+  organizationSchema,
+  promptSchema,
+  sessionSchema,
+  speakerHintSchema,
+  tagSchema,
+  templateSchema,
+  transcriptSchema,
+  wordSchema,
+} from "./zod";
+
+export type CalendarStorage = ToStorageType<typeof calendarSchema>;
+export type SessionStorage = ToStorageType<typeof sessionSchema>;
+export type TranscriptStorage = ToStorageType<typeof transcriptSchema>;
+export type WordStorage = ToStorageType<typeof wordSchema>;
+export type SpeakerHintStorage = ToStorageType<typeof speakerHintSchema>;
+export type TemplateStorage = ToStorageType<typeof templateSchema>;
+export type ChatMessageStorage = ToStorageType<typeof chatMessageSchema>;
+export type EnhancedNoteStorage = ToStorageType<typeof enhancedNoteSchema>;
+export type HumanStorage = ToStorageType<typeof humanSchema>;
+export type OrganizationStorage = ToStorageType<typeof organizationSchema>;
+export type PromptStorage = ToStorageType<typeof promptSchema>;
+export type ChatShortcutStorage = ToStorageType<typeof chatShortcutSchema>;
+export type EventStorage = ToStorageType<typeof eventSchema>;
+export type MappingSessionParticipantStorage = ToStorageType<
+  typeof mappingSessionParticipantSchema
+>;
+export type AIProviderStorage = ToStorageType<typeof aiProviderSchema>;
+export type GeneralStorage = ToStorageType<typeof generalSchema>;
+
+export const tableSchemaForTinybase = {
+  sessions: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    folder_id: { type: "string" },
+    event_id: { type: "string" },
+    title: { type: "string" },
+    raw_md: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof sessionSchema>,
+  transcripts: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    session_id: { type: "string" },
+    started_at: { type: "number" },
+    ended_at: { type: "number" },
+    words: { type: "string" },
+    speaker_hints: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof transcriptSchema>,
+  words: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    transcript_id: { type: "string" },
+    text: { type: "string" },
+    start_ms: { type: "number" },
+    end_ms: { type: "number" },
+    channel: { type: "number" },
+    speaker: { type: "string" },
+    metadata: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof wordSchema>,
+  speaker_hints: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    transcript_id: { type: "string" },
+    word_id: { type: "string" },
+    type: { type: "string" },
+    value: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof speakerHintSchema>,
+  humans: {
+    user_id: { type: "string" },
+    name: { type: "string" },
+    email: { type: "string" },
+    org_id: { type: "string" },
+    job_title: { type: "string" },
+    linkedin_username: { type: "string" },
+    memo: { type: "string" },
+    pinned: { type: "boolean" },
+    pin_order: { type: "number" },
+  } as const satisfies InferTinyBaseSchema<typeof humanSchema>,
+  organizations: {
+    user_id: { type: "string" },
+    name: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof organizationSchema>,
+  calendars: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    tracking_id_calendar: { type: "string" },
+    name: { type: "string" },
+    enabled: { type: "boolean" },
+    provider: { type: "string" },
+    source: { type: "string" },
+    color: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof calendarSchema>,
+  events: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    tracking_id_event: { type: "string" },
+    calendar_id: { type: "string" },
+    title: { type: "string" },
+    started_at: { type: "string" },
+    ended_at: { type: "string" },
+    location: { type: "string" },
+    meeting_link: { type: "string" },
+    description: { type: "string" },
+    note: { type: "string" },
+    ignored: { type: "boolean" },
+    recurrence_series_id: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof eventSchema>,
+  mapping_session_participant: {
+    user_id: { type: "string" },
+    session_id: { type: "string" },
+    human_id: { type: "string" },
+    source: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<
+    typeof mappingSessionParticipantSchema
+  >,
+  tags: {
+    user_id: { type: "string" },
+    name: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof tagSchema>,
+  mapping_tag_session: {
+    user_id: { type: "string" },
+    tag_id: { type: "string" },
+    session_id: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof mappingTagSessionSchema>,
+  templates: {
+    user_id: { type: "string" },
+    title: { type: "string" },
+    description: { type: "string" },
+    category: { type: "string" },
+    targets: { type: "string" },
+    sections: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof templateSchema>,
+  chat_groups: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    title: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof chatGroupSchema>,
+  chat_messages: {
+    user_id: { type: "string" },
+    created_at: { type: "string" },
+    chat_group_id: { type: "string" },
+    role: { type: "string" },
+    content: { type: "string" },
+    metadata: { type: "string" },
+    parts: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof chatMessageSchema>,
+  enhanced_notes: {
+    user_id: { type: "string" },
+    session_id: { type: "string" },
+    content: { type: "string" },
+    template_id: { type: "string" },
+    position: { type: "number" },
+    title: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof enhancedNoteSchema>,
+  prompts: {
+    user_id: { type: "string" },
+    task_type: { type: "string" },
+    content: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof promptSchema>,
+  chat_shortcuts: {
+    user_id: { type: "string" },
+    title: { type: "string" },
+    content: { type: "string" },
+  } as const satisfies InferTinyBaseSchema<typeof chatShortcutSchema>,
+} as const satisfies TablesSchema;
+
+export const valueSchemaForTinybase = {
+  user_id: { type: "string" },
+  autostart: { type: "boolean" },
+  save_recordings: { type: "boolean" },
+  notification_event: { type: "boolean" },
+  notification_detect: { type: "boolean" },
+  respect_dnd: { type: "boolean" },
+  quit_intercept: { type: "boolean" },
+  telemetry_consent: { type: "boolean" },
+  ai_language: { type: "string" },
+  spoken_languages: { type: "string" },
+  ignored_platforms: { type: "string" },
+  ignored_recurring_series: { type: "string" },
+  current_llm_provider: { type: "string" },
+  current_llm_model: { type: "string" },
+  current_stt_provider: { type: "string" },
+  current_stt_model: { type: "string" },
+} as const satisfies InferTinyBaseSchema<typeof generalSchema>;
diff --git a/packages/store/src/zod.ts b/packages/store/src/zod.ts
new file mode 100644
index 0000000000..0d27ace4b3
--- /dev/null
+++ b/packages/store/src/zod.ts
@@ -0,0 +1,253 @@
+// This file is auto-generated by building store-types crate.
+// Do not edit this file manually. Instead, edit the Rust types in
+// crates/store-types/src/types.rs and run `cargo build -p store-types`.
+import { z } from "zod";
+
+import { jsonObject } from "./shared";
+
+export const calendarProviderSchema = z.enum(["apple", "google", "outlook"]);
+export type CalendarProvider = z.infer<typeof calendarProviderSchema>;
+
+export const participantSourceSchema = z.enum(["manual", "auto", "excluded"]);
+export type ParticipantSource = z.infer<typeof participantSourceSchema>;
+
+export const calendarSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  tracking_id_calendar: z.string(),
+  name: z.string(),
+  enabled: z.boolean().default(false),
+  provider: calendarProviderSchema,
+  source: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  color: z.preprocess((val) => val ?? undefined, z.string().optional()),
+});
+export type Calendar = z.infer<typeof calendarSchema>;
+
+export const chatGroupSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  title: z.string(),
+});
+export type ChatGroup = z.infer<typeof chatGroupSchema>;
+
+export const chatMessageSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  chat_group_id: z.string(),
+  role: z.string(),
+  content: z.string(),
+  metadata: jsonObject(z.any()),
+  parts: jsonObject(z.any()),
+});
+export type ChatMessage = z.infer<typeof chatMessageSchema>;
+
+export const chatShortcutSchema = z.object({
+  user_id: z.string(),
+  title: z.string(),
+  content: z.string(),
+});
+export type ChatShortcut = z.infer<typeof chatShortcutSchema>;
+
+export const enhancedNoteSchema = z.object({
+  user_id: z.string(),
+  session_id: z.string(),
+  content: z.string(),
+  template_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  position: z.number(),
+  title: z.preprocess((val) => val ?? undefined, z.string().optional()),
+});
+export type EnhancedNote = z.infer<typeof enhancedNoteSchema>;
+
+export const eventSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  tracking_id_event: z.string(),
+  calendar_id: z.string(),
+  title: z.string(),
+  started_at: z.string(),
+  ended_at: z.string(),
+  location: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  meeting_link: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  description: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  note: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  ignored: z.preprocess((val) => val ?? undefined, z.boolean().optional()),
+  recurrence_series_id: z.preprocess(
+    (val) => val ?? undefined,
+    z.string().optional(),
+  ),
+});
+export type Event = z.infer<typeof eventSchema>;
+
+export const generalSchema = z.object({
+  user_id: z.string(),
+  autostart: z.boolean().default(false),
+  telemetry_consent: z.boolean().default(true),
+  save_recordings: z.boolean().default(true),
+  notification_event: z.boolean().default(true),
+  notification_detect: z.boolean().default(true),
+  respect_dnd: z.boolean().default(false),
+  quit_intercept: z.boolean().default(false),
+  ai_language: z.string().default("en"),
+  spoken_languages: jsonObject(z.array(z.string())).default(["en"]),
+  ignored_platforms: jsonObject(z.array(z.string())).default([]),
+  ignored_recurring_series: jsonObject(z.array(z.string())).default([]),
+  current_llm_provider: z.preprocess(
+    (val) => val ?? undefined,
+    z.string().optional(),
+  ),
+  current_llm_model: z.preprocess(
+    (val) => val ?? undefined,
+    z.string().optional(),
+  ),
+  current_stt_provider: z.preprocess(
+    (val) => val ?? undefined,
+    z.string().optional(),
+  ),
+  current_stt_model: z.preprocess(
+    (val) => val ?? undefined,
+    z.string().optional(),
+  ),
+});
+export type General = z.infer<typeof generalSchema>;
+
+export const humanSchema = z.object({
+  user_id: z.string(),
+  name: z.string(),
+  email: z.string(),
+  org_id: z.string(),
+  job_title: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  linkedin_username: z.preprocess(
+    (val) => val ?? undefined,
+    z.string().optional(),
+  ),
+  memo: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  pinned: z.boolean().default(false),
+  pin_order: z.preprocess((val) => val ?? undefined, z.number().optional()),
+});
+export type Human = z.infer<typeof humanSchema>;
+
+export const mappingSessionParticipantSchema = z.object({
+  user_id: z.string(),
+  session_id: z.string(),
+  human_id: z.string(),
+  source: participantSourceSchema.optional(),
+});
+export type MappingSessionParticipant = z.infer<
+  typeof mappingSessionParticipantSchema
+>;
+
+export const mappingTagSessionSchema = z.object({
+  user_id: z.string(),
+  tag_id: z.string(),
+  session_id: z.string(),
+});
+export type MappingTagSession = z.infer<typeof mappingTagSessionSchema>;
+
+export const organizationSchema = z.object({
+  user_id: z.string(),
+  name: z.string(),
+});
+export type Organization = z.infer<typeof organizationSchema>;
+
+export const promptSchema = z.object({
+  user_id: z.string(),
+  task_type: z.string(),
+  content: z.string(),
+});
+export type Prompt = z.infer<typeof promptSchema>;
+
+export const sessionSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  folder_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  event_id: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  title: z.string(),
+  raw_md: z.string(),
+});
+export type Session = z.infer<typeof sessionSchema>;
+
+export const speakerHintSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  transcript_id: z.string(),
+  word_id: z.string(),
+  type: z.string(),
+  value: jsonObject(z.record(z.string(), z.unknown())),
+});
+export type SpeakerHint = z.infer<typeof speakerHintSchema>;
+
+export const tagSchema = z.object({
+  user_id: z.string(),
+  name: z.string(),
+});
+export type Tag = z.infer<typeof tagSchema>;
+
+export const templateSectionSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+});
+export type TemplateSection = z.infer<typeof templateSectionSchema>;
+
+export const templateSchema = z.object({
+  user_id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  category: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  targets: z.preprocess(
+    (val) => val ?? undefined,
+    jsonObject(z.array(z.string())).optional(),
+  ),
+  sections: jsonObject(z.array(templateSectionSchema)),
+});
+export type Template = z.infer<typeof templateSchema>;
+
+export const transcriptSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  session_id: z.string(),
+  started_at: z.number(),
+  ended_at: z.preprocess((val) => val ?? undefined, z.number().optional()),
+  words: z.string().default("[]"),
+  speaker_hints: z.string().default("[]"),
+});
+export type Transcript = z.infer<typeof transcriptSchema>;
+
+export const wordSchema = z.object({
+  user_id: z.string(),
+  created_at: z.string(),
+  transcript_id: z.string(),
+  text: z.string(),
+  start_ms: z.number(),
+  end_ms: z.number(),
+  channel: z.number(),
+  speaker: z.preprocess((val) => val ?? undefined, z.string().optional()),
+  metadata: z.preprocess(
+    (val) => val ?? undefined,
+    jsonObject(z.record(z.string(), z.unknown())).optional(),
+  ),
+});
+export type Word = z.infer<typeof wordSchema>;
+
+export const providerSpeakerIndexSchema = z.object({
+  speaker_index: z.number(),
+  provider: z.string().optional(),
+  channel: z.number().optional(),
+});
+export type ProviderSpeakerIndexHint = z.infer<
+  typeof providerSpeakerIndexSchema
+>;
+
+export const aiProviderSchema = z
+  .object({
+    type: z.enum(["stt", "llm"]),
+    base_url: z.url().min(1),
+    api_key: z.string(),
+  })
+  .refine(
+    (data) => !data.base_url.startsWith("https:") || data.api_key.length > 0,
+    {
+      message: "API key is required for HTTPS URLs",
+      path: ["api_key"],
+    },
+  );
+export type AIProvider = z.infer<typeof aiProviderSchema>;