diff --git a/benches/change.rs b/benches/change.rs
index e1bd945..731f55c 100644
--- a/benches/change.rs
+++ b/benches/change.rs
@@ -3,23 +3,28 @@
 use std::borrow::Cow;
 
 use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
-use hyperflash::{change_resolver::resolve_changes, change_router::{Transforms, determine_changes}, note::{FieldContent, Identified, Note, NoteField, NoteModel}, note_id_generator::GitNoteIdGenerator};
+use hyperflash::{
+	deck::model::Model,
+	deck::note::ids::GitNoteIdGenerator,
+	deck::note::{Field, Identified, Note},
+	history::{resolve_changes, Transforms, determine_changes},
+};
 use uuid::Uuid;
 
 fn leak(s: String) -> &'static str { Box::leak(s.into_boxed_str()) }
 
 fn make_note(i: usize) -> Note<'static> {
-	let mut model = NoteModel::default();
+	let mut model = Model::default();
 	model.id = Uuid::nil();
 	Note {
 		fields: vec![
-			NoteField {
+			Field {
 				name:    "Front".into(),
-				content: FieldContent::parse(leak(format!("Question {i}"))),
+				content: leak(format!("Question {i}")),
 			},
-			NoteField {
+			Field {
 				name:    "Back".into(),
-				content: FieldContent::parse(leak(format!("Answer {i}"))),
+				content: leak(format!("Answer {i}")),
 			},
 		],
 		model:  Cow::Owned(model),
diff --git a/benches/parse.rs b/benches/parse.rs
index 5ff0b5a..19d6ea2 100644
--- a/benches/parse.rs
+++ b/benches/parse.rs
@@ -3,14 +3,14 @@
 use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
 use evalexpr::build_operator_tree;
 use hyperflash::{
-	note::{Field, NoteModel},
+	deck::model::{Field, Model},
 	parse::{construct, lex, parse_tree},
 };
 use semver::Version;
 use uuid::Uuid;
 
-fn bench_model() -> NoteModel {
-	NoteModel {
+fn bench_model() -> Model {
+	Model {
 		name: "Basic".to_string(),
 		id: Uuid::nil(),
 		templates: vec![],
diff --git a/src/deck/cards.rs b/src/deck/cards.rs
index a69a405..0c6c721 100644
--- a/src/deck/cards.rs
+++ b/src/deck/cards.rs
@@ -6,7 +6,18 @@ use gix::{Commit, Repository, object::tree::Entry};
 use tracing::debug;
 use uuid::Uuid;
 
-use crate::{change_resolver::resolve_changes, change_router::determine_changes, deck::Deck, error::DeckError, note::{Identified, Note, NoteModel}, note_id_generator::{GitNoteIdGenerator, NoteIdGenerator}, parse::{Diagnostic, FlashSyntaxNode, ImportExpander, Severity, construct, parse_tree, syntax::{FlashTreeBuilder, SyntaxKind, child, children, node_text}}};
+use crate::{
+	deck::{model::Model, note::{Identified, Note}, Deck},
+	error::DeckError,
+	history::{resolve_changes, determine_changes},
+	parse::{
+		construct, parse_tree,
+		syntax::{FlashTreeBuilder, SyntaxKind, child, children, node_text},
+		Diagnostic, FlashSyntaxNode, ImportExpander, Severity,
+	},
+};
+
+use super::note::ids::{GitNoteIdGenerator, NoteIdGenerator};
 
 impl Deck {
 	/// The deck's cards, queried from the backing [`tree`](Deck::tree).
@@ -87,7 +98,7 @@ pub(crate) fn build_tree(content: &str, source_name: &str) -> Result<FlashSyntax
 /// Query `tree` for its notes, failing if it has any semantic errors.
 pub(crate) fn query_notes<'t>(
 	tree: &'t FlashSyntaxNode,
-	models: &'t [NoteModel],
+	models: &'t [Model],
 	source_name: &str,
 	content: &str,
 ) -> Result<Vec<Note<'t>>, DeckError> {
@@ -144,7 +155,7 @@ pub(crate) fn content(backing_vcs: &Repository, entry: &Entry) -> Result<String,
 /// references to the notes it tracks instead of cloning their fields, tags, and
 /// models — the only owned state it accumulates is the stable id of each note.
 pub(crate) fn process_history(
-	models: &[NoteModel],
+	models: &[Model],
 	content: &[String],
 	backing_vcs: &Repository,
 	history: &[(Entry, Commit)],
@@ -207,10 +218,14 @@ mod tests {
 	use uuid::Uuid;
 
 	use super::*;
-	use crate::{config::DeckConfig, note::{Field, FieldContent, Note, NoteField, NoteModel}, parse::{construct, parse_tree}};
+	use crate::{
+		config::DeckConfig,
+		deck::{model::Model, model::field::Field as SchemaField, note::{Field, Note}},
+		parse::{construct, parse_tree},
+	};
 
-	fn basic_model() -> NoteModel {
-		NoteModel {
+	fn basic_model() -> Model {
+		Model {
 			name:           "Basic".to_string(),
 			id:             Uuid::new_v4(),
 			templates:      vec![],
@@ -218,8 +233,8 @@ mod tests {
 			defaults:       None,
 			css:            String::new(),
 			fields:         vec![
-				Field { name: "Front".into(), sticky: None, associated_media: None },
-				Field { name: "Back".into(), sticky: None, associated_media: None },
+				SchemaField { name: "Front".into(), sticky: None, associated_media: None },
+				SchemaField { name: "Back".into(), sticky: None, associated_media: None },
 			],
 			latex_pre:      None,
 			latex_post:     None,
@@ -229,18 +244,18 @@ mod tests {
 		}
 	}
 
-	fn make_note<'m>(model: &'m NoteModel, front: &'static str, back: &'static str) -> Note<'m> {
+	fn make_note<'m>(model: &'m Model, front: &'static str, back: &'static str) -> Note<'m> {
 		Note {
 			model:  Cow::Borrowed(model),
 			tags:   vec![],
 			fields: vec![
-				NoteField { name: "Front".into(), content: FieldContent::parse(front) },
-				NoteField { name: "Back".into(), content: FieldContent::parse(back) },
+				Field { name: "Front".into(), content: front },
+				Field { name: "Back".into(), content: back },
 			],
 		}
 	}
 
-	fn empty_deck(models: Vec<NoteModel>) -> Deck {
+	fn empty_deck(models: Vec<Model>) -> Deck {
 		let repo = gix::open(env!("CARGO_MANIFEST_DIR")).expect("project must be a git repo");
 		let (tree, _) = parse_tree("");
 		Deck { models, backing_vcs: repo, tree, note_ids: vec![], configuration: DeckConfig::default() }
diff --git a/src/deck/definition.rs b/src/deck/definition.rs
deleted file mode 100644
index 88a0783..0000000
--- a/src/deck/definition.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use gix::Repository;
-use uuid::Uuid;
-
-use crate::{config::DeckConfig, note::NoteModel, parse::FlashSyntaxNode};
-
-/// A deck, backed by its concrete syntax [`tree`](Deck::tree).
-///
-/// The tree is the single source of truth for the deck's text: it holds every
-/// byte of `index.flash` losslessly. Cards are not stored — they are *queried*
-/// from the tree on demand via [`Deck::cards`], each borrowing its field
-/// text straight out of the tree.
-#[derive(Clone)]
-pub struct Deck {
-	pub models:        Vec<NoteModel>,
-	pub backing_vcs:   Repository,
-	/// The lossless concrete syntax tree of the deck's `index.flash`.
-	pub tree:          FlashSyntaxNode,
-	/// Stable note ids, aligned with the order of [`Deck::cards`].
-	pub note_ids:      Vec<Uuid>,
-	pub configuration: DeckConfig,
-}
diff --git a/src/deck/init.rs b/src/deck/init.rs
deleted file mode 100644
index 5d2f9f4..0000000
--- a/src/deck/init.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use std::{fs, path::Path};
-
-use gix::Repository;
-use tracing::{debug, info, instrument, warn};
-use uuid::Uuid;
-
-use crate::{config::DeckConfig, deck::{Deck, blob_entry::BEntry, cards, history}, deck_locator::scan_deck_contents, error::DeckError, model_catalog::{FilesystemModelCatalog, ModelCatalog}, note::NoteModel, note_id_generator::{GitNoteIdGenerator, NoteIdGenerator}};
-
-fn load_or_create_config(deck_path: &Path, deck_identifer: &Uuid) -> Result<DeckConfig, DeckError> {
-	let config_path = deck_path.join("config.toml");
-
-	let mut configuration: DeckConfig = if config_path.exists() {
-		let config_content = fs::read_to_string(&config_path)
-			.map_err(|_| DeckError::DeckConfigNotFound(config_path.clone()))?;
-		toml::from_str(&config_content)?
-	} else {
-		DeckConfig {
-			flash_uuid: deck_identifer.to_string(),
-			name: deck_path.file_prefix().expect("should always work bro").to_str().unwrap().to_string(),
-			..Default::default()
-		}
-	};
-
-	if configuration.flash_uuid.is_empty() {
-		configuration.flash_uuid = deck_identifer.to_string()
-	}
-
-	Ok(configuration)
-}
-
-impl Deck {
-	#[instrument(skip(deck_path))]
-	pub fn from<P: AsRef<Path>>(deck_path: P) -> Result<Self, DeckError> {
-		let model_catalog = FilesystemModelCatalog;
-		let note_id_generator = GitNoteIdGenerator;
-		Self::from_with(deck_path, &model_catalog, &note_id_generator)
-	}
-
-	#[instrument(skip(deck_path, model_catalog, note_id_generator))]
-	pub fn from_with<P: AsRef<Path>>(
-		deck_path: P,
-		model_catalog: &impl ModelCatalog,
-		note_id_generator: &impl NoteIdGenerator,
-	) -> Result<Self, DeckError> {
-		let deck_path = deck_path.as_ref();
-		info!("Initializing deck from: {:?}", deck_path);
-
-		let card_paths =
-			scan_deck_contents(deck_path).map_err(|e| DeckError::ScanContentsFailed(Box::new(e)))?;
-
-		if card_paths.is_empty() {
-			warn!("No card files found in deck directory");
-		}
-
-		let models =
-			model_catalog.load_models(deck_path).map_err(|e| DeckError::LoadModelsFailed(Box::new(e)))?;
-
-		info!("Loaded {} models", models.len());
-
-		let repo_path = deck_path.join(".git");
-		debug!("Opening repository at: {:?}", repo_path);
-		let backing_vcs = gix::open(repo_path).map_err(DeckError::OpenGitFailed)?;
-
-		let vcs = backing_vcs.clone();
-
-		let deck_identifer = history::derive_core_id(&vcs)?;
-
-		let configuration = load_or_create_config(deck_path, &deck_identifer)?;
-
-		let hist = history::get(&vcs, "index.flash")?;
-
-		let content: Vec<String> = hist
-			.iter()
-			.map(|(entry, _)| cards::content(&backing_vcs, entry))
-			.collect::<Result<Vec<_>, DeckError>>()?;
-
-		let (note_ids, tree) =
-			cards::process_history(&models, &content, &backing_vcs, &hist, note_id_generator)?;
-
-		info!("Deck initialized successfully");
-		Ok(Self { models, backing_vcs, tree, note_ids, configuration })
-	}
-
-	#[instrument(skip(backing_vcs))]
-	pub fn read_file_content(backing_vcs: &Repository, entry: &BEntry) -> Result<String, DeckError> {
-		let binary_blob = backing_vcs.find_blob(entry.entry().id())?;
-		let content = String::from_utf8(binary_blob.data.clone()).map_err(|_| {
-			DeckError::InvalidUtf8(backing_vcs.workdir().expect("Worktree should be checked out").into())
-		})?;
-		Ok(content)
-	}
-
-	#[instrument(skip(models, backing_vcs))]
-	pub fn generate_note_uuids(
-		models: &[NoteModel],
-		backing_vcs: &Repository,
-		target: (gix::object::tree::Entry, gix::Commit),
-	) -> Result<Vec<Uuid>, DeckError> {
-		GitNoteIdGenerator.generate_note_ids_for_revision(models, backing_vcs, target)
-	}
-}
diff --git a/src/deck_locator.rs b/src/deck/locator.rs
similarity index 100%
rename from src/deck_locator.rs
rename to src/deck/locator.rs
diff --git a/src/deck/mod.rs b/src/deck/mod.rs
index 5402f2c..3b8e256 100644
--- a/src/deck/mod.rs
+++ b/src/deck/mod.rs
@@ -1,8 +1,132 @@
 pub mod blob_entry;
 pub mod cards;
-pub mod definition;
-pub mod history;
-pub mod init;
-pub mod note_ids;
+pub mod locator;
+pub mod model;
+pub mod note;
+pub mod uuid_generator;
 
-pub use self::definition::*;
+use std::{fs, path::Path};
+
+use gix::Repository;
+use tracing::{debug, info, instrument, warn};
+use uuid::Uuid;
+
+use crate::{
+	config::DeckConfig,
+	deck::{blob_entry::BEntry, model::Model, note::ids::NoteIdGenerator},
+	error::DeckError,
+	history::{self},
+	parse::FlashSyntaxNode,
+};
+
+/// A deck, backed by its concrete syntax [`tree`](Deck::tree).
+///
+/// The tree is the single source of truth for the deck's text: it holds every
+/// byte of `index.flash` losslessly. Cards are not stored — they are *queried*
+/// from the tree on demand via [`Deck::cards`], each borrowing its field
+/// text straight out of the tree.
+#[derive(Clone)]
+pub struct Deck {
+	pub models: Vec<Model>,
+	pub backing_vcs: Repository,
+	/// The lossless concrete syntax tree of the deck's `index.flash`.
+	pub tree: FlashSyntaxNode,
+	/// Stable note ids, aligned with the order of [`Deck::cards`].
+	pub note_ids: Vec<Uuid>,
+	pub configuration: DeckConfig,
+}
+
+fn load_or_create_config(deck_path: &Path, deck_identifer: &Uuid) -> Result<DeckConfig, DeckError> {
+	let config_path = deck_path.join("config.toml");
+
+	let mut configuration: DeckConfig = if config_path.exists() {
+		let config_content = fs::read_to_string(&config_path)
+			.map_err(|_| DeckError::DeckConfigNotFound(config_path.clone()))?;
+		toml::from_str(&config_content)?
+	} else {
+		DeckConfig {
+			flash_uuid: deck_identifer.to_string(),
+			name: deck_path.file_prefix().expect("should always work bro").to_str().unwrap().to_string(),
+			..Default::default()
+		}
+	};
+
+	if configuration.flash_uuid.is_empty() {
+		configuration.flash_uuid = deck_identifer.to_string()
+	}
+
+	Ok(configuration)
+}
+
+impl Deck {
+	#[instrument(skip(deck_path))]
+	pub fn from<P: AsRef<Path>>(deck_path: P) -> Result<Self, DeckError> {
+		let model_catalog = model::catalog::FilesystemModelCatalog;
+		let note_id_generator = note::ids::GitNoteIdGenerator;
+		Self::from_with(deck_path, &model_catalog, &note_id_generator)
+	}
+
+	#[instrument(skip(deck_path, model_catalog, note_id_generator))]
+	pub fn from_with<P: AsRef<Path>>(
+		deck_path: P,
+		model_catalog: &impl model::catalog::ModelCatalog,
+		note_id_generator: &impl NoteIdGenerator,
+	) -> Result<Self, DeckError> {
+		let deck_path = deck_path.as_ref();
+		info!("Initializing deck from: {:?}", deck_path);
+
+		let card_paths =
+			locator::scan_deck_contents(deck_path)
+				.map_err(|e| DeckError::ScanContentsFailed(Box::new(e)))?;
+
+		if card_paths.is_empty() {
+			warn!("No card files found in deck directory");
+		}
+
+		let models =
+			model_catalog.load_models(deck_path).map_err(|e| DeckError::LoadModelsFailed(Box::new(e)))?;
+
+		info!("Loaded {} models", models.len());
+
+		let repo_path = deck_path.join(".git");
+		debug!("Opening repository at: {:?}", repo_path);
+		let backing_vcs = gix::open(repo_path).map_err(DeckError::OpenGitFailed)?;
+
+		let vcs = backing_vcs.clone();
+
+		let deck_identifer = history::derive_core_id(&vcs)?;
+
+		let configuration = load_or_create_config(deck_path, &deck_identifer)?;
+
+		let hist = history::get(&vcs, "index.flash")?;
+
+		let content: Vec<String> = hist
+			.iter()
+			.map(|(entry, _)| cards::content(&backing_vcs, entry))
+			.collect::<Result<Vec<_>, DeckError>>()?;
+
+		let (note_ids, tree) =
+			cards::process_history(&models, &content, &backing_vcs, &hist, note_id_generator)?;
+
+		info!("Deck initialized successfully");
+		Ok(Self { models, backing_vcs, tree, note_ids, configuration })
+	}
+
+	#[instrument(skip(backing_vcs))]
+	pub fn read_file_content(backing_vcs: &Repository, entry: &BEntry) -> Result<String, DeckError> {
+		let binary_blob = backing_vcs.find_blob(entry.entry().id())?;
+		let content = String::from_utf8(binary_blob.data.clone()).map_err(|_| {
+			DeckError::InvalidUtf8(backing_vcs.workdir().expect("Worktree should be checked out").into())
+		})?;
+		Ok(content)
+	}
+
+	#[instrument(skip(models, backing_vcs))]
+	pub fn generate_note_uuids(
+		models: &[Model],
+		backing_vcs: &Repository,
+		target: (gix::object::tree::Entry, gix::Commit),
+	) -> Result<Vec<Uuid>, DeckError> {
+		note::ids::GitNoteIdGenerator.generate_note_ids_for_revision(models, backing_vcs, target)
+	}
+}
diff --git a/src/model_catalog.rs b/src/deck/model/catalog.rs
similarity index 58%
rename from src/model_catalog.rs
rename to src/deck/model/catalog.rs
index 5016f73..514b7d5 100644
--- a/src/model_catalog.rs
+++ b/src/deck/model/catalog.rs
@@ -2,10 +2,10 @@ use std::{fs::ReadDir, path::Path};
 
 use dir_spec::data_home;
 
-use crate::{error::DeckError, model_loader, note::NoteModel};
+use crate::{deck::model::Model, error::DeckError};
 
 pub trait ModelCatalog {
-	fn load_models(&self, deck_path: &Path) -> Result<Vec<NoteModel>, DeckError>;
+	fn load_models(&self, deck_path: &Path) -> Result<Vec<Model>, DeckError>;
 }
 
 #[derive(Clone, Copy, Debug, Default)]
@@ -20,7 +20,7 @@ impl FilesystemModelCatalog {
 }
 
 impl ModelCatalog for FilesystemModelCatalog {
-	fn load_models(&self, deck_path: &Path) -> Result<Vec<NoteModel>, DeckError> {
-		model_loader::load_models(self.find_models()?, deck_path)
+	fn load_models(&self, deck_path: &Path) -> Result<Vec<Model>, DeckError> {
+		super::loader::load_models(self.find_models()?, deck_path)
 	}
 }
diff --git a/src/note/model/completion.rs b/src/deck/model/completion.rs
similarity index 90%
rename from src/note/model/completion.rs
rename to src/deck/model/completion.rs
index 40b1cf4..3044caf 100644
--- a/src/note/model/completion.rs
+++ b/src/deck/model/completion.rs
@@ -2,10 +2,10 @@ use std::{fs, path::Path};
 
 use tracing::{debug, info};
 
-use crate::{error::DeckError, note::{Complete, NoteModel, Partial}};
+use crate::{deck::model::{Complete, Model, Partial}, error::DeckError};
 
-impl NoteModel<Partial> {
-	pub fn complete(self, dir: &Path) -> Result<NoteModel<Complete>, DeckError> {
+impl Model<Partial> {
+	pub fn complete(self, dir: &Path) -> Result<Model<Complete>, DeckError> {
 		let mut css = String::new();
 		let css_path = dir.join("style.css");
 		if css_path.exists() {
@@ -54,12 +54,12 @@ impl NoteModel<Partial> {
 				// Find or create template
 				let tmpl = templates
 					.iter_mut()
-					.find(|t: &&mut crate::note::model::Template| t.name == template_name);
+					.find(|t: &&mut crate::deck::model::Template| t.name == template_name);
 
 				let tmpl = if let Some(t) = tmpl {
 					t
 				} else {
-					templates.push(crate::note::model::Template {
+					templates.push(crate::deck::model::Template {
 						name:                    template_name.clone(),
 						order:                   templates.len() as i32,
 						question_format:         String::new(),
@@ -90,7 +90,7 @@ impl NoteModel<Partial> {
 			}
 		}
 
-		Ok(NoteModel {
+		Ok(Model {
 			name,
 			id: self.id,
 			templates,
@@ -111,7 +111,7 @@ impl NoteModel<Partial> {
 mod tests {
 	use std::fs;
 
-	use crate::note::NoteModel;
+	use crate::deck::model::Model;
 
 	#[test]
 	fn complete_without_optional_files() {
@@ -122,7 +122,7 @@ mod tests {
 		fs::write(model_path.join("style.css"), "body { color: red; }").unwrap();
 		fs::write(model_path.join("Front+front.hbs"), "{{Front}}").unwrap();
 
-		let partial = NoteModel { name: Some("Test".into()), ..NoteModel::default() };
+		let partial = Model { name: Some("Test".into()), ..Model::default() };
 		let complete = partial.complete(&model_path).unwrap();
 		assert_eq!(complete.name, "Test");
 		assert_eq!(complete.css, "body { color: red; }");
@@ -136,7 +136,7 @@ mod tests {
 		fs::write(model_path.join("style.css"), "").unwrap();
 		fs::write(model_path.join("Q+front.hbs"), "{{Q}}").unwrap();
 
-		let partial = NoteModel::default();
+		let partial = Model::default();
 		let complete = partial.complete(&model_path).unwrap();
 		assert_eq!(complete.name, "MyModel");
 	}
@@ -149,7 +149,7 @@ mod tests {
 		fs::write(model_path.join("style.css"), ".card { font-size: 14px; }").unwrap();
 		fs::write(model_path.join("F+front.hbs"), "{{F}}").unwrap();
 
-		let partial = NoteModel::default();
+		let partial = Model::default();
 		let complete = partial.complete(&model_path).unwrap();
 		assert_eq!(complete.css, ".card { font-size: 14px; }");
 	}
@@ -164,7 +164,7 @@ mod tests {
 		fs::write(model_path.join("pre.tex"), "\\prelude").unwrap();
 		fs::write(model_path.join("post.tex"), "\\postlude").unwrap();
 
-		let partial = NoteModel::default();
+		let partial = Model::default();
 		let complete = partial.complete(&model_path).unwrap();
 		assert_eq!(complete.latex_pre, Some("\\prelude".into()));
 		assert_eq!(complete.latex_post, Some("\\postlude".into()));
@@ -177,7 +177,7 @@ mod tests {
 		fs::create_dir(&model_path).unwrap();
 		fs::write(model_path.join("F+front.hbs"), "{{F}}").unwrap();
 
-		let partial = NoteModel::default();
+		let partial = Model::default();
 		let complete = partial.complete(&model_path).unwrap();
 		assert_eq!(complete.css, "");
 	}
@@ -191,7 +191,7 @@ mod tests {
 		fs::write(model_path.join("Card1+front.hbs"), "{{Front}}").unwrap();
 		fs::write(model_path.join("Card1+back.hbs"), "{{Back}}").unwrap();
 
-		let partial = NoteModel::default();
+		let partial = Model::default();
 		let complete = partial.complete(&model_path).unwrap();
 		assert_eq!(complete.templates.len(), 1);
 		assert_eq!(complete.templates[0].name, "Card1");
@@ -210,7 +210,7 @@ mod tests {
 		fs::write(model_path.join("C+back.hbs"), "A").unwrap();
 		fs::write(model_path.join("C+back.browser.hbs"), "A_browser").unwrap();
 
-		let partial = NoteModel::default();
+		let partial = Model::default();
 		let complete = partial.complete(&model_path).unwrap();
 		let tmpl = &complete.templates[0];
 		assert_eq!(tmpl.question_format, "Q");
@@ -227,7 +227,7 @@ mod tests {
 		fs::write(model_path.join("style.css"), "").unwrap();
 		fs::write(model_path.join("invalid.hbs"), "{{F}}").unwrap();
 
-		let partial = NoteModel::default();
+		let partial = Model::default();
 		let result = partial.complete(&model_path);
 		assert!(result.is_err());
 	}
@@ -243,7 +243,7 @@ mod tests {
 		let partial_id;
 		let partial_schema;
 		let complete = {
-			let partial = NoteModel { name: Some("CustomName".into()), ..NoteModel::default() };
+			let partial = Model { name: Some("CustomName".into()), ..Model::default() };
 			partial_id = partial.id;
 			partial_schema = partial.schema_version.clone();
 			partial.complete(&model_path).unwrap()
diff --git a/src/deck/model/field.rs b/src/deck/model/field.rs
new file mode 100644
index 0000000..23c3893
--- /dev/null
+++ b/src/deck/model/field.rs
@@ -0,0 +1,10 @@
+use std::path::PathBuf;
+
+use serde::Deserialize;
+
+#[derive(Deserialize, Ord, PartialOrd, Eq, Hash, Clone, PartialEq, Debug)]
+pub struct Field {
+	pub name: String,
+	pub sticky: Option<bool>,
+	pub associated_media: Option<Vec<PathBuf>>,
+}
diff --git a/src/model_loader.rs b/src/deck/model/loader.rs
similarity index 82%
rename from src/model_loader.rs
rename to src/deck/model/loader.rs
index bd22a56..83c5128 100644
--- a/src/model_loader.rs
+++ b/src/deck/model/loader.rs
@@ -2,10 +2,10 @@ use std::{fs::{self, ReadDir}, path::Path};
 
 use tracing::{debug, info, instrument};
 
-use crate::{error::DeckError, note::{NoteModel, Partial}};
+use crate::{deck::model::{Model, Partial}, error::DeckError};
 
 #[instrument]
-pub fn load_models(model_paths: ReadDir, deck_path: &Path) -> Result<Vec<NoteModel>, DeckError> {
+pub fn load_models(model_paths: ReadDir, deck_path: &Path) -> Result<Vec<Model>, DeckError> {
 	info!("Loading models");
 
 	let mut all_models = Vec::new();
@@ -20,7 +20,7 @@ pub fn load_models(model_paths: ReadDir, deck_path: &Path) -> Result<Vec<NoteMod
 			.map_err(|_| DeckError::ModelConfigNotFound(config_path.clone()))?;
 
 		// TODO: Make errors lossless, this caused a traumatic error...
-		let model: NoteModel<Partial> = toml::from_str(&config_content).unwrap();
+		let model: Model<Partial> = toml::from_str(&config_content).unwrap();
 
 		// TODO: This path should be more dynamic
 		let model = model.complete(model_path.as_path())?;
diff --git a/src/deck/model/mod.rs b/src/deck/model/mod.rs
new file mode 100644
index 0000000..188e681
--- /dev/null
+++ b/src/deck/model/mod.rs
@@ -0,0 +1,113 @@
+pub mod catalog;
+pub mod completion;
+pub mod field;
+pub mod loader;
+pub mod template;
+
+pub use self::field::Field;
+pub use self::template::{Defaults, Template};
+
+use std::fmt::Debug;
+use std::hash::Hash;
+
+use evalexpr::Node;
+use semver::Version;
+use serde::Deserialize;
+use uuid::Uuid;
+
+pub trait ModelStage: Default + Clone + std::fmt::Debug + PartialEq + Eq + PartialOrd + Ord + Hash {
+	type Name: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
+	type Css: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
+	type Templates: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
+	type Latex: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
+}
+
+#[derive(Default, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Partial;
+
+#[derive(Default, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Complete;
+
+impl ModelStage for Partial {
+	type Css = String;
+	type Latex = Option<String>;
+	type Name = Option<String>;
+	type Templates = Vec<Template>;
+}
+
+impl ModelStage for Complete {
+	type Css = String;
+	type Latex = Option<String>;
+	type Name = String;
+	type Templates = Vec<Template>;
+}
+
+#[derive(Debug, Eq, PartialOrd, Ord, Hash, Deserialize, Clone, PartialEq)]
+#[serde(
+	bound = "Stage::Name: Deserialize<'de>, Stage::Templates: Deserialize<'de>, Stage::Css: Deserialize<'de>, Stage::Latex: Deserialize<'de>"
+)]
+pub struct Model<Stage: ModelStage = Complete> {
+	#[serde(skip)]
+	pub name: Stage::Name,
+
+	pub id: Uuid,
+
+	pub templates: Stage::Templates,
+
+	pub schema_version: Version,
+
+	pub defaults: Option<Defaults>,
+
+	#[serde(skip)]
+	pub css: Stage::Css,
+
+	pub fields: Vec<Field>,
+
+	#[serde(skip)]
+	pub latex_pre: Stage::Latex,
+	#[serde(skip)]
+	pub latex_post: Stage::Latex,
+
+	pub sort_field: Option<String>,
+	pub tags: Option<Vec<String>>,
+
+	pub required: Node,
+}
+
+impl Default for Model<Complete> {
+	fn default() -> Self {
+		Self {
+			name: String::from("Default Model"),
+			id: Uuid::new_v4(),
+			templates: Vec::new(),
+			schema_version: Version::new(0, 1, 0),
+			defaults: None,
+			css: String::new(),
+			fields: Vec::new(),
+			latex_pre: None,
+			latex_post: None,
+			sort_field: None,
+			tags: None,
+			required: evalexpr::build_operator_tree("true").unwrap(),
+		}
+	}
+}
+
+impl Default for Model<Partial> {
+	fn default() -> Self {
+		Self {
+			name: Some(String::from("Default Model")),
+			id: Uuid::new_v4(),
+			templates: Vec::new(),
+			schema_version: Version::new(0, 1, 0),
+			defaults: None,
+			css: String::new(),
+			fields: Vec::new(),
+			latex_pre: None,
+			latex_post: None,
+			sort_field: None,
+			tags: None,
+			required: evalexpr::build_operator_tree("true").unwrap(),
+		}
+	}
+}
diff --git a/src/note/model/mod.rs b/src/deck/model/template.rs
similarity index 80%
rename from src/note/model/mod.rs
rename to src/deck/model/template.rs
index af99b52..d6c0faa 100644
--- a/src/note/model/mod.rs
+++ b/src/deck/model/template.rs
@@ -1,5 +1,3 @@
-pub mod completion;
-
 use serde::Deserialize;
 
 #[derive(Deserialize, Ord, PartialOrd, Eq, Hash, Clone, PartialEq, Debug)]
@@ -12,17 +10,17 @@ pub struct Template {
 	#[serde(skip)]
 	pub question_format: String,
 	#[serde(skip)]
-	pub answer_format:   String,
+	pub answer_format: String,
 
 	#[serde(skip)]
 	pub browser_question_format: String,
 	#[serde(skip)]
-	pub browser_answer_format:   String,
+	pub browser_answer_format: String,
 }
 
 #[derive(Deserialize, PartialOrd, Ord, Eq, Hash, Clone, PartialEq, Debug)]
 pub struct Defaults {
 	pub font: String,
 	pub size: u32,
-	pub rtl:  bool,
+	pub rtl: bool,
 }
diff --git a/src/deck/note/cloze.rs b/src/deck/note/cloze.rs
new file mode 100644
index 0000000..cdfc30d
--- /dev/null
+++ b/src/deck/note/cloze.rs
@@ -0,0 +1,116 @@
+type Djot<'content> = Vec<jotdown::Event<'content>>;
+
+/// Extract plain text from a Djot event stream
+pub fn djot_to_string(events: &[jotdown::Event<'_>]) -> String {
+	let mut s = String::new();
+	for event in events {
+		if let jotdown::Event::Str(text) = event {
+			s.push_str(text);
+		}
+	}
+	s
+}
+
+#[derive(Debug, Eq, Clone, PartialEq)]
+pub struct Cloze<'content> {
+	pub id: u32,
+	pub answer: Djot<'content>,
+	pub hint: Option<String>,
+}
+
+impl Ord for Cloze<'_> {
+	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+		self.id.cmp(&other.id)
+	}
+}
+
+impl PartialOrd for Cloze<'_> {
+	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+/// Scan `raw` for `{Answer|Hint>Id}` clozes, in document order.
+pub fn scan_clozes(raw: &str) -> Vec<Cloze<'_>> {
+	let bytes = raw.as_bytes();
+	let mut clozes = Vec::new();
+	let mut idx = 0;
+	while idx < raw.len() {
+		if bytes[idx] == b'{'
+			&& let Some(parsed) = crate::parse::helpers::cloze::parse(&raw[idx..])
+		{
+			clozes.push(Cloze {
+				id: parsed.id.and_then(|id| id.trim().parse::<u32>().ok()).unwrap_or(0),
+				answer: vec![jotdown::Event::Str(parsed.answer.trim().into())],
+				hint: parsed.hint.map(|hint| hint.trim().to_string()),
+			});
+			idx += parsed.len;
+			continue;
+		}
+		idx += 1;
+	}
+	clozes
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{Cloze, djot_to_string};
+
+	#[test]
+	fn djot_to_string_empty() {
+		assert_eq!(djot_to_string(&[]), "");
+	}
+
+	#[test]
+	fn djot_to_string_single_text() {
+		let events = vec![jotdown::Event::Str(std::borrow::Cow::Borrowed("Hello"))];
+		assert_eq!(djot_to_string(&events), "Hello");
+	}
+
+	#[test]
+	fn djot_to_string_multiple_texts() {
+		let events = vec![
+			jotdown::Event::Str(std::borrow::Cow::Borrowed("Hello ")),
+			jotdown::Event::Str(std::borrow::Cow::Borrowed("World")),
+		];
+		assert_eq!(djot_to_string(&events), "Hello World");
+	}
+
+	#[test]
+	fn djot_to_string_skips_non_str_events() {
+		let events = vec![
+			jotdown::Event::Str(std::borrow::Cow::Borrowed("Hello")),
+			jotdown::Event::Softbreak,
+			jotdown::Event::Str(std::borrow::Cow::Borrowed("World")),
+		];
+		assert_eq!(djot_to_string(&events), "HelloWorld");
+	}
+
+	#[test]
+	fn cloze_cmp_orders_by_id() {
+		let a = Cloze { id: 1, answer: Vec::new(), hint: None };
+		let b = Cloze { id: 2, answer: Vec::new(), hint: None };
+		let c = Cloze { id: 1, answer: Vec::new(), hint: None };
+		assert!(a < b);
+		assert!(b > a);
+		assert_eq!(a, c);
+	}
+
+	#[test]
+	fn cloze_partial_cmp_matches_cmp() {
+		let a = Cloze { id: 1, answer: Vec::new(), hint: None };
+		let b = Cloze { id: 2, answer: Vec::new(), hint: None };
+		assert_eq!(a.partial_cmp(&b), Some(std::cmp::Ordering::Less));
+		assert_eq!(b.partial_cmp(&a), Some(std::cmp::Ordering::Greater));
+		assert_eq!(a.partial_cmp(&a), Some(std::cmp::Ordering::Equal));
+	}
+
+	#[test]
+	fn cloze_ord_consistent_with_partial_ord() {
+		let a = Cloze { id: 3, answer: Vec::new(), hint: None };
+		let b = Cloze { id: 7, answer: Vec::new(), hint: None };
+		assert_eq!(a.cmp(&b), std::cmp::Ordering::Less);
+		assert_eq!(b.cmp(&a), std::cmp::Ordering::Greater);
+		assert_eq!(a.cmp(&a), std::cmp::Ordering::Equal);
+	}
+}
diff --git a/src/note/content.rs b/src/deck/note/content.rs
similarity index 53%
rename from src/note/content.rs
rename to src/deck/note/content.rs
index 2785085..39a7cda 100644
--- a/src/note/content.rs
+++ b/src/deck/note/content.rs
@@ -1,40 +1,35 @@
 use tracing::instrument;
 
-use crate::note::Note;
+use crate::deck::note::Note;
 
 impl<'model> Note<'model> {
-	/// Generate a deterministic string representation of the note's content
-	/// for UUID generation.
-	///
-	/// Each field contributes its name followed by its raw content source, so
-	/// the same deck text always hashes to the same id.
-	#[instrument(skip(self))]
-	pub fn to_content_string(&self) -> String {
-		let mut content = String::new();
-		for field in &self.fields {
-			content.push_str(&field.name);
-			content.push('\0');
-			content.push_str(field.content.raw);
-			content.push('\0');
-		}
-		content
-	}
+    #[instrument(skip(self))]
+    pub fn to_content_string(&self) -> String {
+        let mut content = String::new();
+        for field in &self.fields {
+            content.push_str(&field.name);
+            content.push('\0');
+            content.push_str(field.content);
+            content.push('\0');
+        }
+        content
+    }
 }
 
 #[cfg(test)]
 mod tests {
 	use std::borrow::Cow;
 
-	use crate::note::{FieldContent, Note, NoteField, NoteModel};
+    use crate::deck::{model::Model, note::{Field, Note}};
 
-	fn text_field(name: &str, value: &'static str) -> NoteField<'static> {
-		NoteField { name: name.into(), content: FieldContent::parse(value) }
-	}
+    fn text_field(name: &str, value: &'static str) -> Field<'static> {
+        Field { name: name.into(), content: value }
+    }
 
 	#[test]
 	fn to_content_string_empty_fields() {
 		let note =
-			Note { fields: Vec::new(), model: Cow::Owned(NoteModel::default()), tags: Vec::new() };
+			Note { fields: Vec::new(), model: Cow::Owned(Model::default()), tags: Vec::new() };
 		assert_eq!(note.to_content_string(), "");
 	}
 
@@ -42,7 +37,7 @@ mod tests {
 	fn to_content_string_single_field() {
 		let note = Note {
 			fields: vec![text_field("Front", "Hello World")],
-			model:  Cow::Owned(NoteModel::default()),
+			model:  Cow::Owned(Model::default()),
 			tags:   Vec::new(),
 		};
 		assert_eq!(note.to_content_string(), "Front\0Hello World\0");
@@ -52,7 +47,7 @@ mod tests {
 	fn to_content_string_multiple_fields() {
 		let note = Note {
 			fields: vec![text_field("Front", "Hello"), text_field("Back", "World")],
-			model:  Cow::Owned(NoteModel::default()),
+			model:  Cow::Owned(Model::default()),
 			tags:   Vec::new(),
 		};
 		assert_eq!(note.to_content_string(), "Front\0Hello\0Back\0World\0");
@@ -62,7 +57,7 @@ mod tests {
 	fn to_content_string_with_empty_field_content() {
 		let note = Note {
 			fields: vec![text_field("Front", "")],
-			model:  Cow::Owned(NoteModel::default()),
+			model:  Cow::Owned(Model::default()),
 			tags:   Vec::new(),
 		};
 		assert_eq!(note.to_content_string(), "Front\0\0");
@@ -72,7 +67,7 @@ mod tests {
 	fn to_content_string_includes_cloze_source() {
 		let note = Note {
 			fields: vec![text_field("Text", "Capital of France is {Paris}")],
-			model:  Cow::Owned(NoteModel::default()),
+			model:  Cow::Owned(Model::default()),
 			tags:   Vec::new(),
 		};
 		assert_eq!(note.to_content_string(), "Text\0Capital of France is {Paris}\0");
diff --git a/src/deck/note/field.rs b/src/deck/note/field.rs
new file mode 100644
index 0000000..006db3e
--- /dev/null
+++ b/src/deck/note/field.rs
@@ -0,0 +1,68 @@
+use std::path::PathBuf;
+
+use crate::deck::note::cloze::{self, Cloze, djot_to_string};
+
+#[derive(Debug, PartialOrd, Ord, Default, Eq, Clone, PartialEq)]
+pub struct Field<'content> {
+	pub name: String,
+	pub content: &'content str,
+}
+
+impl<'content> Field<'content> {
+	pub fn parse(name: String, content: &'content str) -> Self {
+		Self { name, content }
+	}
+
+	pub fn events(&self) -> Vec<jotdown::Event<'content>> {
+		jotdown::Parser::new(self.content).collect()
+	}
+
+	pub fn clozes(&self) -> Vec<Cloze<'content>> {
+		cloze::scan_clozes(self.content)
+	}
+
+	pub fn plain_text(&self) -> String {
+		djot_to_string(&self.events())
+	}
+
+	pub fn media_paths(&self) -> Vec<PathBuf> {
+		self
+			.events()
+			.iter()
+			.filter_map(|event| match event {
+				jotdown::Event::Start(jotdown::Container::Image(url, _), _) => {
+					Some(PathBuf::from(url.as_ref()))
+				}
+				_ => None,
+			})
+			.collect()
+	}
+
+	pub fn to_anki_html(&self) -> String {
+		let mut substituted = String::with_capacity(self.content.len());
+		let bytes = self.content.as_bytes();
+		let mut run_start = 0;
+		let mut idx = 0;
+		while idx < self.content.len() {
+			if bytes[idx] == b'{'
+				&& let Some(cloze) = crate::parse::helpers::cloze::parse(&self.content[idx..])
+			{
+				substituted.push_str(&self.content[run_start..idx]);
+				let answer = cloze.answer.trim();
+				let id = cloze.id.and_then(|s| s.trim().parse::<u32>().ok()).unwrap_or(0);
+				match cloze.hint {
+					Some(hint) => {
+						substituted.push_str(&format!("{{{{c{id}::{answer}::{}}}}}", hint.trim()));
+					}
+					None => substituted.push_str(&format!("{{{{c{id}::{answer}}}}}")),
+				}
+				idx += cloze.len;
+				run_start = idx;
+				continue;
+			}
+			idx += 1;
+		}
+		substituted.push_str(&self.content[run_start..]);
+		jotdown::html::render_to_string(jotdown::Parser::new(&substituted))
+	}
+}
diff --git a/src/note/identifiable.rs b/src/deck/note/identifiable.rs
similarity index 90%
rename from src/note/identifiable.rs
rename to src/deck/note/identifiable.rs
index 5bda402..dcda39c 100644
--- a/src/note/identifiable.rs
+++ b/src/deck/note/identifiable.rs
@@ -1,6 +1,6 @@
 use uuid::Uuid;
 
-use crate::note::Identified;
+use crate::deck::note::Identified;
 
 // Extension trait to add .identified() method
 pub trait Identifiable: Sized {
@@ -62,9 +62,9 @@ mod tests {
 	fn identified_for_note() {
 		use std::borrow::Cow;
 
-		use crate::note::{Note, NoteModel};
+		use crate::deck::{model::Model, note::Note};
 		let note =
-			Note { fields: Vec::new(), model: Cow::Owned(NoteModel::default()), tags: Vec::new() };
+			Note { fields: Vec::new(), model: Cow::Owned(Model::default()), tags: Vec::new() };
 		let identified = note.identified(Uuid::from_u128(5));
 		assert_eq!(identified.id, Uuid::from_u128(5));
 	}
diff --git a/src/deck/note_ids.rs b/src/deck/note/ids.rs
similarity index 61%
rename from src/deck/note_ids.rs
rename to src/deck/note/ids.rs
index 4194b91..78b554e 100644
--- a/src/deck/note_ids.rs
+++ b/src/deck/note/ids.rs
@@ -2,12 +2,32 @@ use gix::{Commit, Repository, object::tree::Entry};
 use tracing::debug;
 use uuid::Uuid;
 
-use crate::{deck::{Deck, blob_entry::BEntry, cards}, error::DeckError, note::Note, note_id_generator::{GitNoteIdGenerator, NoteIdGenerator}, uuid_generator::{self, HostUuid}};
+use crate::{
+	deck::{blob_entry::BEntry, uuid_generator::{self, HostUuid}, Deck},
+	deck::model::Model,
+	error::DeckError,
+};
+
+use super::Note;
+
+pub trait NoteIdGenerator {
+	fn generate_note_ids_for_revision(
+		&self,
+		models: &[Model],
+		backing_vcs: &Repository,
+		target: (Entry, Commit),
+	) -> Result<Vec<Uuid>, DeckError>;
+
+	fn generate_note_id_for_added_note(&self, note: &Note) -> Uuid;
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct GitNoteIdGenerator;
 
 impl NoteIdGenerator for GitNoteIdGenerator {
 	fn generate_note_ids_for_revision(
 		&self,
-		models: &[crate::note::NoteModel],
+		models: &[Model],
 		backing_vcs: &Repository,
 		target: (Entry, Commit),
 	) -> Result<Vec<Uuid>, DeckError> {
@@ -20,8 +40,8 @@ impl NoteIdGenerator for GitNoteIdGenerator {
 
 		let file_content = Deck::read_file_content(backing_vcs, &entry)?;
 		let name = entry.entry().filename().to_string();
-		let tree = cards::build_tree(&file_content, &name)?;
-		let notes = cards::query_notes(&tree, models, &name, &file_content)?;
+		let tree = crate::deck::cards::build_tree(&file_content, &name)?;
+		let notes = crate::deck::cards::query_notes(&tree, models, &name, &file_content)?;
 
 		let uuids = notes
 			.iter()
diff --git a/src/deck/note/mod.rs b/src/deck/note/mod.rs
new file mode 100644
index 0000000..d865d2c
--- /dev/null
+++ b/src/deck/note/mod.rs
@@ -0,0 +1,30 @@
+pub mod cloze;
+pub mod content;
+pub mod field;
+pub mod identifiable;
+pub mod ids;
+
+pub use self::cloze::{Cloze, djot_to_string};
+pub use self::field::Field;
+
+use std::borrow::Cow;
+
+use uuid::Uuid;
+
+use crate::deck::model::Model;
+use crate::deck::note::identifiable::Identifiable;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Identified<T> {
+	pub id: Uuid,
+	pub inner: T,
+}
+
+#[derive(Debug, PartialOrd, Ord, Clone, Eq, PartialEq)]
+pub struct Note<'model> {
+	pub fields: Vec<Field<'model>>,
+	pub model: Cow<'model, Model>,
+	pub tags: Vec<String>,
+}
+
+impl Identifiable for Note<'_> {}
diff --git a/src/uuid_generator.rs b/src/deck/uuid_generator.rs
similarity index 100%
rename from src/uuid_generator.rs
rename to src/deck/uuid_generator.rs
diff --git a/src/deck/history.rs b/src/history/interface.rs
similarity index 95%
rename from src/deck/history.rs
rename to src/history/interface.rs
index 5a458b6..302f7a2 100644
--- a/src/deck/history.rs
+++ b/src/history/interface.rs
@@ -2,7 +2,7 @@ use gix::{Commit, Repository, object::tree::Entry};
 use tracing::{error, info};
 use uuid::Uuid;
 
-use crate::{error::DeckError, uuid_generator};
+use crate::{deck::uuid_generator, error::DeckError};
 
 fn file_changed_since_parent<'repo>(
 	vcs: &'repo Repository,
@@ -71,7 +71,7 @@ pub fn get<'repo>(
 	}
 }
 
-pub(crate) fn derive_core_id(vcs: &Repository) -> Result<Uuid, DeckError> {
+pub fn derive_core_id(vcs: &Repository) -> Result<Uuid, DeckError> {
 	let head_id = vcs.head_id().unwrap();
 	let walk = vcs.rev_walk([head_id]).all()?;
 
diff --git a/src/history/mod.rs b/src/history/mod.rs
new file mode 100644
index 0000000..630c6bd
--- /dev/null
+++ b/src/history/mod.rs
@@ -0,0 +1,7 @@
+pub mod interface;
+pub mod resolver;
+pub mod router;
+
+pub use self::interface::{derive_core_id, get};
+pub use self::resolver::resolve_changes;
+pub use self::router::{determine_changes, ChangeRouter, Transforms};
diff --git a/src/change_resolver.rs b/src/history/resolver.rs
similarity index 90%
rename from src/change_resolver.rs
rename to src/history/resolver.rs
index 514321a..0dd48da 100644
--- a/src/change_resolver.rs
+++ b/src/history/resolver.rs
@@ -7,7 +7,11 @@
 //! user doesn't attempt more than one change operation at a time (Following
 //! typical Git commit standards)
 
-use crate::{change_router::Transforms::{self, Additions, Deletions, Modifications, Reorders}, note::{Identified, Note}, note_id_generator::NoteIdGenerator};
+use crate::{
+	deck::note::ids::NoteIdGenerator,
+	deck::note::{Identified, Note},
+	history::router::Transforms::{self, Additions, Deletions, Modifications, Reorders},
+};
 
 /// This function takes a set of transformations, in order from earliest to
 /// latest, and applies them to the original notes within a deck. It is tracking
@@ -64,16 +68,21 @@ mod tests {
 	use uuid::Uuid;
 
 	use super::resolve_changes;
-	use crate::{change_router::Transforms, note::{FieldContent, Identified, Note, NoteField, NoteModel}, note_id_generator::GitNoteIdGenerator};
+	use crate::{
+		deck::{model::Model, note::{Field, Identified, Note}},
+		history::router::Transforms,
+	};
 
-	fn text_field(name: &str, value: &'static str) -> NoteField<'static> {
-		NoteField { name: name.into(), content: FieldContent::parse(value) }
+	use crate::deck::note::ids::GitNoteIdGenerator;
+
+	fn text_field(name: &str, value: &'static str) -> Field<'static> {
+		Field { name: name.into(), content: value }
 	}
 
 	fn make_note(front: &'static str, back: &'static str) -> Note<'static> {
 		Note {
 			fields: vec![text_field("Front", front), text_field("Back", back)],
-			model:  Cow::Owned(NoteModel::default()),
+			model:  Cow::Owned(Model::default()),
 			tags:   Vec::new(),
 		}
 	}
@@ -134,7 +143,7 @@ mod tests {
 		assert_eq!(cards.len(), 1);
 		assert_eq!(cards[0].id, Uuid::from_u128(42));
 		// The slot now points at the modified note, but keeps the original id.
-		assert_eq!(cards[0].inner.fields[0].content.raw, "Q1_changed");
+		assert_eq!(cards[0].inner.fields[0].content, "Q1_changed");
 	}
 
 	#[test]
diff --git a/src/change_router.rs b/src/history/router.rs
similarity index 97%
rename from src/change_router.rs
rename to src/history/router.rs
index 9b7395c..b0181ba 100644
--- a/src/change_router.rs
+++ b/src/history/router.rs
@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 
-use crate::{error::DeckError, note::Note};
+use crate::{deck::note::Note, error::DeckError};
 
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub enum Transforms<'borrow, 'content> {
@@ -174,14 +174,14 @@ mod tests {
 	use uuid::Uuid;
 
 	use super::determine_changes;
-	use crate::note::{FieldContent, Note, NoteField, NoteModel};
+	use crate::deck::{model::Model, note::{Field, Note}};
 
 	fn note<'a>(front: &'a str, back: &'a str) -> Note<'a> {
-		let model = NoteModel { id: Uuid::nil(), ..Default::default() };
+		let model = Model { id: Uuid::nil(), ..Default::default() };
 		Note {
 			fields: vec![
-				NoteField { name: "Front".into(), content: FieldContent::parse(front) },
-				NoteField { name: "Back".into(), content: FieldContent::parse(back) },
+				Field { name: "Front".into(), content: front },
+				Field { name: "Back".into(), content: back },
 			],
 			model:  Cow::Owned(model),
 			tags:   Vec::new(),
diff --git a/src/lib.rs b/src/lib.rs
index 81e9ddd..3bf752a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,16 +3,9 @@
 // Large error variants are accepted here; boxing them would add complexity.
 #![allow(clippy::result_large_err)]
 
-pub mod change_resolver;
-pub mod change_router;
 pub mod config;
 pub mod deck;
-pub mod deck_locator;
 pub mod error;
-pub mod model_catalog;
-pub mod model_loader;
-pub mod note;
-pub mod note_id_generator;
+pub mod history;
 pub mod parse;
 pub mod sync;
-pub mod uuid_generator;
diff --git a/src/note/definition.rs b/src/note/definition.rs
deleted file mode 100644
index c06d9a8..0000000
--- a/src/note/definition.rs
+++ /dev/null
@@ -1,314 +0,0 @@
-use std::{borrow::Cow, fmt::Debug, hash::Hash, path::PathBuf};
-
-use evalexpr::Node;
-use semver::Version;
-use serde::Deserialize;
-use uuid::Uuid;
-
-use crate::note::{identifiable::Identifiable, model::{Defaults, Template}};
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct Identified<T> {
-	pub id:    Uuid,
-	pub inner: T,
-}
-
-#[derive(Debug, PartialOrd, Ord, Clone, Eq, PartialEq)]
-pub struct Note<'model> {
-	pub fields: Vec<NoteField<'model>>,
-	pub model:  Cow<'model, NoteModel>,
-	pub tags:   Vec<String>,
-}
-
-impl Identifiable for Note<'_> {}
-
-#[derive(Debug, PartialOrd, Ord, Default, Eq, Clone, PartialEq)]
-pub struct NoteField<'content> {
-	pub name:    String,
-	pub content: FieldContent<'content>,
-}
-
-pub trait ModelStage: Default + Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash {
-	type Name: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
-	type Css: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
-	type Templates: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
-	type Latex: Clone + Debug + PartialEq + Eq + PartialOrd + Ord + Hash + Default;
-}
-
-#[derive(Default, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Partial;
-
-#[derive(Default, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Complete;
-
-impl ModelStage for Partial {
-	type Css = String;
-	type Latex = Option<String>;
-	type Name = Option<String>;
-	type Templates = Vec<Template>;
-}
-
-impl ModelStage for Complete {
-	type Css = String;
-	type Latex = Option<String>;
-	type Name = String;
-	type Templates = Vec<Template>;
-}
-
-#[derive(Debug, Eq, PartialOrd, Ord, Hash, Deserialize, Clone, PartialEq)]
-#[serde(
-	bound = "Stage::Name: Deserialize<'de>, Stage::Templates: Deserialize<'de>, Stage::Css: Deserialize<'de>, Stage::Latex: Deserialize<'de>"
-)]
-pub struct NoteModel<Stage: ModelStage = Complete> {
-	#[serde(skip)]
-	pub name: Stage::Name,
-
-	pub id: Uuid,
-
-	pub templates: Stage::Templates,
-
-	pub schema_version: Version,
-
-	pub defaults: Option<Defaults>,
-
-	#[serde(skip)]
-	pub css: Stage::Css,
-
-	pub fields: Vec<Field>,
-
-	#[serde(skip)]
-	pub latex_pre:  Stage::Latex,
-	#[serde(skip)]
-	pub latex_post: Stage::Latex,
-
-	pub sort_field: Option<String>,
-	pub tags:       Option<Vec<String>>,
-
-	pub required: Node,
-}
-
-impl Default for NoteModel<Complete> {
-	fn default() -> Self {
-		Self {
-			name:           String::from("Default Model"),
-			id:             Uuid::new_v4(),
-			templates:      Vec::new(),
-			schema_version: Version::new(0, 1, 0),
-			defaults:       None,
-			css:            String::new(),
-			fields:         Vec::new(),
-			latex_pre:      None,
-			latex_post:     None,
-			sort_field:     None,
-			tags:           None,
-			required:       evalexpr::build_operator_tree("true").unwrap(),
-		}
-	}
-}
-
-impl Default for NoteModel<Partial> {
-	fn default() -> Self {
-		Self {
-			name:           Some(String::from("Default Model")),
-			id:             Uuid::new_v4(),
-			templates:      Vec::new(),
-			schema_version: Version::new(0, 1, 0),
-			defaults:       None,
-			css:            String::new(),
-			fields:         Vec::new(),
-			latex_pre:      None,
-			latex_post:     None,
-			sort_field:     None,
-			tags:           None,
-			required:       evalexpr::build_operator_tree("true").unwrap(),
-		}
-	}
-}
-
-type Djot<'content> = Vec<jotdown::Event<'content>>;
-
-/// Extract plain text from a Djot event stream
-pub fn djot_to_string(events: &[jotdown::Event<'_>]) -> String {
-	let mut s = String::new();
-	for event in events {
-		if let jotdown::Event::Str(text) = event {
-			s.push_str(text);
-		}
-	}
-	s
-}
-
-#[derive(Debug, Eq, Clone, PartialEq)]
-pub struct Cloze<'content> {
-	pub id:     u32,
-	pub answer: Djot<'content>,
-	pub hint:   Option<String>,
-}
-
-impl Ord for Cloze<'_> {
-	fn cmp(&self, other: &Self) -> std::cmp::Ordering { self.id.cmp(&other.id) }
-}
-
-impl PartialOrd for Cloze<'_> {
-	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> { Some(self.cmp(other)) }
-}
-
-/// The body of a single field.
-///
-/// Field content is djot, borrowed directly from the concrete syntax tree.
-/// The text in [`raw`](FieldContent::raw) is the only state. The djot events,
-/// clozes, plain_text, and media_paths are all derived on demand.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Default)]
-pub struct FieldContent<'content> {
-	/// The trimmed content source, borrowed from the tree's content token.
-	pub raw: &'content str,
-}
-
-impl<'content> FieldContent<'content> {
-	/// Build a field body from its (already trimmed) source slice.
-	pub fn parse(raw: &'content str) -> Self { Self { raw } }
-
-	/// Parsed djot events over [`raw`](FieldContent::raw).
-	pub fn events(&self) -> Vec<jotdown::Event<'content>> { jotdown::Parser::new(self.raw).collect() }
-
-	/// Clozes parsed out of [`raw`](FieldContent::raw), in document order.
-	pub fn clozes(&self) -> Vec<Cloze<'content>> { scan_clozes(self.raw) }
-
-	/// Plain text of the content (djot markup and clozes flattened away).
-	pub fn plain_text(&self) -> String { djot_to_string(&self.events()) }
-
-	/// Every media path referenced by a djot image in this field.
-	pub fn media_paths(&self) -> Vec<PathBuf> {
-		self
-			.events()
-			.iter()
-			.filter_map(|event| match event {
-				jotdown::Event::Start(jotdown::Container::Image(url, _), _) => {
-					Some(PathBuf::from(url.as_ref()))
-				}
-				_ => None,
-			})
-			.collect()
-	}
-
-	/// Render the field to Anki-flavoured HTML.
-	pub fn to_anki_html(&self) -> String {
-		let mut substituted = String::with_capacity(self.raw.len());
-		let bytes = self.raw.as_bytes();
-		let mut run_start = 0;
-		let mut idx = 0;
-		while idx < self.raw.len() {
-			if bytes[idx] == b'{'
-				&& let Some(cloze) = crate::parse::helpers::cloze::parse(&self.raw[idx..])
-			{
-				substituted.push_str(&self.raw[run_start..idx]);
-				let answer = cloze.answer.trim();
-				let id = cloze.id.and_then(|s| s.trim().parse::<u32>().ok()).unwrap_or(0);
-				match cloze.hint {
-					Some(hint) => {
-						substituted.push_str(&format!("{{{{c{id}::{answer}::{}}}}}", hint.trim()));
-					}
-					None => substituted.push_str(&format!("{{{{c{id}::{answer}}}}}")),
-				}
-				idx += cloze.len;
-				run_start = idx;
-				continue;
-			}
-			idx += 1;
-		}
-		substituted.push_str(&self.raw[run_start..]);
-		jotdown::html::render_to_string(jotdown::Parser::new(&substituted))
-	}
-}
-
-/// Scan `raw` for `{Answer|Hint>Id}` clozes, in document order.
-fn scan_clozes(raw: &str) -> Vec<Cloze<'_>> {
-	let bytes = raw.as_bytes();
-	let mut clozes = Vec::new();
-	let mut idx = 0;
-	while idx < raw.len() {
-		if bytes[idx] == b'{'
-			&& let Some(parsed) = crate::parse::helpers::cloze::parse(&raw[idx..])
-		{
-			clozes.push(Cloze {
-				id:     parsed.id.and_then(|id| id.trim().parse::<u32>().ok()).unwrap_or(0),
-				answer: vec![jotdown::Event::Str(parsed.answer.trim().into())],
-				hint:   parsed.hint.map(|hint| hint.trim().to_string()),
-			});
-			idx += parsed.len;
-			continue;
-		}
-		idx += 1;
-	}
-	clozes
-}
-
-#[derive(Deserialize, Ord, PartialOrd, Eq, Hash, Clone, PartialEq, Debug)]
-pub struct Field {
-	pub name:             String,
-	pub sticky:           Option<bool>,
-	pub associated_media: Option<Vec<PathBuf>>,
-}
-
-#[cfg(test)]
-mod tests {
-	use super::{Cloze, djot_to_string};
-
-	#[test]
-	fn djot_to_string_empty() {
-		assert_eq!(djot_to_string(&[]), "");
-	}
-
-	#[test]
-	fn djot_to_string_single_text() {
-		let events = vec![jotdown::Event::Str(std::borrow::Cow::Borrowed("Hello"))];
-		assert_eq!(djot_to_string(&events), "Hello");
-	}
-
-	#[test]
-	fn djot_to_string_multiple_texts() {
-		let events = vec![
-			jotdown::Event::Str(std::borrow::Cow::Borrowed("Hello ")),
-			jotdown::Event::Str(std::borrow::Cow::Borrowed("World")),
-		];
-		assert_eq!(djot_to_string(&events), "Hello World");
-	}
-
-	#[test]
-	fn djot_to_string_skips_non_str_events() {
-		let events = vec![
-			jotdown::Event::Str(std::borrow::Cow::Borrowed("Hello")),
-			jotdown::Event::Softbreak,
-			jotdown::Event::Str(std::borrow::Cow::Borrowed("World")),
-		];
-		assert_eq!(djot_to_string(&events), "HelloWorld");
-	}
-
-	#[test]
-	fn cloze_cmp_orders_by_id() {
-		let a = Cloze { id: 1, answer: Vec::new(), hint: None };
-		let b = Cloze { id: 2, answer: Vec::new(), hint: None };
-		let c = Cloze { id: 1, answer: Vec::new(), hint: None };
-		assert!(a < b);
-		assert!(b > a);
-		assert_eq!(a, c);
-	}
-
-	#[test]
-	fn cloze_partial_cmp_matches_cmp() {
-		let a = Cloze { id: 1, answer: Vec::new(), hint: None };
-		let b = Cloze { id: 2, answer: Vec::new(), hint: None };
-		assert_eq!(a.partial_cmp(&b), Some(std::cmp::Ordering::Less));
-		assert_eq!(b.partial_cmp(&a), Some(std::cmp::Ordering::Greater));
-		assert_eq!(a.partial_cmp(&a), Some(std::cmp::Ordering::Equal));
-	}
-
-	#[test]
-	fn cloze_ord_consistent_with_partial_ord() {
-		let a = Cloze { id: 3, answer: Vec::new(), hint: None };
-		let b = Cloze { id: 7, answer: Vec::new(), hint: None };
-		assert_eq!(a.cmp(&b), std::cmp::Ordering::Less);
-		assert_eq!(b.cmp(&a), std::cmp::Ordering::Greater);
-		assert_eq!(a.cmp(&a), std::cmp::Ordering::Equal);
-	}
-}
diff --git a/src/note/mod.rs b/src/note/mod.rs
deleted file mode 100644
index 5dc26f4..0000000
--- a/src/note/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub mod content;
-pub mod definition;
-pub mod identifiable;
-pub mod model;
-
-pub use self::definition::*;
diff --git a/src/note_id_generator.rs b/src/note_id_generator.rs
deleted file mode 100644
index 7b94312..0000000
--- a/src/note_id_generator.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use gix::{Commit, Repository, object::tree::Entry};
-use uuid::Uuid;
-
-use crate::{error::DeckError, note::{Note, NoteModel}};
-
-pub trait NoteIdGenerator {
-	fn generate_note_ids_for_revision(
-		&self,
-		models: &[NoteModel],
-		backing_vcs: &Repository,
-		target: (Entry, Commit),
-	) -> Result<Vec<Uuid>, DeckError>;
-
-	fn generate_note_id_for_added_note(&self, note: &Note) -> Uuid;
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-pub struct GitNoteIdGenerator;
diff --git a/src/parse/construct/build.rs b/src/parse/construct/build.rs
index 2b9c81f..255016c 100644
--- a/src/parse/construct/build.rs
+++ b/src/parse/construct/build.rs
@@ -3,12 +3,12 @@ use std::collections::{HashMap, HashSet};
 use evalexpr::{ContextWithMutableVariables, DefaultNumericTypes, HashMapContext, Value};
 
 use super::group::RawNote;
-use crate::note::{FieldContent, Note, NoteField, NoteModel};
+use crate::deck::{model::Model, note::{Field, Note}};
 use crate::parse::helpers::diagnostic::Diagnostic;
 
 pub fn build_note<'a>(
 	raw: RawNote<'a>,
-	model: &'a NoteModel,
+	model: &'a Model,
 	resolve: &impl Fn(&str) -> String,
 	base: &HashMapContext<DefaultNumericTypes>,
 	diagnostics: &mut Vec<Diagnostic>,
@@ -27,28 +27,28 @@ pub fn build_note<'a>(
 
 fn resolve_fields<'a>(
 	raw: &RawNote<'a>,
-	model: &'a NoteModel,
+	model: &'a Model,
 	resolve: &impl Fn(&str) -> String,
 	base: &HashMapContext<DefaultNumericTypes>,
 	diagnostics: &mut Vec<Diagnostic>,
-) -> (HashMapContext<DefaultNumericTypes>, HashMap<String, FieldContent<'a>>, bool) {
+) -> (HashMapContext<DefaultNumericTypes>, HashMap<String, &'a str>, bool) {
 	let valid_model_fields: HashSet<&str> = model.fields.iter().map(|f| f.name.as_str()).collect();
 
 	let mut context = base.clone();
 	let mut provided_fields = HashMap::new();
 	let mut has_unknown = false;
 
-	for (raw_name, content) in &raw.fields {
-		let resolved_name = resolve(raw_name);
+	for field in &raw.fields {
+		let resolved_name = resolve(&field.name);
 
 		context.set_value(resolved_name.clone(), Value::from(true)).ok();
 
 		if valid_model_fields.contains(resolved_name.as_str()) {
-			provided_fields.insert(resolved_name, *content);
+            provided_fields.insert(resolved_name, field.content);
 		} else {
 			has_unknown = true;
 			let known = model.fields.iter().map(|f| f.name.as_str()).collect::<Vec<_>>().join(", ");
-			diagnostics.push(Diagnostic::unknown_field(raw.span.clone(), raw_name, &model.name, &known));
+            diagnostics.push(Diagnostic::unknown_field(raw.span.clone(), &field.name, &model.name, &known));
 		}
 	}
 
@@ -57,9 +57,9 @@ fn resolve_fields<'a>(
 
 fn check_requirements(
 	span: &std::ops::Range<usize>,
-	model: &NoteModel,
+	model: &Model,
 	context: &HashMapContext<DefaultNumericTypes>,
-	provided_fields: &HashMap<String, FieldContent<'_>>,
+	provided_fields: &HashMap<String, &'_ str>,
 	diagnostics: &mut Vec<Diagnostic>,
 ) {
 	if model.required.eval_with_context(context) == Ok(Value::from(true)) {
@@ -87,16 +87,16 @@ fn check_requirements(
 }
 
 fn assemble_note<'a>(
-	model: &'a NoteModel,
-	mut provided_fields: HashMap<String, FieldContent<'a>>,
+	model: &'a Model,
+	mut provided_fields: HashMap<String, &'a str>,
 	tags: Vec<String>,
 ) -> Note<'a> {
-	let fields: Vec<NoteField> = model
+	let fields: Vec<Field<'a>> = model
 		.fields
 		.iter()
-		.map(|model_field| NoteField {
+		.map(|model_field| Field {
 			name:    model_field.name.clone(),
-			content: provided_fields.remove(&model_field.name).unwrap_or_default(),
+            content: provided_fields.remove(&model_field.name).unwrap_or(""),
 		})
 		.collect();
 
diff --git a/src/parse/construct/group.rs b/src/parse/construct/group.rs
index fae4339..0c2e15c 100644
--- a/src/parse/construct/group.rs
+++ b/src/parse/construct/group.rs
@@ -1,14 +1,14 @@
 use std::collections::HashSet;
 
 use super::parse;
-use crate::note::{FieldContent, NoteModel};
+use crate::deck::{model::Model, note::Field};
 use crate::parse::helpers::diagnostic::Diagnostic;
 use crate::parse::syntax::{FlashSyntaxNode, SyntaxKind, span};
 
 #[derive(Default)]
 pub struct RawNote<'a> {
 	pub tags:   Vec<String>,
-	pub fields: Vec<(String, FieldContent<'a>)>,
+	pub fields: Vec<Field<'a>>,
 	pub span:   std::ops::Range<usize>,
 }
 
@@ -19,7 +19,7 @@ pub struct RawNote<'a> {
 /// are skipped.
 pub fn group_notes<'a>(
 	section: &'a FlashSyntaxNode,
-	model: &'a NoteModel,
+	model: &'a Model,
 	resolve: &impl Fn(&str) -> String,
 	diagnostics: &mut Vec<Diagnostic>,
 ) -> Vec<RawNote<'a>> {
@@ -69,8 +69,8 @@ fn handle_field<'a>(
 	// Safety: child shares the same green tree as the section passed to
 	// group_notes, so its token text is valid for the 'a lifetime.
 	let child_ref: &'a FlashSyntaxNode = unsafe { &*(child as *const FlashSyntaxNode) };
-	let (name, content) = parse::parse_field(child_ref);
-	let resolved = resolve(&name);
+	let field = parse::parse_field(child_ref);
+	let resolved = resolve(&field.name);
 	let field_span = span(child_ref);
 
 	let is_new = seen_fields.insert(resolved.clone());
@@ -78,7 +78,7 @@ fn handle_field<'a>(
 
 	if !is_new && !is_required {
 		let note_span = active_note.as_ref().map_or_else(|| field_span.clone(), |n| n.span.clone());
-		diagnostics.push(Diagnostic::duplicate_field(&name, note_span, field_span.clone()));
+		diagnostics.push(Diagnostic::duplicate_field(&field.name, note_span, field_span.clone()));
 		return;
 	}
 
@@ -91,5 +91,5 @@ fn handle_field<'a>(
 	let note =
 		active_note.get_or_insert_with(|| RawNote { span: field_span.clone(), ..RawNote::default() });
 	note.span.end = field_span.end;
-	note.fields.push((name, content));
+	note.fields.push(field);
 }
diff --git a/src/parse/construct/mod.rs b/src/parse/construct/mod.rs
index 1fd1670..7a72b3d 100644
--- a/src/parse/construct/mod.rs
+++ b/src/parse/construct/mod.rs
@@ -1,7 +1,7 @@
 use evalexpr::{ContextWithMutableVariables, DefaultNumericTypes, HashMapContext};
 
 use self::{build::build_note, group::group_notes, model::{build_alias_map, section_model}, prefix::compute_unique_prefix};
-use crate::note::{Note, NoteModel};
+use crate::deck::{model::Model, note::Note};
 use crate::parse::helpers::diagnostic::Diagnostic;
 use crate::parse::syntax::{FlashSyntaxNode, SyntaxKind, children};
 
@@ -14,7 +14,7 @@ mod prefix;
 /// Walk every section of `tree`, producing notes and any semantic diagnostics.
 pub fn notes<'a>(
 	tree: &'a FlashSyntaxNode,
-	models: &'a [NoteModel],
+	models: &'a [Model],
 ) -> (Vec<Note<'a>>, Vec<Diagnostic>) {
 	let mut notes = Vec::new();
 	let mut diagnostics = Vec::new();
@@ -29,7 +29,7 @@ pub fn notes<'a>(
 
 fn process_section<'a>(
 	section: &'a FlashSyntaxNode,
-	models: &'a [NoteModel],
+	models: &'a [Model],
 	notes: &mut Vec<Note<'a>>,
 	diagnostics: &mut Vec<Diagnostic>,
 ) {
diff --git a/src/parse/construct/model.rs b/src/parse/construct/model.rs
index 85870c5..f44bc03 100644
--- a/src/parse/construct/model.rs
+++ b/src/parse/construct/model.rs
@@ -1,15 +1,15 @@
 use std::collections::HashMap;
 
 use super::parse;
-use crate::note::NoteModel;
+use crate::deck::model::Model;
 use crate::parse::helpers::diagnostic::Diagnostic;
 use crate::parse::syntax::{FlashSyntaxNode, SyntaxKind, child, children, node_text, span};
 
 pub fn section_model<'a>(
 	section: &'a FlashSyntaxNode,
-	models: &'a [NoteModel],
+	models: &'a [Model],
 	diagnostics: &mut Vec<Diagnostic>,
-) -> Option<&'a NoteModel> {
+) -> Option<&'a Model> {
 	let header = child(section, SyntaxKind::SectionHeader)?;
 	let header_text = node_text(&header);
 	let name = header_text.trim().trim_matches(['/', '=']).trim();
diff --git a/src/parse/construct/parse.rs b/src/parse/construct/parse.rs
index 525361e..85bd302 100644
--- a/src/parse/construct/parse.rs
+++ b/src/parse/construct/parse.rs
@@ -1,17 +1,17 @@
-use crate::note::FieldContent;
+use crate::deck::note::Field;
 use crate::parse::syntax::{FlashSyntaxNode, SyntaxKind, child, child_token_text, children, direct_tokens, node_text};
 
-pub fn parse_field<'a>(field_node: &'a FlashSyntaxNode) -> (String, FieldContent<'a>) {
+pub fn parse_field<'a>(field_node: &'a FlashSyntaxNode) -> Field<'a> {
 	let name = child(field_node, SyntaxKind::FieldHeader)
 		.and_then(|header| child(&header, SyntaxKind::FieldName))
 		.map(|field_name| node_text(&field_name).trim().to_string())
 		.unwrap_or_default();
 
 	let content = child_token_text(field_node, SyntaxKind::Content)
-		.map(|raw| FieldContent::parse(raw.trim()))
-		.unwrap_or_default();
+		.map(|raw| raw.trim())
+		.unwrap_or("");
 
-	(name, content)
+	Field { name, content }
 }
 
 pub fn parse_tags(tags_node: &FlashSyntaxNode) -> Vec<String> {
diff --git a/src/parse/construct/prefix.rs b/src/parse/construct/prefix.rs
index 68820e8..f62a4e2 100644
--- a/src/parse/construct/prefix.rs
+++ b/src/parse/construct/prefix.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::note::Field;
+use crate::deck::model::Field;
 
 pub fn compute_unique_prefix(sorted_fields: &[Field]) -> HashMap<String, String> {
 	let mut map = HashMap::with_capacity(sorted_fields.len());
diff --git a/src/parse/syntax.rs b/src/parse/syntax.rs
index 3557352..2003f7f 100644
--- a/src/parse/syntax.rs
+++ b/src/parse/syntax.rs
@@ -8,7 +8,7 @@ use core::ops::{Deref, DerefMut};
 
 use biome_rowan::{AstNode, Language, ParsedChildren, RawSyntaxKind, RawSyntaxNode, SyntaxFactory, SyntaxKindSet, SyntaxNode, TreeBuilder};
 
-use crate::note::Note;
+use crate::deck::note::Note;
 
 /// Every token and node kind in the flash grammar.
 ///
@@ -208,7 +208,7 @@ impl<'a> FlashTreeBuilder<'a> {
 		}
 
 		for field in &note.fields {
-			self.field(&field.name, field.content.raw);
+			self.field(&field.name, field.content);
 			self.part(SyntaxKind::Newline);
 		}
 	}
diff --git a/src/parse/tests.rs b/src/parse/tests.rs
index 5097753..0c6dd97 100644
--- a/src/parse/tests.rs
+++ b/src/parse/tests.rs
@@ -2,10 +2,13 @@ use semver::Version;
 use uuid::Uuid;
 
 use super::{Diagnostic, FlashSyntaxNode, Severity, construct, parse_tree};
-use crate::note::{Field, Note, NoteModel};
+use crate::deck::{
+	model::{Field as SchemaField, Model},
+	note::Note,
+};
 
-fn mock_model() -> NoteModel {
-	NoteModel {
+fn mock_model() -> Model {
+	Model {
 		name:           "Basic".to_string(),
 		id:             Uuid::new_v4(),
 		templates:      vec![],
@@ -13,8 +16,8 @@ fn mock_model() -> NoteModel {
 		defaults:       None,
 		css:            String::new(),
 		fields:         vec![
-			Field { name: "Front".into(), sticky: None, associated_media: None },
-			Field { name: "Back".into(), sticky: None, associated_media: None },
+			SchemaField { name: "Front".into(), sticky: None, associated_media: None },
+			SchemaField { name: "Back".into(), sticky: None, associated_media: None },
 		],
 		latex_pre:      None,
 		latex_post:     None,
@@ -26,7 +29,7 @@ fn mock_model() -> NoteModel {
 
 fn with_notes<R>(
 	input: &str,
-	models: &[NoteModel],
+	models: &[Model],
 	f: impl FnOnce(Result<Vec<Note<'_>>, Vec<Diagnostic>>) -> R,
 ) -> R {
 	let (tree, mut diagnostics): (FlashSyntaxNode, Vec<Diagnostic>) = parse_tree(input);
@@ -40,7 +43,7 @@ fn with_notes<R>(
 	f(result)
 }
 
-fn first_field_text(notes: &[Note<'_>]) -> String { notes[0].fields[0].content.plain_text() }
+fn first_field_text(notes: &[Note<'_>]) -> String { notes[0].fields[0].plain_text() }
 
 #[test]
 fn parse_single_note() {
@@ -73,10 +76,10 @@ fn parse_multiline_field_form() {
 	with_notes(input, &models, |result| {
 		let notes = result.expect("should parse the multi-line field form");
 		assert_eq!(notes.len(), 1);
-		let front = notes[0].fields[0].content.plain_text();
+		let front = notes[0].fields[0].plain_text();
 		assert!(front.contains("Hello"));
 		assert!(front.contains("still front"));
-		assert!(notes[0].fields[1].content.plain_text().contains("World"));
+		assert!(notes[0].fields[1].plain_text().contains("World"));
 	});
 }
 
@@ -87,8 +90,8 @@ fn parse_paren_only_header_then_content() {
 	with_notes(input, &models, |result| {
 		let notes = result.expect("should parse `(Front)\\nHello` form");
 		assert_eq!(notes.len(), 1);
-		assert!(notes[0].fields[0].content.plain_text().contains("Hello"));
-		assert!(notes[0].fields[1].content.plain_text().contains("World"));
+		assert!(notes[0].fields[0].plain_text().contains("Hello"));
+		assert!(notes[0].fields[1].plain_text().contains("World"));
 	});
 }
 
@@ -141,8 +144,8 @@ fn parse_alias_and_multiple_notes() {
 		let notes = result.expect("should parse aliases + notes");
 		assert_eq!(notes.len(), 2);
 		assert_eq!(notes[0].fields[0].name, "Front");
-		assert!(notes[0].fields[0].content.plain_text().contains("What is Rust?"));
-		assert!(notes[1].fields[0].content.plain_text().contains("Is it fast?"));
+		assert!(notes[0].fields[0].plain_text().contains("What is Rust?"));
+		assert!(notes[1].fields[0].plain_text().contains("Is it fast?"));
 	});
 }
 
@@ -153,7 +156,7 @@ fn parse_with_cloze() {
 	with_notes(input, &models, |result| {
 		let notes = result.expect("should parse a cloze");
 		assert_eq!(notes.len(), 1);
-		let clozes = notes[0].fields[0].content.clozes();
+		let clozes = notes[0].fields[0].clozes();
 		assert_eq!(clozes.len(), 1);
 		assert_eq!(clozes[0].id, 1);
 		assert_eq!(clozes[0].hint.as_deref(), Some("capital"));
@@ -166,7 +169,7 @@ fn parse_cloze_without_id() {
 	let input = "/ Basic /\n(Front) Capital {Paris}\n(Back) France\n";
 	with_notes(input, &models, |result| {
 		let notes = result.expect("should parse a cloze without id");
-		assert_eq!(notes[0].fields[0].content.clozes().len(), 1);
+		assert_eq!(notes[0].fields[0].clozes().len(), 1);
 	});
 }
 
@@ -176,14 +179,14 @@ fn media_is_recovered_from_djot_image() {
 	let input = "/ Basic /\n(Front) See ![alt](img/p.png)\n(Back) ok\n";
 	with_notes(input, &models, |result| {
 		let notes = result.expect("should parse a djot image");
-		let media = notes[0].fields[0].content.media_paths();
+		let media = notes[0].fields[0].media_paths();
 		assert_eq!(media, vec![std::path::PathBuf::from("img/p.png")]);
 	});
 }
 
 #[test]
 fn unknown_model_is_a_structured_error() {
-	let models: Vec<NoteModel> = vec![];
+	let models: Vec<Model> = vec![];
 	let input = "/ Unknown /\n(Front) Q1\n(Back) A1\n";
 	with_notes(input, &models, |result| {
 		let diagnostics = result.expect_err("an unknown model must fail");
@@ -211,17 +214,17 @@ fn cst_is_lossless() {
 }
 
 #[test]
-fn field_content_ordering_is_total_and_stable() {
-	use crate::note::FieldContent;
-	let a = FieldContent::parse("alpha");
-	let b = FieldContent::parse("beta");
+fn field_ordering_is_total_and_stable() {
+	use crate::deck::note::Field;
+	let a = Field { name: "".into(), content: "alpha" };
+	let b = Field { name: "".into(), content: "beta" };
 	assert!(a < b);
 	assert!(b > a);
 	assert_eq!(a.cmp(&a.clone()), std::cmp::Ordering::Equal);
 }
 
-fn basic_4field_model() -> NoteModel {
-	NoteModel {
+fn basic_4field_model() -> Model {
+	Model {
 		name:           "Basic".to_string(),
 		id:             Uuid::new_v4(),
 		templates:      vec![],
@@ -229,10 +232,10 @@ fn basic_4field_model() -> NoteModel {
 		defaults:       None,
 		css:            String::new(),
 		fields:         vec![
-			Field { name: "Question".into(), sticky: None, associated_media: None },
-			Field { name: "Answer".into(), sticky: None, associated_media: None },
-			Field { name: "Notes".into(), sticky: None, associated_media: None },
-			Field { name: "Example".into(), sticky: None, associated_media: None },
+			SchemaField { name: "Question".into(), sticky: None, associated_media: None },
+			SchemaField { name: "Answer".into(), sticky: None, associated_media: None },
+			SchemaField { name: "Notes".into(), sticky: None, associated_media: None },
+			SchemaField { name: "Example".into(), sticky: None, associated_media: None },
 		],
 		latex_pre:      None,
 		latex_post:     None,
@@ -254,7 +257,7 @@ fn unique_prefix_q_resolves_to_question() {
 				.fields
 				.iter()
 				.find(|f| f.name == "Question")
-				.map(|f| !f.content.plain_text().is_empty())
+				.map(|f| !f.plain_text().is_empty())
 				.unwrap_or(false)
 		);
 	});
diff --git a/src/sync/deck_sync.rs b/src/sync/deck.rs
similarity index 93%
rename from src/sync/deck_sync.rs
rename to src/sync/deck.rs
index 93debdd..a07f0a7 100644
--- a/src/sync/deck_sync.rs
+++ b/src/sync/deck.rs
@@ -6,17 +6,25 @@ use serde_json::json;
 use tracing::{info, warn};
 use uuid::Uuid;
 
-use crate::{config::DeckConfig, sync::{client::{FlashClient, unique_name}, connection::CollectionSnapshot, error::SyncError, identity::FLASH_DECK_UUID_KEY}};
+use crate::{
+	config::DeckConfig,
+	sync::{
+		client::{FlashClient, unique_name},
+		connection::CollectionSnapshot,
+		error::SyncError,
+		identity::FLASH_DECK_UUID_KEY,
+	},
+};
 
 pub struct DeckSyncData {
-	pub uuid:   Uuid,
-	pub name:   String,
+	pub uuid: Uuid,
+	pub name: String,
 	pub config: DeckConfig,
 }
 
 /// Sync a deck: create if new, update if existing.
 /// Returns the deck name as it exists in Anki (may differ if renamed).
-pub async fn sync_deck(
+pub async fn sync(
 	client: &FlashClient,
 	deck: &DeckSyncData,
 	snapshot: &CollectionSnapshot,
diff --git a/src/sync/sync_engine.rs b/src/sync/engine.rs
similarity index 66%
rename from src/sync/sync_engine.rs
rename to src/sync/engine.rs
index 04470ed..97b0c70 100644
--- a/src/sync/sync_engine.rs
+++ b/src/sync/engine.rs
@@ -4,10 +4,26 @@ use eyre::{Result, WrapErr};
 use tracing::info;
 use uuid::Uuid;
 
-use crate::{config::DeckConfig, deck::Deck, note::{Identified, Note as FlashNote}, sync::{backend::ExportBackend, client::FlashClient, connection::{self, CollectionSnapshot}, deck_sync::{self, DeckSyncData}, media_sync, model_sync::{self, ModelSyncData, TemplateSyncData}, note_sync::{self, NoteSyncData}, reconcile}};
+use crate::{
+	config::DeckConfig,
+	deck::{
+		Deck,
+		note::{Identified, Note},
+	},
+	sync::{
+		backend::ExportBackend,
+		client::FlashClient,
+		connection::{self, CollectionSnapshot},
+		deck::{self, DeckSyncData},
+		media,
+		model::{self, ModelSyncData, TemplateSyncData},
+		note::{self, NoteSyncData},
+		reconcile,
+	},
+};
 
 pub struct SyncEngine {
-	client:   FlashClient,
+	client: FlashClient,
 	snapshot: CollectionSnapshot,
 }
 
@@ -54,8 +70,8 @@ impl SyncEngine {
 		deck_path: &Path,
 		deck_uuid: &Uuid,
 		deck_name: &str,
-		models: &[crate::note::NoteModel],
-		cards: &[Identified<FlashNote<'_>>],
+		models: &[crate::deck::model::Model],
+		cards: &[Identified<Note<'_>>],
 		config: &DeckConfig,
 	) -> Result<()> {
 		info!("Syncing deck '{}' ({})", deck_name, deck_uuid);
@@ -64,7 +80,7 @@ impl SyncEngine {
 		let deck_data =
 			DeckSyncData { uuid: *deck_uuid, name: deck_name.to_string(), config: config.clone() };
 
-		let resolved_deck_name = deck_sync::sync_deck(&self.client, &deck_data, &self.snapshot).await?;
+		let resolved_deck_name = deck::sync(&self.client, &deck_data, &self.snapshot).await?;
 		self.snapshot.decks.insert(resolved_deck_name.clone(), 0);
 		info!("Deck '{}' synced", resolved_deck_name);
 
@@ -72,23 +88,23 @@ impl SyncEngine {
 		let mut model_name_map: Vec<(Uuid, String)> = Vec::new();
 		for model in models {
 			let model_data = ModelSyncData {
-				uuid:       model.id,
-				name:       model.name.clone(),
-				fields:     model.fields.iter().map(|f| f.name.clone()).collect(),
-				templates:  model
+				uuid: model.id,
+				name: model.name.clone(),
+				fields: model.fields.iter().map(|f| f.name.clone()).collect(),
+				templates: model
 					.templates
 					.iter()
 					.map(|t| TemplateSyncData {
-						name:  t.name.clone(),
+						name: t.name.clone(),
 						front: t.question_format.clone(),
-						back:  t.answer_format.clone(),
+						back: t.answer_format.clone(),
 					})
 					.collect(),
-				css:        model.css.clone(),
-				latex_pre:  model.latex_pre.clone(),
+				css: model.css.clone(),
+				latex_pre: model.latex_pre.clone(),
 				latex_post: model.latex_post.clone(),
 			};
-			let anki_name = model_sync::sync_model(&self.client, &model_data).await?;
+			let anki_name = model::sync(&self.client, &model_data).await?;
 			model_name_map.push((model.id, anki_name));
 		}
 
@@ -113,35 +129,34 @@ impl SyncEngine {
 				tags: card.inner.tags.clone(),
 			};
 
-			note_sync::sync_note(&self.client, &note_data, deck_uuid, &resolved_deck_name).await?;
+			note::sync(&self.client, &note_data, deck_uuid, &resolved_deck_name).await?;
 		}
 
 		info!("Synced {} note(s)", cards.len());
 
 		// 4. Reconcile deletions
-		reconcile::reconcile_deletions(&self.client, &resolved_deck_name, deck_uuid, &current_uuids)
-			.await?;
+		reconcile::deletions(&self.client, &resolved_deck_name, deck_uuid, &current_uuids).await?;
 
 		// 5. Sync media
 		let note_media: Vec<std::path::PathBuf> = {
 			let mut paths: Vec<std::path::PathBuf> = cards
 				.iter()
 				.flat_map(|card| card.inner.fields.iter())
-				.flat_map(|field| field.content.media_paths())
+				.flat_map(|field| field.media_paths())
 				.collect();
 			paths.sort();
 			paths.dedup();
 			paths
 		};
-		media_sync::sync_media(&self.client, deck_path, &note_media).await?;
+		media::sync(&self.client, deck_path, &note_media).await?;
 
 		info!("Deck '{}' sync complete", resolved_deck_name);
 		Ok(())
 	}
 }
 
-fn render_fields(card: &Identified<FlashNote<'_>>) -> std::collections::HashMap<String, String> {
-	card.inner.fields.iter().map(|field| (field.name.clone(), field.content.to_anki_html())).collect()
+fn render_fields(card: &Identified<Note<'_>>) -> std::collections::HashMap<String, String> {
+	card.inner.fields.iter().map(|field| (field.name.clone(), field.to_anki_html())).collect()
 }
 
 #[cfg(test)]
@@ -151,18 +166,21 @@ mod tests {
 	use uuid::Uuid;
 
 	use super::render_fields;
-	use crate::note::{FieldContent, Identified, Note, NoteField, NoteModel};
+	use crate::deck::{
+		model::Model,
+		note::{Field, Identified, Note},
+	};
 
-	fn text_field(name: &str, value: &'static str) -> NoteField<'static> {
-		NoteField { name: name.into(), content: FieldContent::parse(value) }
+	fn text_field(name: &str, value: &'static str) -> Field<'static> {
+		Field { name: name.into(), content: value }
 	}
 
 	#[test]
 	fn render_fields_plain_text() {
 		let note = Note {
 			fields: vec![text_field("Front", "Hello"), text_field("Back", "World")],
-			model:  Cow::Owned(NoteModel::default()),
-			tags:   vec![],
+			model: Cow::Owned(Model::default()),
+			tags: vec![],
 		};
 		let card = Identified { id: Uuid::new_v4(), inner: note };
 
@@ -176,8 +194,8 @@ mod tests {
 	fn render_fields_empty_content() {
 		let note = Note {
 			fields: vec![text_field("Front", "")],
-			model:  Cow::Owned(NoteModel::default()),
-			tags:   vec![],
+			model: Cow::Owned(Model::default()),
+			tags: vec![],
 		};
 		let card = Identified { id: Uuid::new_v4(), inner: note };
 
@@ -187,12 +205,8 @@ mod tests {
 
 	#[test]
 	fn render_fields_cloze_without_hint() {
-		let field = NoteField {
-			name:    "Text".into(),
-			content: FieldContent::parse("The capital of France is {Paris>1}."),
-		};
-		let note =
-			Note { fields: vec![field], model: Cow::Owned(NoteModel::default()), tags: vec![] };
+		let field = Field { name: "Text".into(), content: "The capital of France is {Paris>1}." };
+		let note = Note { fields: vec![field], model: Cow::Owned(Model::default()), tags: vec![] };
 		let card = Identified { id: Uuid::new_v4(), inner: note };
 
 		let result = render_fields(&card);
@@ -201,12 +215,9 @@ mod tests {
 
 	#[test]
 	fn render_fields_cloze_with_hint() {
-		let field = NoteField {
-			name:    "Text".into(),
-			content: FieldContent::parse("A synonym for happy is {joyful|starts with j>2}."),
-		};
-		let note =
-			Note { fields: vec![field], model: Cow::Owned(NoteModel::default()), tags: vec![] };
+		let field =
+			Field { name: "Text".into(), content: "A synonym for happy is {joyful|starts with j>2}." };
+		let note = Note { fields: vec![field], model: Cow::Owned(Model::default()), tags: vec![] };
 		let card = Identified { id: Uuid::new_v4(), inner: note };
 
 		let result = render_fields(&card);
@@ -215,12 +226,11 @@ mod tests {
 
 	#[test]
 	fn render_fields_mixed_cloze_and_text() {
-		let field = NoteField {
-			name:    "Q".into(),
-			content: FieldContent::parse("{Berlin>1} is the capital of {Germany|European country>2}"),
+		let field = Field {
+			name: "Q".into(),
+			content: "{Berlin>1} is the capital of {Germany|European country>2}",
 		};
-		let note =
-			Note { fields: vec![field], model: Cow::Owned(NoteModel::default()), tags: vec![] };
+		let note = Note { fields: vec![field], model: Cow::Owned(Model::default()), tags: vec![] };
 		let card = Identified { id: Uuid::new_v4(), inner: note };
 
 		let result = render_fields(&card);
@@ -237,8 +247,8 @@ mod tests {
 				text_field("Answer", "That!"),
 				text_field("Extra", "Details..."),
 			],
-			model:  Cow::Owned(NoteModel::default()),
-			tags:   vec![],
+			model: Cow::Owned(Model::default()),
+			tags: vec![],
 		};
 		let card = Identified { id: Uuid::new_v4(), inner: note };
 
diff --git a/src/sync/media_sync.rs b/src/sync/media.rs
similarity index 88%
rename from src/sync/media_sync.rs
rename to src/sync/media.rs
index 48bf535..8f9b444 100644
--- a/src/sync/media_sync.rs
+++ b/src/sync/media.rs
@@ -1,4 +1,7 @@
-use std::{fs, path::{Path, PathBuf}};
+use std::{
+	fs,
+	path::{Path, PathBuf},
+};
 
 use base64::{Engine, prelude::BASE64_STANDARD};
 use eyre::Result;
@@ -6,11 +9,7 @@ use tracing::info;
 
 use crate::sync::{client::FlashClient, error::SyncError};
 
-pub async fn sync_media(
-	client: &FlashClient,
-	deck_path: &Path,
-	note_media: &[PathBuf],
-) -> Result<()> {
+pub async fn sync(client: &FlashClient, deck_path: &Path, note_media: &[PathBuf]) -> Result<()> {
 	let assets_dir = deck_path.join("Assets");
 	if assets_dir.is_dir() {
 		info!("Syncing media from {:?}", assets_dir);
diff --git a/src/sync/mod.rs b/src/sync/mod.rs
index 4a1041b..63f2a1a 100644
--- a/src/sync/mod.rs
+++ b/src/sync/mod.rs
@@ -1,13 +1,13 @@
 pub mod backend;
 pub mod client;
 pub mod connection;
-pub mod deck_sync;
+pub mod deck;
 pub mod error;
 pub mod identity;
-pub mod media_sync;
-pub mod model_sync;
-pub mod note_sync;
+pub mod media;
+pub mod model;
+pub mod note;
 pub mod reconcile;
-pub mod sync_engine;
+pub mod engine;
 
-pub use self::{backend::*, sync_engine::SyncEngine};
+pub use self::{backend::*, engine::SyncEngine};
diff --git a/src/sync/model_sync.rs b/src/sync/model.rs
similarity index 88%
rename from src/sync/model_sync.rs
rename to src/sync/model.rs
index 34a4602..b8f973d 100644
--- a/src/sync/model_sync.rs
+++ b/src/sync/model.rs
@@ -4,25 +4,29 @@ use ankit::CreateModelParams;
 use eyre::Result;
 use tracing::{info, warn};
 
-use crate::sync::{client::{FlashClient, unique_name}, error::SyncError, identity::make_model_uuid_comment};
+use crate::sync::{
+	client::{FlashClient, unique_name},
+	error::SyncError,
+	identity::make_model_uuid_comment,
+};
 
 pub struct ModelSyncData {
-	pub uuid:       uuid::Uuid,
-	pub name:       String,
-	pub fields:     Vec<String>,
-	pub templates:  Vec<TemplateSyncData>,
-	pub css:        String,
-	pub latex_pre:  Option<String>,
+	pub uuid: uuid::Uuid,
+	pub name: String,
+	pub fields: Vec<String>,
+	pub templates: Vec<TemplateSyncData>,
+	pub css: String,
+	pub latex_pre: Option<String>,
 	pub latex_post: Option<String>,
 }
 
 pub struct TemplateSyncData {
-	pub name:  String,
+	pub name: String,
 	pub front: String,
-	pub back:  String,
+	pub back: String,
 }
 
-pub async fn sync_model(client: &FlashClient, model: &ModelSyncData) -> Result<String> {
+pub async fn sync(client: &FlashClient, model: &ModelSyncData) -> Result<String> {
 	let existing_model_name = find_model_by_uuid(client, &model.uuid).await?;
 
 	let model_name = if let Some(existing_name) = existing_model_name {
@@ -170,16 +174,16 @@ mod tests {
 
 	fn sample_model() -> ModelSyncData {
 		ModelSyncData {
-			uuid:       Uuid::from_u128(42),
-			name:       "Test Model".into(),
-			fields:     vec!["Front".into(), "Back".into()],
-			templates:  vec![TemplateSyncData {
-				name:  "Card 1".into(),
+			uuid: Uuid::from_u128(42),
+			name: "Test Model".into(),
+			fields: vec!["Front".into(), "Back".into()],
+			templates: vec![TemplateSyncData {
+				name: "Card 1".into(),
 				front: "{{Front}}".into(),
-				back:  "{{Back}}".into(),
+				back: "{{Back}}".into(),
 			}],
-			css:        ".card { color: red; }".into(),
-			latex_pre:  None,
+			css: ".card { color: red; }".into(),
+			latex_pre: None,
 			latex_post: None,
 		}
 	}
diff --git a/src/sync/note_sync.rs b/src/sync/note.rs
similarity index 74%
rename from src/sync/note_sync.rs
rename to src/sync/note.rs
index 3286283..66fee89 100644
--- a/src/sync/note_sync.rs
+++ b/src/sync/note.rs
@@ -5,21 +5,28 @@ use eyre::Result;
 use tracing::info;
 use uuid::Uuid;
 
-use crate::{note::{Identified, Note}, sync::{client::FlashClient, error::SyncError, identity::{flash_tag_prefix, make_flash_tag}}};
+use crate::{
+	deck::note::{Identified, Note},
+	sync::{
+		client::FlashClient,
+		error::SyncError,
+		identity::{flash_tag_prefix, make_flash_tag},
+	},
+};
 
 pub struct NoteSyncData {
-	pub uuid:       Uuid,
+	pub uuid: Uuid,
 	pub model_uuid: Uuid,
 	pub model_name: String,
-	pub fields:     HashMap<String, String>,
-	pub tags:       Vec<String>,
+	pub fields: HashMap<String, String>,
+	pub tags: Vec<String>,
 }
 
 impl<'model> From<&Identified<Note<'model>>> for NoteSyncData {
 	fn from(note: &Identified<Note<'model>>) -> Self {
 		let mut fields = HashMap::new();
 		for field in &note.inner.fields {
-			fields.insert(field.name.clone(), field.content.to_anki_html());
+			fields.insert(field.name.clone(), field.to_anki_html());
 		}
 
 		NoteSyncData {
@@ -32,7 +39,7 @@ impl<'model> From<&Identified<Note<'model>>> for NoteSyncData {
 	}
 }
 
-pub async fn sync_note(
+pub async fn sync(
 	client: &FlashClient,
 	note: &NoteSyncData,
 	deck_uuid: &Uuid,
@@ -89,19 +96,22 @@ mod tests {
 	use uuid::Uuid;
 
 	use super::NoteSyncData;
-	use crate::note::{FieldContent, Identified, Note, NoteField, NoteModel};
+	use crate::deck::{
+		model::Model,
+		note::{Field, Identified, Note},
+	};
 
-	fn text_field(name: &str, value: &'static str) -> NoteField<'static> {
-		NoteField { name: name.into(), content: FieldContent::parse(value) }
+	fn text_field(name: &str, value: &'static str) -> Field<'static> {
+		Field { name: name.into(), content: value }
 	}
 
 	#[test]
 	fn from_identified_note_basic_fields() {
-		let model = NoteModel::default();
+		let model = Model::default();
 		let note = Note {
 			fields: vec![text_field("Front", "Hello"), text_field("Back", "World")],
-			model:  Cow::Owned(model.clone()),
-			tags:   vec!["tag1".into(), "tag2".into()],
+			model: Cow::Owned(model.clone()),
+			tags: vec!["tag1".into(), "tag2".into()],
 		};
 		let identified = Identified { id: Uuid::from_u128(1), inner: note };
 
@@ -120,8 +130,8 @@ mod tests {
 	fn from_identified_note_handles_empty_tags() {
 		let note = Note {
 			fields: vec![text_field("Front", "Test")],
-			model:  Cow::Owned(NoteModel::default()),
-			tags:   vec![],
+			model: Cow::Owned(Model::default()),
+			tags: vec![],
 		};
 		let identified = Identified { id: Uuid::new_v4(), inner: note };
 
@@ -131,31 +141,19 @@ mod tests {
 
 	#[test]
 	fn from_identified_note_handles_multiple_fields() {
-		let model = NoteModel {
+		let model = Model {
 			fields: vec![
-				crate::note::Field {
-					name:             "Front".into(),
-					sticky:           None,
-					associated_media: None,
-				},
-				crate::note::Field {
-					name:             "Back".into(),
-					sticky:           None,
-					associated_media: None,
-				},
-				crate::note::Field {
-					name:             "Extra".into(),
-					sticky:           None,
-					associated_media: None,
-				},
+				crate::deck::model::Field { name: "Front".into(), sticky: None, associated_media: None },
+				crate::deck::model::Field { name: "Back".into(), sticky: None, associated_media: None },
+				crate::deck::model::Field { name: "Extra".into(), sticky: None, associated_media: None },
 			],
 			..Default::default()
 		};
 
 		let note = Note {
 			fields: vec![text_field("Front", "Q"), text_field("Back", "A"), text_field("Extra", "Note")],
-			model:  Cow::Owned(model),
-			tags:   vec![],
+			model: Cow::Owned(model),
+			tags: vec![],
 		};
 		let identified = Identified { id: Uuid::new_v4(), inner: note };
 
diff --git a/src/sync/reconcile.rs b/src/sync/reconcile.rs
index 8fe39b0..03abd58 100644
--- a/src/sync/reconcile.rs
+++ b/src/sync/reconcile.rs
@@ -4,12 +4,16 @@ use eyre::Result;
 use tracing::{info, warn};
 use uuid::Uuid;
 
-use crate::sync::{client::FlashClient, error::SyncError, identity::{flash_tag_wildcard, parse_note_uuid_from_tag}};
+use crate::sync::{
+	client::FlashClient,
+	error::SyncError,
+	identity::{flash_tag_wildcard, parse_note_uuid_from_tag},
+};
 
 /// Delete notes from Anki that have flash tags but whose UUIDs are not in the
 /// current set. This handles the case where a note was removed from a .flash
 /// file.
-pub async fn reconcile_deletions(
+pub async fn deletions(
 	client: &FlashClient,
 	deck_name: &str,
 	deck_uuid: &Uuid,