diff --git a/.cspell.json b/.cspell.json
index a9926c364..96b8cde14 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -18,7 +18,8 @@
 		"esbuild",
 		"coloneqq",
 		"FiltVect",
-		"networkidle"
+		"networkidle",
+		"devlog"
 	],
 	"words": [
 		"abelian",
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index 020e30eb0..61e6b5934 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -34,9 +34,6 @@ jobs:
           pnpm db:setup:catdat
           pnpm db:update
 
-      - name: Redundancy check
-        run: pnpm db:redundancies
-
       - name: Cache Playwright browsers
         uses: actions/cache@v6
         with:
diff --git a/databases/app/scripts/setup.ts b/databases/app/scripts/setup.ts
index 106d38bde..7bcc51691 100644
--- a/databases/app/scripts/setup.ts
+++ b/databases/app/scripts/setup.ts
@@ -1,5 +1,6 @@
 import dotenv from 'dotenv'
 import { createClient } from '@libsql/client'
+import { devlog } from '$shared/utils'
 
 dotenv.config({ quiet: true })
 
@@ -39,7 +40,7 @@ async function create_visits_table() {
         )
     `)
 
-	console.info('Visits table ready')
+	devlog('Visits table ready')
 }
 
 /**
@@ -58,7 +59,7 @@ async function create_submissions_table() {
         )
     `)
 
-	console.info('Submissions table ready')
+	devlog('Submissions table ready')
 }
 
 /**
@@ -74,5 +75,5 @@ async function create_actions_table() {
         )
     `)
 
-	console.info('User actions table ready')
+	devlog('User actions table ready')
 }
diff --git a/databases/catdat/scripts/config.ts b/databases/catdat/scripts/config.ts
deleted file mode 100644
index 7014eef2d..000000000
--- a/databases/catdat/scripts/config.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-export const STRUCTURE_TYPES = ['category', 'functor', 'morphism'] as const
-
-export type StructureType = (typeof STRUCTURE_TYPES)[number]
-
-export const STRUCTURE_TYPES_WITH_DUALS: StructureType[] = ['category']
-
-export const PLURALS = {
-	category: 'categories',
-	functor: 'functors',
-	morphism: 'morphisms'
-} as const
-
-export const TABLES = {
-	category: 'categories',
-	functor: 'functors',
-	morphism: 'morphisms'
-} as const
diff --git a/databases/catdat/scripts/deduce-implications.ts b/databases/catdat/scripts/deduce-implications.ts
index ef7eff7ce..14ed69ea8 100644
--- a/databases/catdat/scripts/deduce-implications.ts
+++ b/databases/catdat/scripts/deduce-implications.ts
@@ -1,8 +1,13 @@
-import { STRUCTURE_TYPES_WITH_DUALS, type StructureType } from './config'
-import { are_equal_sets, parse_nested_json_set, parse_json_set } from './utils/helpers'
-import { get_client } from './utils/db'
+import { type StructureType, STRUCTURE_TYPES_WITH_DUALS } from '$shared/config'
+import {
+	are_equal_sets,
+	parse_nested_json_set,
+	parse_json_set,
+	devlog
+} from '$shared/utils'
+import { get_client } from '$shared/db'
 
-const db = get_client()
+const db = get_client({ readonly: false })
 
 /**
  * Clears all deduced implications. This is done before the deduction starts.
@@ -151,7 +156,7 @@ export function create_dualized_implications(type: StructureType) {
 			}
 		}
 
-		console.info(`Deduced ${count} ${type} implications by duality`)
+		devlog(`Deduced ${count} ${type} implications by duality`)
 	})
 
 	insert_duals()
@@ -203,5 +208,5 @@ export function create_self_dual_implications(type: StructureType) {
 		conclusion_insert.run(implication_id, p.dual, type)
 	}
 
-	console.info(`Deduced ${relevant_props.length} ${type} implications by self-duality`)
+	devlog(`Deduced ${relevant_props.length} ${type} implications by self-duality`)
 }
diff --git a/databases/catdat/scripts/deduce-special-morphisms.ts b/databases/catdat/scripts/deduce-special-morphisms.ts
index b3bcf14e8..5d167fb82 100644
--- a/databases/catdat/scripts/deduce-special-morphisms.ts
+++ b/databases/catdat/scripts/deduce-special-morphisms.ts
@@ -1,6 +1,7 @@
-import { get_client } from './utils/db'
+import { get_client } from '$shared/db'
+import { devlog } from '$shared/utils'
 
-const db = get_client()
+const db = get_client({ readonly: false })
 
 // TODO: deduce further morphisms,
 // e.g. isomorphisms = bijective morphisms in algebraic categories,
@@ -46,5 +47,5 @@ function deduce_special_morphisms_of_dual_categories() {
 		)
 		.run()
 
-	console.info(`Deduced ${res.changes} special morphisms by duality`)
+	devlog(`Deduced ${res.changes} special morphisms by duality`)
 }
diff --git a/databases/catdat/scripts/deduce-special-objects.ts b/databases/catdat/scripts/deduce-special-objects.ts
index c944a3b49..c65c57914 100644
--- a/databases/catdat/scripts/deduce-special-objects.ts
+++ b/databases/catdat/scripts/deduce-special-objects.ts
@@ -1,6 +1,7 @@
-import { get_client } from './utils/db'
+import { get_client } from '$shared/db'
+import { devlog } from '$shared/utils'
 
-const db = get_client()
+const db = get_client({ readonly: false })
 
 export function deduce_special_objects() {
 	console.info('\n--- Deduce special objects ---')
@@ -40,5 +41,5 @@ function deduce_special_objects_of_dual_categories() {
 		)
 		.run()
 
-	console.info(`Deduced ${res.changes} special objects by duality`)
+	devlog(`Deduced ${res.changes} special objects by duality`)
 }
diff --git a/databases/catdat/scripts/deduce-structure-properties.ts b/databases/catdat/scripts/deduce-structure-properties.ts
index cbb827ba3..a17f331b5 100644
--- a/databases/catdat/scripts/deduce-structure-properties.ts
+++ b/databases/catdat/scripts/deduce-structure-properties.ts
@@ -1,168 +1,99 @@
 /**
  * This file contains all functions that are used to deduce properties
- * for categories and functors.
+ * for categories and other categorical structures.
  */
 
-import { type Database, SqliteError } from 'better-sqlite3'
-import { is_subset } from './utils/helpers'
-import { get_client } from './utils/db'
+import { type Database } from 'better-sqlite3'
+import { deduce_properties, refute_properties } from '$shared/deduction.utils'
+import { get_client } from '$shared/db'
 import {
 	get_properties_dict,
 	get_property_assignments,
 	type PropertyMeta
 } from './utils/properties'
-import {
-	get_contradiction_string,
-	get_normalized_implications,
-	get_proof_string,
-	NormalizedImplication
-} from './utils/implications'
-import { STRUCTURE_TYPES_WITH_DUALS, type StructureType } from './config'
+import { get_contradiction_string, get_proof_string } from './utils/implications'
+import { type StructureType, STRUCTURE_TYPES_WITH_DUALS } from '$shared/config'
 import { get_structures, is_dual_structure, type StructureMeta } from './utils/structures'
+import { get_normalized_implications, NormalizedImplication } from '$shared/implications'
+import { devlog } from '$shared/utils'
 
 /**
- * Returns the set of satisfied properties that can be deduced from a set
- * of satisfied properties, based on a list of normalized implications. If a
- * property dictionary is provided, human-readable proofs are generated as well.
+ * Deduce satisfied properties for a given structure from given ones
+ * by using a list of normalized implications.
+ * Human-readable proofs are generated as well.
+ * Warning: This mutates the set of satisfied properties.
  */
