use fourcc as object tags (bad idea); store type info within objects

13 files changed, 346 insertions, 354 deletions

diff --git a/common/object/src/buffer.rs b/common/object/src/buffer.rs
index 05557e4..829cade 100644
--- a/common/object/src/buffer.rs
+++ b/common/object/src/buffer.rs
@@ -30,8 +30,9 @@ impl ObjectBuffer {
         let mut temp = Vec::new();
         for (tag, val) in fields {
             tags.push(tag.0);
-            let off = (values.len() as u32) << 2;
-            if val.is_aligned() {
+            let ty = val.get_type();
+            let off = (values.len() as u32) << 5 | (ty as u32) << 2;
+            if ty.is_aligned() {
                 offsets.push(off);
                 val.store_aligned(&mut values);
             } else {
diff --git a/common/object/src/debug.rs b/common/object/src/debug.rs
new file mode 100644
index 0000000..15812b1
--- /dev/null
+++ b/common/object/src/debug.rs
@@ -0,0 +1,59 @@
+/*
+    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
+    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
+    Copyright (C) 2026 metamuffin <metamuffin.org>
+*/
+
+use crate::{Object, ObjectBuffer, Tag, TypedTag, ValueType};
+use std::{any::type_name, fmt::Debug};
+
+impl Debug for ObjectBuffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.as_object().fmt(f)
+    }
+}
+
+impl Debug for Object<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut s = f.debug_struct("Object");
+        let mut nonexhaustive = false;
+        for (i, tag) in self.keys().enumerate() {
+            let kbytes = tag.0.to_be_bytes();
+            let k = str::from_utf8(&kbytes).unwrap();
+            let ty = self.offset_type(i);
+            let sz = self.size(i);
+            match (ty, sz) {
+                (ValueType::String, _) => s.field(k, &self.get_typed::<&str>(i).unwrap()),
+                (ValueType::Binary, _) => s.field(k, &self.get_typed::<&[u8]>(i).unwrap()),
+                (ValueType::Object, _) => s.field(k, &self.get_typed::<Object>(i).unwrap()),
+                (ValueType::UInt, 4) => s.field(k, &self.get_typed::<u32>(i).unwrap()),
+                (ValueType::UInt, 8) => s.field(k, &self.get_typed::<u64>(i).unwrap()),
+                (ValueType::Int, 8) => s.field(k, &self.get_typed::<i64>(i).unwrap()),
+                _ => {
+                    nonexhaustive = true;
+                    &mut s
+                }
+            };
+        }
+        if nonexhaustive {
+            s.finish_non_exhaustive()
+        } else {
+            s.finish()
+        }
+    }
+}
+
+impl<T> Debug for TypedTag<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple(&format!("TypedTag<{}>", type_name::<T>()))
+            .field(&self.0)
+            .finish()
+    }
+}
+impl Debug for Tag {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let bytes = self.0.to_be_bytes();
+        let name = str::from_utf8(&bytes).unwrap();
+        f.debug_tuple("Tag").field(&name).finish()
+    }
+}
diff --git a/common/object/src/inspect.rs b/common/object/src/inspect.rs
deleted file mode 100644
index cfab5c3..0000000
--- a/common/object/src/inspect.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
-    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
-    Copyright (C) 2026 metamuffin <metamuffin.org>
-*/
-
-use crate::{Object, Registry, Tag, TypedTag, types::*};
-use std::{any::type_name, fmt::Debug};
-
-pub struct Inspector<'a, T>(pub &'a Registry, pub T);
-
-impl Debug for Inspector<'_, Object<'_>> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut s = f.debug_struct("Object");
-        let mut nonexhaustive = false;
-        for (i, k) in self.1.keys().enumerate() {
-            let Some(info) = self.0.info(k) else {
-                nonexhaustive = true;
-                continue;
-            };
-            let Some(ty) = info.r#type else {
-                nonexhaustive = true;
-                continue;
-            };
-            match ty {
-                x if x == STR => s.field(info.name, &self.1.get_typed::<&str>(i).unwrap()),
-                x if x == BINARY => s.field(info.name, &self.1.get_typed::<&[u8]>(i).unwrap()),
-                x if x == OBJECT => s.field(info.name, &self.1.get_typed::<Object>(i).unwrap()),
-                x if x == U32 => s.field(info.name, &self.1.get_typed::<u32>(i).unwrap()),
-                x if x == U64 => s.field(info.name, &self.1.get_typed::<u64>(i).unwrap()),
-                x if x == I64 => s.field(info.name, &self.1.get_typed::<i64>(i).unwrap()),
-                _ => {
-                    nonexhaustive = true;
-                    &mut s
-                }
-            };
-        }
-        if nonexhaustive {
-            s.finish_non_exhaustive()
-        } else {
-            s.finish()
-        }
-    }
-}
-
-impl<T> Debug for Inspector<'_, TypedTag<T>> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let name = self.0.info(self.1.0).map(|t| t.name).unwrap_or("unknown");
-        f.debug_tuple(&format!("TypedTag<{}>", type_name::<T>()))
-            .field(&name)
-            .finish()
-    }
-}
-impl Debug for Inspector<'_, Tag> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let name = self.0.info(self.1).map(|t| t.name).unwrap_or("unknown");
-        f.debug_tuple("Tag").field(&name).finish()
-    }
-}
diff --git a/common/object/src/json.rs b/common/object/src/json.rs
index 0aa4cbd..cbb8bda 100644
--- a/common/object/src/json.rs
+++ b/common/object/src/json.rs
@@ -4,36 +4,30 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use crate::{Object, Registry, types::*};
+use crate::{Object, ValueType};
 use serde_json::{Map, Value};
 
-pub fn object_to_json(reg: &Registry, ob: Object<'_>) -> Value {
+pub fn object_to_json(ob: Object<'_>) -> Value {
     let mut o = Map::new();
     let mut nonexhaustive = false;
     for (i, tag) in ob.keys().enumerate() {
-        let Some(info) = reg.info(tag) else {
-            nonexhaustive = true;
-            continue;
-        };
-        let Some(ty) = info.r#type else {
-            nonexhaustive = true;
-            continue;
-        };
-        let key = info.name.to_string();
-
-        let val = match ty {
-            x if x == STR => ob.get_typed::<&str>(i).unwrap().to_string().into(),
-            x if x == OBJECT => object_to_json(reg, ob.get_typed::<Object>(i).unwrap()),
-            x if x == U32 => ob.get_typed::<u32>(i).unwrap().into(),
-            x if x == U64 => ob.get_typed::<u64>(i).unwrap().into(),
-            x if x == I64 => ob.get_typed::<i64>(i).unwrap().into(),
-            x if x == F64 => ob.get_typed::<f64>(i).unwrap().into(),
+        let kbytes = tag.0.to_be_bytes();
+        let k = str::from_utf8(&kbytes).unwrap().to_string();
+        let ty = ob.offset_type(i);
+        let sz = ob.size(i);
+        let val = match (ty, sz) {
+            (ValueType::String, _) => ob.get_typed::<&str>(i).unwrap().to_string().into(),
+            (ValueType::Object, _) => object_to_json(ob.get_typed::<Object>(i).unwrap()),
+            (ValueType::UInt, 4) => ob.get_typed::<u32>(i).unwrap().into(),
+            (ValueType::UInt, 8) => ob.get_typed::<u64>(i).unwrap().into(),
+            (ValueType::Int, 8) => ob.get_typed::<i64>(i).unwrap().into(),
+            (ValueType::Float, 8) => ob.get_typed::<f64>(i).unwrap().into(),
             _ => {
                 nonexhaustive = true;
                 continue;
             }
         };
-        multi_insert(&mut o, key, val);
+        multi_insert(&mut o, k, val);
     }
     if nonexhaustive {
         o.insert("_nonexhaustive".to_owned(), Value::Bool(true));
diff --git a/common/object/src/lib.rs b/common/object/src/lib.rs
index 771dd94..bd00639 100644
--- a/common/object/src/lib.rs
+++ b/common/object/src/lib.rs
@@ -6,7 +6,7 @@
 #![feature(iter_array_chunks)]
 
 mod buffer;
-pub mod inspect;
+pub mod debug;
 #[cfg(feature = "json")]
 pub mod json;
 mod path;
@@ -20,14 +20,30 @@ pub use path::*;
 pub use registry::*;
 pub use value::*;
 
-use std::{collections::BTreeSet, hash::Hash, marker::PhantomData};
+use std::{collections::BTreeSet, fmt::Display, hash::Hash, marker::PhantomData};
 
 #[repr(transparent)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Tag(pub u32);
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+impl Tag {
+    pub const fn new(fourcc: &[u8; 4]) -> Self {
+        Self(u32::from_be_bytes(*fourcc))
+    }
+}
+impl Display for Tag {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(str::from_utf8(&self.0.to_be_bytes()).unwrap())
+    }
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
 pub struct TypedTag<T>(pub Tag, pub PhantomData<T>);
+impl<T> Display for TypedTag<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
 
 impl<T> Clone for TypedTag<T> {
     fn clone(&self) -> Self {
@@ -36,7 +52,7 @@ impl<T> Clone for TypedTag<T> {
 }
 impl<T> Copy for TypedTag<T> {}
 
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+#[derive(Clone, Copy, Hash, PartialEq, Eq)]
 pub struct Object<'a> {
     tags: &'a [u32],
     offsets: &'a [u32],
@@ -89,33 +105,50 @@ impl<'a> Object<'a> {
     fn offset(&self, i: usize) -> usize {
         self.offsets
             .get(i)
-            .map(|&v| v >> 2)
+            .map(|&v| v >> 5)
             .unwrap_or(self.values.len() as u32) as usize
     }
+    fn offset_type(&self, i: usize) -> ValueType {
+        let raw = (self.offsets[i] >> 2) & 0b111;
+        ValueType::from_num(raw)
+    }
+    fn size(&self, i: usize) -> u32 {
+        let start_raw = self.offsets[i];
+        let end_raw = self
+            .offsets
+            .get(i + 1)
+            .copied()
+            .unwrap_or((self.values.len() as u32) << 5);
+
+        let u32_len = (end_raw >> 5) - (start_raw >> 5);
+        let padding = start_raw & 0b11;
+        u32_len * 4 - padding
+    }
     fn get_aligned(&self, index: usize) -> Option<&'a [u32]> {
         let start_raw = self.offsets[index];
         let end_raw = self
             .offsets
             .get(index + 1)
             .copied()
-            .unwrap_or((self.values.len() as u32) << 2);
+            .unwrap_or((self.values.len() as u32) << 5);
 
-        let start = start_raw >> 2;
-        let end = end_raw >> 2;
+        let start = start_raw >> 5;
+        let end = end_raw >> 5;
 
         Some(&self.values[start as usize..end as usize])
     }
+
     fn get_unaligned(&self, index: usize) -> Option<&'a [u8]> {
         let start_raw = self.offsets[index];
         let end_raw = self
             .offsets
             .get(index + 1)
             .copied()
-            .unwrap_or((self.values.len() as u32) << 2);
+            .unwrap_or((self.values.len() as u32) << 5);
 
-        let start = (start_raw >> 2) * 4;
+        let start = (start_raw >> 5) * 4;
         let padding = start_raw & 0b11;
-        let end = (end_raw >> 2) * 4 - padding;
+        let end = (end_raw >> 5) * 4 - padding;
 
         let values_u8: &[u8] = bytemuck::cast_slice(self.values);
         Some(&values_u8[start as usize..end as usize])
@@ -228,8 +261,9 @@ impl<'a> Object<'a> {
         let mut temp = Vec::new();
         let values_new = buf.len();
         for (i, val) in values.iter().enumerate() {
-            let off = (buf.len() as u32 - values_start) << 2;
-            if val.is_aligned() {
+            let ty = val.get_type();
+            let off = (buf.len() as u32 - values_start) << 5 | (ty as u32) << 2;
+            if ty.is_aligned() {
                 buf[new_offs + i] = off;
                 val.store_aligned(&mut buf);
             } else {
@@ -242,7 +276,7 @@ impl<'a> Object<'a> {
         }
         let values_insert_size = buf.len() - values_new;
         let values_cut_size = values_suffix - values_prefix;
-        let suffix_offset = (values_insert_size as i32 - values_cut_size as i32) * 4;
+        let suffix_offset = (values_insert_size as i32 - values_cut_size as i32) << 5;
         if suffix_offset != 0 {
             buf[suffix_offs..suffix_end]
                 .iter_mut()
diff --git a/common/object/src/registry.rs b/common/object/src/registry.rs
index 5f1f36e..af028e8 100644
--- a/common/object/src/registry.rs
+++ b/common/object/src/registry.rs
@@ -4,8 +4,7 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use crate::Tag;
-use std::{any::TypeId, collections::BTreeMap};
+use std::any::TypeId;
 
 pub mod types {
     use crate::Object;
@@ -20,31 +19,6 @@ pub mod types {
     pub const F64: TypeId = TypeId::of::<f64>();
 }
 
-#[derive(Default, Clone)]
-pub struct Registry {
-    tags: BTreeMap<Tag, TagInfo>,
-}
-impl Registry {
-    pub fn add(&mut self, tag: Tag, info: TagInfo) {
-        if let Some(other) = self.tags.get(&tag) {
-            panic!(
-                "Conflicting names for tag {}: {:?} vs {:?}",
-                tag.0, info.name, other.name
-            )
-        }
-        self.tags.insert(tag, info);
-    }
-    pub fn info(&self, tag: Tag) -> Option<&TagInfo> {
-        self.tags.get(&tag)
-    }
-    pub fn name(&self, tag: Tag) -> &str {
-        match self.tags.get(&tag) {
-            Some(inf) => inf.name,
-            None => "unknown",
-        }
-    }
-}
-
 #[derive(Clone)]
 pub struct TagInfo {
     pub name: &'static str,
@@ -53,19 +27,13 @@ pub struct TagInfo {
 
 #[macro_export]
 macro_rules! fields {
-    ($($id:ident: $type:ty = $tag:literal $name:literal;)*) => {
-        $(pub const $id: $crate::TypedTag<$type> = $crate::TypedTag($crate::Tag($tag), std::marker::PhantomData);)*
-        pub(crate) fn register_fields(reg: &mut $crate::Registry) {
-            $(reg.add($crate::Tag($tag), $crate::TagInfo { name: $name, r#type: Some(std::any::TypeId::of::<$type>()) });)*
-        }
+    ($($id:ident: $type:ty = $tag:literal;)*) => {
+        $(pub const $id: $crate::TypedTag<$type> = $crate::TypedTag($crate::Tag::new($tag), std::marker::PhantomData);)*
     };
 }
 #[macro_export]
 macro_rules! enums {
-    ($($id:ident = $tag:literal $name:literal;)*) => {
-        $(pub const $id: $crate::Tag = $crate::Tag($tag);)*
-        pub(crate) fn register_enums(reg: &mut $crate::Registry) {
-            $(reg.add($crate::Tag($tag), $crate::TagInfo { name: $name, r#type: None });)*
-        }
+    ($($id:ident = $tag:literal;)*) => {
+        $(pub const $id: $crate::Tag = $crate::Tag::new($tag);)*
     };
 }
diff --git a/common/object/src/tests.rs b/common/object/src/tests.rs
index 616ac69..73f7b6f 100644
--- a/common/object/src/tests.rs
+++ b/common/object/src/tests.rs
@@ -4,19 +4,13 @@
     Copyright (C) 2026 metamuffin <metamuffin.org>
 */
 
-use crate::{Object, ObjectBuffer, Registry, fields, inspect::Inspector};
-use std::sync::LazyLock;
+use crate::{Object, ObjectBuffer, fields};
 
-pub static TAGREG: LazyLock<Registry> = LazyLock::new(|| {
-    let mut reg = Registry::default();
-    register_fields(&mut reg);
-    reg
-});
 fields! {
-    NAME: &str = 15 "name";
-    AGE: u32 = 13 "age";
-    FRIEND: &str = 54321 "friend";
-    STUFF: Object = 3 "stuff";
+    NAME: &str = b"name";
+    AGE: u32 = b"age1";
+    FRIEND: &str = b"frnd";
+    STUFF: Object = b"stff";
 }
 
 fn test_object() -> ObjectBuffer {
@@ -86,21 +80,9 @@ fn insert_empty() {
 }
 
 #[test]
-fn inspect_object() {
-    let bob = test_object();
-    eprintln!("{:#?}", Inspector(&TAGREG, bob.as_object()));
-    // panic!()
-}
-
-#[test]
-fn inspect_tag() {
-    assert_eq!(
-        format!("{:?}", Inspector(&TAGREG, FRIEND)),
-        "TypedTag<&str>(\"friend\")"
-    );
+fn debug() {
     assert_eq!(
-        format!("{:?}", Inspector(&TAGREG, AGE)),
-        "TypedTag<u32>(\"age\")"
+        format!("{:?}", test_object()),
+        "Object { age1: 35, frnd: \"Alice\", frnd: \"Charlie\", name: \"Bob\" }"
     );
-    assert_eq!(format!("{:?}", Inspector(&TAGREG, NAME.0)), "Tag(\"name\")");
 }
diff --git a/common/object/src/value.rs b/common/object/src/value.rs
index 733e3a0..eb9de7c 100644
--- a/common/object/src/value.rs
+++ b/common/object/src/value.rs
@@ -17,8 +17,44 @@ pub trait Value<'a>: ValueStore + Sized {
         unimplemented!()
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ValueType {
+    Binary,
+    String,
+    Object,
+    UInt,
+    Int,
+    Tag,
+    Float,
+    Bool,
+}
+
+impl ValueType {
+    #[inline]
+    pub fn is_aligned(self) -> bool {
+        match self {
+            ValueType::Binary | ValueType::String => false,
+            _ => true,
+        }
+    }
+    pub fn from_num(n: u32) -> Self {
+        match n {
+            0 => Self::Binary,
+            1 => Self::String,
+            2 => Self::Object,
+            3 => Self::UInt,
+            4 => Self::Int,
+            5 => Self::Tag,
+            6 => Self::Float,
+            7 => Self::Bool,
+            _ => unreachable!(),
+        }
+    }
+}
+
 pub trait ValueStore {
-    fn is_aligned(&self) -> bool;
+    fn get_type(&self) -> ValueType;
     fn store_aligned(&self, _buf: &mut Vec<u32>) {}
     fn store_unaligned(&self, _buf: &mut Vec<u8>) {}
     fn size(&self) -> usize;
@@ -30,8 +66,8 @@ impl<'a> Value<'a> for &'a str {
     }
 }
 impl ValueStore for &str {
-    fn is_aligned(&self) -> bool {
-        false
+    fn get_type(&self) -> ValueType {
+        ValueType::String
     }
     fn store_unaligned(&self, buf: &mut Vec<u8>) {
         buf.extend(self.as_bytes());
@@ -47,8 +83,8 @@ impl Value<'_> for u32 {
     }
 }
 impl ValueStore for u32 {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::UInt
     }
     fn store_aligned(&self, buf: &mut Vec<u32>) {
         buf.push(self.to_be());
@@ -64,8 +100,8 @@ impl Value<'_> for Tag {
     }
 }
 impl ValueStore for Tag {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::String
     }
     fn store_aligned(&self, buf: &mut Vec<u32>) {
         buf.push(self.0.to_be());
@@ -83,8 +119,8 @@ impl Value<'_> for u64 {
     }
 }
 impl ValueStore for u64 {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::UInt
     }
     fn store_aligned(&self, buf: &mut Vec<u32>) {
         buf.push(((self >> 32) as u32).to_be());
@@ -108,8 +144,8 @@ impl Value<'_> for f64 {
     }
 }
 impl ValueStore for f64 {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::Float
     }
     fn store_aligned(&self, buf: &mut Vec<u32>) {
         let b = self.to_be_bytes();
@@ -127,8 +163,8 @@ impl Value<'_> for i64 {
     }
 }
 impl ValueStore for i64 {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::Int
     }
     fn store_aligned(&self, buf: &mut Vec<u32>) {
         (*self as u64).store_aligned(buf);
@@ -144,8 +180,8 @@ impl<'a> Value<'a> for Object<'a> {
     }
 }
 impl ValueStore for Object<'_> {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::Object
     }
     fn store_aligned(&self, buf: &mut Vec<u32>) {
         buf.push(self.tags.len() as u32);
@@ -158,8 +194,8 @@ impl ValueStore for Object<'_> {
     }
 }
 impl ValueStore for ObjectBuffer {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::Object
     }
     fn store_aligned(&self, buf: &mut Vec<u32>) {
         buf.extend(&self.0);
@@ -175,8 +211,8 @@ impl<'a> Value<'a> for &'a [u8] {
     }
 }
 impl ValueStore for &[u8] {
-    fn is_aligned(&self) -> bool {
-        false
+    fn get_type(&self) -> ValueType {
+        ValueType::Binary
     }
     fn store_unaligned(&self, buf: &mut Vec<u8>) {
         buf.extend(*self);
@@ -192,8 +228,8 @@ impl<'a> Value<'a> for () {
     }
 }
 impl ValueStore for () {
-    fn is_aligned(&self) -> bool {
-        true
+    fn get_type(&self) -> ValueType {
+        ValueType::Binary
     }
     fn store_aligned(&self, _buf: &mut Vec<u32>) {}
     fn size(&self) -> usize {
diff --git a/common/src/api.rs b/common/src/api.rs
index 2aac57b..13962a3 100644
--- a/common/src/api.rs
+++ b/common/src/api.rs
@@ -7,54 +7,54 @@
 use jellyobject::{Object, Tag, enums, fields};
 
 fields! {
-    QUERY_PARENT: u64 = 2000 "parent";
-    QUERY_SEARCH: &str = 2001 "search";
-    QUERY_KIND: Tag = 2004 "kind"; // multi
-    QUERY_SORT: Tag = 2002 "sort"; // one of RTYP_*, NU_RATING, NO_DURATION, NO_NAME
-    QUERY_SORT_ASCENDING: () = 2003 "sort_ascending";
+    QUERY_PARENT: u64 = b"prnt";
+    QUERY_SEARCH: &str = b"sear";
+    QUERY_KIND: Tag = b"kind"; // multi
+    QUERY_SORT: Tag = b"sort"; // one of RTYP_*, NU_RATING, NO_DURATION, NO_NAME
+    QUERY_SORT_ASCENDING: () = b"sasc";
 
-    VIEW_TITLE: &str = 2005 "title";
-    VIEW_MESSAGE: Object = 2010 "message";
-    VIEW_NODE_PAGE: Object = 2011 "node_page";
-    VIEW_NODE_LIST: Object = 2012 "node_list"; // multi
-    VIEW_PLAYER: u64 = 2028 "player";
-    VIEW_STATGROUP: Object = 2041 "statgroup";
-    VIEW_STATTEXT: Object = 2042 "stattext";
-    VIEW_ACCOUNT_LOGIN: () = 2043 "account_login";
-    VIEW_ACCOUNT_LOGOUT: () = 2044 "account_logout";
-    VIEW_ACCOUNT_SET_PASSWORD: &str = 2045 "account_set_password";
-    VIEW_ADMIN_DASHBOARD: () = 2046 "admin_dashboard";
-    VIEW_ADMIN_IMPORT: Object = 2047 "admin_import";
+    VIEW_TITLE: &str = b"titl";
+    VIEW_MESSAGE: Object = b"mesg";
+    VIEW_NODE_PAGE: Object = b"npag";
+    VIEW_NODE_LIST: Object = b"nlis"; // multi
+    VIEW_PLAYER: u64 = b"play";
+    VIEW_STATGROUP: Object = b"stag";
+    VIEW_STATTEXT: Object = b"stat";
+    VIEW_ACCOUNT_LOGIN: () = b"acli";
+    VIEW_ACCOUNT_LOGOUT: () = b"aclo";
+    VIEW_ACCOUNT_SET_PASSWORD: &str = b"acsp";
+    VIEW_ADMIN_DASHBOARD: () = b"adda";
+    VIEW_ADMIN_IMPORT: Object = b"adim";
 
-    ADMIN_IMPORT_BUSY: () = 2048 "busy";
-    ADMIN_IMPORT_ERROR: &str = 2049 "error"; // multi
+    ADMIN_IMPORT_BUSY: () = b"busy";
+    ADMIN_IMPORT_ERROR: &str = b"erro"; // multi
 
-    NKU_NODE: Object = 2025 "node";
-    NKU_UDATA: Object = 2026 "udata";
-    NKU_ROLE: &str = 2027 "role";
+    NKU_NODE: Object = b"node";
+    NKU_UDATA: Object = b"udat";
+    NKU_ROLE: &str = b"role";
 
-    NODELIST_TITLE: &str = 2007 "title";
-    NODELIST_DISPLAYSTYLE: Tag = 2008 "displaystyle";
-    NODELIST_ITEM: Object = 2009 "item";
+    NODELIST_TITLE: &str = b"titl";
+    NODELIST_DISPLAYSTYLE: Tag = b"dsty";
+    NODELIST_ITEM: Object = b"item";
 
-    MESSAGE_KIND: &str = 2029 "kind";
-    MESSAGE_TEXT: &str = 2030 "text";
+    MESSAGE_KIND: &str = b"kind";
+    MESSAGE_TEXT: &str = b"text";
 
-    STATGROUP_TITLE: &str = 2039 "title";
-    STATGROUP_BIN: Object = 2040 "bin";
+    STATGROUP_TITLE: &str = b"titl";
+    STATGROUP_BIN: Object = b"bin1";
 
-    STAT_NAME: &str = 2038 "name";
-    STAT_COUNT: u64 = 2031 "count";
-    STAT_TOTAL_SIZE: u64 = 2032 "total_size";
-    STAT_TOTAL_DURATION: f64 = 2033 "total_duration";
-    STAT_MAX_SIZE: u64 = 2036 "max_size";
-    STAT_MAX_DURATION: f64 = 2037 "max_duration";
+    STAT_NAME: &str = b"name";
+    STAT_COUNT: u64 = b"cont";
+    STAT_TOTAL_SIZE: u64 = b"tlsz";
+    STAT_TOTAL_DURATION: f64 = b"tldu";
+    STAT_MAX_SIZE: u64 = b"mxsz";
+    STAT_MAX_DURATION: f64 = b"mxdu";
 }
 
 enums! {
-    NLSTYLE_GRID = 1023 "grid";
-    NLSTYLE_INLINE = 1024 "inline";
-    NLSTYLE_LIST = 1025 "list";
+    NLSTYLE_GRID = b"grid";
+    NLSTYLE_INLINE = b"inli";
+    NLSTYLE_LIST = b"list";
 }
 
 // use crate::user::{NodeUserData, User};
diff --git a/common/src/internal.rs b/common/src/internal.rs
index 94876f1..58a2dae 100644
--- a/common/src/internal.rs
+++ b/common/src/internal.rs
@@ -7,6 +7,6 @@
 use jellyobject::fields;
 
 fields! {
-    IM_PATH: &str = 0x11001 "path";
-    IM_MTIME: u64 = 0x11002 "mtime";
+    IM_PATH: &str = b"Ipth";
+    IM_MTIME: u64 = b"Imtm";
 }
diff --git a/common/src/lib.rs b/common/src/lib.rs
index 4f8ffca..d94c72c 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -15,24 +15,3 @@ pub use jellystream_types as stream;
 pub use api::*;
 pub use node::*;
 pub use user::*;
-
-use jellyobject::{Registry, TypedTag};
-use std::sync::LazyLock;
-
-pub static TAGREG: LazyLock<Registry> = LazyLock::new(|| {
-    let mut reg = Registry::default();
-    node::register_fields(&mut reg);
-    node::register_enums(&mut reg);
-    user::register_fields(&mut reg);
-    api::register_fields(&mut reg);
-    api::register_enums(&mut reg);
-    internal::register_fields(&mut reg);
-    reg
-});
-
-#[test]
-fn check_tag_conflicts() {
-    let _ = &*TAGREG;
-}
-
-pub struct Identifier(pub TypedTag<&'static str>, pub String);
diff --git a/common/src/node.rs b/common/src/node.rs
index 60544e2..42e07ca 100644
--- a/common/src/node.rs
+++ b/common/src/node.rs
@@ -9,125 +9,123 @@ use jellyobject::{Object, Tag, enums, fields};
 fields! {
     // Tag counter: 111
 
-    NO_KIND: Tag = 1 "kind";
-    NO_TITLE: &str = 2 "title";
-    NO_PARENT: u64 = 3 "parent"; // multi
-    NO_SUBTITLE: &str = 38 "subtitle";
-    NO_TAGLINE: &str = 4 "tagline";
-    NO_DESCRIPTION: &str = 5 "description";
-    NO_RELEASEDATE: i64 = 6 "releasedate";
-    NO_DURATION: f64 = 39 "duration";
-    NO_INDEX: u64 = 7 "index";
-    NO_SEASON_INDEX: u64 = 8 "season_index";
-    NO_TRACK: Object = 9 "track"; // multi
-    NO_CHAPTER: Object = 32 "chapter"; // multi
-    NO_TAG: &str = 10 "tag"; // multi
-    NO_RATINGS: Object = 11 "ratings";
-    NO_PICTURES: Object = 12 "pictures";
-    NO_IDENTIFIERS: Object = 13 "identifiers";
-    NO_VISIBILITY: Tag = 14 "visibility";
-    NO_STORAGE_SIZE: u64 = 15 "storage_size";
-    NO_CREDIT: Object = 33 "credit"; // multi
-    NO_SLUG: &str = 37 "slug";
+    NO_KIND: Tag = b"kind";
+    NO_TITLE: &str = b"titl";
+    NO_PARENT: u64 = b"prnt"; // multi
+    NO_SUBTITLE: &str = b"sbtl";
+    NO_TAGLINE: &str = b"tgln";
+    NO_DESCRIPTION: &str = b"desc";
+    NO_RELEASEDATE: i64 = b"rldt";
+    NO_DURATION: f64 = b"durn";
+    NO_INDEX: u64 = b"indx";
+    NO_SEASON_INDEX: u64 = b"sidx";
+    NO_TRACK: Object = b"trak"; // multi
+    NO_CHAPTER: Object = b"chpt"; // multi
+    NO_TAG: &str = b"tag1"; // multi
+    NO_RATINGS: Object = b"rtng";
+    NO_PICTURES: Object = b"pict";
+    NO_IDENTIFIERS: Object = b"iden";
+    NO_VISIBILITY: Tag = b"visi";
+    NO_STORAGE_SIZE: u64 = b"stsz";
+    NO_CREDIT: Object = b"crdt"; // multi
+    NO_SLUG: &str = b"slug";
 
-    CR_NODE: u64 = 34 "node";
-    CR_KIND: Tag = 35 "kind";
-    CR_ROLE: &str = 36 "role"; // multi
+    CR_NODE: u64 = b"node";
+    CR_KIND: Tag = b"kind";
+    CR_ROLE: &str = b"role"; // multi
 
-    TR_KIND: Tag = 16 "kind";
-    TR_SOURCE: Object = 17 "source";
-    TR_NAME: &str = 18 "name";
-    TR_CODEC: &str = 19 "codec";
-    TR_LANGUAGE: &str = 20 "language"; // BCP 47
-    TR_RATE: f64 = 23 "rate";
-    TR_BIT_DEPTH: u32 = 25 "bit_depth";
-    TR_CHANNELS: u32 = 28 "channels";
-    TR_PIXEL_WIDTH: u32 = 26 "pixel_width";
-    TR_PIXEL_HEIGHT: u32 = 27 "pixel_height";
+    TR_KIND: Tag = b"kind";
+    TR_SOURCE: Object = b"sour";
+    TR_NAME: &str = b"name";
+    TR_CODEC: &str = b"codc";
+    TR_LANGUAGE: &str = b"lang"; // BCP 47
+    TR_RATE: f64 = b"rate";
+    TR_BIT_DEPTH: u32 = b"bdep";
+    TR_CHANNELS: u32 = b"chnl";
+    TR_PIXEL_WIDTH: u32 = b"pwid";
+    TR_PIXEL_HEIGHT: u32 = b"phei";
 
-    TRSOURCE_LOCAL_PATH: &str = 21 "local_path";
-    TRSOURCE_LOCAL_TRACKNUM: u64 = 22 "local_tracknum";
+    TRSOURCE_LOCAL_PATH: &str = b"lpat";
+    TRSOURCE_LOCAL_TRACKNUM: u64 = b"ltrn";
 
-    CH_START: f64 = 29 "start";
-    CH_END: f64 = 30 "end";
-    CH_NAME: &str = 31 "name";
+    CH_START: f64 = b"strt";
+    CH_END: f64 = b"end1";
+    CH_NAME: &str = b"name";
 
-    PICT_COVER: &str = 45 "cover";
-    PICT_BACKDROP: &str = 46 "backdrop";
+    PICT_COVER: &str = b"covr";
+    PICT_BACKDROP: &str = b"bdro";
 
-    RTYP_IMDB: f64 = 47 "imdb";
-    RTYP_TMDB: f64 = 48 "tmdb";
-    RTYP_ROTTEN_TOMATOES: f64 = 49 "rotten_tomatoes";
-    RTYP_METACRITIC: f64 = 50 "metacritic";
-    RTYP_YOUTUBE_VIEWS: f64 = 51 "youtube_views";
-    RTYP_YOUTUBE_LIKES: f64 = 52 "youtube_likes";
-    RTYP_YOUTUBE_FOLLOWERS: f64 = 53 "youtube_followers";
-    RTYP_TRAKT: f64 = 54 "trakt";
+    RTYP_IMDB: f64 = b"imdb";
+    RTYP_TMDB: f64 = b"tmdb";
+    RTYP_ROTTEN_TOMATOES: f64 = b"rtom";
+    RTYP_METACRITIC: f64 = b"mcri";
+    RTYP_YOUTUBE_VIEWS: f64 = b"ytvi";
+    RTYP_YOUTUBE_LIKES: f64 = b"ytli";
+    RTYP_YOUTUBE_SUBSCRIBERS: f64 = b"ytsu";
+    RTYP_TRAKT: f64 = b"trkt";
 
-    IDENT_MUSICBRAINZ_RECORDING: &str = 55 "musicbrainz_recording";
-    IDENT_MUSICBRAINZ_ARTIST: &str = 56 "musicbrainz_artist";
-    IDENT_MUSICBRAINZ_RELEASE: &str = 57 "musicbrainz_release";
-    IDENT_MUSICBRAINZ_RELEASE_GROUP: &str = 58 "musicbrainz_release_group";
-    IDENT_ACOUST_ID_TRACK: &str = 59 "acoust_id_track";
-    IDENT_YOUTUBE_VIDEO: &str = 60 "youtube_video";
-    IDENT_YOUTUBE_CHANNEL: &str = 61 "youtube_channel";
-    IDENT_YOUTUBE_CHANNEL_HANDLE: &str = 62 "youtube_channel_handle";
-    IDENT_BANDCAMP: &str = 63 "bandcamp";
-    IDENT_ISRC: &str = 64 "isrc";
-    IDENT_BARCODE: &str = 65 "barcode";
-    IDENT_TRAKT_MOVIE: &str = 66 "trakt_movie";
-    IDENT_TRAKT_SHOW: &str = 67 "trakt_show";
-    IDENT_TRAKT_SEASON: &str = 68 "trakt_season";
-    IDENT_TRAKT_EPISODE: &str = 69 "trakt_episode";
-    IDENT_IMDB: &str = 70 "imdb";
-    IDENT_TMDB_SERIES: &str = 71 "tmdb_series";
-    IDENT_TMDB_MOVIE: &str = 72 "tmdb_movie";
-    IDENT_TVDB: &str = 73 "tvdb";
-    IDENT_OMDB: &str = 74 "omdb";
-    IDENT_VGMDB_ARTIST: &str = 75 "vgmdb_artist";
+    IDENT_MUSICBRAINZ_RECORDING: &str = b"mbrc";
+    IDENT_MUSICBRAINZ_ARTIST: &str = b"mbar";
+    IDENT_MUSICBRAINZ_RELEASE: &str = b"mbrl";
+    IDENT_MUSICBRAINZ_RELEASE_GROUP: &str = b"mbrg";
+    IDENT_ACOUST_ID_TRACK: &str = b"actr";
+    IDENT_YOUTUBE_VIDEO: &str = b"ytvi";
+    IDENT_YOUTUBE_CHANNEL: &str = b"ytc1";
+    IDENT_YOUTUBE_CHANNEL_HANDLE: &str = b"ytch";
+    IDENT_BANDCAMP: &str = b"bcmp";
+    IDENT_ISRC: &str = b"isrc";
+    IDENT_BARCODE: &str = b"barc";
+    IDENT_TRAKT_MOVIE: &str = b"trmv";
+    IDENT_TRAKT_SHOW: &str = b"trsh";
+    IDENT_TRAKT_SEASON: &str = b"trse";
+    IDENT_TRAKT_EPISODE: &str = b"trep";
+    IDENT_IMDB: &str = b"imdb";
+    IDENT_TMDB_SERIES: &str = b"tmse";
+    IDENT_TMDB_MOVIE: &str = b"tmmv";
+    IDENT_TVDB: &str = b"tvdb";
+    IDENT_OMDB: &str = b"omdb";
+    IDENT_VGMDB_ARTIST: &str = b"vgar";
 
 }
 
-pub type Kind = Tag;
-
 enums! {
-    VISI_HIDDEN = 76 "hidden";
-    VISI_REDUCED = 77 "reduced";
-    VISI_VISIBLE = 78 "visible";
+    VISI_HIDDEN = b"hidn";
+    VISI_REDUCED = b"rdcd";
+    VISI_VISIBLE = b"visi";
 
-    TRKIND_VIDEO = 79 "video";
-    TRKIND_AUDIO = 80 "audio";
-    TRKIND_TEXT = 81 "text";
-    TRKIND_UNKNOWN = 82 "unknown";
+    TRKIND_VIDEO = b"vide";
+    TRKIND_AUDIO = b"audi";
+    TRKIND_TEXT = b"text";
+    TRKIND_UNKNOWN = b"unkn";
 
-    KIND_MOVIE = 83 "movie";
-    KIND_VIDEO = 84 "video";
-    KIND_MUSIC = 85 "music";
-    KIND_SHORTFORMVIDEO = 86 "shortformvideo";
-    KIND_COLLECTION = 87 "collection";
-    KIND_CHANNEL = 88 "channel";
-    KIND_SHOW = 89 "show";
-    KIND_SERIES = 90 "series";
-    KIND_SEASON = 91 "season";
-    KIND_EPISODE = 92 "episode";
+    KIND_MOVIE = b"movi";
+    KIND_VIDEO = b"vide";
+    KIND_MUSIC = b"musi";
+    KIND_SHORTFORMVIDEO = b"sfvi";
+    KIND_COLLECTION = b"coll";
+    KIND_CHANNEL = b"chnl";
+    KIND_SHOW = b"show";
+    KIND_SERIES = b"seri";
+    KIND_SEASON = b"sesn";
+    KIND_EPISODE = b"epsd";
 
-    CRCAT_CAST = 93 "cast";
-    CRCAT_WRITING = 94 "writing";
-    CRCAT_DIRECTING = 95 "directing";
-    CRCAT_ART = 96 "art";
-    CRCAT_SOUND = 97 "sound";
-    CRCAT_CAMERA = 98 "camera";
-    CRCAT_LIGHTING = 99 "lighting";
-    CRCAT_CREW = 100 "crew";
-    CRCAT_EDITING = 101 "editing";
-    CRCAT_PRODUCTION = 102 "production";
-    CRCAT_VFX = 0x200b "vfx";
-    CRCAT_COSTUME_MAKEUP = 103 "costume_makeup";
-    CRCAT_CREATED_BY = 104 "created_by";
-    CRCAT_PERFORMANCE = 105 "performance";
-    CRCAT_INSTRUMENT = 106 "instrument";
-    CRCAT_VOCAL = 107 "vocal";
-    CRCAT_ARRANGER = 108 "arranger";
-    CRCAT_PRODUCER = 109 "producer";
-    CRCAT_ENGINEER = 110 "engineer";
+    CRCAT_CAST = b"cast";
+    CRCAT_WRITING = b"writ";
+    CRCAT_DIRECTING = b"dire";
+    CRCAT_ART = b"art1";
+    CRCAT_SOUND = b"sond";
+    CRCAT_CAMERA = b"came";
+    CRCAT_LIGHTING = b"ligh";
+    CRCAT_CREW = b"crew";
+    CRCAT_EDITING = b"edit";
+    CRCAT_PRODUCTION = b"prod";
+    CRCAT_VFX = b"vfx1";
+    CRCAT_COSTUME_MAKEUP = b"coma";
+    CRCAT_CREATED_BY = b"crby";
+    CRCAT_PERFORMANCE = b"perf";
+    CRCAT_INSTRUMENT = b"inst";
+    CRCAT_VOCAL = b"voca";
+    CRCAT_ARRANGER = b"arra";
+    CRCAT_PRODUCER = b"pro2";
+    CRCAT_ENGINEER = b"engi";
 }
diff --git a/common/src/user.rs b/common/src/user.rs
index 47716da..fcb8eea 100644
--- a/common/src/user.rs
+++ b/common/src/user.rs
@@ -7,11 +7,11 @@
 use jellyobject::fields;
 
 fields! {
-    USER_LOGIN: &str = 1001 "login";
-    USER_PASSWORD: &[u8] = 1002 "password";
-    USER_NAME: &str = 1003 "name";
-    USER_ADMIN: () = 1004 "admin";
+    USER_LOGIN: &str = b"Ulgn";
+    USER_PASSWORD: &[u8] = b"Upwd";
+    USER_NAME: &str = b"Unam";
+    USER_ADMIN: () = b"Uadm";
 
-    UDATA_WATCHED: () = 1005 "watched";
-    UDATA_RATING: f64 = 1006 "rating";
+    UDATA_WATCHED: () = b"Dwat";
+    UDATA_RATING: f64 = b"Drat";
 }