-export function get_deduced_satisfied_properties(
-	satisfied_properties: Set<string>,
+function deduce_satisfied_properties(
+	db: Database,
+	structure: StructureMeta,
 	implications: NormalizedImplication[],
-	options: {
-		properties_dict?: Record<string, PropertyMeta>
-		stop_when_found?: string
-	},
-	type: StructureType,
-	associated_satisfied_properties?: Record<string, Set<string>>
+	satisfied_properties: Set<string>,
+	unsatisfied_properties: Set<string>,
+	properties_dict: Record<string, PropertyMeta>,
+	type: StructureType
 ) {
-	const found = new Set<string>()
-	const proofs: Record<string, string> = {}
-	const deduced_satisfied_properties = new Set(satisfied_properties)
-
-	while (true) {
-		const newly_found = new Set<string>()
-
-		for (const implication of implications) {
-			const is_valid =
-				is_subset(implication.assumptions, deduced_satisfied_properties) &&
-				!deduced_satisfied_properties.has(implication.conclusion) &&
-				!newly_found.has(implication.conclusion)
-
-			if (!is_valid) continue
-
-			if (implication.mapped_assumptions) {
-				const is_applicable = Object.keys(implication.mapped_assumptions).every(
-					(key) => {
-						return is_subset(
-							implication.mapped_assumptions?.[key] ?? new Set(),
-							associated_satisfied_properties?.[key] ?? new Set()
-						)
-					}
-				)
-				if (!is_applicable) continue
-			}
-
-			newly_found.add(implication.conclusion)
-			found.add(implication.conclusion)
-
-			if (options?.stop_when_found === implication.conclusion) {
-				deduced_satisfied_properties.add(implication.conclusion)
-				return { deduced_satisfied_properties, found, proofs }
-			}
+	const { found, proofs, stop_property } = deduce_properties(
+		satisfied_properties,
+		implications,
+		(implication) => ({
+			proof: get_proof_string(implication, properties_dict, type),
+			stop: unsatisfied_properties.has(implication.conclusion)
+		}),
+		structure.associated_satisfied_properties
+	)
 
-			if (options.properties_dict) {
-				proofs[implication.conclusion] = get_proof_string(
-					implication,
-					options.properties_dict,
-					type
-				)
-			}
-		}
+	if (stop_property) {
+		console.error(
+			`❌ Property assignments of ${structure.id} are contradictory: "${stop_property}" can be deduced from its satisfied properties, but is marked as unsatisfied.`
+		)
+		process.exit(1)
+	}
 
-		for (const p of newly_found) deduced_satisfied_properties.add(p)
+	for (const p of found) satisfied_properties.add(p)
 
-		if (!newly_found.size) break
-	}
+	save_satisfied_properties(db, structure.id, found, proofs, type)
 
-	return { deduced_satisfied_properties, found, proofs }
+	devlog(`Deduced ${found.size} satisfied properties for ${structure.id}`)
 }
 
 /**
- * Returns the set of unsatisfied properties that can be deduced from
- * a set of satisfied properties and a set of unsatisfied properties,
- * based on a list of normalized implications. If a property dictionary
- * is provided, human-readable proofs are generated as well.
+ * Deduce unsatisfied properties for a given structure from given ones
+ * by using satisfied properties and a list of normalized implications.
+ * Human-readable proofs are generated as well.
+ * Warning: This mutates the set of unsatisfied properties.
  */
-export function get_deduced_unsatisfied_properties(
+function deduce_unsatisfied_properties(
+	db: Database,
+	structure: StructureMeta,
+	implications: NormalizedImplication[],
 	satisfied_properties: Set<string>,
 	unsatisfied_properties: Set<string>,
-	implications: NormalizedImplication[],
-	options: {
-		properties_dict?: Record<string, PropertyMeta>
-		stop_when_found?: string
-	},
-	type: StructureType,
-	associated_satisfied_properties?: Record<string, Set<string>>
+	properties_dict: Record<string, PropertyMeta>,
+	type: StructureType
 ) {
-	const found = new Set<string>()
-	const proofs: Record<string, string> = {}
-	const deduced_unsatisfied_properties = new Set(unsatisfied_properties)
-
-	while (true) {
-		const newly_found = new Set<string>()
-
-		for (const implication of implications) {
-			if (!deduced_unsatisfied_properties.has(implication.conclusion)) continue
-			for (const p of implication.assumptions) {
-				const is_valid =
-					!deduced_unsatisfied_properties.has(p) &&
-					!newly_found.has(p) &&
-					is_subset(implication.assumptions, satisfied_properties, {
-						exception: p
-					})
-				if (!is_valid) continue
-
-				if (implication.mapped_assumptions) {
-					const is_applicable = Object.keys(
-						implication.mapped_assumptions
-					).every((key) => {
-						return is_subset(
-							implication.mapped_assumptions?.[key] ?? new Set(),
-							associated_satisfied_properties?.[key] ?? new Set()
-						)
-					})
-					if (!is_applicable) continue
-				}
-
-				if (satisfied_properties.has(p)) {
-					throw new Error(`Contradiction has been found for: ${p}`)
-				}
-
-				if (options?.stop_when_found === p) {
-					deduced_unsatisfied_properties.add(p)
-					return { deduced_unsatisfied_properties, found, proofs }
-				}
-
-				newly_found.add(p)
-				found.add(p)
-
-				if (options.properties_dict) {
-					proofs[p] = get_contradiction_string(
-						implication,
-						options.properties_dict,
-						p,
-						type
-					)
-				}
+	const { found, proofs } = refute_properties<string>(
+		satisfied_properties,
+		unsatisfied_properties,
+		implications,
+		(implication, property) => {
+			return {
+				proof: get_contradiction_string(
+					implication,
+					properties_dict,
+					property,
+					type
+				),
+				stop: false
 			}
-		}
+		},
+		structure.associated_satisfied_properties
+	)
 
-		for (const p of newly_found) deduced_unsatisfied_properties.add(p)
+	for (const p of found) unsatisfied_properties.add(p)
 
-		if (!newly_found.size) break
-	}
+	save_unsatisfied_properties(db, structure.id, found, proofs, type)
 
-	return { deduced_unsatisfied_properties, found, proofs }
+	devlog(`Deduced ${found.size} unsatisfied properties for ${structure.id}`)
 }
 
 /**
@@ -172,33 +103,19 @@ function save_satisfied_properties(
 	db: Database,
 	structure_id: string,
 	found: Set<string>,
-	proofs: Record<string, string>,
+	proofs: Partial<Record<string, string>>,
 	type: StructureType
 ) {
 	if (found.size === 0) return
 
-	const err_msg = `❌ Failed to complete deduction of satisfied properties for ${structure_id} because of a conflict. The likely cause is a contradiction between its assigned properties.`
-
 	const property_insert = db.prepare(`
 		INSERT INTO property_assignments
 			(structure_id, property_id, type, is_satisfied, proof, is_deduced)
 		VALUES (?, ?, ?, TRUE, ?, TRUE)
 	`)
 
-	try {
-		for (const p of found) {
-			property_insert.run(structure_id, p, type, proofs[p])
-		}
-	} catch (err) {
-		if (err instanceof SqliteError) {
-			if (err.code.startsWith('SQLITE_CONSTRAINT')) {
-				console.error(err_msg)
-			}
-			console.error(err.message)
-		} else {
-			console.error(err)
-		}
-		process.exit(1)
+	for (const p of found) {
+		property_insert.run(structure_id, p, type, proofs[p])
 	}
 }
 
@@ -209,94 +126,22 @@ function save_unsatisfied_properties(
 	db: Database,
 	structure_id: string,
 	found: Set<string>,
-	proofs: Record<string, string>,
+	proofs: Partial<Record<string, string>>,
 	type: StructureType
 ) {
 	if (found.size === 0) return
 
-	const err_msg = `❌ Failed to complete deduction of unsatisfied properties for ${structure_id} because of a conflict. The likely cause is a contradiction between its assigned properties.`
-
 	const property_insert = db.prepare(`
 		INSERT INTO property_assignments
 			(structure_id, property_id, type, is_satisfied, proof, is_deduced)
 		VALUES (?, ?, ?, FALSE, ?, TRUE)
 	`)
 
-	try {
-		for (const p of found) {
-			property_insert.run(structure_id, p, type, proofs[p])
-		}
-	} catch (err) {
-		if (err instanceof SqliteError) {
-			if (err.code.startsWith('SQLITE_CONSTRAINT')) {
-				console.error(err_msg)
-			}
-			console.error(err.message)
-		} else {
-			console.error(err)
-		}
-		process.exit(1)
+	for (const p of found) {
+		property_insert.run(structure_id, p, type, proofs[p])
 	}
 }
 
-/**
- * Deduce satisfied properties for a given structure from given ones
- * by using the list of normalized implications.
- * Warning: This mutates the set of satisfied properties.
- */
-function deduce_satisfied_properties(
-	db: Database,
-	structure: StructureMeta,
-	implications: NormalizedImplication[],
-	satisfied_properties: Set<string>,
-	properties_dict: Record<string, PropertyMeta>,
-	type: StructureType
-) {
-	const { found, proofs } = get_deduced_satisfied_properties(
-		satisfied_properties,
-		implications,
-		{ properties_dict },
-		type,
-		structure.associated_satisfied_properties
-	)
-
-	for (const p of found) satisfied_properties.add(p)
-
-	save_satisfied_properties(db, structure.id, found, proofs, type)
-
-	console.info(`Deduced ${found.size} satisfied properties for ${structure.id}`)
-}
-
-/**
- * Deduce unsatisfied properties for a given structure from given ones
- * by using the satisfied properties and the list of normalized implications.
- * Warning: This mutates the set of unsatisfied properties.
- */
-function deduce_unsatisfied_properties(
-	db: Database,
-	structure: StructureMeta,
-	implications: NormalizedImplication[],
-	satisfied_properties: Set<string>,
-	unsatisfied_properties: Set<string>,
-	properties_dict: Record<string, PropertyMeta>,
-	type: StructureType
-) {
-	const { found, proofs } = get_deduced_unsatisfied_properties(
-		satisfied_properties,
-		unsatisfied_properties,
-		implications,
-		{ properties_dict },
-		type,
-		structure.associated_satisfied_properties
-	)
-
-	for (const p of found) unsatisfied_properties.add(p)
-
-	save_unsatisfied_properties(db, structure.id, found, proofs, type)
-
-	console.info(`Deduced ${found.size} unsatisfied properties for ${structure.id}`)
-}
-
 /**
  * Assign dual properties to dual structures:
  * If C has property P, then C^op has property P^op (if defined).
@@ -355,7 +200,7 @@ function deduce_dual_properties(
 		property_insert.run(structure.id, p, type, 1, proof_satisfied)
 	}
 
-	console.info(
+	devlog(
 		`Deduced ${new_satisfied.size} satisfied properties by duality for ${structure.id}`
 	)
 
@@ -363,7 +208,7 @@ function deduce_dual_properties(
 		property_insert.run(structure.id, q, type, 0, proof_unsatisfied)
 	}
 
-	console.info(
+	devlog(
 		`Deduced ${new_unsatisfied.size} unsatisfied properties by duality for ${structure.id}`
 	)
 
@@ -371,7 +216,7 @@ function deduce_dual_properties(
 		property_insert.run(structure.id, q, type, null, proof_undecidable)
 	}
 
-	console.info(
+	devlog(
 		`Deduced ${new_undecidable.size} undecidable properties by duality for ${structure.id}`
 	)
 }
@@ -392,7 +237,7 @@ function delete_deduced_properties(db: Database, type: StructureType) {
 export function deduce_properties_for_structures(type: StructureType) {
 	console.info(`\n--- Deduce ${type} properties ---`)
 
-	const db = get_client()
+	const db = get_client({ readonly: false })
 
 	delete_deduced_properties(db, type)
 
@@ -410,6 +255,7 @@ export function deduce_properties_for_structures(type: StructureType) {
 				structure,
 				implications,
 				assigned.satisfied,
+				assigned.unsatisfied,
 				properties_dict,
 				type
 			)
@@ -455,6 +301,7 @@ export function deduce_properties_for_structures(type: StructureType) {
 				structure,
 				implications,
 				assigned.satisfied,
+				assigned.unsatisfied,
 				properties_dict,
 				type
 			)
diff --git a/databases/catdat/scripts/proof-length.ts b/databases/catdat/scripts/proof-length.ts
index af5544169..ebfde75c5 100644
--- a/databases/catdat/scripts/proof-length.ts
+++ b/databases/catdat/scripts/proof-length.ts
@@ -1,7 +1,8 @@
-import { type StructureType } from './config'
-import { get_client } from './utils/db'
+import { STRUCTURE_TYPES, type StructureType } from '$shared/config'
+import { get_client } from '$shared/db'
+get_client
 
-const db = get_client()
+const db = get_client({ readonly: true })
 
 const PROOF_LENGTH_THRESHOLD = 1200
 
@@ -12,10 +13,12 @@ report_long_proofs()
  * perhaps be moved to a separate content page.
  */
 function report_long_proofs() {
-	report_long_property_proofs('category')
-	report_long_property_proofs('functor')
-	report_long_implication_proofs('category')
-	report_long_implication_proofs('functor')
+	for (const type of STRUCTURE_TYPES) {
+		report_long_property_proofs(type)
+	}
+	for (const type of STRUCTURE_TYPES) {
+		report_long_implication_proofs(type)
+	}
 }
 
 function report_long_property_proofs(type: StructureType) {
diff --git a/databases/catdat/scripts/redundancies.ts b/databases/catdat/scripts/redundancies.ts
index 3e1af4df6..bf3520a7e 100644
--- a/databases/catdat/scripts/redundancies.ts
+++ b/databases/catdat/scripts/redundancies.ts
@@ -1,17 +1,15 @@
-import { get_client } from './utils/db'
-import {
-	get_deduced_satisfied_properties,
-	get_deduced_unsatisfied_properties
-} from './deduce-structure-properties'
+import { get_client } from '$shared/db'
 import { get_property_assignments_by_deduction } from './utils/properties'
-import type { StructureType } from './config'
+import { STRUCTURE_TYPES, type StructureType } from '$shared/config'
 import {
 	get_normalized_implications,
+	stringify_implication,
 	type NormalizedImplication
-} from './utils/implications'
+} from '$shared/implications'
+import { deduce_properties, refute_properties } from '$shared/deduction.utils'
 import { get_structures } from './utils/structures'
 
-const db = get_client()
+const db = get_client({ readonly: true })
 
 check_redundancies()
 
@@ -20,13 +18,14 @@ check_redundancies()
  * No error is thrown intentionally.
  */
 function check_redundancies() {
-	check_redundant_property_assignments('category')
-	check_redundant_property_assignments('functor')
+	for (const type of STRUCTURE_TYPES) {
+		check_redundant_property_assignments(type)
+	}
 }
 
 /**
  * Checks for redundant (structure, property)-assignments and logs
- * one per functor if any are found (satisfied or unsatisfied).
+ * one per structure if any are found (satisfied or unsatisfied).
  * No error is thrown intentionally.
  */
 function check_redundant_property_assignments(type: StructureType) {
@@ -48,7 +47,6 @@ function check_redundant_property_assignments(type: StructureType) {
 
 	for (const structure of structures) {
 		const redundant_satisfied_property = get_redundant_satisfied_property(
-			type,
 			assignments[structure.id].satisfied.non_deduced,
 			implications,
 			ignore_dict[structure.id],
@@ -69,7 +67,6 @@ function check_redundant_property_assignments(type: StructureType) {
 		])
 
 		const redundant_unsatisfied_property = get_redundant_unsatisfied_property(
-			type,
 			all_satisfied_properties,
 			assignments[structure.id].unsatisfied.non_deduced,
 			implications,
@@ -104,25 +101,31 @@ function check_redundant_property_assignments(type: StructureType) {
  * If no such property exists, null is returned.
  */
 function get_redundant_satisfied_property(
-	type: StructureType,
 	satisfied_properties: Set<string>,
 	implications: NormalizedImplication[],
 	ignored: Set<string> = new Set(),
-	associated_satisfied_properties?: Record<string, Set<string>>
+	associated_satisfied_properties?: Partial<Record<string, Set<string>>>
 ) {
 	for (const p of [...satisfied_properties]) {
 		if (ignored.has(p)) continue
+
 		satisfied_properties.delete(p)
-		const { deduced_satisfied_properties } = get_deduced_satisfied_properties(
+
+		const { deduced_satisfied_properties } = deduce_properties(
 			satisfied_properties,
 			implications,
-			{ stop_when_found: p },
-			type,
+			(implication) => ({
+				proof: stringify_implication(implication),
+				stop: implication.conclusion === p
+			}),
 			associated_satisfied_properties
 		)
+
 		if (deduced_satisfied_properties.has(p)) return p
+
 		satisfied_properties.add(p)
 	}
+
 	return null
 }
 
@@ -133,25 +136,30 @@ function get_redundant_satisfied_property(
  * If no such property exists, null is returned.
  */
 function get_redundant_unsatisfied_property(
-	type: StructureType,
 	satisfied_properties: Set<string>,
 	unsatisfied_properties: Set<string>,
 	implications: NormalizedImplication[],
 	ignored: Set<string> = new Set(),
-	associated_satisfied_properties?: Record<string, Set<string>>
+	associated_satisfied_properties?: Partial<Record<string, Set<string>>>
 ) {
 	for (const p of [...unsatisfied_properties]) {
 		if (ignored.has(p)) continue
+
 		unsatisfied_properties.delete(p)
-		const { deduced_unsatisfied_properties } = get_deduced_unsatisfied_properties(
+
+		const { deduced_unsatisfied_properties } = refute_properties(
 			satisfied_properties,
 			unsatisfied_properties,
 			implications,
-			{ stop_when_found: p },
-			type,
+			(implication, property) => ({
+				proof: stringify_implication(implication),
+				stop: property === p
+			}),
 			associated_satisfied_properties
 		)
+
 		if (deduced_unsatisfied_properties.has(p)) return p
+
 		unsatisfied_properties.add(p)
 	}
 	return null
diff --git a/databases/catdat/scripts/restrict-functor-properties.ts b/databases/catdat/scripts/restrict-functor-properties.ts
index c7af74cb2..70588dd65 100644
--- a/databases/catdat/scripts/restrict-functor-properties.ts
+++ b/databases/catdat/scripts/restrict-functor-properties.ts
@@ -1,6 +1,7 @@
-import { get_client } from './utils/db'
+import { get_client } from '$shared/db'
+import { devlog } from '$shared/utils'
 
-const db = get_client()
+const db = get_client({ readonly: false })
 
 /**
  * Ensures that only functors with target Set are representable.
@@ -38,5 +39,5 @@ export function restrict_representable_functors() {
 		)
 		.run()
 
-	console.info(`Deduced that ${res.changes} functors cannot be representable`)
+	devlog(`Deduced that ${res.changes} functors cannot be representable`)
 }
diff --git a/databases/catdat/scripts/seed.ts b/databases/catdat/scripts/seed.ts
index 78eb7bfd1..9c60ddf84 100644
--- a/databases/catdat/scripts/seed.ts
+++ b/databases/catdat/scripts/seed.ts
@@ -1,6 +1,6 @@
 import path from 'node:path'
 import { seed_file, seed_files } from './utils/seed.helpers'
-import { get_client } from './utils/db'
+import { get_client } from '$shared/db'
 import type {
 	CategoryYaml,
 	ConfigYaml,
@@ -12,9 +12,10 @@ import type {
 	MorphismYaml
 } from './utils/seed.types'
 import { create_schema_hash, get_saved_schema_hash } from './utils/schema'
-import { PLURALS, STRUCTURE_TYPES, type StructureType } from './config'
+import { STRUCTURE_TYPES, type StructureType, PLURALS } from '$shared/config'
+import { are_disjoint, devlog } from '$shared/utils'
 
-const db = get_client()
+const db = get_client({ readonly: false })
 
 const data_folder = path.resolve('databases', 'catdat', 'data')
 
@@ -47,7 +48,7 @@ function seed() {
  * Checks if the schema is up-to-date, and throws an error otherwise.
  */
 function check_schema() {
-	console.info(`\nCheck schema ...`)
+	devlog(`\nCheck schema ...`)
 
 	const schema_hash = get_saved_schema_hash()
 	const actual_hash = create_schema_hash()
@@ -62,7 +63,7 @@ function check_schema() {
  * Clears all tables in the database. This is done as a first step.
  */
 function clear_all_tables() {
-	console.info(`\nClear all tables ...`)
+	devlog(`\nClear all tables ...`)
 
 	const tx = db.transaction(() => {
 		db.pragma('defer_foreign_keys = ON')
@@ -89,7 +90,6 @@ function clear_all_tables() {
 		db.prepare(`DELETE FROM structure_tags`).run()
 		db.prepare(`DELETE FROM relations`).run()
 
-		// this deletes categories and functors automatically
 		db.prepare(`DELETE FROM structures`).run()
 	})
 
@@ -216,6 +216,20 @@ function seed_structures<T extends StructureYaml>({
 	}
 
 	function insert_structure(structure: T) {
+		const properties_are_disjoint = are_disjoint(
+			[
+				structure.satisfied_properties,
+				structure.unsatisfied_properties,
+				structure.undecidable_properties ?? []
+			],
+			(entry) => entry.property
+		)
+
+		if (!properties_are_disjoint) {
+			console.error(`❌ Properties of ${structure.id} are contradictory.`)
+			process.exit(1)
+		}
+
 		structure_insert.run(
 			structure.id,
 			type,
diff --git a/databases/catdat/scripts/setup.ts b/databases/catdat/scripts/setup.ts
index f70c93a2d..4c1fa136e 100644
--- a/databases/catdat/scripts/setup.ts
+++ b/databases/catdat/scripts/setup.ts
@@ -1,7 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { get_client } from './utils/db'
+import { get_client } from '$shared/db'
 import { create_schema_hash, write_schema_hash } from './utils/schema'
+import { devlog } from '$shared/utils'
 
 const schema_folder = path.resolve('databases', 'catdat', 'schema')
 
@@ -13,7 +14,7 @@ setup()
 function setup() {
 	console.info('\n--- Setup CatDat database ---')
 
-	const db = get_client()
+	const db = get_client({ readonly: false })
 
 	const files = fs
 		.readdirSync(schema_folder, 'utf8')
@@ -26,7 +27,7 @@ function setup() {
 	for (const file of files) {
 		const sql = fs.readFileSync(path.join(schema_folder, file), 'utf8')
 
-		console.info(`Apply: ${file}`)
+		devlog(`Apply: ${file}`)
 
 		try {
 			db.exec(sql)
@@ -39,5 +40,5 @@ function setup() {
 	const hash = create_schema_hash()
 	write_schema_hash(hash)
 
-	console.info('Setup complete')
+	devlog('Setup complete')
 }
diff --git a/databases/catdat/scripts/test.ts b/databases/catdat/scripts/test.ts
index f34ee047d..1e501574d 100644
--- a/databases/catdat/scripts/test.ts
+++ b/databases/catdat/scripts/test.ts
@@ -12,14 +12,14 @@ import id_Set_expected from './expected-data/id_Set.json'
 import decided_categories from './expected-data/decided-categories.json'
 import decided_functors from './expected-data/decided-functors.json'
 import decided_morphisms from './expected-data/decided-morphisms.json'
-import { capitalize } from './utils/helpers'
-import { get_client } from './utils/db'
-import { PLURALS, STRUCTURE_TYPES, type StructureType } from './config'
+import { capitalize, devlog } from '$shared/utils'
+import { get_client } from '$shared/db'
+import { STRUCTURE_TYPES, type StructureType, PLURALS } from '$shared/config'
 import fs from 'node:fs'
 import path from 'node:path'
-import { decode_property_ID } from '../../../src/lib/commons/property.utils'
+import { decode_property_ID } from '$shared/property.utils'
 
-const db = get_client()
+const db = get_client({ readonly: true })
 
 execute_tests()
 
@@ -28,10 +28,12 @@ execute_tests()
  */
 function execute_tests() {
 	try {
-		console.info('--- Test link targets ---')
+		console.info('--- Database Tests ---')
+
+		devlog('\n--- Test link targets ---')
 		check_link_targets_exist()
 
-		console.info('\n--- Test categories ---')
+		devlog('\n--- Test categories ---')
 
 		test_mutual_structure_duals('category')
 		test_positivity('1', 'category')
@@ -42,7 +44,7 @@ function execute_tests() {
 			'category'
 		)
 
-		console.info('\n--- Test functors ---')
+		devlog('\n--- Test functors ---')
 
 		test_positivity('id_Set', 'functor')
 		test_mutual_property_duals('functor')
@@ -52,7 +54,7 @@ function execute_tests() {
 			'functor'
 		)
 
-		console.info('\n--- Test morphisms ---')
+		devlog('\n--- Test morphisms ---')
 
 		test_positivity('id_X', 'morphism')
 		test_decided_structures(decided_morphisms, 'morphism')
@@ -91,7 +93,7 @@ function test_mutual_structure_duals(type: StructureType) {
 		}
 	}
 
-	console.info(`✅ ${capitalize(PLURALS[type])} are mutually dual`)
+	devlog(`✅ ${capitalize(PLURALS[type])} are mutually dual`)
 }
 
 /**
@@ -113,11 +115,11 @@ function test_positivity(structure_id: string, type: StructureType) {
 		)
 	}
 
-	console.info(`✅ The ${type} ${structure_id} has no unsatisfied properties`)
+	devlog(`✅ The ${type} ${structure_id} has no unsatisfied properties`)
 }
 
 /**
- * Tests for all properties p,q of categories or functors that
+ * Tests for all properties p,q of structures that
  * if p is dual to q, then q is dual to p.
  */
 function test_mutual_property_duals(type: StructureType) {
@@ -141,11 +143,11 @@ function test_mutual_property_duals(type: StructureType) {
 		}
 	}
 
-	console.info(`✅ ${capitalize(type)} properties are mutually dual`)
+	devlog(`✅ ${capitalize(type)} properties are mutually dual`)
 }
 
 /**
- * Tests that for a specified list of categories or functors all properties have
+ * Tests that for a specified list of structures all properties have
  * been decided. If this test fails, property assignments or implications are missing.
  */
 function test_decided_structures(structure_ids: string[], type: StructureType) {
@@ -168,12 +170,12 @@ function test_decided_structures(structure_ids: string[], type: StructureType) {
 			)
 		}
 
-		console.info(`✅ All properties have been decided for ${structure_id}`)
+		devlog(`✅ All properties have been decided for ${structure_id}`)
 	}
 }
 
 /**
- * Tests if selected categories or functors behave as expected:
+ * Tests if selected structures behave as expected:
  * All of their properties in the database have to match those in the
  * respective JSON files in the subfolder "expected-data".
  * We exclude undecidable properties here.
@@ -199,7 +201,7 @@ function test_properties_of_selected_structures(
 			throw new Error(`❌ Incorrect property of ${structure_id}: ${property_id}`)
 		}
 
-		console.info(`✅ Properties of ${structure_id} are correct`)
+		devlog(`✅ Properties of ${structure_id} are correct`)
 	}
 }
 
@@ -285,5 +287,5 @@ function check_link_targets_exist() {
 		}
 	}
 
-	console.info(`✅ Link targets exist`)
+	devlog(`✅ Link targets exist`)
 }
diff --git a/databases/catdat/scripts/utils/db.ts b/databases/catdat/scripts/utils/db.ts
deleted file mode 100644
index a2b477874..000000000
--- a/databases/catdat/scripts/utils/db.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import Database from 'better-sqlite3'
-import path from 'node:path'
-
-export function get_client() {
-	const db_path = path.resolve('databases', 'catdat', 'catdat.db')
-	const db = new Database(db_path, { readonly: false })
-	db.pragma('foreign_keys = ON')
-	return db
-}
diff --git a/databases/catdat/scripts/utils/helpers.ts b/databases/catdat/scripts/utils/helpers.ts
deleted file mode 100644
index 7d66d9e28..000000000
--- a/databases/catdat/scripts/utils/helpers.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-export function are_equal_sets<T>(a: Set<T>, b: Set<T>) {
-	return a.size === b.size && [...a].every((el) => b.has(el))
-}
-
-export function is_subset<T>(a: Set<T>, b: Set<T>, options?: { exception: T }) {
-	for (const x of a) {
-		if (x !== options?.exception && !b.has(x)) return false
-	}
-	return true
-}
-
-export function capitalize(txt: string) {
-	return txt[0].toUpperCase() + txt.slice(1)
-}
-
-export function parse_json_set<T>(json: string): Set<T> {
-	return new Set(JSON.parse(json))
-}
-
-export function parse_nested_json_set<T>(json: string): Partial<Record<string, Set<T>>> {
-	const obj = JSON.parse(json)
-	const result: Partial<Record<string, Set<T>>> = {}
-	for (const key in obj) {
-		result[key] = parse_json_set(obj[key])
-	}
-	return result
-}
diff --git a/databases/catdat/scripts/utils/implications.ts b/databases/catdat/scripts/utils/implications.ts
index 5c02874ef..2d5f6a5a8 100644
--- a/databases/catdat/scripts/utils/implications.ts
+++ b/databases/catdat/scripts/utils/implications.ts
@@ -1,91 +1,7 @@
-import { type Database } from 'better-sqlite3'
 import type { PropertyMeta } from './properties'
-import { StructureType } from '../config'
-import { parse_nested_json_set, parse_json_set } from './helpers'
-import { get_property_label } from '../../../../src/lib/commons/property.utils'
-
-export type NormalizedImplication = {
-	id: string
-	assumptions: Set<string>
-	conclusion: string
-	mapped_assumptions?: Partial<Record<string, Set<string>>>
-}
-
-/**
- * Implications have the form
- * P_1 + ... + P_n ===> Q_1 + ... + Q_m
- * or
- * P_1 + ... + P_n <===> Q_1 + ... + Q_m.
- * This function decomposes them into normalized implications,
- * which have the form
- * P_1 + ... + P_n ===> Q.
- */
-export function get_normalized_implications(
-	db: Database,
-	type: StructureType
-): NormalizedImplication[] {
-	const implications_db = db
-		.prepare<
-			[StructureType],
-			{
-				id: string
-				is_equivalence: 0 | 1
-				assumptions: string
-				conclusions: string
-				mapped_assumptions: string
-			}
-		>(
-			`SELECT
-				id,
-				is_equivalence,
-				assumptions,
-				conclusions,
-				mapped_assumptions
-			FROM implications_view i
-			WHERE i.type = ?`
-		)
-		.all(type)
-
-	const implications: NormalizedImplication[] = []
-
-	for (const impl of implications_db) {
-		const assumptions = parse_json_set<string>(impl.assumptions)
-		const conclusions = parse_json_set<string>(impl.conclusions)
-		const mapped_assumptions = parse_nested_json_set<string>(impl.mapped_assumptions)
-
-		for (const conclusion of conclusions) {
-			const implication: NormalizedImplication = {
-				id: impl.id,
-				assumptions,
-				conclusion
-			}
-
-			if (Object.keys(mapped_assumptions).length > 0) {
-				implication.mapped_assumptions = mapped_assumptions
-			}
-
-			implications.push(implication)
-		}
-
-		if (impl.is_equivalence) {
-			for (const assumption of assumptions) {
-				const implication: NormalizedImplication = {
-					id: impl.id,
-					assumptions: conclusions,
-					conclusion: assumption
-				}
-
-				if (Object.keys(mapped_assumptions).length > 0) {
-					implication.mapped_assumptions = mapped_assumptions
-				}
-
-				implications.push(implication)
-			}
-		}
-	}
-
-	return implications
-}
+import { type StructureType } from '$shared/config'
+import { get_property_label } from '$shared/property.utils'
+import { type NormalizedImplication } from '$shared/implications'
 
 function get_assumption_string(
 	implication: NormalizedImplication,
diff --git a/databases/catdat/scripts/utils/properties.ts b/databases/catdat/scripts/utils/properties.ts
index cdfcfa84c..df629bccb 100644
--- a/databases/catdat/scripts/utils/properties.ts
+++ b/databases/catdat/scripts/utils/properties.ts
@@ -1,5 +1,5 @@
 import { type Database } from 'better-sqlite3'
-import type { StructureType } from '../config'
+import { type StructureType } from '$shared/config'
 
 /**
  * Property of a categorical structure
@@ -38,8 +38,7 @@ export function get_properties_dict(db: Database, type: StructureType) {
 
 /**
  * Returns a dictionary with all assigned properties of a list of structures
- * (categories or functors), grouped by id and
- * value (satisfied / unsatisfied / undecidable).
+ * grouped by id and value (satisfied / unsatisfied / undecidable).
  */
 export function get_property_assignments(
 	db: Database,
@@ -123,9 +122,7 @@ export function get_property_assignments_by_deduction(
 				is_satisfied,
 				is_deduced
 			FROM property_assignments
-			WHERE
-				type = ?
-				AND is_satisfied IS NOT NULL`
+			WHERE type = ? AND is_satisfied IS NOT NULL`
 		)
 		.all(type)
 
diff --git a/databases/catdat/scripts/utils/seed.helpers.ts b/databases/catdat/scripts/utils/seed.helpers.ts
index 1b04e7d2c..933675168 100644
--- a/databases/catdat/scripts/utils/seed.helpers.ts
+++ b/databases/catdat/scripts/utils/seed.helpers.ts
@@ -2,6 +2,7 @@ import type { Database } from 'better-sqlite3'
 import path from 'node:path'
 import fs from 'node:fs'
 import YAML from 'yaml'
+import { devlog } from '$shared/utils'
 
 function read_yaml_file<T>(...parts: string[]): T {
 	const content = fs.readFileSync(path.join(...parts), 'utf8')
@@ -21,7 +22,7 @@ export function seed_file<T>(
 	file: string,
 	insert: (item: T) => void
 ) {
-	console.info(`\nSeed ${label} ...`)
+	devlog(`\nSeed ${label} ...`)
 	const item = read_yaml_file<T>(file)
 
 	const tx = db.transaction(() => {
@@ -43,7 +44,7 @@ export function seed_files<T>(
 	folder: string,
 	insert: (item: T) => void
 ) {
-	console.info(`\nSeed ${label} ...`)
+	devlog(`\nSeed ${label} ...`)
 
 	const files = get_yaml_files(folder)
 
@@ -51,7 +52,7 @@ export function seed_files<T>(
 		db.pragma('defer_foreign_keys = ON')
 
 		for (const file of files) {
-			console.info(`Seed: ${file}`)
+			devlog(`Seed: ${file}`)
 
 			const item = read_yaml_file<T>(folder, file)
 			insert(item)
diff --git a/databases/catdat/scripts/utils/structures.ts b/databases/catdat/scripts/utils/structures.ts
index 565f848e9..17c6848e6 100644
--- a/databases/catdat/scripts/utils/structures.ts
+++ b/databases/catdat/scripts/utils/structures.ts
@@ -1,5 +1,5 @@
 import { type Database } from 'better-sqlite3'
-import { StructureType, TABLES } from '../config'
+import { type StructureType } from '$shared/config'
 
 /**
  * Type for various types of categorical structures (category, functor, ...)
@@ -8,7 +8,17 @@ export type StructureMeta = {
 	id: string
 	name: string
 	dual?: string | null
-	associated_satisfied_properties?: Record<string, Set<string>>
+	associated_satisfied_properties?: Partial<Record<string, Set<string>>>
+}
+
+/**
+ * Dictionary associating to every structure type the name of the table.
+ * Currently, this is the same as the plural.
+ */
+const TABLES: Record<StructureType, string> = {
+	category: 'categories',
+	functor: 'functors',
+	morphism: 'morphisms'
 }
 
 /**
@@ -30,7 +40,11 @@ export function get_structures(db: Database, type: StructureType): StructureMeta
 		.all(type)
 
 	const structure_maps = db
-		.prepare<[StructureType], string>(`SELECT map FROM structure_maps WHERE type = ?`)
+		.prepare<[StructureType], string>(
+			`SELECT map
+			FROM structure_maps
+			WHERE type = ?`
+		)
 		.pluck()
 		.all(type)
 
diff --git a/databases/tsconfig.json b/databases/tsconfig.json
new file mode 100644
index 000000000..0bee711b6
--- /dev/null
+++ b/databases/tsconfig.json
@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"paths": {
+			"$shared/*": ["../shared/*"]
+		},
+		"strict": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"noEmit": true
+	},
+	"include": ["**/*.ts"]
+}
diff --git a/package.json b/package.json
index aac44ed52..6e756261c 100644
--- a/package.json
+++ b/package.json
@@ -17,16 +17,16 @@
 		"env:check": "tsx scripts/env.check",
 		"db:shell": "sqlite3 databases/catdat/catdat.db",
 		"db:kill": "rm -rf databases/catdat/catdat.db",
-		"db:setup:catdat": "pnpm db:kill && tsx databases/catdat/scripts/setup.ts",
-		"db:setup": "pnpm db:kill && tsx databases/catdat/scripts/setup.ts && tsx databases/app/scripts/setup.ts",
-		"db:seed": "tsx databases/catdat/scripts/seed.ts",
-		"db:deduce": "tsx databases/catdat/scripts/deduce.ts",
-		"db:test": "tsx databases/catdat/scripts/test.ts",
+		"db:setup:catdat": "pnpm db:kill && tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/setup.ts",
+		"db:setup": "pnpm db:kill && tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/setup.ts && tsx --tsconfig databases/tsconfig.json databases/app/scripts/setup.ts",
+		"db:seed": "tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/seed.ts",
+		"db:deduce": "tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/deduce.ts",
+		"db:test": "tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/test.ts",
 		"db:snapshot": "cp databases/catdat/catdat.db static/databases/catdat-snapshot.db",
 		"db:update": "pnpm db:seed && pnpm db:deduce && pnpm db:test && pnpm db:snapshot",
-		"db:watch": "tsx databases/catdat/scripts/watch.ts",
-		"db:redundancies": "tsx databases/catdat/scripts/redundancies.ts",
-		"db:proof-length": "tsx databases/catdat/scripts/proof-length.ts",
+		"db:watch": "tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/watch.ts",
+		"db:redundancies": "tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/redundancies.ts",
+		"db:proof-length": "tsx --tsconfig databases/tsconfig.json databases/catdat/scripts/proof-length.ts",
 		"e2e": "PUBLIC_PLAYWRIGHT=true pnpm exec playwright test",
 		"e2e:debug": "PUBLIC_PLAYWRIGHT=true pnpm exec playwright test --debug",
 		"e2e:ui": "PUBLIC_PLAYWRIGHT=true pnpm exec playwright test --ui"
diff --git a/src/lib/commons/structures.ts b/shared/config.ts
similarity index 65%
rename from src/lib/commons/structures.ts
rename to shared/config.ts
index a857ee361..9e4a2311f 100644
--- a/src/lib/commons/structures.ts
+++ b/shared/config.ts
@@ -6,16 +6,10 @@ export function is_structure_type(txt: string): txt is StructureType {
 	return (STRUCTURE_TYPES as readonly string[]).includes(txt)
 }
 
+export const STRUCTURE_TYPES_WITH_DUALS: StructureType[] = ['category']
+
 export const PLURALS: Record<StructureType, string> = {
 	category: 'categories',
 	functor: 'functors',
 	morphism: 'morphisms'
 }
-
-export function get_selected_type(pathname: string): StructureType {
-	for (const type of STRUCTURE_TYPES) {
-		const matches = pathname.startsWith(`/${type}`)
-		if (matches) return type
-	}
-	return 'category'
-}
diff --git a/shared/db.ts b/shared/db.ts
new file mode 100644
index 000000000..19cf92365
--- /dev/null
+++ b/shared/db.ts
@@ -0,0 +1,10 @@
+import Database from 'better-sqlite3'
+import path from 'node:path'
+
+const db_path = path.resolve('databases', 'catdat', 'catdat.db')
+
+export function get_client(options: { readonly: boolean }) {
+	const db = new Database(db_path, options)
+	db.pragma('foreign_keys = ON')
+	return db
+}
diff --git a/shared/deduction.utils.ts b/shared/deduction.utils.ts
new file mode 100644
index 000000000..4fe21763f
--- /dev/null
+++ b/shared/deduction.utils.ts
@@ -0,0 +1,134 @@
+import { type NormalizedImplication } from './implications'
+import { is_subset } from './utils'
+
+export function deduce_properties<ProofType>(
+	satisfied_properties: Set<string>,
+	implications: NormalizedImplication[],
+	on_discover: (implication: NormalizedImplication) => {
+		proof: ProofType
+		stop: boolean
+	},
+	associated_satisfied_properties?: Partial<Record<string, Set<string>>>
+) {
+	const found = new Set<string>()
+	const proofs: Partial<Record<string, ProofType>> = {}
+	const deduced_satisfied_properties = new Set(satisfied_properties)
+
+	while (true) {
+		const newly_found = new Set<string>()
+
+		for (const implication of implications) {
+			const is_valid =
+				is_subset(implication.assumptions, deduced_satisfied_properties) &&
+				!deduced_satisfied_properties.has(implication.conclusion) &&
+				!newly_found.has(implication.conclusion)
+
+			if (!is_valid) continue
+
+			if (!is_applicable(implication, associated_satisfied_properties)) continue
+
+			newly_found.add(implication.conclusion)
+			found.add(implication.conclusion)
+
+			const { proof, stop } = on_discover(implication)
+
+			proofs[implication.conclusion] = proof
+
+			if (stop) {
+				for (const p of newly_found) deduced_satisfied_properties.add(p)
+				return {
+					deduced_satisfied_properties,
+					found,
+					proofs,
+					stop_property: implication.conclusion
+				}
+			}
+		}
+
+		for (const p of newly_found) deduced_satisfied_properties.add(p)
+
+		if (!newly_found.size) break
+	}
+
+	return { deduced_satisfied_properties, found, proofs }
+}
+
+export function refute_properties<ProofType>(
+	satisfied_properties: Set<string>,
+	unsatisfied_properties: Set<string>,
+	implications: NormalizedImplication[],
+	on_discover: (
+		implication: NormalizedImplication,
+		property: string
+	) => { proof: ProofType; stop: boolean },
+	associated_satisfied_properties?: Partial<Record<string, Set<string>>>
+) {
+	const found = new Set<string>()
+	const proofs: Partial<Record<string, ProofType>> = {}
+	const deduced_unsatisfied_properties = new Set(unsatisfied_properties)
+
+	while (true) {
+		const newly_found = new Set<string>()
+
+		for (const implication of implications) {
+			if (!deduced_unsatisfied_properties.has(implication.conclusion)) continue
+
+			for (const property of implication.assumptions) {
+				const is_valid =
+					!deduced_unsatisfied_properties.has(property) &&
+					!newly_found.has(property) &&
+					is_subset(implication.assumptions, satisfied_properties, {
+						exception: property
+					})
+
+				if (!is_valid) continue
+
+				if (!is_applicable(implication, associated_satisfied_properties)) continue
+
+				if (satisfied_properties.has(property)) {
+					throw new Error(`Contradiction has been found for: ${property}`)
+				}
+
+				newly_found.add(property)
+				found.add(property)
+
+				const discovery = on_discover(implication, property)
+
+				if (discovery.proof !== undefined) {
+					proofs[property] = discovery.proof
+				}
+
+				if (discovery.stop) {
+					for (const p of newly_found) deduced_unsatisfied_properties.add(p)
+					return {
+						deduced_unsatisfied_properties,
+						found,
+						proofs,
+						stop_property: property
+					}
+				}
+			}
+		}
+
+		for (const property of newly_found) deduced_unsatisfied_properties.add(property)
+
+		if (!newly_found.size) break
+	}
+
+	return { deduced_unsatisfied_properties, found, proofs }
+}
+
+function is_applicable(
+	implication: NormalizedImplication,
+	associated_satisfied_properties?: Partial<Record<string, Set<string>>>
+) {
+	return (
+		!implication.mapped_assumptions ||
+		Object.keys(implication.mapped_assumptions).every((key) => {
+			return is_subset(
+				implication.mapped_assumptions?.[key] ?? new Set(),
+				associated_satisfied_properties?.[key] ?? new Set()
+			)
+		})
+	)
+}
diff --git a/shared/implications.ts b/shared/implications.ts
new file mode 100644
index 000000000..9fbfb749f
--- /dev/null
+++ b/shared/implications.ts
@@ -0,0 +1,92 @@
+import { type Database } from 'better-sqlite3'
+import { type StructureType } from './config'
+import { parse_json_set, parse_nested_json_set } from './utils'
+
+export type NormalizedImplication = {
+	id: string
+	assumptions: Set<string>
+	conclusion: string
+	mapped_assumptions?: Partial<Record<string, Set<string>>>
+}
+
+/**
+ * Implications have the form
+ * P_1 + ... + P_n ===> Q_1 + ... + Q_m
+ * or
+ * P_1 + ... + P_n <===> Q_1 + ... + Q_m.
+ * This function decomposes them into normalized implications,
+ * which have the form
+ * P_1 + ... + P_n ===> Q.
+ */
+export function get_normalized_implications(
+	db: Database,
+	type: StructureType
+): NormalizedImplication[] {
+	const implications_db = db
+		.prepare<
+			[StructureType],
+			{
+				id: string
+				is_equivalence: 0 | 1
+				assumptions: string
+				conclusions: string
+				mapped_assumptions: string
+			}
+		>(
+			`SELECT
+				id,
+				is_equivalence,
+				assumptions,
+				conclusions,
+				mapped_assumptions
+			FROM implications_view
+			WHERE type = ?`
+		)
+		.all(type)
+
+	const implications: NormalizedImplication[] = []
+
+	for (const impl of implications_db) {
+		const assumptions = parse_json_set<string>(impl.assumptions)
+		const conclusions = parse_json_set<string>(impl.conclusions)
+		const mapped_assumptions = parse_nested_json_set<string>(impl.mapped_assumptions)
+
+		const has_mapped_assumptions = Object.keys(mapped_assumptions).length > 0
+
+		for (const conclusion of conclusions) {
+			const implication: NormalizedImplication = {
+				id: impl.id,
+				assumptions,
+				conclusion
+			}
+
+			if (has_mapped_assumptions) {
+				implication.mapped_assumptions = mapped_assumptions
+			}
+
+			implications.push(implication)
+		}
+
+		if (impl.is_equivalence) {
+			for (const assumption of assumptions) {
+				const implication: NormalizedImplication = {
+					id: impl.id,
+					assumptions: conclusions,
+					conclusion: assumption
+				}
+
+				if (has_mapped_assumptions) {
+					implication.mapped_assumptions = mapped_assumptions
+				}
+
+				implications.push(implication)
+			}
+		}
+	}
+
+	return implications
+}
+
+export function stringify_implication(implication: NormalizedImplication) {
+	return `${[...implication.assumptions].join(' ∧ ')} ⟹ ${implication.conclusion}`
+}
diff --git a/src/lib/commons/property.utils.ts b/shared/property.utils.ts
similarity index 94%
rename from src/lib/commons/property.utils.ts
rename to shared/property.utils.ts
index 305e35989..88eef66f0 100644
--- a/src/lib/commons/property.utils.ts
+++ b/shared/property.utils.ts
@@ -1,4 +1,4 @@
-import type { StructureType } from './types'
+import type { StructureType } from './config'
 
 const ENCODE_MAP: Record<string, string> = {
 	' ': '_',
diff --git a/shared/utils.ts b/shared/utils.ts
new file mode 100644
index 000000000..0cb45d731
--- /dev/null
+++ b/shared/utils.ts
@@ -0,0 +1,79 @@
+export function is_string_array(arr: unknown): arr is string[] {
+	return Array.isArray(arr) && arr.every((el) => typeof el === 'string')
+}
+
+export function is_object(obj: unknown): obj is Record<string, unknown> {
+	return obj != null && obj.constructor.name === 'Object'
+}
+
+export function are_equal_sets<T>(a: Set<T>, b: Set<T>) {
+	return a.size === b.size && [...a].every((el) => b.has(el))
+}
+
+export function is_subset<T>(a: Set<T>, b: Set<T>, options?: { exception: T }) {
+	for (const x of a) {
+		if (x !== options?.exception && !b.has(x)) return false
+	}
+	return true
+}
+
+export function are_disjoint<T, S>(lists: T[][], transform: (x: T) => S) {
+	for (let i = 0; i < lists.length; i++) {
+		const a = lists[i].map(transform)
+		for (let j = i + 1; j < lists.length; j++) {
+			const b = lists[j].map(transform)
+			if (a.some((x) => b.includes(x))) return false
+		}
+	}
+	return true
+}
+
+export const sleep = (delay: number) => new Promise<void>((res) => setTimeout(res, delay))
+
+export function capitalize(txt: string) {
+	return txt[0].toUpperCase() + txt.slice(1)
+}
+
+export function pluralize(count: number, forms: { one: string; other: string }) {
+	const word = count === 1 ? forms.one : forms.other
+	return word.replace('{count}', String(count))
+}
+
+/**
+ * Removes accents from letters and transforms to lowercase
+ */
+export function normalize_text(txt: string) {
+	return txt
+		.toLowerCase()
+		.normalize('NFD')
+		.replace(/\p{Diacritic}/gu, '')
+}
+
+export function parse_json_set<T>(json: string): Set<T> {
+	return new Set(JSON.parse(json))
+}
+
+export function parse_nested_json_set<T>(json: string): Partial<Record<string, Set<T>>> {
+	const obj = JSON.parse(json)
+	const result: Partial<Record<string, Set<T>>> = {}
+	for (const key in obj) {
+		result[key] = parse_json_set(obj[key])
+	}
+	return result
+}
+
+export function to_placeholders(arr: string[]): string {
+	return `(${arr.map(() => '?').join(', ')})`
+}
+
+export function strip_math(s: string) {
+	return s.replaceAll('$', '')
+}
+
+export function add_math(s: string) {
+	return `$${s}$`
+}
+
+export function devlog(msg: string) {
+	if (!process.env.CI) console.info(msg)
+}
diff --git a/src/components/ImplicationItem.svelte b/src/components/ImplicationItem.svelte
index 2404f7866..4e4932536 100644
--- a/src/components/ImplicationItem.svelte
+++ b/src/components/ImplicationItem.svelte
@@ -6,7 +6,7 @@
 		faPlus
 	} from '@fortawesome/free-solid-svg-icons'
 	import Fa from 'svelte-fa'
-	import { get_property_url } from '$lib/commons/property.utils'
+	import { get_property_url } from '$shared/property.utils'
 	import type { ImplicationDisplay, StructureType } from '$lib/commons/types'
 
 	type Props = {
@@ -18,7 +18,7 @@
 	let { type, implication, highlighted_property }: Props = $props()
 
 	let has_additional_assumptions = $derived(
-		Object.values(implication.mapped_assumptions).some((list) => list?.length)
+		Object.values(implication.mapped_assumptions).some((list) => list?.size)
 	)
 </script>
 
diff --git a/src/components/PropertyAssignmentList.svelte b/src/components/PropertyAssignmentList.svelte
index 90f5c7265..1e204186c 100644
--- a/src/components/PropertyAssignmentList.svelte
+++ b/src/components/PropertyAssignmentList.svelte
@@ -9,7 +9,7 @@
 		StructureType
 	} from '$lib/commons/types'
 	import { assignment_level } from '$lib/states/assignment_level.svelte'
-	import { pluralize } from '$lib/client/utils'
+	import { pluralize } from '$shared/utils'
 
 	type Props = {
 		type: StructureType
diff --git a/src/components/PropertyList.svelte b/src/components/PropertyList.svelte
index 5ef66a527..1c49878a1 100644
--- a/src/components/PropertyList.svelte
+++ b/src/components/PropertyList.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { get_property_label, get_property_url } from '$lib/commons/property.utils'
+	import { get_property_label, get_property_url } from '$shared/property.utils'
 	import type { StructureType } from '$lib/commons/types'
 	import TextWithProof from './TextWithProof.svelte'
 
diff --git a/src/components/StructureSelector.svelte b/src/components/StructureSelector.svelte
index c73e86cf7..f36a7943b 100644
--- a/src/components/StructureSelector.svelte
+++ b/src/components/StructureSelector.svelte
@@ -1,8 +1,8 @@
 <script lang="ts">
 	import { goto } from '$app/navigation'
 	import { page } from '$app/state'
-	import { PLURALS, STRUCTURE_TYPES } from '$lib/commons/structures'
 	import type { StructureType } from '$lib/commons/types'
+	import { STRUCTURE_TYPES, PLURALS } from '$shared/config'
 
 	type Props = {
 		selected_type: StructureType
diff --git a/src/components/UndistinguishableStructures.svelte b/src/components/UndistinguishableStructures.svelte
index fa8228901..6a6af38cf 100644
--- a/src/components/UndistinguishableStructures.svelte
+++ b/src/components/UndistinguishableStructures.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
-	import { PLURALS } from '$lib/commons/structures'
 	import type { StructureShort, StructureType } from '$lib/commons/types'
+	import { PLURALS } from '$shared/config'
 	import StructureList from './StructureList.svelte'
 
 	type Props = {
diff --git a/src/lib/client/nav.ts b/src/lib/client/nav.ts
index bd687d930..2c67db8f7 100644
--- a/src/lib/client/nav.ts
+++ b/src/lib/client/nav.ts
@@ -14,8 +14,8 @@ import {
 	faSearch,
 	type IconDefinition
 } from '@fortawesome/free-solid-svg-icons'
-import { capitalize } from './utils'
-import { PLURALS } from '$lib/commons/structures'
+import { capitalize } from '$shared/utils'
+import { PLURALS } from '$shared/config'
 
 type Link = {
 	href: string
diff --git a/src/lib/client/utils.ts b/src/lib/client/utils.ts
index 08731e494..76faab46c 100644
--- a/src/lib/client/utils.ts
+++ b/src/lib/client/utils.ts
@@ -1,3 +1,4 @@
+import { normalize_text } from '$shared/utils'
 import type { Attachment } from 'svelte/attachments'
 
 export function get_device_type() {
@@ -7,25 +8,6 @@ export function get_device_type() {
 	return 'desktop'
 }
 
-export function pluralize(count: number, forms: { one: string; other: string }) {
-	const word = count === 1 ? forms.one : forms.other
-	return word.replace('{count}', String(count))
-}
-
-export function capitalize(txt: string) {
-	return txt[0].toUpperCase() + txt.slice(1)
-}
-
-/**
- * Removes accents from letters and transforms to lowercase
- */
-export function normalize_text(txt: string) {
-	return txt
-		.toLowerCase()
-		.normalize('NFD')
-		.replace(/\p{Diacritic}/gu, '')
-}
-
 export function get_comparison_score(value: string, query: string) {
 	if (!query) return -1
 	const v = normalize_text(value)
diff --git a/src/lib/commons/compare.utils.ts b/src/lib/commons/compare.utils.ts
index a36e44b45..d3a78927b 100644
--- a/src/lib/commons/compare.utils.ts
+++ b/src/lib/commons/compare.utils.ts
@@ -1,6 +1,6 @@
 import { browser } from '$app/environment'
 import type { StructureType } from './types'
-import { is_string_array } from './utils'
+import { is_string_array } from '$shared/utils'
 
 export const MAX_STRUCTURES_COMPARE = 10
 
diff --git a/src/lib/commons/types.ts b/src/lib/commons/types.ts
index b45f4526d..3745873f0 100644
--- a/src/lib/commons/types.ts
+++ b/src/lib/commons/types.ts
@@ -1,4 +1,4 @@
-import type { StructureType } from './structures'
+import type { StructureType } from '$shared/config'
 
 export type { StructureType }
 
@@ -28,8 +28,6 @@ export type StructureDisplay = {
 
 export type MappedTypes = Record<string, StructureType>
 
-export type TagObject = { tag: string }
-
 export type CommentObject = { id: number; comment: string }
 
 export type PropertyDB = {
@@ -68,6 +66,11 @@ export type PropertyAssignmentDisplay = {
 	is_deduced: boolean
 }
 
+export type CategoryDefinition = {
+	objects: string
+	morphisms: string
+}
+
 export type SpecialObject = {
 	type: string
 	description: string
@@ -97,16 +100,10 @@ export type ImplicationDisplay = Replace<
 		is_deduced: boolean
 		assumptions: string[]
 		conclusions: string[]
-		mapped_assumptions: Partial<Record<string, string[]>>
+		mapped_assumptions: Partial<Record<string, Set<string>>>
 	}
 >
 
-export type NormalizedImplication = {
-	id: string
-	assumptions: Set<string>
-	conclusion: string
-}
-
 export type SearchResults = {
 	contradiction: string[] | null
 	satisfied_properties: string[]
diff --git a/src/lib/commons/utils.ts b/src/lib/commons/utils.ts
deleted file mode 100644
index c6990b9f1..000000000
--- a/src/lib/commons/utils.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export function is_string_array(arr: unknown): arr is string[] {
-	return Array.isArray(arr) && arr.every((el) => typeof el === 'string')
-}
diff --git a/src/lib/server/cache.ts b/src/lib/server/cache.ts
new file mode 100644
index 000000000..31c86a61a
--- /dev/null
+++ b/src/lib/server/cache.ts
@@ -0,0 +1,6 @@
+import type { RequestEvent } from '@sveltejs/kit'
+
+export function cache_page(event: RequestEvent) {
+	// shared cache for 30min
+	event.setHeaders({ 'cache-control': 'public, max-age=0, s-maxage=1800' })
+}
diff --git a/src/lib/server/consistency.ts b/src/lib/server/consistency.ts
index a2ce131cc..1e9cab31a 100644
--- a/src/lib/server/consistency.ts
+++ b/src/lib/server/consistency.ts
@@ -1,23 +1,25 @@
-import { is_subset } from './utils'
-import type { SqliteError } from 'better-sqlite3'
-import type { NormalizedImplication, StructureType } from '$lib/commons/types'
-import { get_normalized_implications } from './fetchers/implications'
-
-// TODO: If possible, remove the code duplication with deduction and redundancy scripts.
+import { deduce_properties } from '$shared/deduction.utils'
+import type { StructureType } from '$lib/commons/types'
+import {
+	get_normalized_implications,
+	type NormalizedImplication,
+	stringify_implication
+} from '$shared/implications'
+import { db } from './db'
 
 export function get_contradiction(
 	satisfied_properties: Set<string>,
 	unsatisfied_properties: Set<string>,
 	type: StructureType
-): { contradiction: string[] | null; err: SqliteError | null } {
+): { contradiction: string[] | null } {
 	for (const p of satisfied_properties) {
 		const contradiction = [`${p} ⟹ ${p}`]
-		if (unsatisfied_properties.has(p)) return { contradiction, err: null }
+		if (unsatisfied_properties.has(p)) return { contradiction }
 	}
 
-	const { implications, err } = get_normalized_implications(type)
-
-	if (err) return { contradiction: null, err }
+	const implications = get_normalized_implications(db, type).filter(
+		(impl) => !impl.mapped_assumptions
+	)
 
 	const contradiction = contradiction_worker(
 		satisfied_properties,
@@ -25,7 +27,7 @@ export function get_contradiction(
 		implications
 	)
 
-	return { contradiction, err: null }
+	return { contradiction }
 }
 
 export function contradiction_worker(
@@ -37,49 +39,23 @@ export function contradiction_worker(
 		if (unsatisfied_properties.has(p)) return [`${p} ⟹ ${p}`]
 	}
 
-	const deduction_dict: Record<string, NormalizedImplication> = {}
-	const deduced_satisfied_properties = new Set(satisfied_properties)
-
-	// bfs to find contradiction
-
-	let contradictory_property: string | null = null
-
-	while (!contradictory_property) {
-		const new_properties = new Set<string>()
-
-		for (const implication of implications) {
-			const is_valid =
-				is_subset(implication.assumptions, deduced_satisfied_properties) &&
-				!deduced_satisfied_properties.has(implication.conclusion) &&
-				!new_properties.has(implication.conclusion)
-			if (!is_valid) continue
-
-			new_properties.add(implication.conclusion)
-			deduction_dict[implication.conclusion] = implication
-
-			if (unsatisfied_properties.has(implication.conclusion)) {
-				contradictory_property = implication.conclusion
-				break
-			}
-		}
-
-		if (!new_properties.size) break
-
-		for (const p of new_properties) deduced_satisfied_properties.add(p)
-	}
-
-	if (!contradictory_property) return null
-
-	return build_shortest_proof(
+	const { proofs, stop_property } = deduce_properties(
 		satisfied_properties,
-		deduction_dict,
-		contradictory_property
+		implications,
+		(implication) => ({
+			proof: implication,
+			stop: unsatisfied_properties.has(implication.conclusion)
+		})
 	)
+
+	if (!stop_property) return null
+
+	return build_shortest_proof(satisfied_properties, proofs, stop_property)
 }
 
 function build_shortest_proof(
 	satisfied_properties: Set<string>,
-	deduction_dict: Record<string, NormalizedImplication>,
+	proofs: Partial<Record<string, NormalizedImplication>>,
 	target_property: string
 ) {
 	const proof: string[] = []
@@ -91,7 +67,7 @@ function build_shortest_proof(
 		if (satisfied_properties.has(property)) return
 		visited_properties.add(property)
 
-		const implication = deduction_dict[property]
+		const implication = proofs[property]
 		if (!implication) throw new Error(`Missing deduction for property: ${property}`)
 
 		for (const p of implication.assumptions) derive(p)
@@ -103,7 +79,3 @@ function build_shortest_proof(
 
 	return proof
 }
-
-function stringify_implication(implication: NormalizedImplication) {
-	return `${[...implication.assumptions].join(' ∧ ')} ⟹ ${implication.conclusion}`
-}
diff --git a/src/lib/server/db.catdat.ts b/src/lib/server/db.catdat.ts
deleted file mode 100644
index b936667ec..000000000
--- a/src/lib/server/db.catdat.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import type { Arrayed } from '$lib/commons/types'
-import Database, { type SqliteError } from 'better-sqlite3'
-import path from 'node:path'
-
-const db_path = path.resolve('databases', 'catdat', 'catdat.db')
-
-/**
- * Database client for the CatDat database holding all mathematical knowledge
- */
-const db = new Database(db_path, { readonly: true, fileMustExist: true })
-
-/**
- * Small wrapper around db.prepare.all to handle errors,
- * use sql templates, and specify the type of the result.
- */
-export function query<T>({ sql, values = [] }: { sql: string; values?: any[] }) {
-	try {
-		const rows = db.prepare<unknown[], T>(sql).all(...values)
-		return { rows, err: null }
-	} catch (err) {
-		console.error(err)
-		return { rows: null, err: err as SqliteError }
-	}
-}
-
-/**
- * Small wrapper around db.transaction to handle errors
- * use sql templates, and specify the type of the result.
- */
-export function batch<T extends any[]>(queries: { sql: string; values?: any[] }[]) {
-	try {
-		const run_batch = db.transaction(() => {
-			const results = []
-
-			for (const { sql, values = [] } of queries) {
-				const result = db.prepare(sql).all(...values)
-				results.push(result)
-			}
-
-			return results
-		})
-
-		const results = run_batch() as Arrayed<T>
-		return { results, err: null }
-	} catch (err) {
-		console.error(err)
-		return { rows: null, err: err as SqliteError }
-	}
-}
diff --git a/src/lib/server/db.ts b/src/lib/server/db.ts
new file mode 100644
index 000000000..878e0c097
--- /dev/null
+++ b/src/lib/server/db.ts
@@ -0,0 +1,6 @@
+import { get_client } from '$shared/db'
+
+/**
+ * Database client for the CatDat database holding all mathematical knowledge
+ */
+export const db = get_client({ readonly: true })
diff --git a/src/lib/server/fetchers/category.ts b/src/lib/server/fetchers/category.ts
index 170baf9ed..edfdf13a0 100644
--- a/src/lib/server/fetchers/category.ts
+++ b/src/lib/server/fetchers/category.ts
@@ -1,58 +1,57 @@
-import type { SpecialMorphism, SpecialObject, StructureShort } from '$lib/commons/types'
-import sql from 'sql-template-tag'
-import { batch, query } from '$lib/server/db.catdat'
+import type {
+	CategoryDefinition,
+	SpecialMorphism,
+	SpecialObject,
+	StructureShort
+} from '$lib/commons/types'
+import { db } from '$lib/server/db'
 import { error } from '@sveltejs/kit'
 
 export function fetch_category(id: string) {
-	const { results, err } = batch<
-		[
-			{ objects: string; morphisms: string },
-			SpecialObject,
-			SpecialMorphism,
-			StructureShort
-		]
-	>([
-		// specific information for the category
-		sql`
-			SELECT c.objects, c.morphisms
+	const category = db
+		.prepare<[string], CategoryDefinition>(
+			`SELECT c.objects, c.morphisms
 			FROM categories c
-			WHERE c.id = ${id}
-		`,
-		// special objects
-		sql`
-			SELECT s.type, s.description
+			WHERE c.id = ?`
+		)
+		.get(id)
+
+	if (!category) error(404, `Could not find category with ID '${id}'`)
+
+	const special_objects = db
+		.prepare<[string], SpecialObject>(
+			`SELECT s.type, s.description
 			FROM special_objects s
-			INNER JOIN special_object_types t ON t.type = s.type
-			WHERE s.category_id = ${id}
-			ORDER BY t.id
-		`,
-		// special morphisms
-		sql`
-			SELECT t.type, s.description, s.proof
+			INNER JOIN special_object_types t
+			ON t.type = s.type
+			WHERE s.category_id = ?
+			ORDER BY t.id`
+		)
+		.all(id)
+
+	const special_morphisms = db
+		.prepare<[string], SpecialMorphism>(
+			`SELECT t.type, s.description, s.proof
 			FROM special_morphism_types t
 			LEFT JOIN special_morphisms s
-				ON s.type = t.type AND s.category_id = ${id}
-			ORDER BY t.id
-		`,
-		// functors whose source or target is the current category
-		sql`
-			SELECT f.id, s.name
+			ON s.type = t.type AND s.category_id = ?
+			ORDER BY t.id`
+		)
+		.all(id)
+
+	const functors = db
+		.prepare<[string, string], StructureShort>(
+			`SELECT f.id, s.name
 			FROM functors f
 			INNER JOIN structures s ON s.id = f.id
-			WHERE f.source = ${id} OR f.target = ${id}
-			ORDER BY lower(s.name)
-		`
-	])
-
-	if (err) error(500, 'Could not load category')
-
-	const [categories, special_objects, special_morphisms, functors] = results
-
-	if (!categories.length) error(404, `Could not find category with ID '${id}'`)
+			WHERE f.source = ? OR f.target = ?
+			ORDER BY lower(s.name)`
+		)
+		.all(id, id)
 
 	return {
 		type: 'category' as const,
-		...categories[0],
+		...category,
 		special_objects,
 		special_morphisms,
 		functors
@@ -60,20 +59,19 @@ export function fetch_category(id: string) {
 }
 
 export function fetch_categories_with_missing_morphisms() {
-	const { rows, err } = query<StructureShort & { count: number }>(
-		sql`
-			SELECT s.id, s.name, COUNT(*) AS count
+	return db
+		.prepare<never[], StructureShort & { count: number }>(
+			`SELECT
+				s.id,
+				s.name,
+				COUNT(*) AS count
 			FROM structures s
 			JOIN special_morphism_types t
 			LEFT JOIN special_morphisms m
-				ON m.category_id = s.id AND m.type = t.type
+			ON m.category_id = s.id AND m.type = t.type
 			WHERE s.type = 'category' AND m.type IS NULL
 			GROUP BY s.id
-			ORDER BY lower(s.name);
-		`
-	)
-
-	if (err) error(500, 'Failed to load data')
-
-	return rows
+			ORDER BY lower(s.name)`
+		)
+		.all()
 }
diff --git a/src/lib/server/fetchers/comparison.ts b/src/lib/server/fetchers/comparison.ts
index 7a18cf052..3c5f674e1 100644
--- a/src/lib/server/fetchers/comparison.ts
+++ b/src/lib/server/fetchers/comparison.ts
@@ -1,10 +1,10 @@
 import { error } from '@sveltejs/kit'
-import { query } from '$lib/server/db.catdat'
+import { db } from '$lib/server/db'
 import { render_nested_formulas } from '$lib/server/formulas'
 import { MAX_STRUCTURES_COMPARE } from '$lib/commons/compare.utils'
 import type { ComparisonResult, StructureType } from '$lib/commons/types'
-import { PLURALS } from '$lib/commons/structures'
-import { to_placeholders } from '$lib/server/utils'
+import { to_placeholders } from '$shared/utils'
+import { PLURALS } from '$shared/config'
 
 export function fetch_comparison_result(
 	compared_ids: string[],
@@ -20,69 +20,30 @@ export function fetch_comparison_result(
 		)
 	}
 
-	const { rows, err: err_cat } = query<{
-		id: string
-		name: string
-		notation: string
-	}>({
-		sql: `
-			SELECT id, name, notation 
+	const unsorted_structures = db
+		.prepare<string[], { id: string; name: string; notation: string }>(
+			`SELECT id, name, notation 
 			FROM structures
 			WHERE type = ?
-			AND id in (${to_placeholders(compared_ids)})`,
-		values: [type, ...compared_ids]
-	})
-
-	if (err_cat) error(500, `Could not load ${PLURALS[type]}`)
+			AND id in ${to_placeholders(compared_ids)}`
+		)
+		.all(type, ...compared_ids)
 
-	const invalid_id = compared_ids.find((id) => rows.every((row) => row.id !== id))
+	const invalid_id = compared_ids.find((id) =>
+		unsorted_structures.every((row) => row.id !== id)
+	)
 	if (invalid_id) error(404, `Could not find ${type} with ID '${invalid_id}'`)
 
-	const structures = rows.sort(
+	const structures = unsorted_structures.sort(
 		(a, b) => compared_ids.indexOf(a.id) - compared_ids.indexOf(b.id)
 	)
 
-	const select_columns = compared_ids
-		.map(
-			(_, i) =>
-				`CASE 
-					WHEN a${i}.is_satisfied = TRUE THEN 'yes'
-					WHEN a${i}.is_satisfied = FALSE THEN 'no'
-					ELSE 'unknown'
-				END AS struct${i}`
-		)
-		.join(',\n')
-
-	const join_fragments: string[] = []
-	const values: string[] = []
-
-	compared_ids.forEach((id, i) => {
-		join_fragments.push(`
-			LEFT JOIN property_assignments a${i}
-			ON a${i}.property_id = p.id AND a${i}.structure_id = ?
-		`)
-		values.push(id)
-	})
-
-	values.push(type)
-
-	const comparison_query = `
-		SELECT
-			p.id AS property_id,
-			${select_columns}
-		FROM properties p
-		${join_fragments.join('\n')}
-		WHERE p.type = ?
-		ORDER BY lower(p.id)`
-
-	const { rows: comparison_objects, err } = query<Record<string, string>>({
-		sql: comparison_query,
-		values
-	})
-
-	if (err) error(500, 'Could not load comparison table')
+	const comparison_query = get_comparison_query(compared_ids)
 
-	const comparison_table = comparison_objects.map((obj) => Object.values(obj))
+	const comparison_table = db
+		.prepare<string[], string[]>(comparison_query)
+		.raw()
+		.all(...compared_ids, type)
 
 	callback()
 
@@ -92,3 +53,29 @@ export function fetch_comparison_result(
 		type
 	}
 }
+
+function get_comparison_query(compared_ids: string[]) {
+	const columns = compared_ids.map(
+		(_, i) =>
+			`CASE 
+				WHEN a${i}.is_satisfied = TRUE THEN 'yes'
+				WHEN a${i}.is_satisfied = FALSE THEN 'no'
+				ELSE 'unknown'
+			END AS struct${i}`
+	)
+
+	const joins = compared_ids.map(
+		(_, i) =>
+			`LEFT JOIN property_assignments a${i}
+			ON a${i}.property_id = p.id AND a${i}.structure_id = ?`
+	)
+
+	return `
+		SELECT
+			p.id AS property_id,
+			${columns.join(',\n')}
+		FROM properties p
+		${joins.join('\n')}
+		WHERE p.type = ?
+		ORDER BY lower(p.id)`
+}
diff --git a/src/lib/server/fetchers/content.ts b/src/lib/server/fetchers/content.ts
index b235f4206..5b233684a 100644
--- a/src/lib/server/fetchers/content.ts
+++ b/src/lib/server/fetchers/content.ts
@@ -1,38 +1,32 @@
 import type { PropertyShort, StructureShort } from '$lib/commons/types'
-import { batch } from '$lib/server/db.catdat'
-import { error } from '@sveltejs/kit'
-import sql from 'sql-template-tag'
+import { db } from '$lib/server/db'
 
 export function fetch_category_references(content_id: string) {
-	const { results, err: err_categories } = batch<
-		[StructureShort, PropertyShort, { id: string }]
-	>([
-		sql`
-            SELECT DISTINCT s.id, s.name
-            FROM property_assignments pa
-            INNER JOIN structures s ON s.id = pa.structure_id
-            WHERE
-                pa.type = 'category'
-                AND pa.proof LIKE '%/content/' || ${content_id} || '%'
-                
-        `,
-		sql`
-            SELECT id, relation FROM properties
-            WHERE
-                type = 'category'
-                AND description LIKE '%/content/' || ${content_id} || '%'
-        `,
-		sql`
-            SELECT id FROM implications
-            WHERE
-                type = 'category'
-                AND proof LIKE '%/content/' || ${content_id} || '%'
-        `
-	])
+	const categories = db
+		.prepare<[string], StructureShort>(
+			`SELECT DISTINCT s.id, s.name
+	        FROM property_assignments pa
+	        INNER JOIN structures s ON s.id = pa.structure_id
+	        WHERE pa.type = 'category'
+	        AND pa.proof LIKE '%/content/' || ? || '%'`
+		)
+		.all(content_id)
 
-	if (err_categories) error(500, 'Could not load context')
+	const category_properties = db
+		.prepare<[string], PropertyShort>(
+			`SELECT id, relation FROM properties
+            WHERE type = 'category'
+            AND description LIKE '%/content/' || ? || '%'`
+		)
+		.all(content_id)
 
-	const [categories, category_properties, category_implications] = results
+	const category_implications = db
+		.prepare<[string], { id: string }>(
+			`SELECT id FROM implications
+            WHERE type = 'category'
+            AND proof LIKE '%/content/' || ? || '%'`
+		)
+		.all(content_id)
 
 	return { categories, category_properties, category_implications }
 }
diff --git a/src/lib/server/fetchers/functor.ts b/src/lib/server/fetchers/functor.ts
index 5e4705dec..448dc8d5f 100644
--- a/src/lib/server/fetchers/functor.ts
+++ b/src/lib/server/fetchers/functor.ts
@@ -1,13 +1,11 @@
 import type { FunctorSpecificDisplay } from '$lib/commons/types'
-import sql from 'sql-template-tag'
-import { query } from '$lib/server/db.catdat'
+import { db } from '$lib/server/db'
 import { error } from '@sveltejs/kit'
 
 export function fetch_functor(id: string) {
-	const { rows: functors, err } = query<FunctorSpecificDisplay>(
-		// specific information for the functor
-		sql`
-            SELECT
+	const functor = db
+		.prepare<[string], FunctorSpecificDisplay>(
+			`SELECT
                 f.source,
                 f.target,
                 source.name AS source_name,
@@ -26,13 +24,11 @@ export function fetch_functor(id: string) {
             LEFT JOIN structures AS la ON la.id = f.left_adjoint
             LEFT JOIN functors AS rf ON rf.left_adjoint = f.id
             LEFT JOIN structures AS ra ON ra.id = rf.id
-            WHERE f.id = ${id}
-        `
-	)
+            WHERE f.id = ?`
+		)
+		.get(id)
 
-	if (err) error(500, 'Could not load functor')
+	if (!functor) error(404, `Could not find functor with ID '${id}'`)
 
-	if (!functors.length) error(404, `Could not find functor with ID '${id}'`)
-
-	return { type: 'functor' as const, ...functors[0] }
+	return { type: 'functor' as const, ...functor }
 }
diff --git a/src/lib/server/fetchers/implication.ts b/src/lib/server/fetchers/implication.ts
index 36b7bd7eb..48e18cf8c 100644
--- a/src/lib/server/fetchers/implication.ts
+++ b/src/lib/server/fetchers/implication.ts
@@ -1,5 +1,4 @@
-import { batch } from '$lib/server/db.catdat'
-import sql from 'sql-template-tag'
+import { db } from '$lib/server/db'
 import { error } from '@sveltejs/kit'
 import type {
 	ImplicationDB,
@@ -10,11 +9,9 @@ import type {
 import { display_implication } from '$lib/server/transforms'
 
 export function fetch_implication(type: StructureType, id: string) {
-	const { results, err } = batch<
-		[ImplicationDB, StructureShort, { map: string; mapped_type: StructureType }]
-	>([
-		sql`
-            SELECT
+	const implication_db = db
+		.prepare<[string], ImplicationDB>(
+			`SELECT
                 id,
                 is_equivalence,
                 is_deduced,
@@ -24,32 +21,33 @@ export function fetch_implication(type: StructureType, id: string) {
                 conclusions,
                 mapped_assumptions
             FROM implications_view
-            WHERE id = ${id}
-        `,
-		sql`
-            SELECT DISTINCT s.id, s.name
+            WHERE id = ?`
+		)
+		.get(id)
+
+	const structures = db
+		.prepare<[StructureType, string], StructureShort>(
+			`SELECT DISTINCT s.id, s.name
             FROM property_assignments pa
             INNER JOIN structures s ON s.id = pa.structure_id
-            WHERE
-                pa.type = ${type}
-                AND pa.proof LIKE '%/' || ${type} || '-implication/' || ${id} || '%'
-        `,
-		sql`
-            SELECT map, mapped_type
+            WHERE pa.type = ?
+            AND pa.proof LIKE '%/' || pa.type || '-implication/' || ? || '%'`
+		)
+		.all(type, id)
+
+	const structure_maps = db
+		.prepare<[StructureType], { map: string; mapped_type: StructureType }>(
+			`SELECT map, mapped_type
             FROM structure_maps
-            WHERE type = ${type}
-        `
-	])
-
-	if (err) error(500, 'Could not load implication')
-
-	const [implications, structures, structure_maps] = results
+            WHERE type = ?`
+		)
+		.all(type)
 
-	if (!implications.length) {
+	if (!implication_db) {
 		error(404, `Could not find implication with ID '${id}'`)
 	}
 
-	const implication = display_implication(implications[0])
+	const implication = display_implication(implication_db)
 
 	const mapped_types: MappedTypes = {}
 
diff --git a/src/lib/server/fetchers/implications.ts b/src/lib/server/fetchers/implications.ts
index 8f9d5ede3..42bdcb253 100644
--- a/src/lib/server/fetchers/implications.ts
+++ b/src/lib/server/fetchers/implications.ts
@@ -1,90 +1,26 @@
-import { query } from '$lib/server/db.catdat'
-import sql from 'sql-template-tag'
-import { error } from '@sveltejs/kit'
-import type {
-	ImplicationDB,
-	NormalizedImplication,
-	StructureType
-} from '$lib/commons/types'
+import { db } from '$lib/server/db'
+import type { ImplicationDB, StructureType } from '$lib/commons/types'
 import { display_implication } from '$lib/server/transforms'
-import { parse_json_set, parse_nested_json_list } from '$lib/server/utils'
 
 export function fetch_implications(type: StructureType) {
-	const { rows, err } = query<ImplicationDB>(sql`
-        SELECT
-            id,
-            is_equivalence,
-            is_deduced,
-            dualized_from,
-            proof,
-            assumptions,
-            conclusions,
-			mapped_assumptions
-        FROM implications_view
-        WHERE type = ${type}
-        ORDER BY lower(assumptions) || ' ' || lower(conclusions)
-    `)
-
-	if (err) error(500, 'Could not load implications')
-
-	const implications = rows.map(display_implication)
-
-	return { type, implications }
-}
-
-/**
- * List of normalized implications of a given type that have no mapped assumptions
- * (e.g. no source and no target assumptions in the case of functors),
- * i.e. those that are universally true. Only those are relevant
- * for the consistency check.
- */
-export function get_normalized_implications(type: StructureType) {
-	// TODO: remove duplication with deduction script
-
-	const { rows, err } = query<{
-		id: string
-		is_equivalence: 0 | 1
-		assumptions: string
-		mapped_assumptions: string
-		conclusions: string
-	}>(
-		sql`
-			SELECT
+	const implications_db = db
+		.prepare<[StructureType], ImplicationDB>(
+			`SELECT
 				id,
 				is_equivalence,
+				is_deduced,
+				dualized_from,
+				proof,
 				assumptions,
 				conclusions,
 				mapped_assumptions
 			FROM implications_view
-			WHERE type = ${type}
-		`
-	)
+			WHERE type = ?
+			ORDER BY lower(assumptions) || ' ' || lower(conclusions)`
+		)
+		.all(type)
 
-	if (err) return { implications: null, err }
+	const implications = implications_db.map(display_implication)
 
-	const implications: NormalizedImplication[] = []
-
-	for (const impl of rows) {
-		const assumptions = parse_json_set<string>(impl.assumptions)
-		const conclusions = parse_json_set<string>(impl.conclusions)
-		const mapped_assumptions = parse_nested_json_list<string>(impl.mapped_assumptions)
-
-		if (Object.values(mapped_assumptions).some((list) => list?.length)) continue
-
-		for (const conclusion of conclusions) {
-			implications.push({ id: impl.id, assumptions, conclusion })
-		}
-
-		if (impl.is_equivalence) {
-			for (const assumption of assumptions) {
-				implications.push({
-					id: impl.id,
-					assumptions: conclusions,
-					conclusion: assumption
-				})
-			}
-		}
-	}
-
-	return { implications, err: null }
+	return { type, implications }
 }
diff --git a/src/lib/server/fetchers/missing_data.ts b/src/lib/server/fetchers/missing_data.ts
index 9a67bc7bf..0ead8d4ce 100644
--- a/src/lib/server/fetchers/missing_data.ts
+++ b/src/lib/server/fetchers/missing_data.ts
@@ -1,95 +1,85 @@
-import { batch } from '$lib/server/db.catdat'
-import sql from 'sql-template-tag'
+import { db } from '$lib/server/db'
 import type { StructureShort, StructureType } from '$lib/commons/types'
-import { error } from '@sveltejs/kit'
 import { contradiction_worker } from '$lib/server/consistency'
-import { get_normalized_implications } from './implications'
+import { get_normalized_implications } from '$shared/implications'
 
 export function fetch_missing_data(type: StructureType) {
-	const { results, err } = batch<
-		[
-			StructureShort & { count: number },
-			{ id1: string; name1: string; id2: string; name2: string },
-			{ id: string; dual_property_id: string | null },
-			{ p: string; q: string }
-		]
-	>([
-		// structures with unknown properties
-		sql`
-			SELECT s.id, s.name, COUNT(*) AS count
+	const structures_with_unknown_properties = db
+		.prepare<[StructureType], StructureShort & { count: number }>(
+			`SELECT
+				s.id,
+				s.name,
+				COUNT(*) AS count
 			FROM structures s
 			INNER JOIN properties p ON p.type = s.type
 			LEFT JOIN property_assignments pa
-				ON pa.structure_id = s.id
-				AND pa.property_id = p.id
-			WHERE
-				s.type = ${type}
-				AND pa.property_id IS NULL
+			ON pa.structure_id = s.id AND pa.property_id = p.id
+			WHERE s.type = ? AND pa.property_id IS NULL
 			GROUP BY s.id
-			ORDER BY lower(s.name);
-		`,
-		// undistinguishable structure pairs
-		sql`
-			SELECT
+			ORDER BY lower(s.name)`
+		)
+		.all(type)
+
+	const undistinguishable_structure_pairs = db
+		.prepare<
+			[StructureType],
+			{ id1: string; name1: string; id2: string; name2: string }
+		>(
+			`SELECT
 				s1.id AS id1, s1.name AS name1,
 				s2.id AS id2, s2.name AS name2
 			FROM structures s1
 			JOIN structures s2
-				ON s1.id < s2.id AND s2.type = s1.type
+			ON s1.id < s2.id AND s2.type = s1.type
 			JOIN properties p ON p.type = s1.type
 			LEFT JOIN property_assignments a1
-				ON a1.structure_id = s1.id AND a1.property_id = p.id
+			ON a1.structure_id = s1.id AND a1.property_id = p.id
 			LEFT JOIN property_assignments a2
-				ON a2.structure_id = s2.id AND a2.property_id = p.id
-			WHERE s1.type = ${type}
+			ON a2.structure_id = s2.id AND a2.property_id = p.id
+			WHERE s1.type = ?
 			GROUP BY s1.id, s1.name, s2.id, s2.name
 			HAVING SUM(
-			CASE
-				WHEN a1.is_satisfied IS a2.is_satisfied THEN 0
-				ELSE 1
-			END
-			) = 0;
-		`,
-		// properties
-		sql`
-			SELECT id, dual_property_id
+				CASE
+					WHEN a1.is_satisfied IS a2.is_satisfied THEN 0
+					ELSE 1
+				END
+			) = 0`
+		)
+		.all(type)
+
+	const properties = db
+		.prepare<[StructureType], { id: string; dual_property_id: string | null }>(
+			`SELECT id, dual_property_id
 			FROM properties
-			WHERE type = ${type}
-			ORDER BY lower(id)
-		`,
-		// witnessed property combinations of the form "p and not q"
-		sql`
-            SELECT DISTINCT
+			WHERE type = ?
+			ORDER BY lower(id)`
+		)
+		.all(type)
+
+	const witnessed_pairs = db
+		.prepare<[StructureType], { p: string; q: string }>(
+			`SELECT DISTINCT
                 a.property_id AS p,
                 an.property_id AS q
             FROM property_assignments a
             INNER JOIN property_assignments an
             ON a.structure_id = an.structure_id
             WHERE
-                a.type = ${type}
-                AND an.type = ${type}
+                a.type = ?
+                AND an.type = a.type
                 AND a.is_satisfied = TRUE
-                AND an.is_satisfied = FALSE
-	    `
-	])
-
-	if (err) error(500, 'Failed to load data')
-
-	const [
-		structures_with_unknown_properties,
-		undistinguishable_structure_pairs,
-		properties,
-		witnessed_pairs
-	] = results
+                AND an.is_satisfied = FALSE`
+		)
+		.all(type)
 
 	const total_unknown_property_pairs = structures_with_unknown_properties.reduce(
 		(total, item) => item.count + total,
 		0
 	)
 
-	const { implications, err: err_imp } = get_normalized_implications(type)
-
-	if (err_imp) error(500, 'Failed to load data')
+	const implications = get_normalized_implications(db, type).filter(
+		(impl) => !impl.mapped_assumptions
+	)
 
 	const witnessed_pairs_set = new Set(witnessed_pairs.map(({ p, q }) => `${p}|${q}`))
 
diff --git a/src/lib/server/fetchers/morphism.ts b/src/lib/server/fetchers/morphism.ts
index 4fdc5e7fe..8aacbf9a8 100644
--- a/src/lib/server/fetchers/morphism.ts
+++ b/src/lib/server/fetchers/morphism.ts
@@ -1,25 +1,21 @@
 import type { MorphismSpecificDisplay } from '$lib/commons/types'
-import sql from 'sql-template-tag'
-import { query } from '$lib/server/db.catdat'
+import { db } from '$lib/server/db'
 import { error } from '@sveltejs/kit'
 
 export function fetch_morphism(id: string) {
-	const { rows: morphisms, err } = query<MorphismSpecificDisplay>(
-		// specific information for the morphism
-		sql`
-            SELECT
+	const morphism = db
+		.prepare<[string], MorphismSpecificDisplay>(
+			`SELECT
                 c.id AS category,
                 c.name AS category_name,
                 c.notation AS category_notation
             FROM morphisms m
             INNER JOIN structures AS c ON c.id = m.category
-            WHERE m.id = ${id}
-        `
-	)
+            WHERE m.id = ?`
+		)
+		.get(id)
 
-	if (err) error(500, 'Could not load morphism')
+	if (!morphism) error(404, `Could not find morphism with ID '${id}'`)
 
-	if (!morphisms.length) error(404, `Could not find morphism with ID '${id}'`)
-
-	return { type: 'morphism' as const, ...morphisms[0] }
+	return { type: 'morphism' as const, ...morphism }
 }
diff --git a/src/lib/server/fetchers/properties.ts b/src/lib/server/fetchers/properties.ts
index ee31927b5..442751e8a 100644
--- a/src/lib/server/fetchers/properties.ts
+++ b/src/lib/server/fetchers/properties.ts
@@ -1,52 +1,44 @@
 import type {
 	GroupedPropertyShort,
 	PropertyShort,
-	StructureType,
-	TagObject
+	StructureType
 } from '$lib/commons/types'
-import sql from 'sql-template-tag'
-import { query, batch } from '$lib/server/db.catdat'
-import { error } from '@sveltejs/kit'
+import { db } from '$lib/server/db'
 
 export function get_property_ids(type: StructureType) {
-	const { rows, err } = query<{ id: string }>(
-		sql`
-			SELECT id FROM properties
-			WHERE type = ${type}
-			ORDER BY lower(id)
-		`
-	)
-
-	if (err) error(500, 'Failed to load properties')
-
-	return rows.map(({ id }) => id)
+	return db
+		.prepare<[StructureType], string>(
+			`SELECT id FROM properties
+			WHERE type = ?
+			ORDER BY lower(id)`
+		)
+		.pluck()
+		.all(type)
 }
 
 export function fetch_grouped_properties_and_tags(type: StructureType) {
-	const { results, err } = batch<[GroupedPropertyShort, TagObject]>([
-		sql`
-		SELECT id, relation, dual_property_id
-		FROM properties
-		WHERE type = ${type}
-		ORDER BY lower(id)
-	`,
-		sql`
-			SELECT t.tag
+	const properties = db
+		.prepare<[StructureType], GroupedPropertyShort>(
+			`SELECT id, relation, dual_property_id
+			FROM properties
+			WHERE type = ?
+			ORDER BY lower(id)`
+		)
+		.all(type)
+
+	const tags = db
+		.prepare<[StructureType], string>(
+			`SELECT t.tag
 			FROM property_tags t
-			WHERE t.type = ${type}
+			WHERE t.type = ?
 			AND EXISTS (
 				SELECT 1 FROM property_tag_assignments a
-				WHERE a.tag = t.tag AND a.type = ${type}
+				WHERE a.tag = t.tag AND a.type = t.type
 			)
-			ORDER BY t.id
-		`
-	])
-
-	if (err) error(500, 'Failed to load properties')
-
-	const [properties, tag_objects] = results
-
-	const tags = tag_objects.map(({ tag }) => tag)
+			ORDER BY t.id`
+		)
+		.pluck()
+		.all(type)
 
 	const seen = new Set()
 
@@ -79,16 +71,16 @@ export function fetch_grouped_properties_and_tags(type: StructureType) {
 }
 
 export function fetch_tagged_properties(type: StructureType, tag: string) {
-	const { rows: properties, err } = query<PropertyShort>(sql`
-		SELECT p.id, p.relation
-		FROM property_tag_assignments t
-		INNER JOIN properties p
-		ON p.id = t.property_id AND p.type = ${type}
-		WHERE t.tag = ${tag} AND t.type = ${type}
-		ORDER BY lower(id)
-	`)
-
-	if (err) error(500, `Properties could not be loaded`)
+	const properties = db
+		.prepare<[StructureType, string], PropertyShort>(
+			`SELECT p.id, p.relation
+			FROM property_tag_assignments t
+			INNER JOIN properties p
+			ON p.id = t.property_id AND p.type = ?
+			WHERE t.tag = ? AND t.type = p.type
+			ORDER BY lower(id)`
+		)
+		.all(type, tag)
 
 	return { type, properties, tag }
 }
diff --git a/src/lib/server/fetchers/property.ts b/src/lib/server/fetchers/property.ts
index e4d5244d2..90b391f71 100644
--- a/src/lib/server/fetchers/property.ts
+++ b/src/lib/server/fetchers/property.ts
@@ -2,28 +2,16 @@ import type {
 	ImplicationDB,
 	StructureShort,
 	PropertyDB,
-	StructureType,
-	TagObject
+	StructureType
 } from '$lib/commons/types'
-import { batch } from '$lib/server/db.catdat'
+import { db } from '$lib/server/db'
 import { display_implication, display_property } from '$lib/server/transforms'
 import { error } from '@sveltejs/kit'
-import sql from 'sql-template-tag'
 
 export function fetch_property(type: StructureType, id: string) {
-	const { results, err } = batch<
-		[
-			PropertyDB,
-			{ id: string },
-			TagObject,
-			ImplicationDB,
-			StructureShort & { is_satisfied: 0 | 1 | null },
-			StructureShort
-		]
-	>([
-		// basic information
-		sql`
-            SELECT
+	const property_db = db
+		.prepare<[string, StructureType], PropertyDB>(
+			`SELECT
                 id,
                 relation,
                 description,
@@ -31,27 +19,41 @@ export function fetch_property(type: StructureType, id: string) {
                 nlab_link,
                 invariant_under_equivalences
             FROM properties
-            WHERE id = ${id} AND type = ${type}
-        `,
-		// related properties
-		sql`
-            SELECT related_property_id AS id
+            WHERE id = ? AND type = ?`
+		)
+		.get(id, type)
+
+	if (!property_db) {
+		error(404, `Could not find ${type} property with ID '${id}'`)
+	}
+
+	const property = display_property(property_db)
+
+	const related_properties = db
+		.prepare<[string, StructureType], string>(
+			`SELECT related_property_id AS id
             FROM related_properties
-            WHERE property_id = ${id} AND type = ${type}
-            ORDER BY lower(id)
-        `,
-		// tags
-		sql`
-            SELECT pt.tag
+            WHERE property_id = ? AND type = ?
+            ORDER BY lower(id)`
+		)
+		.pluck()
+		.all(id, type)
+
+	const tags = db
+		.prepare<[StructureType, string], string>(
+			`SELECT pt.tag
             FROM property_tag_assignments pt
             INNER JOIN property_tags t
-                ON t.tag = pt.tag AND t.type = ${type}
-            WHERE pt.property_id = ${id} AND pt.type = ${type}
-            ORDER BY t.id
-        `,
-		// relevant implications
-		sql`
-            SELECT
+            ON t.tag = pt.tag AND t.type = ?
+            WHERE pt.property_id = ? AND pt.type = t.type
+            ORDER BY t.id`
+		)
+		.pluck()
+		.all(type, id)
+
+	const relevant_implications_db = db
+		.prepare<string[], ImplicationDB>(
+			`SELECT
                 id,
                 is_equivalence,
                 is_deduced,
@@ -61,73 +63,54 @@ export function fetch_property(type: StructureType, id: string) {
                 conclusions,
                 mapped_assumptions
             FROM implications_view
-            WHERE type = ${type}
+            WHERE type = ?
             AND (
                 EXISTS (
                     SELECT 1
                     FROM json_each(conclusions)
-                    WHERE value = ${id}
+                    WHERE value = ?
                 )
                 OR
                 EXISTS (
                     SELECT 1
                     FROM json_each(assumptions)
-                    WHERE value = ${id}
+                    WHERE value = ?
                 )
             )
-            ORDER BY lower(assumptions) || ' ' || lower(conclusions)
-        `,
-		// known structures
-		sql`
-            SELECT s.id, s.name, pa.is_satisfied
+            ORDER BY lower(assumptions) || ' ' || lower(conclusions)`
+		)
+		.all(type, id, id)
+
+	const relevant_implications = relevant_implications_db.map(display_implication)
+
+	const known_structures = db
+		.prepare<
+			[StructureType, string],
+			StructureShort & { is_satisfied: 0 | 1 | null }
+		>(
+			`SELECT s.id, s.name, pa.is_satisfied
             FROM property_assignments pa
             INNER JOIN structures s ON s.id = pa.structure_id
-            WHERE
-                s.type = ${type}
-                AND pa.property_id = ${id}
-            ORDER BY lower(s.name)
-        `,
-		// unknown structures
-		sql`
-            SELECT s.id, s.name
+            WHERE s.type = ? AND pa.property_id = ?
+            ORDER BY lower(s.name)`
+		)
+		.all(type, id)
+
+	const unknown_structures = db
+		.prepare<[string, StructureType], StructureShort>(
+			`SELECT s.id, s.name
             FROM structures s
             LEFT JOIN property_assignments pa
-                ON pa.structure_id = s.id
-                AND pa.property_id = ${id}
-            WHERE
-                s.type = ${type}
-                AND pa.property_id IS NULL
-            ORDER BY lower(s.name)
-        `
-	])
-
-	if (err) error(500, 'Could not load property')
-
-	const [
-		properties,
-		related,
-		tag_objects,
-		relevant_implications_db,
-		known_structures,
-		unknown_structures
-	] = results
-
-	if (!properties.length) {
-		error(404, `Could not find property with ID '${id}'`)
-	}
-
-	const property = display_property(properties[0])
-
-	const related_properties = related.map(({ id }) => id)
-
-	const tags = tag_objects.map(({ tag }) => tag)
+            ON pa.structure_id = s.id AND pa.property_id = ?
+            WHERE s.type = ? AND pa.property_id IS NULL
+            ORDER BY lower(s.name)`
+		)
+		.all(id, type)
 
 	const examples = known_structures.filter((f) => f.is_satisfied === 1)
 	const counterexamples = known_structures.filter((f) => f.is_satisfied === 0)
 	const undecidable_structures = known_structures.filter((f) => f.is_satisfied === null)
 
-	const relevant_implications = relevant_implications_db.map(display_implication)
-
 	for (const impl of relevant_implications) {
 		if (!impl.is_equivalence && impl.conclusions.includes(id)) {
 			impl.conclusions = [id]
diff --git a/src/lib/server/fetchers/search.ts b/src/lib/server/fetchers/search.ts
index 1a60725cc..856eb4f8a 100644
--- a/src/lib/server/fetchers/search.ts
+++ b/src/lib/server/fetchers/search.ts
@@ -1,11 +1,10 @@
-import { decode_property_ID } from '$lib/commons/property.utils'
-import { query } from '$lib/server/db.catdat'
+import { decode_property_ID } from '$shared/property.utils'
+import { db } from '$lib/server/db'
 import { error } from '@sveltejs/kit'
 import { SEARCH_SEPARATOR } from '$lib/commons/search.config'
 import { get_contradiction } from '$lib/server/consistency'
 import type { SearchResults, StructureShort, StructureType } from '$lib/commons/types'
-import { to_placeholders } from '$lib/server/utils'
-import sql from 'sql-template-tag'
+import { to_placeholders } from '$shared/utils'
 
 export function fetch_search_results(
 	satisfied_query: string | null,
@@ -17,21 +16,18 @@ export function fetch_search_results(
 		error(400, 'No properties selected')
 	}
 
-	const { rows: all_properties_objects, err: err_all } = query<{
-		id: string
-		dual_property_id: string | null
-	}>(sql`
-		SELECT id, dual_property_id FROM properties
-		WHERE type = ${type}
-		ORDER BY lower(id)
-	`)
+	const all_properties = db
+		.prepare<[StructureType], { id: string; dual_property_id: string | null }>(
+			`SELECT id, dual_property_id FROM properties
+			WHERE type = ?
+			ORDER BY lower(id)`
+		)
+		.all(type)
 
-	if (err_all) error(500, 'Failed to load properties')
-
-	const all_properties = new Set(all_properties_objects.map(({ id }) => id))
+	const all_properties_ids = new Set(all_properties.map(({ id }) => id))
 
 	const dual_properties_dict: Record<string, string | null> = {}
-	for (const row of all_properties_objects) {
+	for (const row of all_properties) {
 		dual_properties_dict[row.id] = row.dual_property_id
 	}
 
@@ -40,7 +36,7 @@ export function fetch_search_results(
 		: []
 
 	const invalid_satisfied_property = satisfied_properties.find(
-		(p) => !all_properties.has(p)
+		(p) => !all_properties_ids.has(p)
 	)
 
 	if (invalid_satisfied_property) {
@@ -52,7 +48,7 @@ export function fetch_search_results(
 		: []
 
 	const invalid_unsatisfied_property = unsatisfied_properties.find(
-		(p) => !all_properties.has(p)
+		(p) => !all_properties_ids.has(p)
 	)
 
 	if (invalid_unsatisfied_property) {
@@ -71,14 +67,12 @@ export function fetch_search_results(
 		dual_satisfied_properties.every(Boolean) &&
 		dual_unsatisfied_properties.every(Boolean)
 
-	const { contradiction, err: err_con } = get_contradiction(
+	const { contradiction } = get_contradiction(
 		new Set(satisfied_properties),
 		new Set(unsatisfied_properties),
 		type
 	)
 
-	if (err_con) error(500, 'Consistency check failed')
-
 	if (contradiction) {
 		callback()
 
@@ -97,17 +91,19 @@ export function fetch_search_results(
 	const all_selected_properties = [...satisfied_properties, ...unsatisfied_properties]
 
 	const search_query = `
-		SELECT s.id, s.name FROM structures s
-		INNER JOIN property_assignments a ON a.structure_id = s.id
+		SELECT s.id, s.name
+		FROM structures s
+		INNER JOIN property_assignments a
+		ON a.structure_id = s.id
 		WHERE
 			s.type = ? AND a.type = s.type
-			AND property_id IN (${to_placeholders(all_selected_properties)})
+			AND property_id IN ${to_placeholders(all_selected_properties)}
 		GROUP BY structure_id
 		HAVING
 			SUM (
 				CASE
 					WHEN
-						property_id IN (${to_placeholders(satisfied_properties)})
+						property_id IN ${to_placeholders(satisfied_properties)}
 						AND is_satisfied = TRUE
 					THEN 1
 					ELSE 0
@@ -117,7 +113,7 @@ export function fetch_search_results(
 			SUM(
 				CASE
 					WHEN
-						property_id IN (${to_placeholders(unsatisfied_properties)})
+						property_id IN ${to_placeholders(unsatisfied_properties)}
 						AND is_satisfied = FALSE
 					THEN 1
 					ELSE 0
@@ -126,17 +122,14 @@ export function fetch_search_results(
 		ORDER BY lower(s.name)
 	`
 
-	const { rows: found_structures, err } = query<StructureShort>({
-		sql: search_query,
-		values: [
+	const found_structures = db
+		.prepare<string[], StructureShort>(search_query)
+		.all(
 			type,
 			...all_selected_properties,
 			...satisfied_properties,
 			...unsatisfied_properties
-		]
-	})
-
-	if (err) error(500, 'Search failed')
+		)
 
 	callback()
 
diff --git a/src/lib/server/fetchers/structure.ts b/src/lib/server/fetchers/structure.ts
index 955f13328..e63f211fc 100644
--- a/src/lib/server/fetchers/structure.ts
+++ b/src/lib/server/fetchers/structure.ts
@@ -6,29 +6,16 @@ import type {
 	StructureDetails,
 	StructureDisplay,
 	StructureShort,
-	StructureType,
-	TagObject
+	StructureType
 } from '$lib/commons/types'
 import { error } from '@sveltejs/kit'
-import sql from 'sql-template-tag'
-import { batch } from '$lib/server/db.catdat'
+import { db } from '$lib/server/db'
 import { display_property_assignment } from '$lib/server/transforms'
 
 export function fetch_structure(type: StructureType, id: string): StructureDetails {
-	const { err, results } = batch<
-		[
-			StructureDisplay,
-			RelatedStructure,
-			TagObject,
-			PropertyAssignmentDB,
-			PropertyShort,
-			StructureShort,
-			CommentObject
-		]
-	>([
-		// basic information
-		sql`
-            SELECT
+	const structure = db
+		.prepare<[string], StructureDisplay>(
+			`SELECT
                 s.id,
                 s.name,
                 s.notation,
@@ -39,30 +26,41 @@ export function fetch_structure(type: StructureType, id: string): StructureDetai
                 ds.notation AS dual_structure_notation
             FROM structures s
             LEFT JOIN structures ds ON ds.id = s.dual_structure_id
-            WHERE s.id = ${id}
-        `,
-		// related structures
-		sql`
-            SELECT
+            WHERE s.id = ?`
+		)
+		.get(id)
+
+	if (!structure) {
+		error(404, `Could not find ${type} with ID '${id}'`)
+	}
+
+	const related_structures = db
+		.prepare<[string], RelatedStructure>(
+			`SELECT
                 c.id,
                 c.name,
                 c.notation
             FROM related_structures r
             INNER JOIN structures c ON c.id = r.related_structure_id
-            WHERE r.structure_id = ${id}
-            ORDER BY lower(c.name)
-        `,
-		// tags
-		sql`
-            SELECT st.tag
+            WHERE r.structure_id = ?
+            ORDER BY lower(c.name)`
+		)
+		.all(id)
+
+	const tags = db
+		.prepare<[StructureType, string], string>(
+			`SELECT st.tag
             FROM structure_tag_assignments st
             INNER JOIN structure_tags t ON t.tag = st.tag
-            WHERE t.type = ${type} AND st.structure_id = ${id}
-            ORDER BY t.id
-        `,
-		// properties
-		sql`
-            SELECT
+            WHERE t.type = ? AND st.structure_id = ?
+            ORDER BY t.id`
+		)
+		.pluck()
+		.all(type, id)
+
+	const properties_db = db
+		.prepare<[string], PropertyAssignmentDB>(
+			`SELECT
                 pa.property_id AS id,
                 pa.is_satisfied,
                 pa.proof,
@@ -76,64 +74,50 @@ export function fetch_structure(type: StructureType, id: string): StructureDetai
             ON p.id = pa.property_id AND p.type = pa.type
             INNER JOIN relations r
             ON r.relation = p.relation
-            WHERE pa.structure_id = ${id}
-            ORDER BY pa.id
-        `,
-		// unknown properties
-		sql`
-            SELECT p.id, p.relation
+            WHERE pa.structure_id = ?
+            ORDER BY pa.id`
+		)
+		.all(id)
+
+	const unknown_properties = db
+		.prepare<[StructureType, string], PropertyShort>(
+			`SELECT p.id, p.relation
             FROM properties p
-            WHERE p.type = ${type} AND NOT EXISTS (
+            WHERE p.type = ?
+            AND NOT EXISTS (
                 SELECT 1 FROM property_assignments
-                WHERE structure_id = ${id} AND property_id = p.id
+                WHERE structure_id = ? AND property_id = p.id
             )
-            ORDER BY lower(p.id)
-        `,
-		// undistinguishable structures
-		sql`
-            SELECT u.id, u.name
+            ORDER BY lower(p.id)`
+		)
+		.all(type, id)
+
+	const undistinguishable_structures = db
+		.prepare<[string, StructureType, string], StructureShort>(
+			`SELECT u.id, u.name
             FROM structures u
             JOIN properties p ON p.type = u.type
             LEFT JOIN property_assignments pa
-                ON pa.structure_id = ${id}
-                AND pa.property_id = p.id
+            ON pa.structure_id = ? AND pa.property_id = p.id
             LEFT JOIN property_assignments up
-                ON up.structure_id = u.id
-                AND up.property_id = p.id
-            WHERE
-                u.type = ${type}
-                AND u.id != ${id}
+            ON up.structure_id = u.id AND up.property_id = p.id
+            WHERE u.type = ? AND u.id != ?
             GROUP BY u.id, u.name
             HAVING SUM(
                 CASE
                     WHEN pa.is_satisfied IS up.is_satisfied THEN 0
                     ELSE 1
                 END
-            ) = 0;
-        `,
-		// comments
-		sql`
-            SELECT id, comment FROM structure_comments
-            WHERE structure_id = ${id}
-        `
-	])
-
-	if (err) error(500, `Could not load ${type} with ID ${id}`)
-
-	const [
-		structures,
-		related_structures,
-		tag_objects,
-		properties_db,
-		unknown_properties,
-		undistinguishable_structures,
-		comments
-	] = results
-
-	if (!structures.length) error(404, `Could not find ${type} with ID '${id}'`)
+            ) = 0`
+		)
+		.all(id, type, id)
 
-	const structure = structures[0]
-	const tags = tag_objects.map(({ tag }) => tag)
+	const comments = db
+		.prepare<[string], CommentObject>(
+			`SELECT id, comment FROM structure_comments
+            WHERE structure_id = ?`
+		)
+		.all(id)
 
 	const satisfied_properties = properties_db
 		.filter((obj) => obj.is_satisfied === 1)
diff --git a/src/lib/server/fetchers/structures.ts b/src/lib/server/fetchers/structures.ts
index fd1868f38..d3cddf4f2 100644
--- a/src/lib/server/fetchers/structures.ts
+++ b/src/lib/server/fetchers/structures.ts
@@ -1,62 +1,57 @@
-import { capitalize } from '$lib/client/utils'
-import { PLURALS } from '$lib/commons/structures'
-import type { StructureShort, StructureType, TagObject } from '$lib/commons/types'
-import { batch, query } from '$lib/server/db.catdat'
-import { error } from '@sveltejs/kit'
-import sql from 'sql-template-tag'
+import type { StructureShort, StructureType } from '$lib/commons/types'
+import { db } from '$lib/server/db'
 
 export function fetch_structures(type: StructureType) {
-	const { rows: structures, err } = query<StructureShort>(sql`
-        SELECT id, name
-        FROM structures
-        WHERE type = ${type}
-        ORDER BY lower(name)
-    `)
-
-	if (err) error(500, `${capitalize(PLURALS[type])} could not be loaded`)
+	const structures = db
+		.prepare<[StructureType], StructureShort>(
+			`SELECT id, name
+            FROM structures
+            WHERE type = ?
+            ORDER BY lower(name)`
+		)
+		.all(type)
 
 	return { structures, type }
 }
 
 export function fetch_structures_and_tags(type: StructureType) {
-	const { results, err } = batch<[StructureShort, TagObject]>([
-		sql`
-            SELECT id, name
+	const structures = db
+		.prepare<[StructureType], StructureShort>(
+			`SELECT id, name
             FROM structures
-            WHERE type = ${type}
-            ORDER BY lower(name)`,
-		sql`
-            SELECT t.tag
+            WHERE type = ?
+            ORDER BY lower(name)`
+		)
+		.all(type)
+
+	const tags = db
+		.prepare<[StructureType], string>(
+			`SELECT t.tag
             FROM structure_tags t
-            WHERE t.type = ${type}
+            WHERE t.type = ?
             AND EXISTS (
                 SELECT 1 FROM structure_tag_assignments a
-                WHERE a.tag = t.tag AND a.type = ${type}
+                WHERE a.tag = t.tag AND a.type = t.type
             )
-            ORDER BY t.id
-        `
-	])
-
-	if (err) error(500, `${capitalize(PLURALS[type])} could not be loaded`)
-
-	const [structures, tag_objects] = results
-
-	const tags = tag_objects.map(({ tag }) => tag)
+            ORDER BY t.id`
+		)
+		.pluck()
+		.all(type)
 
 	return { type, structures, tags }
 }
 
 export function fetch_tagged_structures(type: StructureType, tag: string) {
-	const { rows: structures, err } = query<StructureShort>(sql`
-        SELECT s.id, s.name
-        FROM structure_tag_assignments t
-        INNER JOIN structures s
-        ON s.id = t.structure_id
-        WHERE t.tag = ${tag} AND t.type = ${type}
-        ORDER BY lower(name)
-    `)
-
-	if (err) error(500, `${capitalize(PLURALS[type])} could not be loaded`)
+	const structures = db
+		.prepare<[StructureType, string], StructureShort>(
+			`SELECT s.id, s.name
+            FROM structure_tag_assignments t
+            INNER JOIN structures s
+            ON s.id = t.structure_id
+            WHERE t.type = ? AND t.tag = ?
+            ORDER BY lower(name)`
+		)
+		.all(type, tag)
 
 	return { type, structures, tag }
 }
diff --git a/src/lib/server/fetchers/tags.ts b/src/lib/server/fetchers/tags.ts
index dfd30d0e1..627df5b1b 100644
--- a/src/lib/server/fetchers/tags.ts
+++ b/src/lib/server/fetchers/tags.ts
@@ -1,23 +1,20 @@
 import type { StructureType } from '$lib/commons/types'
-import sql from 'sql-template-tag'
-import { query } from '$lib/server/db.catdat'
+import { db } from '$lib/server/db'
 
 export function fetch_structure_tags() {
-	const { rows, err } = query<{ tag: string; type: StructureType }>(sql`
-		SELECT tag, type FROM structure_tags
-	`)
-
-	if (err) throw new Error('Database error: Failed to load structure tags')
-
-	return rows
+	return db
+		.prepare<
+			never[],
+			{ tag: string; type: StructureType }
+		>(`SELECT tag, type FROM structure_tags`)
+		.all()
 }
 
 export function fetch_property_tags() {
-	const { rows, err } = query<{ tag: string; type: StructureType }>(sql`
-		SELECT tag, type FROM property_tags
-	`)
-
-	if (err) throw new Error('Database error: Failed to load property tags')
-
-	return rows
+	return db
+		.prepare<
+			never[],
+			{ tag: string; type: StructureType }
+		>(`SELECT tag, type FROM property_tags`)
+		.all()
 }
diff --git a/src/lib/server/formulas.ts b/src/lib/server/formulas.ts
index ae74c0d80..302b851cb 100644
--- a/src/lib/server/formulas.ts
+++ b/src/lib/server/formulas.ts
@@ -1,6 +1,12 @@
 import katex from 'katex'
-import { is_object } from './utils'
-import { MACROS } from './macros'
+import { is_object } from '$shared/utils'
+import YAML from 'yaml'
+import path from 'node:path'
+import fs from 'node:fs'
+
+const MACROS = YAML.parse(
+	fs.readFileSync(path.resolve('databases', 'catdat', 'data', 'macros.yaml'), 'utf8'),
+) as Record<string, string>
 
 export const MATH_REGEX = /\$\$(.*?)\$\$|\$(.*?)\$/gs
 
diff --git a/src/lib/server/macros.ts b/src/lib/server/macros.ts
deleted file mode 100644
index 36c84d050..000000000
--- a/src/lib/server/macros.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import YAML from 'yaml'
-import path from 'node:path'
-import fs from 'node:fs'
-
-export const MACROS = YAML.parse(
-	fs.readFileSync(path.resolve('databases', 'catdat', 'data', 'macros.yaml'), 'utf8')
-) as Record<string, string>
diff --git a/src/lib/server/transforms.ts b/src/lib/server/transforms.ts
index 1beacc427..b5c808a79 100644
--- a/src/lib/server/transforms.ts
+++ b/src/lib/server/transforms.ts
@@ -6,7 +6,7 @@ import type {
 	ImplicationDB,
 	ImplicationDisplay
 } from '$lib/commons/types'
-import { parse_nested_json_list } from './utils'
+import { parse_nested_json_set } from '$shared/utils'
 
 export function display_property(property: PropertyDB): PropertyDisplay {
 	return {
@@ -39,6 +39,6 @@ export function display_implication(implication: ImplicationDB): ImplicationDisp
 		proof: implication.proof,
 		assumptions: JSON.parse(implication.assumptions),
 		conclusions: JSON.parse(implication.conclusions),
-		mapped_assumptions: parse_nested_json_list(implication.mapped_assumptions)
+		mapped_assumptions: parse_nested_json_set(implication.mapped_assumptions)
 	}
 }
diff --git a/src/lib/server/utils.ts b/src/lib/server/utils.ts
deleted file mode 100644
index 6b7559e31..000000000
--- a/src/lib/server/utils.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import type { RequestEvent } from '@sveltejs/kit'
-
-export function is_object(obj: unknown): obj is Record<string, unknown> {
-	return obj != null && obj.constructor.name === 'Object'
-}
-
-export function is_subset<T>(a: Set<T>, b: Set<T>) {
-	for (const x of a) {
-		if (!b.has(x)) return false
-	}
-	return true
-}
-
-export function to_placeholders(arr: string[]): string {
-	return arr.map(() => '?').join(', ')
-}
-
-export const sleep = (delay: number) => new Promise<void>((res) => setTimeout(res, delay))
-
-export function parse_json_set<T>(json: string): Set<T> {
-	return new Set(JSON.parse(json))
-}
-
-export function parse_nested_json_list<T>(json: string): Partial<Record<string, T[]>> {
-	const obj = JSON.parse(json)
-	const result: Partial<Record<string, T[]>> = {}
-	for (const key in obj) {
-		result[key] = JSON.parse(obj[key])
-	}
-	return result
-}
-
-export function cache_page(event: RequestEvent) {
-	// shared cache for 30min
-	event.setHeaders({ 'cache-control': 'public, max-age=0, s-maxage=1800' })
-}
-
-export function strip_math(s: string) {
-	return s.replaceAll('$', '')
-}
-
-export function add_math(s: string) {
-	return `$${s}$`
-}
diff --git a/src/pages/CategoryDetailPage.svelte b/src/pages/CategoryDetailPage.svelte
index a40823abd..663dd9c3d 100644
--- a/src/pages/CategoryDetailPage.svelte
+++ b/src/pages/CategoryDetailPage.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
 	import StructureList from '$components/StructureList.svelte'
 	import TextWithProof from '$components/TextWithProof.svelte'
-	import { pluralize } from '$lib/client/utils'
+	import { pluralize } from '$shared/utils'
 	import type { StructureDetails, CategorySpecificDisplay } from '$lib/commons/types'
 	import StructureDetailPage from '$pages/StructureDetailPage.svelte'
 	import { faQuestion } from '@fortawesome/free-solid-svg-icons'
diff --git a/src/pages/ComparisonPage.svelte b/src/pages/ComparisonPage.svelte
index 5951064c0..ac6694796 100644
--- a/src/pages/ComparisonPage.svelte
+++ b/src/pages/ComparisonPage.svelte
@@ -8,7 +8,7 @@
 		MAX_STRUCTURES_COMPARE,
 		save_comparison
 	} from '$lib/commons/compare.utils'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 	import type { StructureShort, StructureType } from '$lib/commons/types'
 
 	type Props = {
diff --git a/src/pages/ComparisonResultPage.svelte b/src/pages/ComparisonResultPage.svelte
index 8436453f0..e8927e0ae 100644
--- a/src/pages/ComparisonResultPage.svelte
+++ b/src/pages/ComparisonResultPage.svelte
@@ -1,7 +1,7 @@
 <script lang="ts">
 	import MetaData from '$components/MetaData.svelte'
-	import { get_property_url } from '$lib/commons/property.utils'
-	import { PLURALS } from '$lib/commons/structures'
+	import { get_property_url } from '$shared/property.utils'
+	import { PLURALS } from '$shared/config'
 	import type { ComparisonResult, StructureType } from '$lib/commons/types'
 	import {
 		faCheck,
diff --git a/src/pages/ImplicationListPage.svelte b/src/pages/ImplicationListPage.svelte
index 629ef24f3..3cd1e9bed 100644
--- a/src/pages/ImplicationListPage.svelte
+++ b/src/pages/ImplicationListPage.svelte
@@ -5,7 +5,7 @@
 	import MetaData from '$components/MetaData.svelte'
 	import SearchFilter from '$components/SearchFilter.svelte'
 	import SuggestionForm from '$components/SuggestionForm.svelte'
-	import { capitalize, normalize_text, pluralize } from '$lib/client/utils'
+	import { capitalize, normalize_text, pluralize } from '$shared/utils'
 	import type { ImplicationDisplay, StructureType } from '$lib/commons/types'
 	import { faInfoCircle } from '@fortawesome/free-solid-svg-icons'
 	import type { Snippet } from 'svelte'
diff --git a/src/pages/ImplicationPage.svelte b/src/pages/ImplicationPage.svelte
index b9850a72c..ed25d86a4 100644
--- a/src/pages/ImplicationPage.svelte
+++ b/src/pages/ImplicationPage.svelte
@@ -2,8 +2,8 @@
 	import StructureList from '$components/StructureList.svelte'
 	import MetaData from '$components/MetaData.svelte'
 	import SuggestionForm from '$components/SuggestionForm.svelte'
-	import { pluralize } from '$lib/client/utils'
-	import { get_property_url } from '$lib/commons/property.utils'
+	import { pluralize } from '$shared/utils'
+	import { get_property_url } from '$shared/property.utils'
 	import { faInfoCircle } from '@fortawesome/free-solid-svg-icons'
 	import Fa from 'svelte-fa'
 	import type {
@@ -12,7 +12,7 @@
 		StructureShort,
 		StructureType
 	} from '$lib/commons/types'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 
 	type Props = {
 		type: StructureType
@@ -39,14 +39,14 @@
 	{/each}
 </p>
 
-{#each Object.entries(implication.mapped_assumptions) as [map, list]}
-	{#if list?.length}
+{#each Object.entries(implication.mapped_assumptions) as [map, set]}
+	{#if set?.size}
 		<p>
 			<strong>Requirements of the {map}:</strong>
 
-			{#each list as property, index}
+			{#each set as property, index}
 				<a href={get_property_url(property, mapped_types[map])}>{property}</a
-				>{#if index < list.length - 1}
+				>{#if index < set.size - 1}
 					,&nbsp;
 				{/if}
 			{/each}
diff --git a/src/pages/PropertyListPage.svelte b/src/pages/PropertyListPage.svelte
index 5ba76cb6c..94137a1f8 100644
--- a/src/pages/PropertyListPage.svelte
+++ b/src/pages/PropertyListPage.svelte
@@ -3,9 +3,9 @@
 	import SearchFilter from '$components/SearchFilter.svelte'
 	import SuggestionForm from '$components/SuggestionForm.svelte'
 	import TagList from '$components/TagList.svelte'
-	import { normalize_text, pluralize } from '$lib/client/utils'
-	import { get_property_label, get_property_url } from '$lib/commons/property.utils'
-	import { PLURALS } from '$lib/commons/structures'
+	import { normalize_text, pluralize } from '$shared/utils'
+	import { get_property_label, get_property_url } from '$shared/property.utils'
+	import { PLURALS } from '$shared/config'
 	import type { GroupedPropertyShort, StructureType } from '$lib/commons/types'
 
 	let search = $state('')
diff --git a/src/pages/PropertyPage.svelte b/src/pages/PropertyPage.svelte
index 2a2d3f023..ce92f952d 100644
--- a/src/pages/PropertyPage.svelte
+++ b/src/pages/PropertyPage.svelte
@@ -4,8 +4,8 @@
 	import ImplicationList from '$components/ImplicationList.svelte'
 	import MetaData from '$components/MetaData.svelte'
 	import SuggestionForm from '$components/SuggestionForm.svelte'
-	import { pluralize } from '$lib/client/utils'
-	import { get_property_url } from '$lib/commons/property.utils'
+	import { pluralize } from '$shared/utils'
+	import { get_property_url } from '$shared/property.utils'
 	import { faInfoCircle } from '@fortawesome/free-solid-svg-icons'
 	import Fa from 'svelte-fa'
 	import type {
@@ -14,7 +14,7 @@
 		StructureShort,
 		StructureType
 	} from '$lib/commons/types'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 	import TagList from '$components/TagList.svelte'
 
 	type Props = {
diff --git a/src/pages/SearchPage.svelte b/src/pages/SearchPage.svelte
index 242558030..0acd7d42f 100644
--- a/src/pages/SearchPage.svelte
+++ b/src/pages/SearchPage.svelte
@@ -1,13 +1,13 @@
 <script lang="ts">
 	import { goto } from '$app/navigation'
 	import Selection from '$components/Selection.svelte'
-	import { encode_property_ID } from '$lib/commons/property.utils'
+	import { encode_property_ID } from '$shared/property.utils'
 	import MetaData from '$components/MetaData.svelte'
 	import { SEARCH_SEPARATOR } from '$lib/commons/search.config'
 	import { navigating } from '$app/state'
 	import { browser } from '$app/environment'
 	import type { StructureType } from '$lib/commons/types'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 	import type { Snippet } from 'svelte'
 
 	type Props = {
diff --git a/src/pages/SearchResultsPage.svelte b/src/pages/SearchResultsPage.svelte
index 21abe5688..642b3e56b 100644
--- a/src/pages/SearchResultsPage.svelte
+++ b/src/pages/SearchResultsPage.svelte
@@ -1,14 +1,14 @@
 <script lang="ts">
 	import { browser } from '$app/environment'
 	import StructureList from '$components/StructureList.svelte'
-	import { encode_property_ID, get_property_url } from '$lib/commons/property.utils'
+	import { encode_property_ID, get_property_url } from '$shared/property.utils'
 	import MetaData from '$components/MetaData.svelte'
 	import { SEARCH_SEPARATOR } from '$lib/commons/search.config'
-	import { pluralize } from '$lib/client/utils'
+	import { pluralize } from '$shared/utils'
 	import Fa from 'svelte-fa'
 	import { faWarning } from '@fortawesome/free-solid-svg-icons'
 	import type { SearchResults, StructureType } from '$lib/commons/types'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 
 	type Props = { type: StructureType } & SearchResults
 
diff --git a/src/pages/StructureDetailPage.svelte b/src/pages/StructureDetailPage.svelte
index 73be5d99d..b57107f1c 100644
--- a/src/pages/StructureDetailPage.svelte
+++ b/src/pages/StructureDetailPage.svelte
@@ -5,7 +5,7 @@
 	import SuggestionForm from '$components/SuggestionForm.svelte'
 	import TagList from '$components/TagList.svelte'
 	import UndistinguishableStructures from '$components/UndistinguishableStructures.svelte'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 	import type {
 		CommentObject,
 		PropertyAssignmentDisplay,
diff --git a/src/pages/StructureListPage.svelte b/src/pages/StructureListPage.svelte
index 8648b5c1d..182009358 100644
--- a/src/pages/StructureListPage.svelte
+++ b/src/pages/StructureListPage.svelte
@@ -2,10 +2,10 @@
 	import MetaData from '$components/MetaData.svelte'
 	import SearchFilter from '$components/SearchFilter.svelte'
 	import SuggestionForm from '$components/SuggestionForm.svelte'
-	import { normalize_text, pluralize } from '$lib/client/utils'
+	import { normalize_text, pluralize } from '$shared/utils'
 	import StructureList from '$components/StructureList.svelte'
 	import type { StructureShort, StructureType } from '$lib/commons/types'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 	import TagList from '$components/TagList.svelte'
 	import Fa from 'svelte-fa'
 	import { faInfoCircle } from '@fortawesome/free-solid-svg-icons'
diff --git a/src/pages/TaggedPropertiesPage.svelte b/src/pages/TaggedPropertiesPage.svelte
index 653c42c27..c77ca465e 100644
--- a/src/pages/TaggedPropertiesPage.svelte
+++ b/src/pages/TaggedPropertiesPage.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
 	import MetaData from '$components/MetaData.svelte'
-	import { pluralize } from '$lib/client/utils'
+	import { pluralize } from '$shared/utils'
 	import type { PropertyShort, StructureType } from '$lib/commons/types'
 	import PropertyList from '$components/PropertyList.svelte'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 
 	type Props = {
 		type: StructureType
diff --git a/src/pages/TaggedStructuresPage.svelte b/src/pages/TaggedStructuresPage.svelte
index 89e80c6bd..69950c56f 100644
--- a/src/pages/TaggedStructuresPage.svelte
+++ b/src/pages/TaggedStructuresPage.svelte
@@ -1,9 +1,9 @@
 <script lang="ts">
 	import StructureList from '$components/StructureList.svelte'
 	import MetaData from '$components/MetaData.svelte'
-	import { capitalize, pluralize } from '$lib/client/utils'
+	import { capitalize, pluralize } from '$shared/utils'
 	import type { StructureShort, StructureType } from '$lib/commons/types'
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 
 	type Props = {
 		type: StructureType
diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte
index 6af2c1b5f..345b81a14 100644
--- a/src/routes/+layout.svelte
+++ b/src/routes/+layout.svelte
@@ -8,9 +8,9 @@
 	import Popup from '$components/Popup.svelte'
 	import { PUBLIC_PLAYWRIGHT } from '$env/static/public'
 	import { track_visit } from '$lib/client/track'
-	import { get_selected_type } from '$lib/commons/structures'
 	import type { StructureType } from '$lib/commons/types'
 	import { tracking } from '$lib/states/tracking.svelte'
+	import { STRUCTURE_TYPES } from '$shared/config'
 	import './app.css'
 
 	let { children } = $props()
@@ -33,7 +33,10 @@
 
 	let nav_dialog = $state<HTMLDialogElement | null>(null)
 
-	let selected_type = $derived<StructureType>(get_selected_type(page.url.pathname))
+	let selected_type = $derived<StructureType>(
+		STRUCTURE_TYPES.find((type) => page.url.pathname.startsWith(`/${type}`)) ||
+			'category',
+	)
 </script>
 
 <svelte:head>
diff --git a/src/routes/[type]-comparison/+page.server.ts b/src/routes/[type]-comparison/+page.server.ts
index 6164bf3ce..421c78d3d 100644
--- a/src/routes/[type]-comparison/+page.server.ts
+++ b/src/routes/[type]-comparison/+page.server.ts
@@ -1,4 +1,4 @@
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { fetch_structures } from '$lib/server/fetchers/structures'
 import { error } from '@sveltejs/kit'
 
diff --git a/src/routes/[type]-comparison/[...ids]/+page.server.ts b/src/routes/[type]-comparison/[...ids]/+page.server.ts
index 326717db7..f39bd4f4f 100644
--- a/src/routes/[type]-comparison/[...ids]/+page.server.ts
+++ b/src/routes/[type]-comparison/[...ids]/+page.server.ts
@@ -1,6 +1,6 @@
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { fetch_comparison_result } from '$lib/server/fetchers/comparison'
-import { cache_page } from '$lib/server/utils'
+import { cache_page } from '$lib/server/cache'
 import { error } from '@sveltejs/kit'
 
 export const prerender = false
diff --git a/src/routes/[type]-implication/[id]/+page.server.ts b/src/routes/[type]-implication/[id]/+page.server.ts
index 5dc67fa23..acb0de2ad 100644
--- a/src/routes/[type]-implication/[id]/+page.server.ts
+++ b/src/routes/[type]-implication/[id]/+page.server.ts
@@ -1,4 +1,4 @@
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { fetch_implication } from '$lib/server/fetchers/implication'
 import { render_nested_formulas } from '$lib/server/formulas'
 import { error } from '@sveltejs/kit'
diff --git a/src/routes/[type]-implications/+page.server.ts b/src/routes/[type]-implications/+page.server.ts
index d8e406583..ccfb65564 100644
--- a/src/routes/[type]-implications/+page.server.ts
+++ b/src/routes/[type]-implications/+page.server.ts
@@ -1,6 +1,6 @@
 import { render_nested_formulas } from '$lib/server/formulas'
 import { fetch_implications } from '$lib/server/fetchers/implications'
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { error } from '@sveltejs/kit'
 
 export const load = (event) => {
diff --git a/src/routes/[type]-list/+page.server.ts b/src/routes/[type]-list/+page.server.ts
index a8ad4c0b6..ebc7eb0ac 100644
--- a/src/routes/[type]-list/+page.server.ts
+++ b/src/routes/[type]-list/+page.server.ts
@@ -1,7 +1,8 @@
-import { is_structure_type, STRUCTURE_TYPES } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { fetch_structures_and_tags } from '$lib/server/fetchers/structures'
 import { error } from '@sveltejs/kit'
 import type { EntryGenerator } from './$types'
+import { STRUCTURE_TYPES } from '$shared/config'
 
 export const entries: EntryGenerator = () => {
 	return STRUCTURE_TYPES.map((type) => ({ type }))
diff --git a/src/routes/[type]-list/[tag]/+page.server.ts b/src/routes/[type]-list/[tag]/+page.server.ts
index b167a39c3..3050f2c03 100644
--- a/src/routes/[type]-list/[tag]/+page.server.ts
+++ b/src/routes/[type]-list/[tag]/+page.server.ts
@@ -1,5 +1,5 @@
 import { fetch_tagged_structures } from '$lib/server/fetchers/structures'
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { error } from '@sveltejs/kit'
 import type { EntryGenerator } from './$types'
 import { fetch_structure_tags } from '$lib/server/fetchers/tags'
diff --git a/src/routes/[type]-properties/+page.server.ts b/src/routes/[type]-properties/+page.server.ts
index c9b3687fe..07950b57d 100644
--- a/src/routes/[type]-properties/+page.server.ts
+++ b/src/routes/[type]-properties/+page.server.ts
@@ -1,4 +1,4 @@
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { fetch_grouped_properties_and_tags } from '$lib/server/fetchers/properties'
 import { error } from '@sveltejs/kit'
 
diff --git a/src/routes/[type]-properties/[tag]/+page.server.ts b/src/routes/[type]-properties/[tag]/+page.server.ts
index 28049e913..d5508d79f 100644
--- a/src/routes/[type]-properties/[tag]/+page.server.ts
+++ b/src/routes/[type]-properties/[tag]/+page.server.ts
@@ -1,4 +1,4 @@
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { fetch_tagged_properties } from '$lib/server/fetchers/properties'
 import { error } from '@sveltejs/kit'
 import type { EntryGenerator } from './$types'
diff --git a/src/routes/[type]-property/[id]/+page.server.ts b/src/routes/[type]-property/[id]/+page.server.ts
index 51bb06fe2..c78782d44 100644
--- a/src/routes/[type]-property/[id]/+page.server.ts
+++ b/src/routes/[type]-property/[id]/+page.server.ts
@@ -1,7 +1,7 @@
 import { render_nested_formulas } from '$lib/server/formulas'
-import { decode_property_ID } from '$lib/commons/property.utils'
+import { decode_property_ID } from '$shared/property.utils'
 import { fetch_property } from '$lib/server/fetchers/property'
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { error } from '@sveltejs/kit'
 
 export const load = (event) => {
diff --git a/src/routes/[type]-search/+page.server.ts b/src/routes/[type]-search/+page.server.ts
index 3bdfc3016..963f48f24 100644
--- a/src/routes/[type]-search/+page.server.ts
+++ b/src/routes/[type]-search/+page.server.ts
@@ -1,4 +1,4 @@
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { get_property_ids } from '$lib/server/fetchers/properties'
 import { error } from '@sveltejs/kit'
 
diff --git a/src/routes/[type]-search/+page.svelte b/src/routes/[type]-search/+page.svelte
index de71fe568..e19c21d44 100644
--- a/src/routes/[type]-search/+page.svelte
+++ b/src/routes/[type]-search/+page.svelte
@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { PLURALS } from '$lib/commons/structures'
+	import { PLURALS } from '$shared/config'
 	import SearchPage from '$pages/SearchPage.svelte'
 
 	let { data } = $props()
diff --git a/src/routes/[type]-search/results/+page.server.ts b/src/routes/[type]-search/results/+page.server.ts
index 5bf7ed6bb..9194e3149 100644
--- a/src/routes/[type]-search/results/+page.server.ts
+++ b/src/routes/[type]-search/results/+page.server.ts
@@ -1,6 +1,6 @@
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { fetch_search_results } from '$lib/server/fetchers/search'
-import { cache_page } from '$lib/server/utils'
+import { cache_page } from '$lib/server/cache'
 import { error } from '@sveltejs/kit'
 
 export const prerender = false
diff --git a/src/routes/[type]/[id]/+page.server.ts b/src/routes/[type]/[id]/+page.server.ts
index d2cc3621a..225573f3c 100644
--- a/src/routes/[type]/[id]/+page.server.ts
+++ b/src/routes/[type]/[id]/+page.server.ts
@@ -1,11 +1,11 @@
 import { render_nested_formulas } from '$lib/server/formulas'
 import { fetch_structure } from '$lib/server/fetchers/structure'
-import { is_structure_type } from '$lib/commons/structures'
+import { is_structure_type } from '$shared/config'
 import { error } from '@sveltejs/kit'
 import { fetch_category } from '$lib/server/fetchers/category'
 import { fetch_functor } from '$lib/server/fetchers/functor'
 import { fetch_morphism } from '$lib/server/fetchers/morphism'
-import { add_math, strip_math } from '$lib/server/utils'
+import { add_math, strip_math } from '$shared/utils'
 
 const special_fetchers = {
 	category: fetch_category,
diff --git a/src/routes/api/track/+server.ts b/src/routes/api/track/+server.ts
index 2793daa02..7126b8a64 100644
--- a/src/routes/api/track/+server.ts
+++ b/src/routes/api/track/+server.ts
@@ -1,4 +1,4 @@
-import { is_object } from '$lib/server/utils'
+import { is_object } from '$shared/utils'
 import { json } from '@sveltejs/kit'
 import { get_geo_data, is_allowed } from './track.utils'
 import { query_app } from '$lib/server/db.app'
diff --git a/src/routes/api/user_action/+server.ts b/src/routes/api/user_action/+server.ts
index 5f361f59b..7ffe9b48f 100644
--- a/src/routes/api/user_action/+server.ts
+++ b/src/routes/api/user_action/+server.ts
@@ -1,5 +1,5 @@
 import { query_app } from '$lib/server/db.app'
-import { is_object } from '$lib/server/utils'
+import { is_object } from '$shared/utils'
 import sql from 'sql-template-tag'
 import { is_allowed } from '../track/track.utils'
 import { json } from '@sveltejs/kit'
diff --git a/src/routes/missing/+page.server.ts b/src/routes/missing/+page.server.ts
index 73599914d..23038fda6 100644
--- a/src/routes/missing/+page.server.ts
+++ b/src/routes/missing/+page.server.ts
@@ -1,6 +1,6 @@
 import { fetch_missing_data } from '$lib/server/fetchers/missing_data'
 import { fetch_categories_with_missing_morphisms } from '$lib/server/fetchers/category'
-import { STRUCTURE_TYPES } from '$lib/commons/structures'
+import { STRUCTURE_TYPES } from '$shared/config'
 
 export const load = () => {
 	const categories_with_missing_morphisms = fetch_categories_with_missing_morphisms()
diff --git a/src/routes/missing/+page.svelte b/src/routes/missing/+page.svelte
index 960290e5f..7c27136d5 100644
--- a/src/routes/missing/+page.svelte
+++ b/src/routes/missing/+page.svelte
@@ -2,9 +2,10 @@
 	import StructureList from '$components/StructureList.svelte'
 	import MetaData from '$components/MetaData.svelte'
 	import SuggestionForm from '$components/SuggestionForm.svelte'
-	import { get_property_url } from '$lib/commons/property.utils'
-	import { PLURALS, STRUCTURE_TYPES } from '$lib/commons/structures'
-	import { capitalize } from '$lib/client/utils'
+	import { get_property_url } from '$shared/property.utils'
+	import { PLURALS } from '$shared/config'
+	import { STRUCTURE_TYPES } from '$shared/config'
+	import { capitalize } from '$shared/utils'
 
 	const { data } = $props()
 </script>
diff --git a/svelte.config.js b/svelte.config.js
index 721beb7a1..2e3148e60 100644
--- a/svelte.config.js
+++ b/svelte.config.js
@@ -7,7 +7,8 @@ const config = {
 	kit: {
 		alias: {
 			$components: './src/components',
-			$pages: './src/pages'
+			$pages: './src/pages',
+			$shared: './shared'
 		},
 		adapter: adapter()
 	}