From a507f00f2fcfcac64c70b992ca1d96404c16193e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Wed, 5 Oct 2022 12:10:20 +0200
Subject: [PATCH 1/9] build: Created the 'state' module

See https://gitlab.com/opensavvy/pedestal/-/issues/19
---
 .gitlab-ci.yml            | 18 +++++++++++++++++
 backbone/build.gradle.kts |  2 +-
 settings.gradle.kts       |  1 +
 spine/build.gradle.kts    |  2 +-
 state/build.gradle.kts    | 42 +++++++++++++++++++++++++++++++++++++++
 5 files changed, 63 insertions(+), 2 deletions(-)
 create mode 100644 state/build.gradle.kts

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index f003752..2d55907 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -29,6 +29,11 @@ logger:publish:
   variables:
     module: logger
 
+state:publish:
+  extends: [ .publish ]
+  variables:
+    module: state
+
 backbone:publish:
   extends: [ .publish ]
   variables:
@@ -87,6 +92,19 @@ logger:convert-coverage:
   variables:
     module: logger
 
+state:test:jvm:
+  extends: [ .test-jvm ]
+  variables:
+    module: state
+
+state:convert-coverage:
+  extends: [ .test-jvm-convert-coverage ]
+  needs:
+    - job: state:test:jvm
+      artifacts: true
+  variables:
+    module: state
+
 backbone:test:jvm:
   extends: [ .test-jvm ]
   variables:
diff --git a/backbone/build.gradle.kts b/backbone/build.gradle.kts
index eaab266..848a207 100644
--- a/backbone/build.gradle.kts
+++ b/backbone/build.gradle.kts
@@ -14,7 +14,7 @@ kotlin {
 	sourceSets {
 		val commonMain by getting {
 			dependencies {
-				api(KotlinX.coroutines.core)
+				api(projects.state)
 				api(KotlinX.datetime)
 
 				implementation(projects.logger)
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 51f95fa..1cc79ae 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -6,6 +6,7 @@ plugins {
 }
 
 include(
+	"state",
 	"backbone",
 	"spine",
 	"spine-ktor-client",
diff --git a/spine/build.gradle.kts b/spine/build.gradle.kts
index ec8139e..4e2b806 100644
--- a/spine/build.gradle.kts
+++ b/spine/build.gradle.kts
@@ -15,7 +15,7 @@ kotlin {
 	sourceSets {
 		val commonMain by getting {
 			dependencies {
-				api(projects.backbone)
+				api(projects.state)
 				api(KotlinX.serialization.core)
 
 				implementation(projects.logger)
diff --git a/state/build.gradle.kts b/state/build.gradle.kts
new file mode 100644
index 0000000..ec84d18
--- /dev/null
+++ b/state/build.gradle.kts
@@ -0,0 +1,42 @@
+@file:Suppress("UNUSED_VARIABLE")
+
+plugins {
+	kotlin("multiplatform")
+}
+
+kotlin {
+	jvm()
+	js(IR) {
+		browser()
+		nodejs()
+	}
+
+	sourceSets {
+		val commonMain by getting {
+			dependencies {
+				api(KotlinX.coroutines.core)
+
+				implementation(projects.logger)
+			}
+		}
+
+		val commonTest by getting {
+			dependencies {
+				implementation(projects.tester)
+
+				api(KotlinX.coroutines.test)
+			}
+		}
+	}
+}
+
+kover {
+	verify {
+		rule {
+			name = "Minimal code coverage"
+			bound {
+				minValue = 80
+			}
+		}
+	}
+}
-- 
2.51.2


From b03b33f44f63c39bf4afddc4a0e39555ba03f609 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Mon, 10 Oct 2022 14:27:43 +0200
Subject: [PATCH 2/9] build(idea): Always generate the coverage report when
 testing

---
 .idea/runConfigurations/All_tests.xml       | 1 +
 .idea/runConfigurations/All_tests__JVM_.xml | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.idea/runConfigurations/All_tests.xml b/.idea/runConfigurations/All_tests.xml
index 40d3617..e7f139a 100644
--- a/.idea/runConfigurations/All_tests.xml
+++ b/.idea/runConfigurations/All_tests.xml
@@ -11,6 +11,7 @@
       <option name="taskNames">
         <list>
           <option value="allTests" />
+          <option value="koverMergedHtmlReport" />
         </list>
       </option>
       <option name="vmOptions" />
diff --git a/.idea/runConfigurations/All_tests__JVM_.xml b/.idea/runConfigurations/All_tests__JVM_.xml
index 2d293ab..bbbe413 100644
--- a/.idea/runConfigurations/All_tests__JVM_.xml
+++ b/.idea/runConfigurations/All_tests__JVM_.xml
@@ -11,6 +11,7 @@
       <option name="taskNames">
         <list>
           <option value="jvmTest" />
+          <option value="koverMergedHtmlReport" />
         </list>
       </option>
       <option name="vmOptions" />
@@ -20,4 +21,4 @@
     <DebugAllEnabled>false</DebugAllEnabled>
     <method v="2" />
   </configuration>
-</component>
\ No newline at end of file
+</component>
-- 
2.51.2


From 8dbe3fd2b567a3d28cd85c0361df36f50c546c96 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Wed, 5 Oct 2022 16:14:18 +0200
Subject: [PATCH 3/9] upgrade: Kotlin 1.7.20

---
 versions.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/versions.properties b/versions.properties
index bb9ef86..61c14a3 100644
--- a/versions.properties
+++ b/versions.properties
@@ -17,7 +17,7 @@ version.com.auth0..java-jwt=3.19.2
 
 version.ch.qos.logback..logback-classic=1.2.11
 
-version.kotlin=1.7.10
+version.kotlin=1.7.20
 
 version.kotlinx.coroutines=1.6.4
 
-- 
2.51.2


From 34121cf8a679272f1d42b36d8059719ffe5f2fb2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Wed, 5 Oct 2022 20:50:19 +0200
Subject: [PATCH 4/9] feat(logger): The default log level is now 'trace'

This makes it easier to have access to everything in tests.
It is recommended for end users to override it to their liking in the 'main' function.
---
 logger/src/commonMain/kotlin/opensavvy.logger/LogLevel.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/logger/src/commonMain/kotlin/opensavvy.logger/LogLevel.kt b/logger/src/commonMain/kotlin/opensavvy.logger/LogLevel.kt
index 8777276..8c1cb39 100644
--- a/logger/src/commonMain/kotlin/opensavvy.logger/LogLevel.kt
+++ b/logger/src/commonMain/kotlin/opensavvy.logger/LogLevel.kt
@@ -47,6 +47,6 @@ enum class LogLevel {
 		 * }
 		 * ```
 		 */
-		var default = INFO
+		var default = TRACE
 	}
 }
-- 
2.51.2


From 31668c3e2f2581096a8ae4357694b8a105e19a5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Wed, 5 Oct 2022 20:53:34 +0200
Subject: [PATCH 5/9] feat(logger): Allow logging null values

---
 .../kotlin/opensavvy.logger/Logger.kt         | 20 +++++++++----------
 .../jsMain/kotlin/opensavvy.logger/Logger.kt  | 10 +++++-----
 .../jvmMain/kotlin/opensavvy/logger/Logger.kt | 12 +++++------
 3 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/logger/src/commonMain/kotlin/opensavvy.logger/Logger.kt b/logger/src/commonMain/kotlin/opensavvy.logger/Logger.kt
index 883a729..66bfdde 100644
--- a/logger/src/commonMain/kotlin/opensavvy.logger/Logger.kt
+++ b/logger/src/commonMain/kotlin/opensavvy.logger/Logger.kt
@@ -66,34 +66,34 @@ interface Logger {
 	 */
 	var level: LogLevel
 
-	fun forceTrace(message: String, vararg objects: Any)
-	fun forceDebug(message: String, vararg objects: Any)
-	fun forceInfo(message: String, vararg objects: Any)
-	fun forceWarn(message: String, vararg objects: Any)
-	fun forceError(message: String, vararg objects: Any)
+	fun forceTrace(message: String, vararg objects: Any?)
+	fun forceDebug(message: String, vararg objects: Any?)
+	fun forceInfo(message: String, vararg objects: Any?)
+	fun forceWarn(message: String, vararg objects: Any?)
+	fun forceError(message: String, vararg objects: Any?)
 
 	companion object {
-		inline fun Logger.trace(vararg objects: Any, message: () -> String) {
+		inline fun Logger.trace(vararg objects: Any?, message: () -> String) {
 			if (level.trace)
 				forceTrace(message(), *objects)
 		}
 
-		inline fun Logger.debug(vararg objects: Any, message: () -> String) {
+		inline fun Logger.debug(vararg objects: Any?, message: () -> String) {
 			if (level.debug)
 				forceDebug(message(), *objects)
 		}
 
-		inline fun Logger.info(vararg objects: Any, message: () -> String) {
+		inline fun Logger.info(vararg objects: Any?, message: () -> String) {
 			if (level.info)
 				forceInfo(message(), *objects)
 		}
 
-		inline fun Logger.warn(vararg objects: Any, message: () -> String) {
+		inline fun Logger.warn(vararg objects: Any?, message: () -> String) {
 			if (level.warn)
 				forceWarn(message(), *objects)
 		}
 
-		inline fun Logger.error(vararg objects: Any, message: () -> String) {
+		inline fun Logger.error(vararg objects: Any?, message: () -> String) {
 			if (level.error)
 				forceError(message(), *objects)
 		}
diff --git a/logger/src/jsMain/kotlin/opensavvy.logger/Logger.kt b/logger/src/jsMain/kotlin/opensavvy.logger/Logger.kt
index 48a15db..e02abc5 100644
--- a/logger/src/jsMain/kotlin/opensavvy.logger/Logger.kt
+++ b/logger/src/jsMain/kotlin/opensavvy.logger/Logger.kt
@@ -3,23 +3,23 @@ package opensavvy.logger
 private class ConsoleLogger(private val self: Any) : Logger {
 	override var level = LogLevel.default
 
-	override fun forceTrace(message: String, vararg objects: Any) {
+	override fun forceTrace(message: String, vararg objects: Any?) {
 		console.log(self::class.simpleName, message, *objects)
 	}
 
-	override fun forceDebug(message: String, vararg objects: Any) {
+	override fun forceDebug(message: String, vararg objects: Any?) {
 		console.log(self::class.simpleName, message, *objects)
 	}
 
-	override fun forceInfo(message: String, vararg objects: Any) {
+	override fun forceInfo(message: String, vararg objects: Any?) {
 		console.info(self::class.simpleName, message, *objects)
 	}
 
-	override fun forceWarn(message: String, vararg objects: Any) {
+	override fun forceWarn(message: String, vararg objects: Any?) {
 		console.warn(self::class.simpleName, message, *objects)
 	}
 
-	override fun forceError(message: String, vararg objects: Any) {
+	override fun forceError(message: String, vararg objects: Any?) {
 		console.error(self::class.simpleName, message, *objects)
 	}
 }
diff --git a/logger/src/jvmMain/kotlin/opensavvy/logger/Logger.kt b/logger/src/jvmMain/kotlin/opensavvy/logger/Logger.kt
index 6aaed4d..3de783d 100644
--- a/logger/src/jvmMain/kotlin/opensavvy/logger/Logger.kt
+++ b/logger/src/jvmMain/kotlin/opensavvy/logger/Logger.kt
@@ -7,7 +7,7 @@ private class SlfLogger(self: Any): Logger {
 	private val logger = LoggerFactory.getLogger(self::class.java)
 		?: error("Could not find a logger for ${self::class.java}")
 
-	private fun generateFormat(message: String, vararg objects: Any): String {
+	private fun generateFormat(message: String, vararg objects: Any?): String {
 		var result = message
 
 		repeat(objects.size) {
@@ -17,23 +17,23 @@ private class SlfLogger(self: Any): Logger {
 		return result
 	}
 
-	override fun forceTrace(message: String, vararg objects: Any) {
+	override fun forceTrace(message: String, vararg objects: Any?) {
 		logger.trace(generateFormat(message, *objects), *objects)
 	}
 
-	override fun forceDebug(message: String, vararg objects: Any) {
+	override fun forceDebug(message: String, vararg objects: Any?) {
 		logger.debug(generateFormat(message, *objects), *objects)
 	}
 
-	override fun forceInfo(message: String, vararg objects: Any) {
+	override fun forceInfo(message: String, vararg objects: Any?) {
 		logger.info(generateFormat(message, *objects), *objects)
 	}
 
-	override fun forceWarn(message: String, vararg objects: Any) {
+	override fun forceWarn(message: String, vararg objects: Any?) {
 		logger.warn(generateFormat(message, *objects), *objects)
 	}
 
-	override fun forceError(message: String, vararg objects: Any) {
+	override fun forceError(message: String, vararg objects: Any?) {
 		logger.error(generateFormat(message, *objects), *objects)
 	}
 
-- 
2.51.2


From 6f323a63d060ffe474193071eabe48a687ea1ae8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Wed, 5 Oct 2022 16:16:20 +0200
Subject: [PATCH 6/9] refactor: Extracted the state and cache management from
 the Backbone project

Closes https://gitlab.com/opensavvy/pedestal/-/issues/19
---
 .gitlab-ci.yml                                |  44 +-
 .../auth/jwt/JwtAuthenticatorTest.kt          |  14 +-
 backbone/build.gradle.kts                     |   1 +
 .../kotlin/opensavvy/backbone/Backbone.kt     |   7 +-
 .../kotlin/opensavvy/backbone/Cache.kt        | 390 ------------------
 .../kotlin/opensavvy/backbone/Data.kt         | 309 --------------
 .../kotlin/opensavvy/backbone/Ref.kt          |  12 +-
 .../kotlin/opensavvy/backbone/RefCache.kt     |  24 ++
 .../kotlin/opensavvy/backbone/Result.kt       | 102 -----
 .../opensavvy/backbone/cache/MemoryCache.kt   | 139 -------
 .../opensavvy.backbone/BackboneCacheTest.kt   |  59 +++
 .../kotlin/opensavvy.backbone/DataTest.kt     | 275 ------------
 .../kotlin/opensavvy.backbone/ResultTest.kt   |  41 --
 .../opensavvy.backbone/cache/CacheTracing.kt  |  89 ----
 .../cache/MemoryCacheTest.kt                  | 169 --------
 cache/build.gradle.kts                        |  41 ++
 .../opensavvy.cache/BatchingCacheAdapter.kt   | 127 ++++++
 .../kotlin/opensavvy.cache/Cache.kt           | 103 +++++
 .../kotlin/opensavvy.cache/CacheAdapter.kt    |  28 ++
 .../opensavvy.cache}/ExpirationCache.kt       |  55 +--
 .../kotlin/opensavvy.cache/MemoryCache.kt     | 173 ++++++++
 .../kotlin/opensavvy.cache/CacheTest.kt       | 224 ++++++++++
 settings.gradle.kts                           |   6 +-
 spine-ktor/build.gradle.kts                   |  49 +++
 .../spine-ktor-client}/build.gradle.kts       |   3 +-
 .../opensavvy.spine.ktor.client/Client.kt     |  40 +-
 .../spine-ktor-server}/build.gradle.kts       |   5 +-
 .../ContextGenerator.kt                       |   0
 .../ResponseStateBuilder.kt                   |   7 +-
 .../opensavvy.spine.ktor.server/Server.kt     |  41 +-
 .../opensavvy.spine.ktor.server/ServerTest.kt |  31 +-
 .../opensavvy.spine.ktor.server/TestApi.kt    |   0
 .../kotlin/opensavvy.spine.ktor/Methods.kt    |  12 +
 .../opensavvy.spine.ktor/NetworkResponse.kt   |  11 +
 .../opensavvy.spine.ktor/StatusCodes.kt       |  20 +
 spine/build.gradle.kts                        |   3 +-
 .../commonMain/kotlin/opensavvy.spine/Id.kt   |   5 +-
 .../kotlin/opensavvy.spine/Operation.kt       |   4 +-
 .../kotlin/opensavvy.spine/Resource.kt        |  50 +--
 .../kotlin/opensavvy.spine/ServiceTest.kt     | 120 +++---
 .../kotlin/opensavvy.state/Identifier.kt      |  12 +
 .../kotlin/opensavvy.state/Progression.kt     | 134 ++++++
 .../kotlin/opensavvy.state/Slice.kt           | 171 ++++++++
 .../kotlin/opensavvy.state/State.kt           |  47 +++
 .../kotlin/opensavvy.state/StateBuilder.kt    | 217 ++++++++++
 .../kotlin/opensavvy.state/Status.kt          |  92 +++++
 .../kotlin/opensavvy.state/ProgressionTest.kt |  48 +++
 .../kotlin/opensavvy.state/SliceTest.kt       | 200 +++++++++
 .../opensavvy.state/StateBuilderTest.kt       |  66 +++
 49 files changed, 2086 insertions(+), 1734 deletions(-)
 delete mode 100644 backbone/src/commonMain/kotlin/opensavvy/backbone/Cache.kt
 delete mode 100644 backbone/src/commonMain/kotlin/opensavvy/backbone/Data.kt
 create mode 100644 backbone/src/commonMain/kotlin/opensavvy/backbone/RefCache.kt
 delete mode 100644 backbone/src/commonMain/kotlin/opensavvy/backbone/Result.kt
 delete mode 100644 backbone/src/commonMain/kotlin/opensavvy/backbone/cache/MemoryCache.kt
 create mode 100644 backbone/src/commonTest/kotlin/opensavvy.backbone/BackboneCacheTest.kt
 delete mode 100644 backbone/src/commonTest/kotlin/opensavvy.backbone/DataTest.kt
 delete mode 100644 backbone/src/commonTest/kotlin/opensavvy.backbone/ResultTest.kt
 delete mode 100644 backbone/src/commonTest/kotlin/opensavvy.backbone/cache/CacheTracing.kt
 delete mode 100644 backbone/src/commonTest/kotlin/opensavvy.backbone/cache/MemoryCacheTest.kt
 create mode 100644 cache/build.gradle.kts
 create mode 100644 cache/src/commonMain/kotlin/opensavvy.cache/BatchingCacheAdapter.kt
 create mode 100644 cache/src/commonMain/kotlin/opensavvy.cache/Cache.kt
 create mode 100644 cache/src/commonMain/kotlin/opensavvy.cache/CacheAdapter.kt
 rename {backbone/src/commonMain/kotlin/opensavvy/backbone/cache => cache/src/commonMain/kotlin/opensavvy.cache}/ExpirationCache.kt (65%)
 create mode 100644 cache/src/commonMain/kotlin/opensavvy.cache/MemoryCache.kt
 create mode 100644 cache/src/commonTest/kotlin/opensavvy.cache/CacheTest.kt
 create mode 100644 spine-ktor/build.gradle.kts
 rename {spine-ktor-client => spine-ktor/spine-ktor-client}/build.gradle.kts (91%)
 rename {spine-ktor-client => spine-ktor/spine-ktor-client}/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt (70%)
 rename {spine-ktor-server => spine-ktor/spine-ktor-server}/build.gradle.kts (89%)
 rename {spine-ktor-server => spine-ktor/spine-ktor-server}/src/commonMain/kotlin/opensavvy.spine.ktor.server/ContextGenerator.kt (100%)
 rename {spine-ktor-server => spine-ktor/spine-ktor-server}/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt (80%)
 rename {spine-ktor-server => spine-ktor/spine-ktor-server}/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt (69%)
 rename {spine-ktor-server => spine-ktor/spine-ktor-server}/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt (79%)
 rename {spine-ktor-server => spine-ktor/spine-ktor-server}/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt (100%)
 create mode 100644 spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt
 create mode 100644 spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/NetworkResponse.kt
 create mode 100644 spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/StatusCodes.kt
 create mode 100644 state/src/commonMain/kotlin/opensavvy.state/Identifier.kt
 create mode 100644 state/src/commonMain/kotlin/opensavvy.state/Progression.kt
 create mode 100644 state/src/commonMain/kotlin/opensavvy.state/Slice.kt
 create mode 100644 state/src/commonMain/kotlin/opensavvy.state/State.kt
 create mode 100644 state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt
 create mode 100644 state/src/commonMain/kotlin/opensavvy.state/Status.kt
 create mode 100644 state/src/commonTest/kotlin/opensavvy.state/ProgressionTest.kt
 create mode 100644 state/src/commonTest/kotlin/opensavvy.state/SliceTest.kt
 create mode 100644 state/src/commonTest/kotlin/opensavvy.state/StateBuilderTest.kt

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 2d55907..74f1964 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -34,6 +34,11 @@ state:publish:
   variables:
     module: state
 
+cache:publish:
+  extends: [ .publish ]
+  variables:
+    module: cache
+
 backbone:publish:
   extends: [ .publish ]
   variables:
@@ -41,24 +46,26 @@ backbone:publish:
 
 .test-jvm:
   image: openjdk:latest
+  variables:
+    module_path: $module
   script:
     - ./gradlew $module:koverReport $module:koverVerify  # implies running the JVM tests
   after_script:
-    - mkdir -p test-report-$module
-    - mv $module/build/reports/tests/jvmTest test-report-$module/test
-    - mv $module/build/reports/kover/html test-report-$module/coverage
-    - mv $module/build/reports/kover/xml/report.xml test-report-$module/coverage.xml
-    - values=$(cat test-report-$module/coverage.xml | tail -7 | head -5 | grep 'INSTRUCTION' | cut -d ' ' -f 3,4 | sed 's/missed="//;s/" covered="/ /;s/"\/>//')
+    - mkdir -p test-report-$module_path
+    - mv $module_path/build/reports/tests/jvmTest test-report-$module_path/test
+    - mv $module_path/build/reports/kover/html test-report-$module_path/coverage
+    - mv $module_path/build/reports/kover/xml/report.xml test-report-$module_path/coverage.xml
+    - values=$(cat test-report-$module_path/coverage.xml | tail -7 | head -5 | grep 'INSTRUCTION' | cut -d ' ' -f 3,4 | sed 's/missed="//;s/" covered="/ /;s/"\/>//')
     - missed=$(<<<$values cut -d ' ' -f 1)
     - covered=$(<<<$values cut -d ' ' -f 2)
     - echo "Coverage $(($covered * 100 / ($covered + $missed)))%"
   coverage: '/Coverage \d+%/'
   artifacts:
     paths:
-      - test-report-$module
+      - test-report-$module_path
     expose_as: 'Test and coverage report'
     reports:
-       junit: $module/build/test-results/jvmTest/**.xml
+      junit: $module_path/build/test-results/jvmTest/**.xml
     when: always
   only:
     - merge_requests
@@ -67,8 +74,10 @@ backbone:publish:
 
 .test-jvm-convert-coverage:
   image: registry.gitlab.com/haynes/jacoco2cobertura:1.0.8
+  variables:
+    module_path: $module
   script:
-    - python /opt/cover2cover.py test-report-$module/coverage.xml $CI_PROJECT_DIR/$module/src/main/kotlin/ > cobertura.xml
+    - python /opt/cover2cover.py test-report-$module_path/coverage.xml $CI_PROJECT_DIR/$module_path/src/main/kotlin/ > cobertura.xml
   artifacts:
     reports:
       coverage_report:
@@ -105,6 +114,19 @@ state:convert-coverage:
   variables:
     module: state
 
+cache:test:jvm:
+  extends: [ .test-jvm ]
+  variables:
+    module: cache
+
+cache:convert-coverage:
+  extends: [ .test-jvm-convert-coverage ]
+  needs:
+    - job: cache:test:jvm
+      artifacts: true
+  variables:
+    module: cache
+
 backbone:test:jvm:
   extends: [ .test-jvm ]
   variables:
@@ -134,7 +156,8 @@ spine:convert-coverage:
 spine-ktor:test:jvm:
   extends: [ .test-jvm ]
   variables:
-    module: spine-ktor-server
+    module: spine-ktor:spine-ktor-server
+    module_path: spine-ktor/spine-ktor-server
 
 spine-ktor:convert-coverage:
   extends: [ .test-jvm-convert-coverage ]
@@ -142,7 +165,8 @@ spine-ktor:convert-coverage:
     - job: spine-ktor:test:jvm
       artifacts: true
   variables:
-    module: spine-ktor-server
+    module: spine-ktor:spine-ktor-server
+    module_path: spine-ktor/spine-ktor-server
 
 auth:test:jvm:
   extends: [ .test-jvm ]
diff --git a/auth/src/jvmTest/kotlin/opensavvy/auth/jwt/JwtAuthenticatorTest.kt b/auth/src/jvmTest/kotlin/opensavvy/auth/jwt/JwtAuthenticatorTest.kt
index 169f7d3..c8ecb7f 100644
--- a/auth/src/jvmTest/kotlin/opensavvy/auth/jwt/JwtAuthenticatorTest.kt
+++ b/auth/src/jvmTest/kotlin/opensavvy/auth/jwt/JwtAuthenticatorTest.kt
@@ -1,17 +1,17 @@
 package opensavvy.auth.jwt
 
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.test.runTest
 import opensavvy.auth.Account
 import opensavvy.auth.Roles
-import opensavvy.backbone.Cache
-import opensavvy.backbone.Data
-import opensavvy.backbone.Result
+import opensavvy.backbone.BackboneCache
+import opensavvy.backbone.RefState
+import opensavvy.backbone.defaultBackboneCache
 import opensavvy.logger.LogLevel
 import opensavvy.logger.Logger.Companion.debug
 import opensavvy.logger.loggerFor
+import opensavvy.state.emitSuccessful
 import org.junit.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
@@ -38,9 +38,9 @@ class JwtAuthenticatorTest {
 	class Accounts : Account.Bone<Role> {
 		override fun fromId(id: String) = Ref(id, this)
 
-		override val cache: Cache<Account<Role>> = Cache.Default()
+		override val cache: BackboneCache<Account<Role>> = defaultBackboneCache()
 
-		override fun directRequest(ref: opensavvy.backbone.Ref<Account<Role>>): Flow<Data<Account<Role>>> = flow {
+		override fun directRequest(ref: opensavvy.backbone.Ref<Account<Role>>): RefState<Account<Role>> = flow {
 			require(ref is Ref) { "$this doesn't support the reference $ref" }
 
 			val account = when (ref.id) {
@@ -50,7 +50,7 @@ class JwtAuthenticatorTest {
 				else -> error("Invalid user id: ${ref.id}")
 			}
 
-			emit(Data(Result.Success(account), Data.Status.Completed, ref))
+			emitSuccessful(ref, account)
 		}
 	}
 
diff --git a/backbone/build.gradle.kts b/backbone/build.gradle.kts
index 848a207..5c89b35 100644
--- a/backbone/build.gradle.kts
+++ b/backbone/build.gradle.kts
@@ -15,6 +15,7 @@ kotlin {
 		val commonMain by getting {
 			dependencies {
 				api(projects.state)
+				api(projects.cache)
 				api(KotlinX.datetime)
 
 				implementation(projects.logger)
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/Backbone.kt b/backbone/src/commonMain/kotlin/opensavvy/backbone/Backbone.kt
index bf87d8f..822bd7e 100644
--- a/backbone/src/commonMain/kotlin/opensavvy/backbone/Backbone.kt
+++ b/backbone/src/commonMain/kotlin/opensavvy/backbone/Backbone.kt
@@ -1,6 +1,5 @@
 package opensavvy.backbone
 
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.emitAll
 import kotlinx.coroutines.flow.flow
 
@@ -18,7 +17,7 @@ interface Backbone<O> {
 	 *
 	 * As a convenience, you can use [request] to launch a request through the cache.
 	 */
-	val cache: Cache<O>
+	val cache: BackboneCache<O>
 
 	/**
 	 * Fetches the value associated with a [ref] in an external media (e.g. a remote server, a database).
@@ -28,7 +27,7 @@ interface Backbone<O> {
 	 *
 	 * The returned flow is **short-lived**: it is closed after the request finishes.
 	 */
-	fun directRequest(ref: Ref<O>): Flow<Data<O>>
+	fun directRequest(ref: Ref<O>): RefState<O>
 
 	/**
 	 * Fetches the value associated with all [refs] in an external media (e.g. a remote server, a database).
@@ -43,7 +42,7 @@ interface Backbone<O> {
 	 *
 	 * The default implementation simply calls [directRequest] sequentially.
 	 */
-	fun batchRequests(refs: Set<Ref<O>>): Flow<Data<O>> = flow {
+	fun batchRequests(refs: Set<Ref<O>>): RefState<O> = flow {
 		for (ref in refs) {
 			emitAll(directRequest(ref))
 		}
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/Cache.kt b/backbone/src/commonMain/kotlin/opensavvy/backbone/Cache.kt
deleted file mode 100644
index 650230a..0000000
--- a/backbone/src/commonMain/kotlin/opensavvy/backbone/Cache.kt
+++ /dev/null
@@ -1,390 +0,0 @@
-package opensavvy.backbone
-
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.channels.ReceiveChannel
-import kotlinx.coroutines.channels.SendChannel
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import opensavvy.backbone.Cache.Batching
-import opensavvy.backbone.Cache.Default
-import opensavvy.backbone.Data.Companion.initialData
-import opensavvy.backbone.Ref.Companion.directRequest
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.coroutines.coroutineContext
-
-/**
- * Stores information temporarily to avoid unneeded network requests.
- *
- * The value stored behind a reference can be accessed through the [get] operator.
- *
- * ### Cache state
- *
- * Each piece of data in a cache can be in three different states:
- * - Up-to-date: the last query was not long ago, we consider its result still valid,
- * - Stale: the last query was long enough ago that it deserves to be checked again, but it probably is still valid.
- * In this case, the cache returns the old value and starts a refresh request in the background.
- * - Expired: the last query was too long ago for the data to still be valid.
- * In this case, the cache starts a refresh request and will not return a value until the request finishes.
- * All data that was never previously queried is in this state.
- *
- * Different cache implementations differ on how they transition data from one state to another.
- * Some cache implementations may not have a 'stale' state.
- * As a user of the cache, you may want to force the state of a specific object if you have more knowledge than the cache,
- * in this case you can use [update] and [expire].
- *
- * ### Cache chaining
- *
- * Cache implementations can be chained.
- * A possible scenario for some data that rarely changes can be:
- * - Cache the data in memory for 5 minutes,
- * - Cache the data in hard storage for 1 hour,
- * - Query the data for real afterwards.
- *
- * Cache chaining is instantiated in the opposite order, like iterators (the last in the chain is the first checked,
- * and delegates to the previous one if they do not have the value).
- * The first element of the chain, and therefore the one responsible for actually starting the request, is [Default] or [Batching].
- * Note that both have a few implementation differences, it is not recommended to use them directly without chaining under another implementation.
- */
-interface Cache<O> {
-
-	/**
-	 * Gets the value associated with a [ref] in this cache.
-	 *
-	 * This function returns a [Flow] synchronously: it is safe to call in synchronous-only areas of the program, such
-	 * as inside the body of a UI component.
-	 * You can then subscribe to the [Flow] to access the actual values.
-	 *
-	 * For example, here is it how using a value in a React application could look like:
-	 * ```kotlin
-	 * fun Component(props) {
-	 *     // Query the cache
-	 *     val flow = props.cache[props.ref]
-	 *     // Create a React-styled state so React re-renders
-	 *     // the component when the cache returns a new value
-	 *     var data by useState(props.ref.initialData)
-	 *
-	 *     // Asynchronously wait for new values in the cache
-	 *     useEffect {
-	 *         val job = Job()
-	 *
-	 *         // Subscribe to new events from the cache, and assign them to
-	 *         // the React state to tell React when a re-render is necessary
-	 *         CoroutineScope(job).launch {
-	 *             flow.collect { data = it }
-	 *         }
-	 *
-	 *         // When the component is unmounted, cancel the asynchronous
-	 *         // job (e.g. unsubscribe from the flow)
-	 *         cleanup {
-	 *             job.cancel()
-	 *         }
-	 *     }
-	 * }
-	 * ```
-	 * Of course, in the real world, this machinery could be hidden behind a custom hook
-	 * (e.g. in [Compose](https://developer.android.com/reference/kotlin/androidx/compose/runtime/package-summary#(kotlinx.coroutines.flow.Flow).collectAsState(kotlin.Any,kotlin.coroutines.CoroutineContext))))).
-	 * However, this is a good demonstration of how to adapt flows to any reactive framework.
-	 *
-	 */
-	operator fun get(ref: Ref<O>): Flow<Data<O>>
-
-	/**
-	 * Force the cache to accept that [value] is a more recent value for the given [ref] than whatever it was previously
-	 * storing.
-	 *
-	 * This is a convenience method around [updateAll].
-	 */
-	suspend fun update(ref: Ref<O>, value: O) {
-		update(Data(Result.Success(value), Data.Status.Completed, ref))
-	}
-
-	/**
-	 * Force the cache to accept that [value] is a more recent value for the given [Data.ref] than whatever it was
-	 * previously storing.
-	 *
-	 * This is a convenience method around [updateAll].
-	 */
-	suspend fun update(value: Data<O>) {
-		updateAll(listOf(value))
-	}
-
-	/**
-	 * Force the cache to accept that the given [values] are more recent values for the given [Data.ref] than
-	 * whatever it was previously storing.
-	 *
-	 * Values are updated in all cache layers.
-	 *
-	 * If multiple values are provided for the same reference, a cache implementation may either:
-	 * - take only the first occurrence into account,
-	 * - take only the last occurrence into account,
-	 * - take all occurrences into account, as if `updateAll` was called once consecutively with each occurrence, in the same order as their appearance in the iterable.
-	 *
-	 * If [values] is empty, this function does nothing.
-	 *
-	 * For convenience, you may use [update] instead.
-	 */
-	suspend fun updateAll(values: Iterable<Data<O>>)
-
-	/**
-	 * Force the cache to accept that whatever value is currently associated with the given [ref] is invalid and
-	 * should be forgotten.
-	 *
-	 * The next call of [get] for the given reference will query the value from scratch instead of using the cache.
-	 *
-	 * To expire a value and immediately start a query, see [refresh].
-	 *
-	 * This is a convenience method around [expireAll].
-	 */
-	suspend fun expire(ref: Ref<O>) {
-		expireAll(listOf(ref))
-	}
-
-	/**
-	 * Force the cache to accept that whatever values are currently associated with the given [refs] are invalid and
-	 * should be forgotten.
-	 *
-	 * The next call of [get] for any of the given references will query the value from scratch instead of using the cache.
-	 * Therefore, calling this function with an empty iterable does nothing.
-	 *
-	 * To expire a single reference, you may use [expire] instead.
-	 * To expire all values, use [expireAll] instead.
-	 */
-	suspend fun expireAll(refs: Iterable<Ref<O>>)
-
-	/**
-	 * Expires all the given values for this layer and the previous ones.
-	 *
-	 * @see expireAll
-	 */
-	suspend fun expireAllRecursively(refs: Iterable<Ref<O>>)
-
-	/**
-	 * Force the cache to forget its entire internal state.
-	 *
-	 * The next call of [get] on any reference will query the value from scratch instead of using the cache.
-	 *
-	 * To expire selected references, use [expire] and [expireAll] instead.
-	 */
-	suspend fun expireAll()
-
-	/**
-	 * Expires all values for this layer and the previous ones.
-	 *
-	 * @see expireAll
-	 */
-	suspend fun expireAllRecursively()
-
-	/**
-	 * Default cache implementation aimed to be used as the first link in a cache chain.
-	 *
-	 * This is not actually a valid implementation of a cache (it doesn't do any caching) and only serves as a link
-	 * between caches and the underlying network APIs (via [Backbone]), it takes a few liberties with the API:
-	 * - [get] doesn't actually return a long-lived flow,
-	 * - [updateAll] and [expireAll] don't actually do anything.
-	 *
-	 * The actual request is delegated to [Backbone.directRequest].
-	 * To call [Backbone.batchRequests] instead, see [Batching].
-	 */
-	class Default<O> : Cache<O> {
-		override fun get(ref: Ref<O>): Flow<Data<O>> = flow {
-			emit(Data(Result.NoData, Data.Status.Loading.Basic(), ref))
-
-			// Request the backbone and emit all the results
-			val result = ref.directRequest()
-			emitAll(result)
-		}
-
-		override suspend fun updateAll(values: Iterable<Data<O>>) {
-			// This has no state, there is nothing to update
-		}
-
-		override suspend fun expireAll(refs: Iterable<Ref<O>>) {
-			// This has no state, there is nothing to expire
-		}
-
-		override suspend fun expireAll() {
-			// This has no state, there is nothing to expire
-		}
-
-		override suspend fun expireAllRecursively() {
-			// This has no state, there is nothing to expire
-		}
-
-		override suspend fun expireAllRecursively(refs: Iterable<Ref<O>>) {
-			// This has no state, there is nothing to expire
-		}
-	}
-
-	/**
-	 * Default cache implementation aimed to be used as the first link in a cache chain, batching requests.
-	 *
-	 * Much like [Default], this is not strictly a valid implementation of [Cache], and is only intended to be used as
-	 * the first layer in a chain.
-	 * More information is found in [Default].
-	 *
-	 * The actual request is delegated to [Backbone.batchRequests].
-	 * To call [Backbone.directRequest] instead, see [Default].
-	 *
-	 * The batching is implemented by having multiple workers collect the various requests.
-	 * Because of this, **all references passed to this class should come from the same [Backbone] instance**.
-	 */
-	class Batching<O>(
-
-		/**
-		 * The number of workers batching the requests.
-		 *
-		 * All requests are split among them.
-		 * Each worker tries to batch as many requests as possible, then calls [Backbone.batchRequests] all at once.
-		 *
-		 * Increasing the number of workers may increase latency.
-		 */
-		workers: Int = 1,
-
-		/**
-		 * The context of execution for the workers.
-		 *
-		 * Use a context you control to be able to stop the workers.
-		 */
-		context: CoroutineContext = EmptyCoroutineContext,
-	) : Cache<O> {
-
-		private val requests: SendChannel<Pair<Ref<O>, CompletableDeferred<StateFlow<Data<O>>>>>
-
-		init {
-			require(workers > 0) { "There must be at least 1 actor: found $workers" }
-
-			val requests = Channel<Pair<Ref<O>, CompletableDeferred<StateFlow<Data<O>>>>>()
-			this.requests = requests
-
-			val scope = CoroutineScope(context)
-			repeat(workers) {
-				scope.launch {
-					worker(requests)
-				}
-			}
-		}
-
-		private suspend fun worker(requests: ReceiveChannel<Pair<Ref<O>, CompletableDeferred<StateFlow<Data<O>>>>>) {
-			while (coroutineContext.isActive) {
-				val batch = HashSet<Ref<O>>()
-
-				// Store the results
-				// We have to store lists of Deferred in case multiple requests to the same Ref happen to be in the same
-				// batch.
-				val results = HashMap<Ref<O>, MutableList<CompletableDeferred<StateFlow<Data<O>>>>>()
-
-				run {
-					// Suspend until a first request arrives
-					val (ref, promise) = requests.receive()
-					batch.add(ref)
-					results.getOrPut(ref) { ArrayList() }
-						.add(promise)
-				}
-
-				while (true) {
-					// Try to read as many requests as possible, without suspending
-					val (ref, promise) = requests.tryReceive()
-						.getOrNull()
-						?: break
-
-					batch.add(ref)
-					results.getOrPut(ref) { ArrayList() }
-						.add(promise)
-				}
-
-				// Just in case, check that they all come from the same Backbone instance
-				// If they don't, batching them makes no sense
-				val backbone = batch.first().backbone
-				check(batch.all { it.backbone === backbone }) { "To start a request batch, all references must depend on the same Backbone instance. Found: $batch" }
-
-				val states = HashMap<Ref<O>, MutableStateFlow<Data<O>>>()
-
-				// Tell all clients that their request is starting
-				for ((ref, promises) in results) {
-					val state = MutableStateFlow(ref.initialData)
-
-					for (promise in promises) {
-						promise.complete(state)
-					}
-
-					states[ref] = state
-				}
-
-				// The channel is now empty, request all of them
-				backbone.batchRequests(batch)
-					.collect {
-						val state = states[it.ref]
-							?: error("Could not find the state for the reference ${it.ref}, this means we received an update for a reference we did not ask for. There may a bug in $backbone.")
-
-						state.value = it
-					}
-			}
-		}
-
-		override fun get(ref: Ref<O>): Flow<Data<O>> = flow {
-			val promise = CompletableDeferred<StateFlow<Data<O>>>()
-
-			requests.send(ref to promise)
-
-			promise.await()
-				.collect {
-					emit(it)
-				}
-		}
-
-		override suspend fun updateAll(values: Iterable<Data<O>>) {
-			// This has no state, there is nothing to update
-		}
-
-		override suspend fun expireAll(refs: Iterable<Ref<O>>) {
-			// This has no state, there is nothing to expire
-		}
-
-		override suspend fun expireAllRecursively(refs: Iterable<Ref<O>>) {
-			// This has no state, there is nothing to expire
-		}
-
-		override suspend fun expireAll() {
-			// This has no state, there is nothing to expire
-		}
-
-		override suspend fun expireAllRecursively() {
-			// This has no state, there is nothing to expire
-		}
-	}
-
-	/**
-	 * Simple implementation that handles delegating to an [upstream] cache layer the functions that should be delegated.
-	 */
-	abstract class CacheLayer<O>(protected val upstream: Cache<O>) : Cache<O> {
-		override suspend fun updateAll(values: Iterable<Data<O>>) {
-			upstream.updateAll(values)
-		}
-
-		override suspend fun expireAllRecursively() {
-			expireAll()
-			upstream.expireAllRecursively()
-		}
-
-		override suspend fun expireAllRecursively(refs: Iterable<Ref<O>>) {
-			expireAll(refs)
-			upstream.expireAllRecursively(refs)
-		}
-	}
-
-	companion object {
-		/**
-		 * Force the cache to request the value again, and start a new query.
-		 *
-		 * This is the same as calling [expire] followed by [get].
-		 */
-		suspend fun <O> Cache<O>.refresh(ref: Ref<O>): Flow<Data<O>> {
-			expire(ref)
-			return get(ref)
-		}
-	}
-}
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/Data.kt b/backbone/src/commonMain/kotlin/opensavvy/backbone/Data.kt
deleted file mode 100644
index 6eeb508..0000000
--- a/backbone/src/commonMain/kotlin/opensavvy/backbone/Data.kt
+++ /dev/null
@@ -1,309 +0,0 @@
-package opensavvy.backbone
-
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.flow.*
-import opensavvy.backbone.Data.Status
-import opensavvy.backbone.Data.Status.Completed
-import opensavvy.backbone.Data.Status.Loading
-import opensavvy.backbone.Data.Status.Loading.Basic
-
-/**
- * Successive values.
- *
- * Model objects should be immutable.
- * The [Data] type is immutable as well.
- * Mutation is represented as change over time.
- *
- * [State] is an asynchronous stream of immutable values.
- * By collecting the [State], it is possible to be notified when the value is updated.
- *
- * To create a new [State], see [state][Data.state].
- */
-typealias State<O> = Flow<Data<O>>
-
-/**
- * Builder type for [State].
- *
- * This type is used for conveniently building asynchronous flows in synchronous environments.
- * For more information, see [state][Data.state].
- */
-typealias StateBuilder<O> = FlowCollector<Data<O>>
-
-/**
- * Wrapper around a data object of type [O].
- *
- * This class represents the state at a specific time of the result of requesting a [reference][Ref].
- * At that specific time, the following combinaisons are possible:
- * - the request is finished and successful,
- * - the request is finished and failed,
- * - the request is not finished,
- * - the request is not finished, but we remember the previous value for the same request.
- *
- * These states are encoded by the values of [data] and [status], for example a finished request that was successful will
- * have [data] be an instance of [Result.Success], with the result being available using [Result.Success.value], and the
- * [status] attribute will be [Status.Completed].
- * Read the documentation of the various values to understand all the possible combinaisons.
- *
- * Use destructuration to easily access the various values:
- * ```kotlin
- * val (data, status) = someData()
- * ```
- *
- * This class represents the state of some data at a specific instant in time, which it does not store.
- * This class will often appear inside a [Flow], allowing to subscribe to updates to the state as requests terminate.
- */
-data class Data<O>(
-	/**
-	 * The data itself.
-	 *
-	 * For more information, read the [Result] documentation.
-	 */
-	val data: Result<O>,
-	/**
-	 * Whether there is an ongoing request to update the [data].
-	 *
-	 * For more information, read the [Status] documentation.
-	 */
-	val status: Status,
-	/**
-	 * The reference to the data this object represents, which was used to initiate the request.
-	 *
-	 * In some contexts, this data is not associated with any object (for example, progression or error messages in a `create` endpoint).
-	 * In these cases, [ref] may be `null` and [data] may not be [successful][Result.Success].
-	 */
-	val ref: Ref<O>?,
-) {
-
-	override fun toString() = "$ref: $data $status"
-
-	/**
-	 * Whether a piece of [Data] is [Completed] or still [Loading].
-	 */
-	sealed class Status {
-
-		/**
-		 * No requests are ongoing for the given [reference][ref].
-		 *
-		 * @see Loading
-		 */
-		object Completed : Status() {
-			override fun toString() = "Completed"
-		}
-
-		/**
-		 * A request is ongoing for the given [reference][ref].
-		 *
-		 * This object stores the amount of [progress][progression] of the ongoing request, which can be used to display
-		 * an indicator to a user.
-		 *
-		 * See [Basic] for a simple implementation of this class.
-		 *
-		 * @see Completed
-		 */
-		abstract class Loading(
-			/**
-			 * How much progress the ongoing request is at.
-			 *
-			 * If it is not possible to know the amount of progress, `null` is used.
-			 * Otherwise, the progression is a number between 0 (inclusive, no progress has been made)
-			 * and 1 (inclusive, the request is completely finished).
-			 *
-			 * The value of 1 is allowed for ease of programming, but it doesn't mean anything: a value which has fully
-			 * finished loading should have a status of [Completed], not "Loading 100%".
-			 */
-			val progression: Float?,
-		) : Status() {
-
-			/**
-			 * How much progress the ongoing request is at, in percents.
-			 *
-			 * This is a convenience property around [progression].
-			 * Much like it, `null` is returned when the progress is unknown.
-			 * When progress is known, this returns an integer value between 0 (inclusive, no progress has been made)
-			 * and 100 (inclusive, the request has finished).
-			 */
-			val percent: Int?
-				get() = progression
-					?.times(100)
-					?.toInt()
-
-			init {
-				if (progression != null)
-					require(progression in 0f..1f) { "The progression must be either null or between 0 and 1 (inclusive), found $progression" }
-			}
-
-			/**
-			 * Simple implementation of the [Loading] abstract class.
-			 *
-			 * This class is a strict implementation without any additional features.
-			 * If you need to add another field (e.g. for transfer units like Mb, speed indicators like Mb/s), create
-			 * your own subclass of [Loading] instead of using this one.
-			 *
-			 * @param progression See [Loading.progression]
-			 */
-			class Basic(progression: Float? = null) : Loading(progression) {
-				override fun toString() =
-					if (progression != null) "Loading($percent%)"
-					else "Loading"
-
-				override fun equals(other: Any?): Boolean {
-					if (this === other) return true
-					if (other !is Loading) return false
-					return progression == other.progression
-				}
-
-				override fun hashCode(): Int {
-					return progression.hashCode()
-				}
-			}
-		}
-	}
-
-	companion object {
-		/**
-		 * The default empty data that can be used as a stand-in for a future value.
-		 *
-		 * This can be used as the argument of React's `useState` or Compose's `collectAsState`.
-		 */
-		val <O> Ref<O>.initialData
-			get() = Data(Result.NoData, Basic(), this)
-
-		//region Access
-
-		val <O> Data<O>.value: O? get() = (this.data as? Result.Success)?.value
-
-		//endregion
-		//region Creation DSL
-
-		/**
-		 * Builder for [State] instances.
-		 *
-		 * ```kotlin
-		 * val foo = state {
-		 *   val ref = /* … */
-		 *   markLoading(ref, 0f) // 0%
-		 *
-		 *   if (someCheck)
-		 *     markInvalid(ref, "The requested object doesn't match [some check]")
-		 *
-		 *   markCompleted(ref, 5)
-		 * }
-		 * ```
-		 */
-		fun <O> state(block: suspend StateBuilder<O>.() -> Unit): State<O> = flow(block)
-			.catch {
-				when (it) {
-					// The user has requested the cancellation of the flow builder.
-					// It is their responsibility to emit the correct exception in the flow, so we have nothing more to do.
-					is StateBuilderCancellation -> Unit
-
-					// The coroutine was cancelled.
-					// CancellationExceptions MUST be rethrown, or it breaks coroutines
-					// See https://kotlinlang.org/docs/cancellation-and-timeouts.html#cancellation-is-cooperative
-					is CancellationException -> throw CancellationException("A state builder was cancelled", it)
-
-					else -> emit(Data(Result.Failure.Kotlin(it), Completed, ref = null))
-				}
-			}
-
-		/**
-		 * Stops the currently running [state] call.
-		 */
-		class StateBuilderCancellation : RuntimeException("The 'state' builder has been cancelled")
-
-		/**
-		 * Marks [ref] as [successful][Result.Success] and [completed][Completed].
-		 */
-		suspend fun <O> StateBuilder<O>.markCompleted(ref: Ref<O>?, value: O) =
-			emit(Data(Result.Success(value), Completed, ref))
-
-		/**
-		 * Marks [ref] as [failed][Result.Failure] and [completed][Completed].
-		 */
-		suspend fun <O> StateBuilder<O>.markFailed(ref: Ref<O>?, error: Result.Failure): Nothing {
-			emit(Data(error, Completed, ref))
-			throw StateBuilderCancellation()
-		}
-
-		/**
-		 * Marks [ref] as [invalid][Result.Failure.Standard.Kind.Invalid] and [completed][Completed].
-		 */
-		suspend fun <O> StateBuilder<O>.markInvalid(ref: Ref<O>?, message: String): Nothing = markFailed(ref, Result.Failure.Standard(Result.Failure.Standard.Kind.Invalid, message))
-
-		/**
-		 * Marks [ref] as [unauthenticated][Result.Failure.Standard.Kind.Unauthenticated] and [completed][Completed].
-		 */
-		suspend fun <O> StateBuilder<O>.markUnauthenticated(ref: Ref<O>?, message: String): Nothing = markFailed(ref, Result.Failure.Standard(Result.Failure.Standard.Kind.Unauthenticated, message))
-
-		/**
-		 * Marks [ref] as [unauthorized][Result.Failure.Standard.Kind.Unauthorized] and [completed][Completed].
-		 */
-		suspend fun <O> StateBuilder<O>.markUnauthorized(ref: Ref<O>?, message: String): Nothing = markFailed(ref, Result.Failure.Standard(Result.Failure.Standard.Kind.Unauthorized, message))
-
-		/**
-		 * Marks [ref] as [not found][Result.Failure.Standard.Kind.NotFound] and [completed][Completed].
-		 */
-		suspend fun <O> StateBuilder<O>.markNotFound(ref: Ref<O>?, message: String): Nothing = markFailed(ref, Result.Failure.Standard(Result.Failure.Standard.Kind.NotFound, message))
-
-		/**
-		 * Marks [ref] as an [unknown failure][Result.Failure.Standard.Kind.Unknown] and [completed][Completed].
-		 */
-		suspend fun <O> StateBuilder<O>.markUnknownFailure(ref: Ref<O>?, message: String): Nothing = markFailed(ref, Result.Failure.Standard(Result.Failure.Standard.Kind.Unknown, message))
-
-		/**
-		 * Marks [ref] as [loading][Basic].
-		 */
-		suspend fun <O> StateBuilder<O>.markLoading(ref: Ref<O>?, progression: Float? = null) = emit(Data(Result.NoData, Basic(progression), ref))
-
-		//endregion
-		//region Result selection
-
-		/**
-		 * Skips the loading events in the [Flow].
-		 *
-		 * After calling this method, the flow will only emit values that are completely finished.
-		 *
-		 * @see firstResult
-		 */
-		fun <O> State<O>.skipLoading() = filter { it.status !is Loading }
-
-		/**
-		 * Returns the first non-loading element of this [Flow].
-		 *
-		 * Because this transforms a flow into a single value, the reactivity is lost.
-		 * Only use this method in contexts where being notified on new values is not important.
-		 *
-		 * @see skipLoading
-		 * @see firstSuccessOrThrow
-		 */
-		suspend fun <O> State<O>.firstResult() = skipLoading().first()
-
-		/**
-		 * Waits for the first concrete value ([Completed] and not [Result.NoData]).
-		 *
-		 * If it is [successful][Result.Success], the value is returned.
-		 * If it is a [failure][Result.Failure], [Result.Failure.throwable] is thrown.
-		 */
-		suspend fun <O> State<O>.firstSuccessOrThrow(): O {
-			val result = skipLoading()
-				.filter { it.data !is Result.NoData }
-				.first()
-
-			return when (result.data) {
-				is Result.NoData -> error("Impossible, we just filtered them out")
-				is Result.Success -> result.data.value
-				is Result.Failure -> throw result.data.throwable
-			}
-		}
-
-		fun <In, Out> State<In>.map(ref: (Ref<In>) -> Ref<Out>, value: (In) -> Out): State<Out> = map {
-			Data(
-				it.data.map(value),
-				it.status,
-				it.ref?.let(ref),
-			)
-		}
-
-		//endregion
-	}
-}
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/Ref.kt b/backbone/src/commonMain/kotlin/opensavvy/backbone/Ref.kt
index 35407dd..e46ba73 100644
--- a/backbone/src/commonMain/kotlin/opensavvy/backbone/Ref.kt
+++ b/backbone/src/commonMain/kotlin/opensavvy/backbone/Ref.kt
@@ -2,9 +2,13 @@ package opensavvy.backbone
 
 import kotlinx.coroutines.flow.Flow
 import opensavvy.backbone.Backbone.Companion.request
-import opensavvy.backbone.Data.Companion.firstSuccessOrThrow
 import opensavvy.backbone.Ref.Companion.directRequest
 import opensavvy.backbone.Ref.Companion.request
+import opensavvy.state.Identifier
+import opensavvy.state.State
+import opensavvy.state.firstResultOrThrow
+
+typealias RefState<O> = State<Ref<O>, O>
 
 /**
  * A reference to a specific [object][O].
@@ -18,7 +22,7 @@ import opensavvy.backbone.Ref.Companion.request
  *
  * @param O The object this reference refers to.
  */
-interface Ref<O> {
+interface Ref<O> : Identifier<O> {
 
 	/**
 	 * The [Backbone] responsible for this reference.
@@ -53,7 +57,7 @@ interface Ref<O> {
 		 * The next time [request] is called, a new request will be started.
 		 */
 		suspend fun <O> Ref<O>.expire() {
-			backbone.cache.expireAllRecursively(listOf(this))
+			backbone.cache.expire(this)
 		}
 
 		/**
@@ -64,6 +68,6 @@ interface Ref<O> {
 		 * is modified.
 		 * This method should therefore only be used in non-reactive contexts (tests, to write the value to the terminal, etc).
 		 */
-		suspend fun <O> Ref<O>.requestValue() = request().firstSuccessOrThrow()
+		suspend fun <O> Ref<O>.requestValue() = request().firstResultOrThrow()
 	}
 }
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/RefCache.kt b/backbone/src/commonMain/kotlin/opensavvy/backbone/RefCache.kt
new file mode 100644
index 0000000..e33331f
--- /dev/null
+++ b/backbone/src/commonMain/kotlin/opensavvy/backbone/RefCache.kt
@@ -0,0 +1,24 @@
+package opensavvy.backbone
+
+import kotlinx.coroutines.flow.emitAll
+import opensavvy.backbone.Ref.Companion.directRequest
+import opensavvy.cache.BatchingCacheAdapter
+import opensavvy.cache.Cache
+import opensavvy.cache.CacheAdapter
+import opensavvy.state.state
+import kotlin.coroutines.CoroutineContext
+
+typealias BackboneCache<O> = Cache<Ref<O>, O>
+
+fun <O> defaultBackboneCache() = CacheAdapter<Ref<O>, O> { it.directRequest() }
+
+fun <O> batchingBackboneCache(context: CoroutineContext, workers: Int = 1) =
+	BatchingCacheAdapter<Ref<O>, O>(context, workers) { requests ->
+		val results = requests.groupBy { it.backbone }
+			.map { (backbone, refs) -> backbone.batchRequests(refs.toHashSet()) }
+
+		state {
+			for (result in results)
+				emitAll(result)
+		}
+	}
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/Result.kt b/backbone/src/commonMain/kotlin/opensavvy/backbone/Result.kt
deleted file mode 100644
index 4096525..0000000
--- a/backbone/src/commonMain/kotlin/opensavvy/backbone/Result.kt
+++ /dev/null
@@ -1,102 +0,0 @@
-package opensavvy.backbone
-
-import opensavvy.backbone.Result.*
-
-/**
- * The various possible results of querying a [reference][Ref].
- *
- * There are three major possible cases:
- * - [NoData]: the request has not finished yet, the request is neither successful nor failed,
- * - [Success]: the request is successful, [Success.value] contains the result,
- * - [Failure]: the request has failed, the object contains the reason why.
- */
-sealed interface Result<out O> {
-
-	/**
-	 * Applies a [transform] to the value stored by this [Result].
-	 */
-	fun <T> map(transform: (O) -> T): Result<T>
-
-	/**
-	 * The request has not finished yet, and no previous result is available.
-	 */
-	object NoData : Result<Nothing> {
-		override fun toString() = "NoData"
-
-		override fun <T> map(transform: (Nothing) -> T) = NoData
-	}
-
-	/**
-	 * The request is successful, [value] contains its result.
-	 */
-	data class Success<O>(val value: O) : Result<O> {
-		override fun toString() = value.toString()
-
-		override fun <T> map(transform: (O) -> T): Result<T> = Success(transform(value))
-	}
-
-	/**
-	 * The request has failed.
-	 */
-	sealed interface Failure : Result<Nothing> {
-		val message: String
-
-		/**
-		 * Converts this failure into a [Throwable] object.
-		 */
-		val throwable: Throwable
-
-		override fun <T> map(transform: (Nothing) -> T): Result<T> = this
-
-		data class Standard(
-			val kind: Kind,
-			override val message: String,
-		) : Failure {
-
-			init {
-				require(message.isNotBlank()) { "The message of a standard error may not be blank: found '$message'" }
-			}
-
-			override val throwable get() = StandardException()
-
-			inner class StandardException : Exception("$kind: $message")
-
-			enum class Kind {
-				/**
-				 * The request is not valid.
-				 *
-				 * All prerequisites are correct (the user is correctly authenticated and authorized…) but the
-				 * request payload is invalid.
-				 */
-				Invalid,
-
-				/**
-				 * The implementation could not determine which user is making the request.
-				 */
-				Unauthenticated,
-
-				/**
-				 * The implementation could determine which user is making the request, but they do not have
-				 * sufficient rights to make the request.
-				 */
-				Unauthorized,
-
-				/**
-				 * The request is well-formed and the user is allowed to make it,
-				 * but the resource it should apply to could not be found.
-				 */
-				NotFound,
-
-				/**
-				 * The implementation caught an unknown error.
-				 */
-				Unknown,
-				;
-			}
-		}
-
-		data class Kotlin(override val throwable: Throwable) : Failure {
-			override val message = throwable.message ?: "No known message"
-		}
-	}
-}
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/cache/MemoryCache.kt b/backbone/src/commonMain/kotlin/opensavvy/backbone/cache/MemoryCache.kt
deleted file mode 100644
index 0ac807d..0000000
--- a/backbone/src/commonMain/kotlin/opensavvy/backbone/cache/MemoryCache.kt
+++ /dev/null
@@ -1,139 +0,0 @@
-package opensavvy.backbone.cache
-
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.sync.withPermit
-import opensavvy.backbone.Cache
-import opensavvy.backbone.Data
-import opensavvy.backbone.Data.Companion.initialData
-import opensavvy.backbone.Ref
-import opensavvy.backbone.cache.MemoryCache.Companion.cachedInMemory
-import opensavvy.logger.Logger.Companion.trace
-import opensavvy.logger.Logger.Companion.warn
-import opensavvy.logger.loggerFor
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-
-/**
- * In-memory [Cache] implementation.
- *
- * Updates from the previous cache layer are stored in a dictionary.
- * When [get] is called, results are returned from the dictionary if available.
- * Otherwise, the query is transmitted to the previous layer.
- *
- * This implementation never frees the cache or invalidates elements inside it.
- * To free memory, add a subsequent layer responsible for it (e.g. [ExpirationCache]).
- *
- * Use the [cachedInMemory] factory for easy cache chaining:
- * ```kotlin
- * val cache = Cache.Default()
- *     .cachedInMemory()
- *     .expireAfter(2.minutes)
- * ```
- */
-class MemoryCache<O>(
-	upstream: Cache<O>,
-	context: CoroutineContext = EmptyCoroutineContext,
-) : Cache.CacheLayer<O>(upstream) {
-
-	private val cache = HashMap<Ref<O>, MutableStateFlow<Data<O>>>()
-	private val cacheLock = Semaphore(1)
-
-	private val jobs = HashMap<Ref<O>, Job>()
-	private val jobsLock = Semaphore(1)
-
-	private val subscribeJob = SupervisorJob(context[Job])
-	private val scope = CoroutineScope(subscribeJob)
-
-	private fun getUnsafe(ref: Ref<O>) = cache.getOrPut(ref) { MutableStateFlow(ref.initialData) }
-
-	override fun get(ref: Ref<O>): Flow<Data<O>> = flow {
-		log.trace(ref) { "get called for" }
-
-		val cached = cacheLock.withPermit { getUnsafe(ref) }
-
-		cached.collect { data ->
-			emit(data)
-
-			jobsLock.withPermit {
-				// A new event arrived
-				// Possible causes:
-				// - the previous layer was updated
-				// - 'update' or 'expire' were called
-
-				// There are three possible cases:
-				// 1. We are not subscribed to the previous layer for this ref
-				//    -> subscribe to it
-				// 2. We are subscribed to the previous layer for this ref
-				//    -> nothing to do
-				// 3. We were previously subscribed, but the subscriber died
-				//    -> subscribe to the ref (overwrite the dead subscriber)
-
-				val job = jobs[ref]
-				if (job == null || !job.isActive) {
-					// job == null: case 1
-					// job is not active: case 3
-					// in both cases, a new job must be started
-
-					jobs[ref] = scope.launch(CoroutineName("MemoryCache for $ref")) {
-						log.trace { "Subscribing to the previous layer for $ref" }
-
-						upstream[ref]
-							.collect { cached.value = it }
-					}
-				} // else: case 2, nothing to do
-			}
-		}
-	}.distinctUntilChanged()
-		.onEach { log.trace(it) { "new value emitted from 'get'" } }
-
-	override suspend fun updateAll(values: Iterable<Data<O>>) {
-		log.trace(values) { "updateAll" }
-
-		cacheLock.withPermit {
-			for (value in values) {
-				if (value.ref != null)
-					getUnsafe(value.ref).value = value
-				else
-					log.warn(value) { "Attempted an update with reference-less data (no-op)" }
-			}
-		}
-
-		super.updateAll(values)
-	}
-
-	override suspend fun expireAll(refs: Iterable<Ref<O>>) {
-		log.trace(refs) { "expireAll" }
-
-		jobsLock.withPermit {
-			for (ref in refs) {
-				jobs.remove(ref)?.cancel("MemoryCache.expireAll(refs) was called")
-			}
-		}
-
-		cacheLock.withPermit {
-			for (ref in refs)
-				cache[ref]?.value = ref.initialData
-		}
-	}
-
-	override suspend fun expireAll() {
-		log.trace { "expireAll" }
-
-		jobsLock.withPermit {
-			jobs.values.forEach { it.cancel("MemoryCache.expireAll() was called") }
-		}
-
-		cacheLock.withPermit {
-			for (ref in cache.keys)
-				cache[ref]?.value = ref.initialData
-		}
-	}
-
-	companion object {
-		private val log = loggerFor(this)
-
-		fun <O> Cache<O>.cachedInMemory(context: CoroutineContext = EmptyCoroutineContext) = MemoryCache(this, context)
-	}
-}
diff --git a/backbone/src/commonTest/kotlin/opensavvy.backbone/BackboneCacheTest.kt b/backbone/src/commonTest/kotlin/opensavvy.backbone/BackboneCacheTest.kt
new file mode 100644
index 0000000..03e409f
--- /dev/null
+++ b/backbone/src/commonTest/kotlin/opensavvy.backbone/BackboneCacheTest.kt
@@ -0,0 +1,59 @@
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package opensavvy.backbone
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.test.runTest
+import opensavvy.backbone.Ref.Companion.expire
+import opensavvy.backbone.Ref.Companion.requestValue
+import opensavvy.state.emitSuccessful
+import opensavvy.state.ensureValid
+import opensavvy.state.state
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class BackboneCacheTest {
+
+	// Id("12") -> 12
+	private class Bone(override val cache: BackboneCache<Int>) : Backbone<Int> {
+		override fun directRequest(ref: Ref<Int>): RefState<Int> = state {
+			ensureValid(ref, ref is Ref.Basic) { "Only basic references are accepted by ${this@Bone}" }
+			val int = ref.id.toIntOrNull()
+			ensureValid(ref, int != null) { "The reference $ref does not refer to a valid integer" }
+			emitSuccessful(ref, int)
+		}
+
+		fun of(int: Int) = Ref.Basic(int.toString(), this)
+	}
+
+	@Test
+	fun default() = runTest {
+		val bone = Bone(defaultBackboneCache())
+		val id5 = bone.of(5)
+		val id2 = bone.of(2)
+
+		assertEquals(5, id5.requestValue())
+		assertEquals(2, id2.requestValue())
+
+		id2.expire()
+		assertEquals(2, id2.requestValue())
+	}
+
+	@Test
+	fun batching() = runTest {
+		val job = Job()
+
+		val bone = Bone(batchingBackboneCache(coroutineContext + job))
+		val id5 = bone.of(5)
+		val id2 = bone.of(2)
+
+		assertEquals(5, id5.requestValue())
+		assertEquals(2, id2.requestValue())
+
+		id2.expire()
+		assertEquals(2, id2.requestValue())
+
+		job.cancel()
+	}
+}
diff --git a/backbone/src/commonTest/kotlin/opensavvy.backbone/DataTest.kt b/backbone/src/commonTest/kotlin/opensavvy.backbone/DataTest.kt
deleted file mode 100644
index ddc84b6..0000000
--- a/backbone/src/commonTest/kotlin/opensavvy.backbone/DataTest.kt
+++ /dev/null
@@ -1,275 +0,0 @@
-@file:OptIn(ExperimentalCoroutinesApi::class)
-
-package opensavvy.backbone
-
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.toList
-import kotlinx.coroutines.flow.transformWhile
-import kotlinx.coroutines.test.runTest
-import opensavvy.backbone.Data.Companion.markCompleted
-import opensavvy.backbone.Data.Companion.markInvalid
-import opensavvy.backbone.Data.Companion.markLoading
-import opensavvy.backbone.Data.Companion.markNotFound
-import opensavvy.backbone.Data.Companion.markUnauthenticated
-import opensavvy.backbone.Data.Companion.markUnauthorized
-import opensavvy.backbone.Data.Companion.state
-import opensavvy.backbone.Data.Companion.value
-import opensavvy.backbone.Ref.Companion.request
-import opensavvy.backbone.cache.ExpirationCache.Companion.expireAfter
-import opensavvy.backbone.cache.MemoryCache.Companion.cachedInMemory
-import kotlin.coroutines.CoroutineContext
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.time.Duration.Companion.seconds
-
-class DataTest {
-
-	@Test
-	fun percent() {
-		val loadingNoInfo = Data.Status.Loading.Basic()
-		assertEquals(null, loadingNoInfo.progression)
-		assertEquals(null, loadingNoInfo.percent)
-		assertEquals("Loading", loadingNoInfo.toString())
-
-		val loadingStart = Data.Status.Loading.Basic(0f)
-		assertEquals(0f, loadingStart.progression)
-		assertEquals(0, loadingStart.percent)
-
-		val loadingThird = Data.Status.Loading.Basic(0.33f)
-		assertEquals(0.33f, loadingThird.progression)
-		assertEquals(33, loadingThird.percent)
-		assertEquals("Loading(33%)", loadingThird.toString())
-
-		val loadingDone = Data.Status.Loading.Basic(1.0f)
-		assertEquals(1.0f, loadingDone.progression)
-		assertEquals(100, loadingDone.percent)
-	}
-
-	private class IntBone(context: CoroutineContext) : Backbone<Int> {
-		override val cache = Cache.Default<Int>().cachedInMemory(context).expireAfter(10.seconds, context)
-
-		override fun directRequest(ref: Ref<Int>): Flow<Data<Int>> = state {
-			markLoading(ref, 0f)
-			delay(20)
-
-			if (ref !is Ref.Basic)
-				markInvalid(ref, "The passed reference is invalid")
-
-			markLoading(ref, 0.2f)
-			delay(20)
-
-			val value = ref.id.toIntOrNull() ?: markInvalid(ref, "Could not convert '${ref.id}' to an integer")
-
-			markLoading(ref, 0.4f)
-			delay(20)
-
-			// just imagine we're testing the credentials here
-			if (value < 0)
-				markUnauthenticated(ref, "Only logged-in users can access the number $value")
-
-			markLoading(ref, 0.6f)
-			delay(20)
-
-			// just imagine we're testing the credentials here
-			if (value == 0)
-				markUnauthorized(ref, "Only administrators can access the number $value")
-
-			markLoading(ref, 0.8f)
-			delay(20)
-
-			if (value >= 100)
-				markNotFound(ref, "Only values lesser than 100 can be found: $value")
-
-			markLoading(ref, 0.9f)
-			delay(20)
-
-			markCompleted(ref, value)
-		}
-	}
-
-	@Test
-	fun successful() = runTest {
-		val job = Job()
-
-		val ref = Ref.Basic("5", IntBone(coroutineContext + job))
-		val real = ref
-			.request()
-			.transformWhile {
-				emit(it)
-				it.data !is Result.Success<*>
-			}
-			.toList()
-
-		val expected = listOf(
-			Data(Result.NoData, Data.Status.Loading.Basic(), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.0f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.2f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.4f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.6f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.8f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.9f), ref),
-			Data(Result.Success(5), Data.Status.Completed, ref),
-		)
-
-		assertEquals(expected, real)
-		assertEquals(5, real.last().value)
-
-		job.cancel()
-	}
-
-	@Test
-	fun invalidReference() = runTest {
-		val job = Job()
-
-		val ref = object : Ref<Int> {
-			override val backbone = IntBone(coroutineContext + job)
-		}
-		val real = ref
-			.request()
-			.transformWhile {
-				emit(it)
-				it.status !is Data.Status.Completed
-			}
-			.toList()
-
-		val expected = listOf(
-			Data(Result.NoData, Data.Status.Loading.Basic(), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.0f), ref),
-			Data(
-				Result.Failure.Standard(Result.Failure.Standard.Kind.Invalid, "The passed reference is invalid"),
-				Data.Status.Completed,
-				ref
-			)
-		)
-
-		assertEquals(expected, real)
-
-		job.cancel()
-	}
-
-	@Test
-	fun invalidId() = runTest {
-		val job = Job()
-
-		val ref = Ref.Basic("foo", IntBone(coroutineContext + job))
-		val real = ref
-			.request()
-			.transformWhile {
-				emit(it)
-				it.status !is Data.Status.Completed
-			}
-			.toList()
-
-		val expected = listOf(
-			Data(Result.NoData, Data.Status.Loading.Basic(), ref),
-			Data(
-				Result.Failure.Standard(Result.Failure.Standard.Kind.Invalid, "Could not convert 'foo' to an integer"),
-				Data.Status.Completed,
-				ref
-			)
-		)
-
-		assertEquals(expected, real)
-
-		job.cancel()
-	}
-
-	@Test
-	fun unauthenticated() = runTest {
-		val job = Job()
-
-		val ref = Ref.Basic("-1", IntBone(coroutineContext + job))
-		val real = ref
-			.request()
-			.transformWhile {
-				emit(it)
-				it.status !is Data.Status.Completed
-			}
-			.toList()
-
-		val expected = listOf(
-			Data(Result.NoData, Data.Status.Loading.Basic(), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.0f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.2f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.4f), ref),
-			Data(
-				Result.Failure.Standard(
-					Result.Failure.Standard.Kind.Unauthenticated,
-					"Only logged-in users can access the number -1"
-				), Data.Status.Completed, ref
-			)
-		)
-
-		assertEquals(expected, real)
-
-		job.cancel()
-	}
-
-	@Test
-	fun unauthorized() = runTest {
-		val job = Job()
-
-		val ref = Ref.Basic("0", IntBone(coroutineContext + job))
-		val real = ref
-			.request()
-			.transformWhile {
-				emit(it)
-				it.status !is Data.Status.Completed
-			}
-			.toList()
-
-		val expected = listOf(
-			Data(Result.NoData, Data.Status.Loading.Basic(), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.0f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.2f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.4f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.6f), ref),
-			Data(
-				Result.Failure.Standard(
-					Result.Failure.Standard.Kind.Unauthorized,
-					"Only administrators can access the number 0"
-				), Data.Status.Completed, ref
-			)
-		)
-
-		assertEquals(expected, real)
-
-		job.cancel()
-	}
-
-	@Test
-	fun notFound() = runTest {
-		val job = Job()
-
-		val ref = Ref.Basic("207", IntBone(coroutineContext + job))
-		val real = ref
-			.request()
-			.transformWhile {
-				emit(it)
-				it.status !is Data.Status.Completed
-			}
-			.toList()
-
-		val expected = listOf(
-			Data(Result.NoData, Data.Status.Loading.Basic(), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.0f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.2f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.4f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.6f), ref),
-			Data(Result.NoData, Data.Status.Loading.Basic(0.8f), ref),
-			Data(
-				Result.Failure.Standard(
-					Result.Failure.Standard.Kind.NotFound,
-					"Only values lesser than 100 can be found: 207"
-				), Data.Status.Completed, ref
-			)
-		)
-
-		assertEquals(expected, real)
-
-		job.cancel()
-	}
-}
diff --git a/backbone/src/commonTest/kotlin/opensavvy.backbone/ResultTest.kt b/backbone/src/commonTest/kotlin/opensavvy.backbone/ResultTest.kt
deleted file mode 100644
index 9bce597..0000000
--- a/backbone/src/commonTest/kotlin/opensavvy.backbone/ResultTest.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-package opensavvy.backbone
-
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class ResultTest {
-
-	private val toString = { it: Int -> it.toString() }
-
-	@Test
-	fun mapNoData() {
-		// NoData doesn't store anything, so mapping its content should do nothing
-		assertEquals(Result.NoData, Result.NoData.map(toString))
-		assertEquals("NoData", Result.NoData.toString())
-	}
-
-	@Test
-	fun mapSuccess() {
-		val input = Result.Success(5)
-		val expected = Result.Success("5")
-
-		assertEquals(expected, input.map(toString))
-	}
-
-	@Test
-	fun mapStandardFailure() {
-		// Failures do not store anything, so mapping their content should do nothing
-		val input = Result.Failure.Standard(Result.Failure.Standard.Kind.NotFound, "Could not find element with identifier 2")
-
-		assertEquals(input, input.map(toString))
-	}
-
-	@Test
-	fun mapKotlinFailure() {
-		// Failures do not store anything, so mapping their content should do nothing
-		val input = Result.Failure.Kotlin(RuntimeException("Could not find element with identifier 2"))
-
-		assertEquals(input, input.map(toString))
-	}
-
-}
diff --git a/backbone/src/commonTest/kotlin/opensavvy.backbone/cache/CacheTracing.kt b/backbone/src/commonTest/kotlin/opensavvy.backbone/cache/CacheTracing.kt
deleted file mode 100644
index 45a3b45..0000000
--- a/backbone/src/commonTest/kotlin/opensavvy.backbone/cache/CacheTracing.kt
+++ /dev/null
@@ -1,89 +0,0 @@
-package opensavvy.backbone.cache
-
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.sync.withPermit
-import kotlinx.coroutines.test.runTest
-import opensavvy.backbone.*
-import opensavvy.backbone.Ref.Companion.expire
-import opensavvy.backbone.Ref.Companion.requestValue
-import opensavvy.backbone.cache.MemoryCache.Companion.cachedInMemory
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class CacheTracing  {
-	private data class TracingRef(val value: Int, override val backbone: Backbone<Int>) : Ref<Int> {
-		override fun toString() = "Int($value)"
-	}
-
-	private class TracingBackbone(override val cache: Cache<Int>): Backbone<Int> {
-		var tracker = 0
-		val lock = Semaphore(1)
-
-		override fun directRequest(ref: Ref<Int>): Flow<Data<Int>> = flow {
-			require(ref is TracingRef) { "This backbone only works with TracingRef, found $ref" }
-
-			lock.withPermit {
-				tracker++
-			}
-
-			delay(10) // give time to the other coroutines to execute
-			emit(Data(Result.Success(ref.value), Data.Status.Completed, ref))
-		}
-
-		fun get(value: Int) = TracingRef(value, this)
-	}
-
-	/**
-	 * Two different subscribers on the same ref
-	 *
-	 * If we expire this ref, only one real request must be launched (not one each!)
-	 */
-	@Test
-	fun concurrentRequest() = runTest {
-		val job = Job()
-
-		val backbone = TracingBackbone(Cache.Default<Int>().cachedInMemory(coroutineContext + job))
-		val zero = backbone.get(0)
-		assertEquals(0, backbone.tracker)
-
-		coroutineScope {
-			// Start 10 parallel requests
-			repeat(10) {
-				launch {
-					assertEquals(0, zero.requestValue())
-				}
-			}
-		}
-
-		// After the 10 requests have finished, check that only one real request was sent
-		assertEquals(1, backbone.tracker)
-
-		job.cancel()
-	}
-
-	/**
-	 * Expiring a value when no one is subscribed to it does not start a new request
-	 */
-	@Test
-	fun expireNoSubscribers() = runTest {
-		val job = Job()
-
-		val backbone = TracingBackbone(Cache.Default<Int>().cachedInMemory(coroutineContext + job))
-		val zero = backbone.get(0)
-		assertEquals(0, backbone.tracker)
-
-		// Start one request to ensure everything is initialized correctly
-		assertEquals(0, zero.requestValue())
-		assertEquals(1, backbone.tracker)
-
-		// Expire the value, no new requests should be started
-		zero.expire()
-		assertEquals(1, backbone.tracker)
-
-		job.cancel()
-	}
-}
diff --git a/backbone/src/commonTest/kotlin/opensavvy.backbone/cache/MemoryCacheTest.kt b/backbone/src/commonTest/kotlin/opensavvy.backbone/cache/MemoryCacheTest.kt
deleted file mode 100644
index 1e9e25a..0000000
--- a/backbone/src/commonTest/kotlin/opensavvy.backbone/cache/MemoryCacheTest.kt
+++ /dev/null
@@ -1,169 +0,0 @@
-package opensavvy.backbone.cache
-
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.drop
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.test.runTest
-import opensavvy.backbone.*
-import opensavvy.backbone.Data.Companion.firstSuccessOrThrow
-import opensavvy.backbone.Data.Companion.skipLoading
-import opensavvy.backbone.Ref.Companion.expire
-import opensavvy.backbone.Ref.Companion.request
-import opensavvy.backbone.Ref.Companion.requestValue
-import opensavvy.backbone.cache.ExpirationCache.Companion.expireAfter
-import opensavvy.backbone.cache.MemoryCache.Companion.cachedInMemory
-import opensavvy.logger.Logger.Companion.info
-import opensavvy.logger.loggerFor
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.minutes
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class MemoryCacheTest {
-
-	private data class AbsoluteIntRef(val value: Int, override val backbone: Backbone<UInt>) : Ref<UInt> {
-		override fun toString() = "UIntOf($value)"
-	}
-
-	private class AbsoluteIntBackbone(override val cache: Cache<UInt>) : Backbone<UInt> {
-		override fun directRequest(ref: Ref<UInt>): Flow<Data<UInt>> = flow {
-			require(ref is AbsoluteIntRef)
-
-			log.info { "directRequest called for $ref" }
-
-			if (ref.value > 0)
-				emit(Data(Result.Success(ref.value.toUInt()), Data.Status.Completed, ref))
-			else
-				emit(Data(Result.Success((-ref.value).toUInt()), Data.Status.Completed, ref))
-		}
-
-		fun convert(value: Int) = AbsoluteIntRef(value, this)
-
-		companion object {
-			private val log = loggerFor(this)
-		}
-	}
-
-	/**
-	 * Tests that running a request through the cache actually sends it to the backbone
-	 */
-	private suspend fun testCache(cache: Cache<UInt>) {
-		cache.expireAllRecursively()
-		val backbone = AbsoluteIntBackbone(cache)
-
-		println("Normal access via directRequest...")
-		val zero = backbone.convert(0)
-		val one = backbone.convert(1)
-		val minus = backbone.convert(-1)
-
-		assertEquals(0u, zero.requestValue())
-		assertEquals(1u, one.requestValue())
-		assertEquals(1u, minus.requestValue())
-	}
-
-	/**
-	 * Tests updating and expiring a value
-	 *
-	 * This test only applies to stateful cache layers (e.g. MemoryCache)
-	 */
-	private suspend fun testUpdateExpiration(cache: Cache<UInt>) {
-		cache.expireAllRecursively()
-		val backbone = AbsoluteIntBackbone(cache)
-
-		println("\nForcing a different value")
-		val zero = backbone.convert(0)
-		backbone.cache.update(zero, 5u)
-		assertEquals(5u, zero.requestValue())
-
-		println("\nExpiring the value re-downloads it and replaces our invalid value")
-		zero.expire()
-		assertEquals(0u, zero.requestValue())
-	}
-
-	/**
-	 * Tests that the data is correctly expired
-	 *
-	 * This test only applies to layers which automatically expire data after some time (e.g. ExpirationCache)
-	 */
-	private suspend fun testAutoExpiration(cache: Cache<UInt>) {
-		cache.expireAllRecursively()
-		val backbone = AbsoluteIntBackbone(cache)
-
-		println("\nAdding 5u to the cache to make updates visible")
-		val zero = backbone.convert(0)
-		assertEquals(0u, zero.requestValue())
-		backbone.cache.update(
-			zero,
-			5u
-		) // adding a weird value, so we can detect when it decides to automatically trigger the update
-
-		println("Querying until the cache a non-5u value")
-		assertEquals(0u, zero.request()
-			.skipLoading()
-			.onEach { println("-> $it") }
-			.drop(1) // ignore the 5u
-			.firstSuccessOrThrow())
-	}
-
-	@Test
-	fun withoutCache() = runTest {
-		val cache = Cache.Default<UInt>()
-
-		testCache(cache)
-	}
-
-	@Test
-	fun infiniteMemoryCache() = runTest {
-		val job = Job()
-		val cache = Cache.Default<UInt>()
-			.cachedInMemory(coroutineContext + job)
-
-		testCache(cache)
-		testUpdateExpiration(cache)
-
-		job.cancel()
-	}
-
-	@Test
-	fun expiringDefaultCache() = runTest {
-		val job = Job()
-		val cache = Cache.Default<UInt>()
-			.expireAfter(1.minutes, coroutineContext + job)
-
-		testCache(cache)
-
-		job.cancel()
-	}
-
-	@Test
-	fun expiringMemoryCache() = runTest {
-		val job = Job()
-		val cache = Cache.Default<UInt>()
-			.cachedInMemory(coroutineContext + job)
-			.expireAfter(300.milliseconds, coroutineContext + job)
-
-		testCache(cache)
-		testUpdateExpiration(cache)
-		testAutoExpiration(cache)
-
-		job.cancel()
-	}
-
-	@Test
-	fun expiringMemoryBatchedCache() = runTest {
-		val job = Job()
-		val cache = Cache.Batching<UInt>()
-			.cachedInMemory(coroutineContext + job)
-			.expireAfter(300.milliseconds, coroutineContext + job)
-
-		testCache(cache)
-		testUpdateExpiration(cache)
-		testAutoExpiration(cache)
-
-		job.cancel()
-	}
-}
diff --git a/cache/build.gradle.kts b/cache/build.gradle.kts
new file mode 100644
index 0000000..1c48154
--- /dev/null
+++ b/cache/build.gradle.kts
@@ -0,0 +1,41 @@
+@file:Suppress("UNUSED_VARIABLE")
+
+plugins {
+	kotlin("multiplatform")
+}
+
+kotlin {
+	jvm()
+	js(IR) {
+		browser()
+	}
+
+	sourceSets {
+		val commonMain by getting {
+			dependencies {
+				api(projects.state)
+				api(KotlinX.datetime)
+
+				implementation(projects.logger)
+			}
+		}
+
+		val commonTest by getting {
+			dependencies {
+				implementation(projects.tester)
+				implementation(KotlinX.coroutines.test)
+			}
+		}
+	}
+}
+
+kover {
+	verify {
+		rule {
+			name = "Minimal code coverage"
+			bound {
+				minValue = 90
+			}
+		}
+	}
+}
diff --git a/cache/src/commonMain/kotlin/opensavvy.cache/BatchingCacheAdapter.kt b/cache/src/commonMain/kotlin/opensavvy.cache/BatchingCacheAdapter.kt
new file mode 100644
index 0000000..fdf67b5
--- /dev/null
+++ b/cache/src/commonMain/kotlin/opensavvy.cache/BatchingCacheAdapter.kt
@@ -0,0 +1,127 @@
+package opensavvy.cache
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.channels.SendChannel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import opensavvy.state.*
+import opensavvy.state.Slice.Companion.pending
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.coroutineContext
+
+/**
+ * Cache implementation aimed to be the first link in a cache chain.
+ *
+ * This is not a valid implementation of a cache (it doesn't do any caching), and only serves as a link between caches
+ * and the underlying network APIs.
+ *
+ * Unlike [CacheAdapter], this class is able to group requests together.
+ */
+class BatchingCacheAdapter<I : Identifier<T>, T>(
+	context: CoroutineContext,
+	/**
+	 * The number of workers batching the requests.
+	 *
+	 * All requests are split among them.
+	 * Each worker tries to batch as many requests as possible, then calls [queryBatch] at once.
+	 *
+	 * Increasing the number of workers may increase latency.
+	 */
+	workers: Int = 1,
+	val queryBatch: (Set<I>) -> State<I, T>,
+) : Cache<I, T> {
+
+	private val requests: SendChannel<Pair<I, CompletableDeferred<StateFlow<Slice<I, T>>>>>
+
+	init {
+		require(workers > 0) { "There must be at least 1 worker: found $workers" }
+
+		val requests = Channel<Pair<I, CompletableDeferred<StateFlow<Slice<I, T>>>>>()
+		this.requests = requests
+
+		val scope = CoroutineScope(context)
+		repeat(workers) {
+			scope.launch {
+				worker(requests)
+			}
+		}
+	}
+
+	private suspend fun worker(requests: ReceiveChannel<Pair<I, CompletableDeferred<StateFlow<Slice<I, T>>>>>) {
+		while (coroutineContext.isActive) {
+			val batch = HashSet<I>()
+
+			// Store the results
+			// We have to store lists of Deferred in case multiple requests to the same Ref happen to be in the same
+			// batch.
+			val results = HashMap<I, MutableList<CompletableDeferred<StateFlow<Slice<I, T>>>>>()
+
+			run {
+				// Suspend until a first request arrives
+				val (ref, promise) = requests.receive()
+				batch.add(ref)
+				results.getOrPut(ref) { ArrayList() }
+					.add(promise)
+			}
+
+			while (true) {
+				// Try to read as many requests as possible, without suspending
+				val (ref, promise) = requests.tryReceive()
+					.getOrNull()
+					?: break
+
+				batch.add(ref)
+				results.getOrPut(ref) { ArrayList() }
+					.add(promise)
+			}
+
+			val states = HashMap<I, MutableStateFlow<Slice<I, T>>>()
+
+			// Tell all clients that their request is starting
+			for ((id, promises) in results) {
+				val state = MutableStateFlow(pending(id, Progression.loading(0.0)))
+
+				for (promise in promises) {
+					promise.complete(state)
+				}
+
+				states[id] = state
+			}
+
+			// The channel is now empty, request all of them
+			queryBatch(batch)
+				.collect {
+					val state = states[it.id]
+						?: error("Could not find the state for the reference ${it.id}, this means we received an update for a reference we did not ask for.")
+
+					state.value = it
+				}
+		}
+	}
+
+	override fun get(id: I): State<I, T> = state {
+		val promise = CompletableDeferred<StateFlow<Slice<I, T>>>()
+
+		requests.send(id to promise)
+
+		emitAll(promise.await())
+	}
+
+	override suspend fun update(values: Collection<Pair<I, T>>) {
+		// This cache layer has no state, nothing to do
+	}
+
+	override suspend fun expire(ids: Collection<I>) {
+		// This cache layer has no state, nothing to do
+	}
+
+	override suspend fun expireAll() {
+		// This cache layer has no state, nothing to do
+	}
+}
diff --git a/cache/src/commonMain/kotlin/opensavvy.cache/Cache.kt b/cache/src/commonMain/kotlin/opensavvy.cache/Cache.kt
new file mode 100644
index 0000000..b297c17
--- /dev/null
+++ b/cache/src/commonMain/kotlin/opensavvy.cache/Cache.kt
@@ -0,0 +1,103 @@
+package opensavvy.cache
+
+import opensavvy.state.Identifier
+import opensavvy.state.State
+
+/**
+ * Stores information temporarily to avoid unneeded network requests.
+ *
+ * ### Cache state
+ *
+ * Each piece of data in a cache can be in three different states:
+ * - Up-to-date: the last query was not long ago, we consider its result still valid,
+ * - Stale: the last query was long enough ago that it deserves to be checked again, but it probably is still valid.
+ * In this case, the cache returns the old value and starts a refresh request in the background.
+ * - Expired: the last query was too long ago for the data to still be valid.
+ * In this case, the cache starts a refresh request and will not return a value until the request finishes.
+ * All data that was never previously queried is in this state.
+ *
+ * Different cache implementations differ on how they transition data from one state to another.
+ * Some cache implementations may not have a 'stale' state.
+ * As a user of the cache, you may want to force the state of a specific object if you have more knowledge than the cache,
+ * in this case you can use [update] and [expire].
+ *
+ * ### Cache chaining
+ *
+ * Cache implementations can be chained.
+ * A possible scenario for some data that rarely changes can be:
+ * - Cache the data in memory for 5 minutes,
+ * - Cache the data in hard storage for 1 hour,
+ * - Query the data for real afterwards.
+ *
+ * Cache chaining is instantiated in the opposite order, like iterators (the last in the chain is the first checked,
+ * and delegates to the previous one if they do not have the value).
+ * The first element of the chain, and therefore the one responsible for actually starting the request, is [CacheAdapter] or [BatchingCacheAdapter].
+ * Note that both have a few implementation differences, it is not recommended to use them directly without chaining under another implementation.
+ */
+interface Cache<I : Identifier<T>, T> {
+
+	/**
+	 * Gets the value associated with an [id] in this cache.
+	 *
+	 * This function returns a [State] instance synchronously: it is safe to call in synchronous-only areas of the program,
+	 * such as inside the body of a UI component.
+	 * You can then subscribe to the [State] to access the actual values.
+	 */
+	operator fun get(id: I): State<I, T>
+
+	/**
+	 * Forces the cache to accept [value] as a more recent value for the given [id] than whatever it was previously storing.
+	 *
+	 * All layers are updated.
+	 */
+	suspend fun update(id: I, value: T) {
+		update(listOf(id to value))
+	}
+
+	/**
+	 * Forces the cache to accept the given [values] as more recent for their associated identifier than whatever was previously stored.
+	 *
+	 * If multiple values are provided for the same identifier, a cache implementation may either:
+	 * - take only the last occurrence into account,
+	 * - take each occurrence into account as subsequent updates, in the same order as they appear in the iterable.
+	 *
+	 * If [values] is empty, this function does nothing.
+	 *
+	 * All layers are updated.
+	 */
+	suspend fun update(values: Collection<Pair<I, T>>)
+
+	/**
+	 * Forces the cache to accept the given [values] as more recent for their associated identifier than whatever was
+	 * previously stored.
+	 *
+	 * This overload is provided for convenience, see [update].
+	 */
+	suspend fun update(vararg values: Pair<I, T>) = update(values.asList())
+
+	/**
+	 * Tells the cache that the value it stores for [id] is out of date, and should be queried again the next time it is
+	 * requested.
+	 *
+	 * All layers are updated.
+	 */
+	suspend fun expire(id: I) {
+		expire(listOf(id))
+	}
+
+	/**
+	 * Tells the cache that the value it stores for the given [ids] are out of date, and should be queried again the next
+	 * time they are requested.
+	 *
+	 * All layers are updated.
+	 */
+	suspend fun expire(ids: Collection<I>)
+
+	/**
+	 * Tells the cache that all values are out of date, and should be queried again the next time they are requested.
+	 *
+	 * All layers are updated.
+	 */
+	suspend fun expireAll()
+
+}
diff --git a/cache/src/commonMain/kotlin/opensavvy.cache/CacheAdapter.kt b/cache/src/commonMain/kotlin/opensavvy.cache/CacheAdapter.kt
new file mode 100644
index 0000000..ca18cc7
--- /dev/null
+++ b/cache/src/commonMain/kotlin/opensavvy.cache/CacheAdapter.kt
@@ -0,0 +1,28 @@
+package opensavvy.cache
+
+import opensavvy.state.Identifier
+import opensavvy.state.State
+
+/**
+ * Cache implementation aimed to be the first link in a cache chain.
+ *
+ * This is not a valid implementation of a cache (it doesn't do any caching), and only serves as a link between caches
+ * and the underlying network APIs.
+ */
+class CacheAdapter<I : Identifier<T>, T>(
+	val query: (I) -> State<I, T>,
+) : Cache<I, T> {
+	override fun get(id: I) = query(id)
+
+	override suspend fun update(values: Collection<Pair<I, T>>) {
+		// This cache layer has no state, nothing to do
+	}
+
+	override suspend fun expire(ids: Collection<I>) {
+		// This cache layer has no state, nothing to do
+	}
+
+	override suspend fun expireAll() {
+		// This cache layer has no state, nothing to do
+	}
+}
diff --git a/backbone/src/commonMain/kotlin/opensavvy/backbone/cache/ExpirationCache.kt b/cache/src/commonMain/kotlin/opensavvy.cache/ExpirationCache.kt
similarity index 65%
rename from backbone/src/commonMain/kotlin/opensavvy/backbone/cache/ExpirationCache.kt
rename to cache/src/commonMain/kotlin/opensavvy.cache/ExpirationCache.kt
index 2826727..198970c 100644
--- a/backbone/src/commonMain/kotlin/opensavvy/backbone/cache/ExpirationCache.kt
+++ b/cache/src/commonMain/kotlin/opensavvy.cache/ExpirationCache.kt
@@ -1,19 +1,17 @@
-package opensavvy.backbone.cache
+package opensavvy.cache
 
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
-import opensavvy.backbone.Cache
-import opensavvy.backbone.Data
-import opensavvy.backbone.Ref
-import opensavvy.backbone.cache.ExpirationCache.Companion.expireAfter
+import opensavvy.cache.ExpirationCache.Companion.expireAfter
 import opensavvy.logger.Logger.Companion.debug
 import opensavvy.logger.Logger.Companion.trace
 import opensavvy.logger.loggerFor
+import opensavvy.state.Identifier
+import opensavvy.state.State
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.time.Duration
@@ -28,11 +26,11 @@ import kotlin.time.Duration.Companion.minutes
  *      .expireAfter(5.minutes, Job())
  * ```
  */
-class ExpirationCache<O>(
+class ExpirationCache<I : Identifier<T>, T>(
 	/**
 	 * The previous cache layer, from which values will be expired.
 	 */
-	upstream: Cache<O>,
+	private val upstream: Cache<I, T>,
 	/**
 	 * After how much time should the values from the previous cache layer be expired.
 	 *
@@ -46,8 +44,10 @@ class ExpirationCache<O>(
 	 * Cancelling this job will cancel the expiration job, after which this cache will stop expiring data.
 	 */
 	context: CoroutineContext = EmptyCoroutineContext,
-) : Cache.CacheLayer<O>(upstream) {
-	private val lastUpdate = HashMap<Ref<O>, Instant>()
+) : Cache<I, T> {
+	private val log = loggerFor(this)
+
+	private val lastUpdate = HashMap<I, Instant>()
 	private val lock = Semaphore(1)
 
 	private val job = Job(context[Job])
@@ -61,14 +61,14 @@ class ExpirationCache<O>(
 
 				lock.withPermit {
 					val now = Clock.System.now()
-					val iterator= lastUpdate.iterator()
+					val iterator = lastUpdate.iterator()
 					while (iterator.hasNext()) {
-						val (ref, instant) = iterator.next()
+						val (id, instant) = iterator.next()
 
 						if (instant < now - expireAfter) {
-							log.trace(ref) { "Removed reference" }
+							log.trace(id) { "Removing" }
 							iterator.remove()
-							upstream.expire(ref)
+							upstream.expire(id)
 						}
 					}
 				}
@@ -76,37 +76,44 @@ class ExpirationCache<O>(
 		}
 	}
 
-	private suspend fun markAsUpdatedNow(ref: Ref<O>) {
+	private suspend fun markAsUpdatedNow(id: I) {
 		lock.withPermit {
-			log.trace(ref) { "markAsUpdatedNow" }
-			lastUpdate[ref] = Clock.System.now()
+			log.trace(id) { "Updated now:" }
+			lastUpdate[id] = Clock.System.now()
 		}
 	}
 
-	override fun get(ref: Ref<O>): Flow<Data<O>> = upstream[ref]
-		.onEach { markAsUpdatedNow(ref) }
+	override fun get(id: I): State<I, T> = upstream[id]
+		.onEach { markAsUpdatedNow(id) }
+
+	override suspend fun update(values: Collection<Pair<I, T>>) {
+		// When the upstream is updated, it will signal the modification through the 'get' function,
+		// which will catch. No need to update anything else here.
+		upstream.update(values)
+	}
 
-	override suspend fun expireAll(refs: Iterable<Ref<O>>) {
-		for (ref in refs)
+	override suspend fun expire(ids: Collection<I>) {
+		for (ref in ids)
 			lock.withPermit {
 				lastUpdate.remove(ref)
 			}
+		upstream.expire(ids)
 	}
 
 	override suspend fun expireAll() {
 		lock.withPermit {
 			lastUpdate.clear()
 		}
+		upstream.expireAll()
 	}
 
 	companion object {
-		private val log = loggerFor(this)
-
 		/**
 		 * Factory function to easily add a [ExpirationCache] layer to an existing cache chain.
 		 *
 		 * @see ExpirationCache
 		 */
-		fun <O> Cache<O>.expireAfter(duration: Duration, context: CoroutineContext = EmptyCoroutineContext) = ExpirationCache(this, duration, context)
+		fun <I : Identifier<T>, T> Cache<I, T>.expireAfter(duration: Duration, context: CoroutineContext) =
+			ExpirationCache(this, duration, context)
 	}
 }
diff --git a/cache/src/commonMain/kotlin/opensavvy.cache/MemoryCache.kt b/cache/src/commonMain/kotlin/opensavvy.cache/MemoryCache.kt
new file mode 100644
index 0000000..89fdb04
--- /dev/null
+++ b/cache/src/commonMain/kotlin/opensavvy.cache/MemoryCache.kt
@@ -0,0 +1,173 @@
+package opensavvy.cache
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
+import opensavvy.cache.MemoryCache.Companion.cachedInMemory
+import opensavvy.logger.Logger.Companion.trace
+import opensavvy.logger.loggerFor
+import opensavvy.state.Identifier
+import opensavvy.state.Slice
+import opensavvy.state.Slice.Companion.successful
+import opensavvy.state.State
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+
+/**
+ * In-memory [Cache] implementation.
+ *
+ * Updates from the previous cache layer are stored in a dictionary.
+ * When [get] is called, results are returned from the dictionary if available.
+ * Otherwise, the query is transmitted to the previous layer.
+ *
+ * This implementation never frees the cache or invalidates elements inside it.
+ * To free memory, add a subsequent layer responsible for it (e.g. [ExpirationCache]).
+ *
+ * Use the [cachedInMemory] factory for easy cache chaining:
+ * ```kotlin
+ * val cache = Cache.Default()
+ *     .cachedInMemory()
+ *     .expireAfter(2.minutes)
+ * ```
+ */
+class MemoryCache<I : Identifier<T>, T>(
+	private val upstream: Cache<I, T>,
+	context: CoroutineContext = EmptyCoroutineContext,
+) : Cache<I, T> {
+
+	private val log = loggerFor(this)
+
+	/* Implementation explanation.
+	 *
+	 * Features:
+	 * - the flow returned by 'get' is infinite (as long as downstream users are subscribed to it)
+	 *   - if there is no cached value, a request is started and this flow becomes responsible for updating its values
+	 *   - if there is a cached value, it is returned (there is NO expiration in this layer)
+	 *   - in both cases, we subscribe to the internal cache and propagate changes to it
+	 * - 'update' sets the cached value
+	 * - 'expire' removed the cached value
+	 */
+
+	private val cache = HashMap<I, MutableStateFlow<Slice<I, T>?>>()
+	private val cacheLock = Semaphore(1)
+
+	private val jobs = HashMap<I, Job>()
+	private val jobsLock = Semaphore(1)
+
+	private val subscribeJob = SupervisorJob(context[Job])
+	private val scope = CoroutineScope(subscribeJob)
+
+	/** **UNSAFE**: only call when owning the [cacheLock] */
+	private fun getUnsafe(id: I) = cache.getOrPut(id) { MutableStateFlow(null) }
+
+	override fun get(id: I): State<I, T> = flow {
+		val cached = cacheLock.withPermit { getUnsafe(id) }
+			.onEach { slice ->
+				if (slice == null) {
+					// Now, someone should make a request to the previous layer.
+					// However, multiple subscribers may see this event at the same time.
+					// One of the subscribers becomes responsible for making the request
+
+					jobsLock.withPermit {
+						val job = jobs[id]
+						if (job == null || !job.isActive) {
+							// No one is currently making the request, I'm taking the responsibility to do it
+
+							jobs[id] = scope.launch(CoroutineName("${this@MemoryCache} for $id")) {
+								log.trace(id) { "Subscribing to the previous layer for" }
+
+								val state = cacheLock.withPermit { getUnsafe(id) }
+
+								upstream[id]
+									.onEach { log.trace(it) { "Event for" } }
+									.onEach { state.value = it }
+									.collect()
+							}
+						}
+					}
+				}
+			}
+			.filterNotNull() // 'null' is an internal value, it shouldn't be returned to downstream users
+
+		emitAll(cached)
+	}
+
+	override suspend fun update(values: Collection<Pair<I, T>>) {
+		log.trace(values) { "updateAll" }
+
+		jobsLock.withPermit {
+			for ((id, _) in values) {
+				jobs.remove(id)?.cancel("MemoryCache.expire(refs) was called")
+			}
+		}
+
+		cacheLock.withPermit {
+			for ((id, value) in values) {
+				getUnsafe(id).value = successful(id, value)
+			}
+		}
+
+		upstream.update(values)
+	}
+
+	override suspend fun expire(ids: Collection<I>) {
+		log.trace(ids) { "expireAll" }
+
+		jobsLock.withPermit {
+			for (id in ids) {
+				jobs.remove(id)?.cancel("MemoryCache.expire(refs) was called")
+			}
+		}
+
+		cacheLock.withPermit {
+			for (id in ids) {
+				val cached = cache[id]
+
+				if (cached == null) {
+					log.trace(id) { "Could not find any cached value for the specified ID, this is a no-op." }
+				} else if (cached.subscriptionCount.value == 0) {
+					// No one cares about the value, we can free it
+					cache.remove(id)
+				} else {
+					// At least one person is subscribed to the value, let's notify them that it's out-of-date
+					cached.value = null
+				}
+			}
+		}
+
+		upstream.expire(ids)
+	}
+
+	override suspend fun expireAll() {
+		log.trace { "expireAll" }
+
+		jobsLock.withPermit {
+			jobs.values.forEach { it.cancel("MemoryCache.expireAll() was called") }
+			jobs.clear()
+		}
+
+		cacheLock.withPermit {
+			val toRemove = ArrayList<I>()
+
+			for ((id, cached) in cache) {
+				if (cached.subscriptionCount.value == 0) {
+					// No one cares about the value, we can free it
+					toRemove += id
+				} else {
+					// At least one person is subscribed to the value, let's notify them that it's out-of-date
+					cached.value = null
+				}
+			}
+
+			for (id in toRemove)
+				cache.remove(id)
+		}
+
+		upstream.expireAll()
+	}
+
+	companion object {
+		fun <I : Identifier<T>, T> Cache<I, T>.cachedInMemory(context: CoroutineContext) = MemoryCache(this, context)
+	}
+}
diff --git a/cache/src/commonTest/kotlin/opensavvy.cache/CacheTest.kt b/cache/src/commonTest/kotlin/opensavvy.cache/CacheTest.kt
new file mode 100644
index 0000000..67157e1
--- /dev/null
+++ b/cache/src/commonTest/kotlin/opensavvy.cache/CacheTest.kt
@@ -0,0 +1,224 @@
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package opensavvy.cache
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.test.runTest
+import opensavvy.cache.ExpirationCache.Companion.expireAfter
+import opensavvy.cache.MemoryCache.Companion.cachedInMemory
+import opensavvy.logger.LogLevel
+import opensavvy.logger.Logger.Companion.debug
+import opensavvy.logger.Logger.Companion.info
+import opensavvy.logger.loggerFor
+import opensavvy.state.*
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.time.Duration.Companion.seconds
+
+class CacheTest {
+
+	private val log = loggerFor(this).apply {
+		level = LogLevel.TRACE
+	}
+
+	private data class IntId(val id: Int) : Identifier<Int> {
+		override fun toString() = "Id($id)"
+	}
+
+	private fun adapter() = CacheAdapter<IntId, Int> {
+		state {
+			log.debug(it) { "Requesting" }
+			delay(100L)
+			emitPending(it, 0.2)
+			delay(10L)
+			ensureValid(it, it.id >= 0) { "Only positive integers are allowed: found ${it.id}" }
+			emitSuccessful(it, it.id)
+		}
+	}
+
+	private suspend fun testCache(cache: Cache<IntId, Int>) {
+		log.info { "Regular access" }
+		val zero = cache[IntId(0)]
+		val one = cache[IntId(1)]
+		val minus = cache[IntId(-1)]
+
+		assertEquals(0, zero.firstResultOrNull())
+		assertEquals(1, one.firstResultOrNull())
+		assertEquals(null, minus.firstResultOrNull())
+	}
+
+	private suspend fun testUpdateExpire(cache: Cache<IntId, Int>) {
+		log.info { "Checking normal behavior" }
+		assertEquals(0, cache[IntId(0)].firstResultOrThrow())
+
+		log.info { "Overwriting with a different value" }
+		cache.update(IntId(0), 5)
+		assertEquals(5, cache[IntId(0)].firstResultOrThrow())
+
+		log.info { "Expiring the value re-downloads and replaces our fake value" }
+		cache.expire(IntId(0))
+		assertEquals(0, cache[IntId(0)].firstResultOrThrow())
+	}
+
+	private suspend fun testAutoExpiration(cache: Cache<IntId, Int>) {
+		log.info { "Adding 5 to the cache to make updates visible" }
+		assertEquals(0, cache[IntId(0)].firstResultOrThrow())
+		cache.update(IntId(0), 5)
+		assertEquals(5, cache[IntId(0)].firstResultOrThrow())
+
+		log.info { "Waiting for the cache to correct itself" }
+		assertEquals(0,
+		             cache[IntId(0)]
+			             .onEach { log.debug(it) { "Found new value" } }
+			             .drop(1) // Skip the bad value we inserted
+			             .firstResultOrThrow()
+		)
+	}
+
+	@Test
+	fun rawAdapter() = runTest {
+		val cache = adapter()
+
+		testCache(cache)
+	}
+
+	@Test
+	fun infiniteMemoryCache() = runTest {
+		val job = Job()
+		val cache = adapter()
+			.cachedInMemory(coroutineContext + job)
+
+		testCache(cache)
+
+		job.cancel()
+	}
+
+	@Test
+	fun infiniteMemoryCacheUpdateExpire() = runTest {
+		val job = Job()
+		val cache = adapter()
+			.cachedInMemory(coroutineContext + job)
+
+		testUpdateExpire(cache)
+
+		job.cancel()
+	}
+
+	@Test
+	fun expiringDefaultCache() = runTest {
+		val job = Job()
+		val cache = adapter()
+			.expireAfter(1.seconds, coroutineContext + job)
+
+		testCache(cache)
+
+		job.cancel()
+	}
+
+	@Test
+	fun expiringMemoryCache() = runTest {
+		val job = Job()
+		val cache = adapter()
+			.cachedInMemory(coroutineContext + job)
+			.expireAfter(1.seconds, coroutineContext + job)
+
+		testCache(cache)
+
+		job.cancel()
+	}
+
+	@Test
+	fun expiringMemoryCacheUpdateExpire() = runTest {
+		val job = Job()
+		val cache = adapter()
+			.cachedInMemory(coroutineContext + job)
+			.expireAfter(1.seconds, coroutineContext + job)
+
+		testUpdateExpire(cache)
+
+		job.cancel()
+	}
+
+	@Test
+	fun expiringMemoryCacheExpirationLayer() = runTest {
+		val job = Job()
+		val cache = adapter()
+			.cachedInMemory(coroutineContext + job)
+			.expireAfter(1.seconds, coroutineContext + job)
+
+		testAutoExpiration(cache)
+
+		job.cancel()
+	}
+
+	@Test
+	fun expireAll() = runTest {
+		val job = Job()
+		val cache = adapter()
+			.cachedInMemory(coroutineContext + job)
+			.expireAfter(1.seconds, coroutineContext + job)
+
+		log.info { "Initial values" }
+		val id0 = IntId(0)
+		val id1 = IntId(1)
+		assertEquals(0, cache[id0].firstResultOrThrow())
+		assertEquals(1, cache[id1].firstResultOrThrow())
+
+		log.info { "Adding 5" }
+		cache.update(
+			id0 to 5,
+			id1 to 6,
+		)
+		assertEquals(5, cache[id0].firstResultOrThrow())
+		assertEquals(6, cache[id1].firstResultOrThrow())
+
+		log.info { "Expiring all values" }
+		cache.expireAll()
+		assertEquals(0, cache[id0].firstResultOrThrow())
+		assertEquals(1, cache[id1].firstResultOrThrow())
+
+		job.cancel()
+	}
+
+	@Test
+	fun batching() = runTest {
+		val job = Job()
+		val cache = BatchingCacheAdapter<IntId, Int>(coroutineContext + job) { ids ->
+			state {
+				for (id in ids) {
+					emitPending(id)
+					delay(10L)
+					emitSuccessful(id, id.id)
+				}
+			}
+		}
+			.cachedInMemory(coroutineContext + job)
+			.expireAfter(1.seconds, coroutineContext + job)
+
+		log.info { "Initial values" }
+		val id0 = IntId(0)
+		val id1 = IntId(1)
+		assertEquals(0, cache[id0].firstResultOrThrow())
+		assertEquals(1, cache[id1].firstResultOrThrow())
+
+		log.info { "Adding 5" }
+		cache.update(
+			id0 to 5,
+			id1 to 6,
+		)
+		assertEquals(5, cache[id0].firstResultOrThrow())
+		assertEquals(6, cache[id1].firstResultOrThrow())
+
+		log.info { "Expiring all values" }
+		cache.expireAll()
+		assertEquals(0, cache[id0].firstResultOrThrow())
+		assertEquals(1, cache[id1].firstResultOrThrow())
+
+		job.cancel()
+	}
+
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 1cc79ae..09fdd99 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -7,10 +7,12 @@ plugins {
 
 include(
 	"state",
+	"cache",
 	"backbone",
 	"spine",
-	"spine-ktor-client",
-	"spine-ktor-server",
+	"spine-ktor",
+	"spine-ktor:spine-ktor-client",
+	"spine-ktor:spine-ktor-server",
 	"logger",
 	"tester",
 	"auth",
diff --git a/spine-ktor/build.gradle.kts b/spine-ktor/build.gradle.kts
new file mode 100644
index 0000000..2d79bc8
--- /dev/null
+++ b/spine-ktor/build.gradle.kts
@@ -0,0 +1,49 @@
+@file:Suppress("UNUSED_VARIABLE")
+
+plugins {
+	kotlin("multiplatform")
+	kotlin("plugin.serialization")
+}
+
+kotlin {
+	jvm()
+	js(IR) {
+		browser()
+		nodejs()
+	}
+
+	sourceSets {
+		val commonMain by getting {
+			dependencies {
+				api(projects.spine)
+
+				api(KotlinX.serialization.core)
+				api(Ktor.http)
+
+				implementation(projects.logger)
+			}
+		}
+
+		val commonTest by getting {
+			dependencies {
+				implementation(projects.tester)
+
+				implementation(KotlinX.coroutines.test)
+				implementation(KotlinX.serialization.json)
+			}
+		}
+	}
+}
+
+koverMerged.enable()
+
+kover {
+	verify {
+		rule {
+			name = "Minimal code coverage"
+			bound {
+				minValue = 80
+			}
+		}
+	}
+}
diff --git a/spine-ktor-client/build.gradle.kts b/spine-ktor/spine-ktor-client/build.gradle.kts
similarity index 91%
rename from spine-ktor-client/build.gradle.kts
rename to spine-ktor/spine-ktor-client/build.gradle.kts
index 8c91b40..bb73561 100644
--- a/spine-ktor-client/build.gradle.kts
+++ b/spine-ktor/spine-ktor-client/build.gradle.kts
@@ -15,10 +15,9 @@ kotlin {
 	sourceSets {
 		val commonMain by getting {
 			dependencies {
-				api(projects.spine)
-
 				api(Ktor.client.core)
 
+				implementation(projects.spineKtor)
 				implementation(projects.logger)
 			}
 		}
diff --git a/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt b/spine-ktor/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
similarity index 70%
rename from spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
rename to spine-ktor/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
index 2fde53b..f86fcd5 100644
--- a/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
+++ b/spine-ktor/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
@@ -4,18 +4,14 @@ import io.ktor.client.*
 import io.ktor.client.call.*
 import io.ktor.client.request.*
 import io.ktor.http.*
-import opensavvy.backbone.Data.Companion.markCompleted
-import opensavvy.backbone.Data.Companion.markInvalid
-import opensavvy.backbone.Data.Companion.markLoading
-import opensavvy.backbone.Data.Companion.markNotFound
-import opensavvy.backbone.Data.Companion.markUnauthenticated
-import opensavvy.backbone.Data.Companion.markUnauthorized
-import opensavvy.backbone.Data.Companion.markUnknownFailure
-import opensavvy.backbone.Data.Companion.state
 import opensavvy.spine.Id
 import opensavvy.spine.Operation
 import opensavvy.spine.Parameters
 import opensavvy.spine.ResourceGroup.AbstractResource
+import opensavvy.spine.ktor.NetworkResponse
+import opensavvy.spine.ktor.toHttp
+import opensavvy.spine.ktor.toSpine
+import opensavvy.state.*
 
 /**
  * Executes a [HttpClient] request, with the information declared in an [Operation].
@@ -50,20 +46,15 @@ inline fun <Resource : Any, reified In : Any, reified Out : Any, reified Params
 	context: Context,
 	contentType: ContentType = ContentType.Application.Json,
 	crossinline configuration: HttpRequestBuilder.() -> Unit = {},
-) = state {
-	markLoading(ref = null, 0f)
+): State<Id<Out>, Out> = state {
+	emitPending(id = null, 0.0)
 
 	operation.validate(this, input, parameters, context)
 
-	markLoading(ref = null, 0.1f)
+	emitPending(id = null, 0.1)
 
 	val result = request {
-		method = when (operation.kind) {
-			Operation.Kind.Read -> HttpMethod.Get
-			Operation.Kind.Create -> HttpMethod.Post
-			Operation.Kind.Edit -> HttpMethod.Patch
-			Operation.Kind.Delete -> HttpMethod.Delete
-		}
+		method = operation.kind.toHttp()
 
 		url {
 			// {baseUrl}/{service}/{path-to-resource}/{path-to-method}
@@ -89,19 +80,14 @@ inline fun <Resource : Any, reified In : Any, reified Out : Any, reified Params
 		configuration()
 	}
 
-	markLoading(ref = null, 0.9f)
+	emitPending(id = null, 0.9)
 
 	if (result.status.isSuccess()) {
-		val response: Out = result.body()
-		markCompleted(ref = null, response)
+		val response: NetworkResponse<Out> = result.body()
+		emitSuccessful(response.id, response.value)
 	} else {
 		val body = result.body<String>().ifBlank { "${result.status} with no provided body" }
-		when (result.status) {
-			HttpStatusCode.NotFound -> markNotFound(ref = null, body)
-			HttpStatusCode.UnprocessableEntity -> markInvalid(ref = null, body)
-			HttpStatusCode.Unauthorized -> markUnauthenticated(ref = null, body)
-			HttpStatusCode.Forbidden -> markUnauthorized(ref = null, body)
-			else -> markUnknownFailure(ref = null, "${result.status}: " + body)
-		}
+		val kind = result.status.toSpine()
+		emitFailed(id = null, kind, body, Progression.done())
 	}
 }
diff --git a/spine-ktor-server/build.gradle.kts b/spine-ktor/spine-ktor-server/build.gradle.kts
similarity index 89%
rename from spine-ktor-server/build.gradle.kts
rename to spine-ktor/spine-ktor-server/build.gradle.kts
index 30f27d7..b6fe128 100644
--- a/spine-ktor-server/build.gradle.kts
+++ b/spine-ktor/spine-ktor-server/build.gradle.kts
@@ -11,10 +11,9 @@ kotlin {
 	sourceSets {
 		val commonMain by getting {
 			dependencies {
-				api(projects.spine)
-
 				api(Ktor.server.core)
 
+				implementation(projects.spineKtor)
 				implementation(projects.logger)
 			}
 		}
@@ -23,7 +22,7 @@ kotlin {
 			dependencies {
 				implementation(projects.tester)
 
-				implementation(projects.spineKtorClient)
+				implementation(projects.spineKtor.spineKtorClient)
 
 				implementation(KotlinX.coroutines.test)
 				implementation(KotlinX.serialization.core)
diff --git a/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ContextGenerator.kt b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ContextGenerator.kt
similarity index 100%
rename from spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ContextGenerator.kt
rename to spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ContextGenerator.kt
diff --git a/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
similarity index 80%
rename from spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
rename to spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
index 40d90a3..fc90efc 100644
--- a/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
+++ b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
@@ -1,14 +1,15 @@
 package opensavvy.spine.ktor.server
 
 import io.ktor.server.application.*
-import opensavvy.backbone.StateBuilder
+import opensavvy.spine.Id
 import opensavvy.spine.Parameters
+import opensavvy.state.StateBuilder
 
 /**
  * Information available in [route].
  */
 class ResponseStateBuilder<In, Out, Params : Parameters?, Context>(
-	builder: StateBuilder<Out>,
+	builder: StateBuilder<Id<Out>, Out>,
 
 	/**
 	 * The body of the request.
@@ -29,4 +30,4 @@ class ResponseStateBuilder<In, Out, Params : Parameters?, Context>(
 	 * The current request's context.
 	 */
 	val context: Context,
-) : StateBuilder<Out> by builder
+) : StateBuilder<Id<Out>, Out> by builder
diff --git a/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
similarity index 69%
rename from spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
rename to spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
index 38b1131..ad6b6d3 100644
--- a/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
+++ b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
@@ -5,12 +5,13 @@ import io.ktor.server.application.*
 import io.ktor.server.request.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
-import opensavvy.backbone.Data.Companion.firstResult
-import opensavvy.backbone.Data.Companion.state
-import opensavvy.backbone.Result
-import opensavvy.backbone.Result.Failure.Standard.Kind.*
 import opensavvy.spine.Operation
 import opensavvy.spine.Parameters
+import opensavvy.spine.ktor.NetworkResponse
+import opensavvy.spine.ktor.toHttp
+import opensavvy.state.Status
+import opensavvy.state.firstResult
+import opensavvy.state.state
 
 /**
  * Builds a route to match the specified [operation].
@@ -48,14 +49,7 @@ inline fun <Resource : Any, reified In : Any, reified Out : Any, reified Params
 ) {
 	val path: String = operation.resource.routeTemplate + (operation.route ?: "")
 
-	val method = when (operation.kind) {
-		Operation.Kind.Read -> HttpMethod.Get
-		Operation.Kind.Create -> HttpMethod.Post
-		Operation.Kind.Edit -> HttpMethod.Patch
-		Operation.Kind.Delete -> HttpMethod.Delete
-	}
-
-	route(path, method) {
+	route(path, operation.kind.toHttp()) {
 		handle {
 			val context = contextGenerator.generate(call)
 
@@ -74,21 +68,24 @@ inline fun <Resource : Any, reified In : Any, reified Out : Any, reified Params
 				responseBuilder.block()
 			}.firstResult() // How can we send loading events via HTTP?
 
-			when (val data = state.data) {
-				is Result.Success -> call.respond(data.value)
+			when (val data = state.status) {
+				is Status.Successful -> call.respond(
+					NetworkResponse(
+						id = state.id ?: error("It's not possible to have a successful result without an ID: $state"),
+						routes = emptyList(), //TODO in #22: advertise the endpoints
+						value = data.value
+					)
+				)
 
 				// This should not be possible (it only happens for loading events, and we ignored them)
-				is Result.NoData -> error("The server did not find any value to return, this should not be possible")
+				is Status.Pending -> error("The server did not find any value to return, this should not be possible")
 
-				is Result.Failure.Standard -> when (data.kind) {
-					Invalid -> call.respond(HttpStatusCode.UnprocessableEntity, data.message)
-					Unauthenticated -> call.respond(HttpStatusCode.Unauthorized, data.message)
-					Unauthorized -> call.respond(HttpStatusCode.Forbidden, data.message)
-					NotFound -> call.respond(HttpStatusCode.NotFound, data.message)
-					Unknown -> call.respond(HttpStatusCode.InternalServerError, data.message)
+				is Status.StandardFailure -> {
+					val code = data.kind.toHttp()
+					call.respond(code, data.message ?: "No message")
 				}
 
-				is Result.Failure.Kotlin -> call.respond(HttpStatusCode.InternalServerError, data.message)
+				is Status.Failed -> call.respond(HttpStatusCode.InternalServerError, data.message ?: "No message")
 			}
 		}
 	}
diff --git a/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
similarity index 79%
rename from spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
rename to spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
index f6fea1e..e6afcfe 100644
--- a/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
+++ b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
@@ -5,13 +5,13 @@ import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.plugins.callloging.*
 import io.ktor.server.testing.*
 import kotlinx.coroutines.flow.onEach
-import opensavvy.backbone.Data.Companion.firstSuccessOrThrow
-import opensavvy.backbone.Data.Companion.markCompleted
-import opensavvy.backbone.Data.Companion.markNotFound
 import opensavvy.logger.Logger.Companion.debug
 import opensavvy.logger.Logger.Companion.info
 import opensavvy.logger.loggerFor
 import opensavvy.spine.ktor.client.request
+import opensavvy.state.emitSuccessful
+import opensavvy.state.ensureFound
+import opensavvy.state.firstResultOrThrow
 import org.junit.Test
 import org.slf4j.event.Level
 import kotlin.test.assertEquals
@@ -49,50 +49,47 @@ class ServerTest {
 				val result = users
 					.filter { parameters.includeArchived || !it.archived }
 					.map { it.id }
-				markCompleted(ref = null, result)
+				emitSuccessful(api.users.get.idOf(), result)
 			}
 
 			route(api.users.create, context) {
 				val name = body.name
 				val newId = api.users.id.idOf(kotlin.random.Random.nextInt().toString())
 				val new = User(newId, name, archived = false)
-				markCompleted(ref = null, new)
+				emitSuccessful(new.id, new)
 			}
 
 			route(api.users.id.get, context) {
 				val id = body
 				val user = users.find { it.id == id }
-					?: markNotFound(ref = null, "Could not find the user $id")
-				markCompleted(ref = null, user)
+				ensureFound(id, user != null) { "Could not find the user $id" }
+				emitSuccessful(id, user)
 			}
 
 			route(api.users.id.archive, context) {
 				val (id, _) = body
 				val userIndex = users.indexOfFirst { it.id == id }
-				if (userIndex < 0)
-					markNotFound(ref = null, "Could not find the user $id")
+				ensureFound(id, userIndex >= 0) { "Could not find user $id" }
 				val user = users.removeAt(userIndex)
 				users.add(user.copy(archived = true))
-				markCompleted(ref = null, user)
+				emitSuccessful(id, user)
 			}
 
 			route(api.users.id.unarchive, context) {
 				val (id, _) = body
 				val userIndex = users.indexOfFirst { it.id == id }
-				if (userIndex < 0)
-					markNotFound(ref = null, "Could not find the user $id")
+				ensureFound(id, userIndex >= 0) { "Could not find user $id" }
 				val user = users.removeAt(userIndex)
 				users.add(user.copy(archived = false))
-				markCompleted(ref = null, user)
+				emitSuccessful(id, user)
 			}
 
 			route(api.users.id.delete, context) {
 				val (id, _) = body
 				val userIndex = users.indexOfFirst { it.id == id }
-				if (userIndex < 0)
-					markNotFound(ref = null, "Could not find the user $id")
+				ensureFound(id, userIndex >= 0) { "Could not find user $id" }
 				val user = users.removeAt(userIndex)
-				markCompleted(ref = null, user)
+				emitSuccessful(id, user)
 			}
 		}
 
@@ -115,7 +112,7 @@ class ServerTest {
 		val params = User.SearchParams().apply { includeArchived = true }
 		val results = client.request(api.users.get, api.users.get.idOf(), api.users.get.idOf(), params, Unit)
 			.onEach { log.debug(it) { "Received event for" } }
-			.firstSuccessOrThrow()
+			.firstResultOrThrow()
 
 		assertEquals(emptyList(), results)
 
diff --git a/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
similarity index 100%
rename from spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
rename to spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
diff --git a/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt
new file mode 100644
index 0000000..0005bf7
--- /dev/null
+++ b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt
@@ -0,0 +1,12 @@
+package opensavvy.spine.ktor
+
+import io.ktor.http.*
+import opensavvy.spine.Operation
+import opensavvy.spine.Operation.Kind.*
+
+fun Operation.Kind.toHttp() = when (this) {
+	Read -> HttpMethod.Get
+	Create -> HttpMethod.Post
+	Edit -> HttpMethod.Patch
+	Delete -> HttpMethod.Delete
+}
diff --git a/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/NetworkResponse.kt b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/NetworkResponse.kt
new file mode 100644
index 0000000..f757e48
--- /dev/null
+++ b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/NetworkResponse.kt
@@ -0,0 +1,11 @@
+package opensavvy.spine.ktor
+
+import kotlinx.serialization.Serializable
+import opensavvy.spine.Id
+
+@Serializable
+data class NetworkResponse<T>(
+	val id: Id<T>,
+	val routes: List<String>,
+	val value: T,
+)
diff --git a/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/StatusCodes.kt b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/StatusCodes.kt
new file mode 100644
index 0000000..3aa4088
--- /dev/null
+++ b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/StatusCodes.kt
@@ -0,0 +1,20 @@
+package opensavvy.spine.ktor
+
+import io.ktor.http.*
+import opensavvy.state.Status
+
+fun HttpStatusCode.toSpine() = when (this) {
+	HttpStatusCode.NotFound -> Status.StandardFailure.Kind.NotFound
+	HttpStatusCode.Unauthorized -> Status.StandardFailure.Kind.Unauthenticated
+	HttpStatusCode.Forbidden -> Status.StandardFailure.Kind.Unauthorized
+	HttpStatusCode.UnprocessableEntity -> Status.StandardFailure.Kind.Invalid
+	else -> Status.StandardFailure.Kind.Unknown
+}
+
+fun Status.StandardFailure.Kind.toHttp() = when (this) {
+	Status.StandardFailure.Kind.Invalid -> HttpStatusCode.UnprocessableEntity
+	Status.StandardFailure.Kind.Unauthenticated -> HttpStatusCode.Unauthorized
+	Status.StandardFailure.Kind.Unauthorized -> HttpStatusCode.Forbidden
+	Status.StandardFailure.Kind.NotFound -> HttpStatusCode.NotFound
+	Status.StandardFailure.Kind.Unknown -> HttpStatusCode.InternalServerError
+}
diff --git a/spine/build.gradle.kts b/spine/build.gradle.kts
index 4e2b806..a1caf4a 100644
--- a/spine/build.gradle.kts
+++ b/spine/build.gradle.kts
@@ -25,8 +25,9 @@ kotlin {
 		val commonTest by getting {
 			dependencies {
 				implementation(projects.tester)
+				implementation(projects.backbone)
 
-				api(KotlinX.coroutines.test)
+				implementation(KotlinX.coroutines.test)
 				implementation(KotlinX.serialization.json)
 			}
 		}
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt
index 9a3adbd..9e9dfe4 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt
@@ -1,12 +1,13 @@
 package opensavvy.spine
 
 import kotlinx.serialization.Serializable
+import opensavvy.state.Identifier
 
 @Serializable
-data class Id<@Suppress("unused") T>(
+data class Id<T>(
 	val service: Route.Segment,
 	val resource: Route,
-) {
+) : Identifier<T> {
 
 	constructor(service: String, resource: Route) : this(Route.Segment(service), resource)
 
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
index 5b5c1aa..36fd8fe 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
@@ -1,8 +1,8 @@
 package opensavvy.spine
 
-import opensavvy.backbone.StateBuilder
+import opensavvy.state.StateBuilder
 
-typealias OperationValidator<In, Out, Params, Context> = suspend StateBuilder<Out>.(In, parameters: Params, context: Context) -> Unit
+typealias OperationValidator<In, Out, Params, Context> = suspend StateBuilder<Id<Out>, Out>.(In, parameters: Params, context: Context) -> Unit
 
 class Operation<Resource : Any, In : Any, Out : Any, Params : Parameters, Context : Any>(
 	val resource: ResourceGroup.AbstractResource<Resource, Context>,
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
index 86168f3..76d18d8 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
@@ -1,9 +1,9 @@
 package opensavvy.spine
 
-import opensavvy.backbone.Data.Companion.markInvalid
-import opensavvy.backbone.StateBuilder
 import opensavvy.spine.ResourceGroup.AbstractResource
 import opensavvy.spine.Route.Companion.div
+import opensavvy.state.StateBuilder
+import opensavvy.state.ensureValid
 
 /**
  * Common ancestor of [Service] and [AbstractResource].
@@ -80,35 +80,36 @@ sealed class ResourceGroup {
 		 * This function is automatically called to verify all identifiers passed to all endpoints to this resource ([get] and the other functions).
 		 * It can be overridden to add checks for user rights, etc.
 		 */
-		open suspend fun StateBuilder<O>.validateId(id: Id<O>, context: Context) {
-			if (id.service != service.name)
-				markInvalid(
-					ref = null,
-					"The passed identifier refers to the service '${id.service}', but this resource belongs to the service '${service.name}'"
-				)
+		open suspend fun StateBuilder<Id<O>, O>.validateId(id: Id<O>, context: Context) {
+			ensureValid(
+				id,
+				id.service == service.name
+			) { "The passed identifier refers to the service '${id.service}', but this resource belongs to the service '${service.name}'" }
 
 			// Let's check that the resource designated by the ID matches with this resource
 			var resource: ResourceGroup = this@AbstractResource
 			var index = id.resource.segments.lastIndex
 			while (resource is AbstractResource<*, *>) {
-				val segment = id.resource.segments.getOrNull(index) ?: markInvalid(
-					ref = null,
-					"The passed identifier's URI length is too short for this resource: '$id' for resource '${this@AbstractResource}'"
-				)
-
-				when (resource) {
+				val segment = id.resource.segments.getOrNull(index)
+				ensureValid(
+					id,
+					segment != null
+				) { "The passed identifier's URI length is too short for this resource: '$id' for resource '${this@AbstractResource}'" }
+
+				@Suppress("NAME_SHADOWING") // necessary for smart cast because 'resource' is mutable
+				when (val resource: AbstractResource<*, *> = resource) {
 					is StaticResource<*, *, *> -> {
-						if (segment != resource.route)
-							markInvalid(
-								ref = null,
-								"The passed identifier's segment #$index doesn't match the resource; expected '${resource.route}' but found '$segment'"
-							)
+						ensureValid(
+							id,
+							segment == resource.route
+						) { "The passed identifier's segment #$index doesn't match the resource; expected '${resource.route}' but found '$segment'" }
 					}
 
 					is DynamicResource<*, *> -> {
 						// There are no constraints on what IDs look like.
 						// If we expect an ID, we can't make any verification on the value.
 					}
+
 					// else -> is impossible
 				}
 
@@ -116,11 +117,10 @@ sealed class ResourceGroup {
 				index--
 			}
 
-			if (index != -1)
-				markInvalid(
-					ref = null,
-					"The passed identifier's URI length is too long for this resource: '$id' for resource '${this@AbstractResource}'"
-				)
+			ensureValid(
+				id,
+				index == -1
+			) { "The passed identifier's URI length is too long for this resource: '$id' for resource '${this@AbstractResource}'" }
 		}
 
 		protected fun <In : Any, Out : Any, Params : Parameters> create(
@@ -196,7 +196,7 @@ sealed class ResourceGroup {
 		 *
 		 * You should override this function if the parameters impact the access rights.
 		 */
-		open suspend fun StateBuilder<O>.validateGetParams(params: GetParams, context: Context) {}
+		open suspend fun StateBuilder<Id<O>, O>.validateGetParams(params: GetParams, context: Context) {}
 
 		@Suppress("LeakingThis") // Not dangerous because Operation's constructor does nothing
 		val get = Operation<O, Id<O>, O, GetParams, Context>(this, Operation.Kind.Read) { it, params, context ->
diff --git a/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt b/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt
index c5ff04c..4bcf685 100644
--- a/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt
+++ b/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt
@@ -6,16 +6,17 @@ package opensavvy.spine
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.test.runTest
-import opensavvy.backbone.*
-import opensavvy.backbone.Data.Companion.markCompleted
-import opensavvy.backbone.Data.Companion.markInvalid
-import opensavvy.backbone.Data.Companion.markNotFound
-import opensavvy.backbone.Data.Companion.markUnauthorized
-import opensavvy.backbone.Data.Companion.skipLoading
-import opensavvy.backbone.Data.Companion.state
+import opensavvy.backbone.Backbone
+import opensavvy.backbone.Ref
 import opensavvy.backbone.Ref.Companion.request
 import opensavvy.backbone.Ref.Companion.requestValue
+import opensavvy.backbone.RefState
+import opensavvy.backbone.defaultBackboneCache
 import opensavvy.spine.Route.Companion.div
+import opensavvy.state.*
+import opensavvy.state.Slice.Companion.failed
+import opensavvy.state.Slice.Companion.mapIdentifier
+import opensavvy.state.Slice.Companion.successful
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -67,25 +68,22 @@ private class Api : Service("v2") {
 			val leave = edit<Unit, Parameters.Empty>(Route / "leave")
 
 			val rename = edit<User.Rename, Parameters.Empty>(Route / "name") { (_, newName), _, _ ->
-				if (newName.name.isBlank())
-					markInvalid(ref = null, "A user's name may not be empty: '${newName.name}'")
+				ensureValid(
+					id = null,
+					newName.name.isNotBlank()
+				) { "A user's name may not be empty: '${newName.name}'" }
 			}
 
 			val departments = Departments()
 		}
 
 		val create = create { it: User.New, _: Parameters.Empty, context: Context ->
-			if (it.name.isBlank())
-				markInvalid(ref = null, "A user's name may not be empty: '${it.name}'")
-
-			if (it.name.length > 100)
-				markInvalid(
-					ref = null,
-					"A user's name may not be longer than 100 characters, found ${it.name.length} characters"
-				)
-
-			if (!context.user.requestValue().admin)
-				markUnauthorized(ref = null, "Only admins can create new users")
+			ensureValid(id = null, it.name.isNotBlank()) { "A user's name may not be empty: '${it.name}'" }
+			ensureValid(
+				id = null,
+				it.name.length < 100
+			) { "A user's name may not be longer than 100 characters, found ${it.name.length} characters: '${it.name}'" }
+			ensureAuthorized(id = null, context.user.requestValue().admin) { "Only admins can create new users" }
 		}
 
 		val id = Unique()
@@ -116,7 +114,7 @@ class ServiceTest {
 	}
 
 	private class UserBone : Backbone<User> {
-		override val cache: Cache<User> = Cache.Default()
+		override val cache = defaultBackboneCache<User>()
 
 		private val users = HashMap<String, User>()
 
@@ -125,13 +123,13 @@ class ServiceTest {
 			users["1"] = User("Admin", admin = true)
 		}
 
-		override fun directRequest(ref: Ref<User>): Flow<Data<User>> = flow {
-			if (ref !is Ref.Basic)
-				markInvalid(ref, "The reference type ${ref::class} is not supported by UserBone")
+		override fun directRequest(ref: Ref<User>): RefState<User> = flow {
+			ensureValid(ref, ref is Ref.Basic) { "The reference type ${ref::class} is not supported by UserBone" }
 
-			val result = users[ref.id] ?: markNotFound(ref, "No user has the ID $ref")
+			val result = users[ref.id]
+			ensureFound(ref, result != null) { "No user has the ID $ref" }
 
-			markCompleted(ref, result)
+			emitSuccessful(ref, result)
 		}
 	}
 
@@ -147,75 +145,67 @@ class ServiceTest {
 
 		val id1 = endpoint.idOf("0")
 		assertEquals(
-			listOf(Data(Result.Success(User("Employee", false)), Data.Status.Completed, employee.user)),
+			successful(id1, User("Employee", false)),
 			state {
 				endpoint.validate(this, id1, Parameters.Empty, employee)
-				emitAll(employee.user.request())
-			}.skipLoading().toList()
+				emitAll(employee.user.request().mapIdentifier { endpoint.idOf((it as Ref.Basic).id) })
+			}.firstResult()
 		)
 
 		// Scenario 2: access with an invalid service ID
 
 		val id2 = Id<User>("this-is-not-the-correct-service-name", Route / "users" / "0")
 		assertEquals(
-			listOf(
-				Data<User>(
-					Result.Failure.Standard(
-						Result.Failure.Standard.Kind.Invalid,
-						"The passed identifier refers to the service 'this-is-not-the-correct-service-name', but this resource belongs to the service 'v2'"
-					), Data.Status.Completed, null
-				)
-			), state {
+			failed(
+				id2,
+				Status.StandardFailure.Kind.Invalid,
+				"The passed identifier refers to the service 'this-is-not-the-correct-service-name', but this resource belongs to the service 'v2'"
+			),
+			state {
 				endpoint.validate(this, id2, Parameters.Empty, employee)
-			}.skipLoading().toList()
+			}.firstResult()
 		)
 
 		// Scenario 3: access with an invalid ID (too short)
 
 		val id3 = Id<User>("v2", Route / "users") // should be /users/0
 		assertEquals(
-			listOf(
-				Data<User>(
-					Result.Failure.Standard(
-						Result.Failure.Standard.Kind.Invalid,
-						"The passed identifier's URI length is too short for this resource: 'v2/users' for resource 'v2/users/{user}'"
-					), Data.Status.Completed, null
-				)
-			), state {
+			failed(
+				id3,
+				Status.StandardFailure.Kind.Invalid,
+				"The passed identifier's URI length is too short for this resource: 'v2/users' for resource 'v2/users/{user}'"
+			),
+			state {
 				endpoint.validate(this, id3, Parameters.Empty, employee)
-			}.skipLoading().toList()
+			}.firstResult()
 		)
 
 		// Scenario 4: access with an invalid ID (wrong resource)
 
 		val id4 = Id<User>("v2", Route / "departments" / "0") // should be /users/0
 		assertEquals(
-			listOf(
-				Data<User>(
-					Result.Failure.Standard(
-						Result.Failure.Standard.Kind.Invalid,
-						"The passed identifier's segment #0 doesn't match the resource; expected 'users' but found 'departments'"
-					), Data.Status.Completed, null
-				)
-			), state {
+			failed(
+				id4,
+				Status.StandardFailure.Kind.Invalid,
+				"The passed identifier's segment #0 doesn't match the resource; expected 'users' but found 'departments'"
+			),
+			state {
 				endpoint.validate(this, id4, Parameters.Empty, employee)
-			}.skipLoading().toList()
+			}.firstResult()
 		)
 
 		// Scenario 5: access with an invalid ID (too long)
 
 		val id5 = Id<User>("v2", Route / "departments" / "users" / "0") // should be /users/0
 		assertEquals(
-			listOf(
-				Data<User>(
-					Result.Failure.Standard(
-						Result.Failure.Standard.Kind.Invalid,
-						"The passed identifier's URI length is too long for this resource: 'v2/departments/users/0' for resource 'v2/users/{user}'"
-					), Data.Status.Completed, null
-				)
-			), state {
+			failed(
+				id5,
+				Status.StandardFailure.Kind.Invalid,
+				"The passed identifier's URI length is too long for this resource: 'v2/departments/users/0' for resource 'v2/users/{user}'"
+			),
+			state {
 				endpoint.validate(this, id5, Parameters.Empty, employee)
-			}.skipLoading().toList()
+			}.firstResult()
 		)
 	}
 
diff --git a/state/src/commonMain/kotlin/opensavvy.state/Identifier.kt b/state/src/commonMain/kotlin/opensavvy.state/Identifier.kt
new file mode 100644
index 0000000..bb5e16f
--- /dev/null
+++ b/state/src/commonMain/kotlin/opensavvy.state/Identifier.kt
@@ -0,0 +1,12 @@
+package opensavvy.state
+
+/**
+ * Simple marker interface to identify an object of type [T].
+ *
+ * ### Contract
+ *
+ * In the following section, "the same" and "different" refer to the [equals] method.
+ * - If two implementations of [Identifier] are the same, the object their refer to must be the same.
+ * - Different implementations of [Identifier] are allowed to refer to the same object, however this is not recommended as it negatively affects caches.
+ */
+interface Identifier<@Suppress("unused") out T>
diff --git a/state/src/commonMain/kotlin/opensavvy.state/Progression.kt b/state/src/commonMain/kotlin/opensavvy.state/Progression.kt
new file mode 100644
index 0000000..60a2100
--- /dev/null
+++ b/state/src/commonMain/kotlin/opensavvy.state/Progression.kt
@@ -0,0 +1,134 @@
+package opensavvy.state
+
+/**
+ * Is work currently happening?
+ *
+ * Values of this type can be in two different states:
+ * - [Done]: no work is happening.
+ * - [Loading]: work is happening, more information may be available depending on the subtype.
+ *
+ * For ease of use, the factory functions [done] and [loading] are provided.
+ */
+sealed interface Progression {
+
+	/**
+	 * No work is currently happening.
+	 *
+	 * For ease of use, see the factory [done].
+	 */
+	object Done : Progression {
+		override fun toString() = "Done"
+	}
+
+	/**
+	 * Work is currently happening.
+	 *
+	 * [Unquantified] work is work for which no progression information is available.
+	 * It is built with the factory [loading()][loading].
+	 *
+	 * [Quantified] work is work for which progression information is available.
+	 * By default, the [loading(Double)][loading] factory stores progression as a percentage point of the work to be done.
+	 * If more information is available (e.g. bandwidth, bitrate, estimated time of completion…), it is possible to create
+	 * your own class which implements [Quantified].
+	 */
+	sealed interface Loading : Progression {
+
+		/**
+		 * Work is currently happening, but we have no information on its progression.
+		 *
+		 * For ease of use, see the factory [loading()][loading].
+		 */
+		object Unquantified : Loading {
+			override fun toString() = "Loading"
+		}
+
+		/**
+		 * Work is currently happening, and we have some information on its progression.
+		 *
+		 * By default, the progression is stored as the ratio of how much work has been done so far to the total amount
+		 * of work expected.
+		 * This ratio is available in two formats, see [normalized] and [percent].
+		 * If this ratio of work is enough for your usage, see the factory [loading(Double)][loading].
+		 *
+		 * To store more information (e.g. bandwidth, estimated time of completion…), implement this interface for your
+		 * own objects.
+		 */
+		interface Quantified : Loading {
+
+			/**
+			 * The normalized ratio of the amount of work done and the total amount of work to be done.
+			 *
+			 * Allowed values are between `0.0` and `1.0`, both inclusive.
+			 * - `0.0` means the work has not started (nothing was done out of the total),
+			 * - `1.0` means the work has finished (everything was done out of the total).
+			 *
+			 * Although `1.0` is semantically the same as [Progression.Done], it is still a legal value to simplify usage.
+			 *
+			 * @see percent
+			 */
+			val normalized: Double
+
+			/**
+			 * The percentage of the amount of work done and the total amount of work to be done.
+			 *
+			 * Allowed values are between `0` and `100`, both inclusive.
+			 * - `0` means the work has not started (nothing was done out of the total),
+			 * - `100` means the work has finished (everything was done out of the total).
+			 *
+			 * Although `100` is semantically the same as [Progression.Done], it is still a legal value to simplify usage.
+			 *
+			 * @see normalized
+			 */
+			val percent: Int
+				get() = (normalized * 100).toInt()
+
+		}
+
+		/**
+		 * Basic implementation of [Quantified].
+		 *
+		 * You should rarely need to interact with this class.
+		 * To create an instance, see [loading].
+		 *
+		 * When downcasting to access information about the progression, we recommend downcasting to [Quantified] instead
+		 * of to this class. This will let your codebase handle other implementations of [Quantified] transparently.
+		 */
+		// The coding style says 'Implementation' should not appear in class names.
+		// This class is more or less for internal use, it shouldn't appear in user's code anyway.
+		data class QuantifiedImplementation(override val normalized: Double) : Quantified {
+
+			init {
+				require(normalized in 0.0..1.0) { "The progression should be a value between 0 and 1, found $normalized" }
+			}
+
+			override fun toString() = "Loading($percent%)"
+		}
+	}
+
+	companion object {
+		/**
+		 * Returns [Done].
+		 *
+		 * @see loading
+		 */
+		fun done() = Done
+
+		/**
+		 * Returns a [Loading] instance with no particular progression information.
+		 *
+		 * @see done
+		 * @see Loading.Unquantified
+		 */
+		fun loading() = Loading.Unquantified
+
+		/**
+		 * Returns a [Loading] instance with a given [progression].
+		 *
+		 * @param progression Progression information, between `0.0` (just started, no progression made so far) and `1.0` (completely finished).
+		 * @see done
+		 * @see Loading.Quantified
+		 * @see Loading.Quantified.normalized
+		 */
+		fun loading(progression: Double) = Loading.QuantifiedImplementation(progression)
+	}
+}
diff --git a/state/src/commonMain/kotlin/opensavvy.state/Slice.kt b/state/src/commonMain/kotlin/opensavvy.state/Slice.kt
new file mode 100644
index 0000000..a128ac5
--- /dev/null
+++ b/state/src/commonMain/kotlin/opensavvy.state/Slice.kt
@@ -0,0 +1,171 @@
+package opensavvy.state
+
+import kotlinx.coroutines.flow.map
+import opensavvy.state.Slice.Companion.failed
+import opensavvy.state.Slice.Companion.pending
+import opensavvy.state.Slice.Companion.successful
+
+/**
+ * Some data at a specific point in time.
+ *
+ * The [State] of a value can change over time.
+ * At each specific instant in time, the 'current state' is represented by this class.
+ *
+ * Instances can be generated with the provided factories: [pending], [successful] and [failed].
+ */
+class Slice<I : Identifier<T>, out T> private constructor(
+	val id: I?,
+	val status: Status<T>,
+	val progression: Progression,
+) {
+
+	//region Destructuration
+
+	operator fun component1() = status
+	operator fun component2() = progression
+	operator fun component3() = id
+
+	//endregion
+	//region equals & hashCode
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (other !is Slice<*, *>) return false
+
+		if (id != other.id) return false
+		if (status != other.status) return false
+		if (progression != other.progression) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = id?.hashCode() ?: 0
+		result = 31 * result + status.hashCode()
+		result = 31 * result + progression.hashCode()
+		return result
+	}
+
+	//endregion
+	//region toString
+
+	override fun toString(): String {
+		val builder = StringBuilder()
+
+		if (id != null) {
+			builder.append(id.toString())
+			builder.append(": ")
+		}
+
+		if (status != Status.Pending) {
+			builder.append(status)
+			builder.append(" ")
+		}
+
+		builder.append(progression)
+
+		return builder.toString()
+	}
+
+	//endregion
+
+	companion object {
+
+		//region Factories
+
+		/**
+		 * Creates a [Slice] with a [pending status][Status.Pending].
+		 */
+		fun <I : Identifier<T>, T> pending(
+			id: I?,
+			progression: Progression.Loading,
+		) = Slice(id, Status.Pending, progression)
+
+		/**
+		 * Creates a [Slice] with a [pending status][Status.Pending] and a current progression.
+		 */
+		fun <I : Identifier<T>, T> pending(
+			id: I?,
+		) = Slice(id, Status.Pending, Progression.loading())
+
+		/**
+		 * Creates a [Slice] with a [pending status][Status.Pending] and a current [progression].
+		 */
+		fun <I : Identifier<T>, T> pending(
+			id: I?,
+			progression: Double,
+		) = Slice(id, Status.Pending, Progression.loading(progression))
+
+		/**
+		 * Creates a [Slice] with a [successful status][Status.Successful].
+		 */
+		fun <I : Identifier<T>, T> successful(
+			id: I,
+			value: T,
+			progression: Progression = Progression.Done,
+		) = Slice(id, Status.Successful(value), progression)
+
+		/**
+		 * Creates a [Slice] with a [failed status][Status.Failed].
+		 *
+		 * More specifically, the status is a [Status.ExceptionFailure].
+		 */
+		fun <I : Identifier<T>, T> failed(
+			id: I?,
+			exception: RuntimeException,
+			message: String,
+			progression: Progression = Progression.Done,
+		) = Slice(id, Status.ExceptionFailure(message, exception), progression)
+
+		/**
+		 * Creates a [Slice] with a [failed status][Status.Failed].
+		 *
+		 * More specifically, the status is a [Status.StandardFailure].
+		 */
+		fun <I : Identifier<T>, T> failed(
+			id: I?,
+			kind: Status.StandardFailure.Kind,
+			message: String,
+			cause: Throwable? = null,
+			progression: Progression = Progression.Done,
+		) = Slice(id, Status.StandardFailure(kind, message, cause), progression)
+
+		//endregion
+		//region Accessors
+
+		/**
+		 * Returns the value of this slice, or `null` if it isn't successful.
+		 *
+		 * @see Status.Successful.value
+		 */
+		val <I : Identifier<T>, T : Any> Slice<I, T>.valueOrNull: T?
+			get() = (status as? Status.Successful)?.value
+
+		/**
+		 * Returns the value of this slice, or throws an exception if it isn't successful.
+		 *
+		 * @see Status.Successful.value
+		 * @see Status
+		 * @throws NoSuchElementException This slice is in the [pending][Status.Pending] status.
+		 * @throws Status.Failed This slice is in the [failed][Status.Failed] status.
+		 */
+		val <I : Identifier<T>, T> Slice<I, T>.valueOrThrow: T
+			get() = when (status) {
+				is Status.Successful -> status.value
+				is Status.Pending -> throw NoSuchElementException("No value is available for this object, it is still pending: $this")
+				is Status.Failed -> throw status
+			}
+
+		//endregion
+		//region Operators
+
+		/**
+		 * Converts the identifier of the incoming state from [I] to [O] using [transform].
+		 */
+		fun <I : Identifier<T>, O : Identifier<T>, T> State<I, T>.mapIdentifier(transform: (I) -> O) =
+			map { Slice(it.id?.let(transform), it.status, it.progression) }
+
+		//endregion
+
+	}
+}
diff --git a/state/src/commonMain/kotlin/opensavvy.state/State.kt b/state/src/commonMain/kotlin/opensavvy.state/State.kt
new file mode 100644
index 0000000..54bd1a7
--- /dev/null
+++ b/state/src/commonMain/kotlin/opensavvy.state/State.kt
@@ -0,0 +1,47 @@
+package opensavvy.state
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.first
+import opensavvy.state.Slice.Companion.valueOrNull
+import opensavvy.state.Slice.Companion.valueOrThrow
+
+/**
+ * Tracks changes to values through time.
+ *
+ * Stored values should be immutable.
+ * At any given time, the current value is represented by the immutable [Slice] class.
+ * This [State] flow allows to subscribe to the future slices.
+ *
+ * To create an instance of [State], see the [state] builder.
+ */
+typealias State<I, T> = Flow<Slice<I, T>>
+
+/**
+ * Skips the loading events in [State].
+ */
+fun <I : Identifier<T>, T> State<I, T>.skipLoading() = filter { it.progression !is Progression.Loading }
+
+/**
+ * Returns the first non-loading element of this [State].
+ *
+ * Because this transforms a flow into a single value, the reactivity is lost.
+ * Only use this method in contexts where being notified on new values is not important.
+ */
+suspend fun <I : Identifier<T>, T> State<I, T>.firstResult() = skipLoading().first()
+
+/**
+ * Returns the first non-loading element's [valueOrNull] of this [State].
+ *
+ * Because this transforms a flow into a single value, the reactivity is lost.
+ * Only use this method in contexts where being notified on new values is not important.
+ */
+suspend fun <I : Identifier<T>, T : Any> State<I, T>.firstResultOrNull() = firstResult().valueOrNull
+
+/**
+ * Returns the first non-loading element's [valueOrThrow] of this [State].
+ *
+ * Because this transforms a flow into a single value, the reactivity is lost.
+ * Only use this method in contexts where being notified on new values is not important.
+ */
+suspend fun <I : Identifier<T>, T> State<I, T>.firstResultOrThrow() = firstResult().valueOrThrow
diff --git a/state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt b/state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt
new file mode 100644
index 0000000..9456036
--- /dev/null
+++ b/state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt
@@ -0,0 +1,217 @@
+package opensavvy.state
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flow
+import opensavvy.state.Slice.Companion.failed
+import opensavvy.state.Slice.Companion.pending
+import opensavvy.state.Slice.Companion.successful
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
+
+/**
+ * Builder for [State].
+ *
+ * This type is used for conveniently building asynchronous flows in synchronous environments.
+ * Instances are generally built using the [state] builder.
+ */
+typealias StateBuilder<I, T> = FlowCollector<Slice<I, T>>
+
+/**
+ * Builder for [State].
+ *
+ * ```kotlin
+ * val id = …
+ * val foo = state {
+ *     emitLoading(id, 50.0) // 50%
+ *     ensureValid(id, currentUser.isAllowedToRead(id)) { "You are not allowed to read the object $id" }
+ *     emitSuccessful(id, database.dereference(id))
+ * }
+ * ```
+ */
+fun <I : Identifier<T>, T> state(block: suspend StateBuilder<I, T>.() -> Unit) = flow(block)
+	.catch {
+		when (it) {
+			// The user has requested the cancellation of the flow builder.
+			// It is their responsibility to emit the correct exception in the flow, so we have nothing more to do.
+			is StateBuilderCancellation -> Unit
+
+			// The coroutine was cancelled.
+			// CancellationExceptions MUST be rethrown, or it breaks coroutines
+			// See https://kotlinlang.org/docs/cancellation-and-timeouts.html#cancellation-is-cooperative
+			is CancellationException -> throw CancellationException("A state builder was cancelled", it)
+
+			// All other exceptions are caught into the Kind.Unknown standard failure.
+			else -> emitFailed(
+				id = null,
+				Status.StandardFailure.Kind.Unknown,
+				"Unknown error caught in the state builder",
+				progression = Progression.done(),
+				cause = it
+			)
+		}
+	}
+
+/**
+ * Exception used internally by the [state] function to provide cancellation functionality.
+ */
+class StateBuilderCancellation : RuntimeException("The 'state' builder has been cancelled")
+
+//region Pending markers
+
+/**
+ * Emits a [pending] slice with the given [progression].
+ */
+suspend fun <I : Identifier<T>, T> StateBuilder<I, T>.emitPending(id: I?, progression: Progression.Loading) {
+	emit(pending(id, progression))
+}
+
+/**
+ * Emits a [pending] slice with an [Unquantified][Progression.Loading.Unquantified] progression.
+ */
+suspend fun <I : Identifier<T>, T> StateBuilder<I, T>.emitPending(id: I?) {
+	emitPending(id, Progression.loading())
+}
+
+/**
+ * Emits a [pending] slice with a [Quantified][Progression.Loading.Quantified] [progression].
+ */
+suspend fun <I : Identifier<T>, T> StateBuilder<I, T>.emitPending(id: I?, progression: Double) {
+	emitPending(id, Progression.loading(progression))
+}
+
+//endregion
+//region Successful markers
+
+/**
+ * Emits a [successful] slice with the given [value].
+ */
+suspend fun <I : Identifier<T>, T> StateBuilder<I, T>.emitSuccessful(
+	id: I,
+	value: T,
+	progression: Progression = Progression.done(),
+) {
+	emit(successful(id, value, progression))
+}
+
+//endregion
+//region Failed markers
+
+/**
+ * Emits a [failed] slice with the given [exception] and [message].
+ */
+suspend fun <I : Identifier<T>, T> StateBuilder<I, T>.emitFailed(
+	id: I?,
+	exception: RuntimeException,
+	message: String,
+	progression: Progression,
+) {
+	emit(failed(id, exception, message, progression))
+}
+
+/**
+ * Emits a [failed] slice with the given [kind] and [message].
+ */
+suspend fun <I : Identifier<T>, T> StateBuilder<I, T>.emitFailed(
+	id: I?,
+	kind: Status.StandardFailure.Kind,
+	message: String,
+	progression: Progression,
+	cause: Throwable? = null,
+) {
+	emit(failed(id, kind, message, cause, progression))
+}
+
+//endregion
+//region Predicate checkers
+
+/**
+ * Ensures that [condition] is `true`.
+ *
+ * If it is, does nothing.
+ * Otherwise, emits an [Invalid][Status.StandardFailure.Kind.Invalid] slice and cancels the [state] builder.
+ */
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <I : Identifier<T>, T> StateBuilder<I, T>.ensureValid(
+	id: I?,
+	condition: Boolean,
+	lazyMessage: () -> String,
+) {
+	contract {
+		returns() implies condition
+	}
+
+	if (!condition) {
+		emitFailed(id, Status.StandardFailure.Kind.Invalid, lazyMessage(), progression = Progression.done())
+		throw StateBuilderCancellation()
+	}
+}
+
+/**
+ * Ensures that [condition] is `true`.
+ *
+ * If it is, does nothing.
+ * Otherwise, emits an [Unauthenticated][Status.StandardFailure.Kind.Unauthenticated] slice and cancels the [state] builder.
+ */
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <I : Identifier<T>, T> StateBuilder<I, T>.ensureAuthenticated(
+	id: I?,
+	condition: Boolean,
+	lazyMessage: () -> String,
+) {
+	contract {
+		returns() implies condition
+	}
+
+	if (!condition) {
+		emitFailed(id, Status.StandardFailure.Kind.Unauthenticated, lazyMessage(), progression = Progression.done())
+		throw StateBuilderCancellation()
+	}
+}
+
+/**
+ * Ensures that [condition] is `true`.
+ *
+ * If it is, does nothing.
+ * Otherwise, emits an [Unauthorized][Status.StandardFailure.Kind.Unauthorized] slice and cancels the [state] builder.
+ */
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <I : Identifier<T>, T> StateBuilder<I, T>.ensureAuthorized(
+	id: I?,
+	condition: Boolean,
+	lazyMessage: () -> String,
+) {
+	contract {
+		returns() implies condition
+	}
+
+	if (!condition) {
+		emitFailed(id, Status.StandardFailure.Kind.Unauthorized, lazyMessage(), progression = Progression.done())
+		throw StateBuilderCancellation()
+	}
+}
+
+/**
+ * Ensures that [condition] is `true`.
+ *
+ * If it is, does nothing.
+ * Otherwise, emits an [NotFound][Status.StandardFailure.Kind.NotFound] slice and cancels the [state] builder.
+ */
+@OptIn(ExperimentalContracts::class)
+suspend inline fun <I : Identifier<T>, T> StateBuilder<I, T>.ensureFound(
+	id: I?,
+	condition: Boolean,
+	lazyMessage: () -> String,
+) {
+	contract {
+		returns() implies condition
+	}
+
+	if (!condition) {
+		emitFailed(id, Status.StandardFailure.Kind.NotFound, lazyMessage(), progression = Progression.done())
+		throw StateBuilderCancellation()
+	}
+}
+
+//endregion
diff --git a/state/src/commonMain/kotlin/opensavvy.state/Status.kt b/state/src/commonMain/kotlin/opensavvy.state/Status.kt
new file mode 100644
index 0000000..5a00ad7
--- /dev/null
+++ b/state/src/commonMain/kotlin/opensavvy.state/Status.kt
@@ -0,0 +1,92 @@
+package opensavvy.state
+
+/**
+ * The status of a value.
+ *
+ * The status can be in three different states:
+ * - [Pending] represents a value which is not yet available.
+ * - [Successful] represents a successful result.
+ * - [Failed] represents an unsuccessful result.
+ */
+sealed interface Status<out T> {
+
+	object Pending : Status<Nothing> {
+		override fun toString() = "Pending"
+	}
+
+	data class Successful<T>(
+		val value: T,
+	) : Status<T> {
+		override fun toString() = "$value"
+	}
+
+	abstract class Failed(message: String?, cause: Throwable?) : RuntimeException(message, cause), Status<Nothing>
+
+	//region Failure implementations
+
+	class ExceptionFailure(message: String, cause: RuntimeException) : Failed(message, cause)
+
+	class StandardFailure(
+		val kind: Kind,
+		message: String,
+		cause: Throwable? = null,
+	) : Failed(message, cause) {
+
+		//region toString, equals, hashCode
+
+		override fun toString() = "$kind($message)"
+		override fun equals(other: Any?): Boolean {
+			if (this === other) return true
+			if (other !is StandardFailure) return false
+
+			if (kind != other.kind) return false
+			if (message != other.message) return false
+
+			return true
+		}
+
+		override fun hashCode(): Int {
+			var result = kind.hashCode()
+			result = 31 * result + message.hashCode()
+			return result
+		}
+
+		//endregion
+
+		enum class Kind {
+			/**
+			 * The request is not valid.
+			 *
+			 * All prerequisites are correct (the user is correctly authenticated and authorized…) but the
+			 * request payload is invalid.
+			 */
+			Invalid,
+
+			/**
+			 * The implementation could not determine which user is making the request.
+			 */
+			Unauthenticated,
+
+			/**
+			 * The implementation could determine which user is making the request, but they do not have
+			 * sufficient rights to make the request.
+			 */
+			Unauthorized,
+
+			/**
+			 * The request is well-formed and the user is allowed to make it,
+			 * but the resource it should apply to could not be found.
+			 */
+			NotFound,
+
+			/**
+			 * The implementation caught an unknown error.
+			 */
+			Unknown,
+			;
+		}
+	}
+
+	//endregion
+
+}
diff --git a/state/src/commonTest/kotlin/opensavvy.state/ProgressionTest.kt b/state/src/commonTest/kotlin/opensavvy.state/ProgressionTest.kt
new file mode 100644
index 0000000..43ed166
--- /dev/null
+++ b/state/src/commonTest/kotlin/opensavvy.state/ProgressionTest.kt
@@ -0,0 +1,48 @@
+package opensavvy.state
+
+import opensavvy.state.Progression.Companion.loading
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFails
+
+class ProgressionTest {
+
+	@Test
+	fun string() {
+		assertEquals("Loading", loading().toString())
+		assertEquals("Loading(0%)", loading(0.0).toString())
+		assertEquals("Loading(33%)", loading(0.33).toString())
+		assertEquals("Loading(100%)", loading(1.0).toString())
+	}
+
+	@Test
+	fun percent0() {
+		val start = loading(0.0)
+		assertEquals(0.0, start.normalized)
+		assertEquals(0, start.percent)
+	}
+
+	@Test
+	fun percentThird() {
+		val third = loading(1.0 / 3)
+		assertEquals(0.3333333333333333, third.normalized)
+		assertEquals(33, third.percent)
+	}
+
+	@Test
+	fun percent100() {
+		val end = loading(1.0)
+		assertEquals(1.0, end.normalized)
+		assertEquals(100, end.percent)
+	}
+
+	@Test
+	fun percentRange() {
+		assertFails { loading(-1.0) }
+		assertFails { loading(1.01) }
+		assertFails { loading(1.00000001) }
+		assertFails { loading(Double.MAX_VALUE) }
+		assertFails { loading(Double.NEGATIVE_INFINITY) }
+		assertFails { loading(Double.POSITIVE_INFINITY) }
+	}
+}
diff --git a/state/src/commonTest/kotlin/opensavvy.state/SliceTest.kt b/state/src/commonTest/kotlin/opensavvy.state/SliceTest.kt
new file mode 100644
index 0000000..3ed8d6e
--- /dev/null
+++ b/state/src/commonTest/kotlin/opensavvy.state/SliceTest.kt
@@ -0,0 +1,200 @@
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package opensavvy.state
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.test.runTest
+import opensavvy.state.Slice.Companion.failed
+import opensavvy.state.Slice.Companion.pending
+import opensavvy.state.Slice.Companion.successful
+import opensavvy.state.Slice.Companion.valueOrNull
+import opensavvy.state.Slice.Companion.valueOrThrow
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNotEquals
+
+class SliceTest {
+
+	private data class IntId(val id: Int) : Identifier<Int> {
+
+		fun request() = state {
+			val id = this@IntId
+
+			emitPending(id, 0.0)
+			delay(20)
+
+			// Just imagine the conditions are related to what we're testing
+			ensureValid(id, id.id > 0) { "The number should be greater than 0: ${id.id}" }
+			emitPending(id, 0.2)
+
+			ensureAuthenticated(id, id.id < 100) { "The number should be lesser than 100: ${id.id}" }
+			emitPending(id, 0.4)
+
+			ensureAuthorized(id, id.id % 2 == 0) { "The number should be even: ${id.id}" }
+			emitPending(id, 0.6)
+
+			ensureFound(id, id.id % 9 == 0) { "The number should be a multiple of 9: ${id.id}" }
+			emitPending(id, 0.8)
+
+			emitSuccessful(id, id.id)
+		}
+
+		override fun toString() = "Id($id)"
+
+	}
+
+	@Test
+	fun successful() = runTest {
+		val id = IntId(18)
+
+		val actual = id
+			.request()
+			.toList()
+
+		val expected = listOf(
+			pending(id, 0.0),
+			pending(id, 0.2),
+			pending(id, 0.4),
+			pending(id, 0.6),
+			pending(id, 0.8),
+			successful(id, 18),
+		)
+
+		assertEquals(expected, actual)
+		assertEquals(18, actual.last().valueOrThrow)
+	}
+
+	@Test
+	fun invalid() = runTest {
+		val id = IntId(-50)
+
+		val actual = id
+			.request()
+			.toList()
+
+		val expected = listOf(
+			pending(id, 0.0),
+			failed(id, Status.StandardFailure.Kind.Invalid, "The number should be greater than 0: -50"),
+		)
+
+		assertEquals(expected, actual)
+	}
+
+	@Test
+	fun unauthenticated() = runTest {
+		val id = IntId(167)
+
+		val actual = id
+			.request()
+			.toList()
+
+		val expected = listOf(
+			pending(id, 0.0),
+			pending(id, 0.2),
+			failed(id, Status.StandardFailure.Kind.Unauthenticated, "The number should be lesser than 100: 167"),
+		)
+
+		assertEquals(expected, actual)
+	}
+
+	@Test
+	fun unauthorized() = runTest {
+		val id = IntId(5)
+
+		val actual = id
+			.request()
+			.toList()
+
+		val expected = listOf(
+			pending(id, 0.0),
+			pending(id, 0.2),
+			pending(id, 0.4),
+			failed(id, Status.StandardFailure.Kind.Unauthorized, "The number should be even: 5"),
+		)
+
+		assertEquals(expected, actual)
+	}
+
+	@Test
+	fun notFound() = runTest {
+		val id = IntId(8)
+
+		val actual = id
+			.request()
+			.toList()
+
+		val expected = listOf(
+			pending(id, 0.0),
+			pending(id, 0.2),
+			pending(id, 0.4),
+			pending(id, 0.6),
+			failed(id, Status.StandardFailure.Kind.NotFound, "The number should be a multiple of 9: 8"),
+		)
+
+		assertEquals(expected, actual)
+	}
+
+	@Suppress("DestructuringWrongName") // false positive, see https://youtrack.jetbrains.com/issue/KT-54374
+	@Test
+	fun destructuration() {
+		val (status, progression, id) = successful(IntId(0), 0)
+
+		assertEquals(Status.Successful(0), status)
+		assertEquals(Progression.done(), progression)
+		assertEquals(IntId(0), id)
+	}
+
+	@Test
+	fun identity() {
+		val success0 = successful(IntId(0), 0)
+		val success1 = successful(IntId(1), 1)
+		assertEquals(successful(IntId(0), 0), success0)
+		assertEquals(successful(IntId(0), 0).hashCode(), success0.hashCode())
+		assertEquals(successful(IntId(1), 1), success1)
+		assertNotEquals(success0, success1)
+
+		val pending0 = pending(IntId(0))
+		val pending1 = pending(IntId(1), 0.5)
+		val pendingX = pending<IntId, Int>(id = null, 1.0 / 3)
+		assertEquals(pending(IntId(0)), pending0)
+		assertEquals(pending(IntId(1), 0.5), pending1)
+		assertEquals(pending(IntId(1), 0.5).hashCode(), pending1.hashCode())
+		assertNotEquals(pending(IntId(1), 0.6), pending1)
+		assertEquals(pending(id = null, 1.0 / 3), pendingX)
+
+		val failed0 = failed(IntId(0), Status.StandardFailure.Kind.Invalid, "error")
+		assertEquals(failed(IntId(0), Status.StandardFailure.Kind.Invalid, "error"), failed0)
+		assertNotEquals(failed(IntId(0), Status.StandardFailure.Kind.NotFound, "error"), failed0)
+		assertNotEquals(failed(IntId(0), Status.StandardFailure.Kind.Unauthenticated, "error"), failed0)
+		assertNotEquals(failed(IntId(0), Status.StandardFailure.Kind.Invalid, "other"), failed0)
+
+		assertEquals("Id(0): 0 Done", success0.toString())
+		assertEquals("Id(1): 1 Done", success1.toString())
+		assertEquals("Id(0): Loading", pending0.toString())
+		assertEquals("Id(1): Loading(50%)", pending1.toString())
+		assertEquals("Loading(33%)", pendingX.toString())
+		assertEquals("Id(0): Invalid(error) Done", failed0.toString())
+	}
+
+	@Test
+	fun value() {
+		val success = successful(IntId(0), 0)
+		val pending = pending(IntId(0))
+		val failed1 = failed(IntId(0), IllegalArgumentException("whatever"), "whatever 2")
+		val failed2 = failed(IntId(0), Status.StandardFailure.Kind.Invalid, "whatever 3")
+
+		assertEquals(0, success.valueOrNull)
+
+		assertEquals(null, pending.valueOrNull)
+		assertEquals(null, failed1.valueOrNull)
+		assertEquals(null, failed2.valueOrNull)
+
+		assertFailsWith<NoSuchElementException> { pending.valueOrThrow }
+		assertFailsWith<Status.ExceptionFailure>("whatever 2") { failed1.valueOrThrow }
+		assertFailsWith<Status.StandardFailure>("whatever 3") { failed2.valueOrThrow }
+	}
+
+}
diff --git a/state/src/commonTest/kotlin/opensavvy.state/StateBuilderTest.kt b/state/src/commonTest/kotlin/opensavvy.state/StateBuilderTest.kt
new file mode 100644
index 0000000..6cee65e
--- /dev/null
+++ b/state/src/commonTest/kotlin/opensavvy.state/StateBuilderTest.kt
@@ -0,0 +1,66 @@
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package opensavvy.state
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import opensavvy.state.Slice.Companion.failed
+import opensavvy.state.Slice.Companion.successful
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class StateBuilderTest {
+
+	private data class IntId(val id: Int) : Identifier<Int>
+
+	@Test
+	fun success() = runTest {
+		val data = state {
+			emitSuccessful(IntId(0), 0)
+		}
+
+		assertEquals(successful(IntId(0), 0), data.firstResult())
+	}
+
+	@Test
+	fun ensure() = runTest {
+		val data = state {
+			ensureValid(IntId(0), condition = false) { "this is always invalid" }
+		}
+
+		assertEquals(
+			failed(IntId(0), Status.StandardFailure.Kind.Invalid, "this is always invalid"),
+			data.firstResult()
+		)
+	}
+
+	@Test
+	fun throwStandard() = runTest {
+		val data = state {
+			throw Status.StandardFailure(Status.StandardFailure.Kind.Invalid, "this is always invalid")
+			@Suppress("UNREACHABLE_CODE") emitSuccessful(IntId(0), 0)
+		}
+
+		assertEquals(
+			failed(id = null, Status.StandardFailure.Kind.Invalid, "this is always invalid"),
+			data.firstResult()
+		)
+	}
+
+	@Test
+	fun throwOther() = runTest {
+		val data = state {
+			error("some error")
+			@Suppress("UNREACHABLE_CODE") emitSuccessful(IntId(0), 0)
+		}
+
+		assertEquals(
+			failed(
+				id = null,
+				Status.StandardFailure.Kind.Unknown,
+				"Unknown error caught in the state builder"
+			), data.firstResult()
+		)
+	}
+
+}
-- 
2.51.2


From 2cb1d14a15b1415ad04e082f2f24931ae99f9367 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Mon, 10 Oct 2022 14:24:50 +0200
Subject: [PATCH 7/9] feat(spine): Added the Action operation kind

Action endpoints are not RESTful, but they are also very common in the wild.

Before this patch, we supported them by creating an Edit operation to a subroute without a body (i.e. `PATCH /users/53/subscribe`).

Now, they are modeled by the Action operation (i.e. `PUT /users/53/subscribe`).
---
 .../kotlin/opensavvy.spine.ktor.server/TestApi.kt    |  4 ++--
 .../kotlin/opensavvy.spine.ktor/Methods.kt           |  1 +
 .../commonMain/kotlin/opensavvy.spine/Operation.kt   |  9 +++++++++
 .../commonMain/kotlin/opensavvy.spine/Resource.kt    | 12 ++++++++++--
 4 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
index 4946920..797f145 100644
--- a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
+++ b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
@@ -43,9 +43,9 @@ class TestApi : Service("test") {
 	inner class Users : StaticResource<List<Id<User>>, User.SearchParams, Unit>("users") {
 		inner class Unique : DynamicResource<User, Unit>("user") {
 
-			val archive = edit<Unit, Parameters.Empty>(Route / "archive")
+			val archive = action<Unit, Parameters.Empty>(Route / "archive")
 
-			val unarchive = edit<Unit, Parameters.Empty>(Route / "reopen")
+			val unarchive = action<Unit, Parameters.Empty>(Route / "reopen")
 
 			val delete = delete<Unit>()
 		}
diff --git a/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt
index 0005bf7..1f3905f 100644
--- a/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt
+++ b/spine-ktor/src/commonMain/kotlin/opensavvy.spine.ktor/Methods.kt
@@ -9,4 +9,5 @@ fun Operation.Kind.toHttp() = when (this) {
 	Create -> HttpMethod.Post
 	Edit -> HttpMethod.Patch
 	Delete -> HttpMethod.Delete
+	Action -> HttpMethod.Put
 }
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
index 36fd8fe..85c498a 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
@@ -45,6 +45,15 @@ class Operation<Resource : Any, In : Any, Out : Any, Params : Parameters, Contex
 		 */
 		Edit,
 
+		/**
+		 * Executes an arbitrary action on a resource.
+		 *
+		 * This operation should not be confused with [Create], [Edit] and [Delete].
+		 *
+		 * This operation may or may not be idempotent.
+		 */
+		Action,
+
 		/**
 		 * Deletes an existing resource.
 		 */
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
index 76d18d8..96a0e7c 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
@@ -129,7 +129,7 @@ sealed class ResourceGroup {
 		) =
 			Operation(this, Operation.Kind.Create, route, validate)
 
-		protected fun <In, Params : Parameters> edit(
+		protected fun <In : Any, Params : Parameters> edit(
 			route: Route? = null,
 			validate: OperationValidator<Pair<Id<O>, In>, Unit, Params, Context> = { _, _, _ -> },
 		) = Operation(this, Operation.Kind.Edit, route) { (id, it): Pair<Id<O>, In>, params: Params, context ->
@@ -137,7 +137,15 @@ sealed class ResourceGroup {
 			validate(id to it, params, context)
 		}
 
-		protected fun <In> delete(validate: OperationValidator<Pair<Id<O>, In>, Unit, Parameters.Empty, Context> = { _, _, _ -> }) =
+		protected fun <In : Any, Params : Parameters> action(
+			route: Route,
+			validate: OperationValidator<Pair<Id<O>, In>, Unit, Params, Context> = { _, _, _ -> },
+		) = Operation(this, Operation.Kind.Action, route) { (id, it): Pair<Id<O>, In>, params: Params, context ->
+			validateId(id, context)
+			validate(id to it, params, context)
+		}
+
+		protected fun <In : Any> delete(validate: OperationValidator<Pair<Id<O>, In>, Unit, Parameters.Empty, Context> = { _, _, _ -> }) =
 			Operation(
 				this,
 				Operation.Kind.Delete,
-- 
2.51.2


From e8296426a88519002f6ff89fc1f7fbaa3fa2870a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Mon, 10 Oct 2022 17:39:28 +0200
Subject: [PATCH 8/9] feat(spine): The ID of the current resource is now
 automatically shared between the client and the server

In previous versions, it was necessary to send the ID as part of the body. It's not the case anymore.
---
 .../opensavvy.spine.ktor.client/Client.kt     |  2 +-
 .../opensavvy.spine.ktor.server/GenerateId.kt | 33 +++++++++++++++++
 .../ResponseStateBuilder.kt                   |  7 +++-
 .../opensavvy.spine.ktor.server/Server.kt     | 20 ++++++++---
 .../opensavvy.spine.ktor.server/ServerTest.kt |  6 +---
 .../opensavvy.spine.ktor.server/TestApi.kt    |  4 +--
 .../commonMain/kotlin/opensavvy.spine/Id.kt   | 10 ++++++
 .../kotlin/opensavvy.spine/Operation.kt       |  4 +--
 .../kotlin/opensavvy.spine/Resource.kt        | 35 ++++++++++---------
 .../kotlin/opensavvy.spine/ServiceTest.kt     | 28 +++++++--------
 .../kotlin/opensavvy.state/StateBuilder.kt    |  8 +++++
 11 files changed, 110 insertions(+), 47 deletions(-)
 create mode 100644 spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/GenerateId.kt

diff --git a/spine-ktor/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt b/spine-ktor/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
index f86fcd5..1ffed14 100644
--- a/spine-ktor/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
+++ b/spine-ktor/spine-ktor-client/src/commonMain/kotlin/opensavvy.spine.ktor.client/Client.kt
@@ -49,7 +49,7 @@ inline fun <Resource : Any, reified In : Any, reified Out : Any, reified Params
 ): State<Id<Out>, Out> = state {
 	emitPending(id = null, 0.0)
 
-	operation.validate(this, input, parameters, context)
+	operation.validate(this, id, input, parameters, context)
 
 	emitPending(id = null, 0.1)
 
diff --git a/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/GenerateId.kt b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/GenerateId.kt
new file mode 100644
index 0000000..7502892
--- /dev/null
+++ b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/GenerateId.kt
@@ -0,0 +1,33 @@
+package opensavvy.spine.ktor.server
+
+import io.ktor.server.application.*
+import opensavvy.spine.Id
+import opensavvy.spine.ResourceGroup
+import opensavvy.spine.Route
+
+fun <O : Any> ApplicationCall.generateId(resource: ResourceGroup.AbstractResource<O, *>): Id<O> {
+	val values = ArrayList<String>()
+
+	var cursor: ResourceGroup = resource
+	while (cursor is ResourceGroup.AbstractResource<*, *>) {
+		values += when (cursor) {
+			is ResourceGroup.StaticResource<*, *, *> -> {
+				cursor.route.segment
+			}
+
+			is ResourceGroup.DynamicResource<*, *> -> {
+				val name = cursor.name
+				val value = parameters[name]
+					?: error("Missing path parameter: '{$name}' in '${resource.routeTemplate}'")
+				value
+			}
+		}
+		cursor = cursor.parent
+	}
+
+	values.reverse()
+
+	val service = resource.service.name
+	val route = Route(values.map { Route.Segment(it) })
+	return Id(service, route)
+}
diff --git a/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
index fc90efc..25d51d7 100644
--- a/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
+++ b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/ResponseStateBuilder.kt
@@ -8,9 +8,14 @@ import opensavvy.state.StateBuilder
 /**
  * Information available in [route].
  */
-class ResponseStateBuilder<In, Out, Params : Parameters?, Context>(
+class ResponseStateBuilder<Resource, In, Out, Params : Parameters?, Context>(
 	builder: StateBuilder<Id<Out>, Out>,
 
+	/**
+	 * The identifier of the resource being requested.
+	 */
+	val id: Id<Resource>,
+
 	/**
 	 * The body of the request.
 	 */
diff --git a/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
index ad6b6d3..0c5371f 100644
--- a/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
+++ b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
@@ -45,26 +45,36 @@ import opensavvy.state.state
 inline fun <Resource : Any, reified In : Any, reified Out : Any, reified Params : Parameters, Context : Any> Route.route(
 	operation: Operation<Resource, In, Out, Params, Context>,
 	contextGenerator: ContextGenerator<Context>,
-	crossinline block: suspend ResponseStateBuilder<In, Out, Params, Context>.() -> Unit,
+	crossinline block: suspend ResponseStateBuilder<Resource, In, Out, Params, Context>.() -> Unit,
 ) {
 	val path: String = operation.resource.routeTemplate + (operation.route ?: "")
 
-	route(path, operation.kind.toHttp()) {
+	val method = operation.kind.toHttp()
+	route(path, method) {
 		handle {
 			val context = contextGenerator.generate(call)
 
+			val id = call.generateId(operation.resource)
+
 			val params = Params::class.java
 				.getConstructor()
 				.newInstance() // Created via reflection, assumes the default constructor is present
 			for ((name, values) in call.parameters.entries())
 				params.data[name] = values.first() // if a parameter is added multiple times, only the first one is kept
 
-			val body = call.receive<In>()
+			val body = when {
+				// If the expected input is Unit, don't even try to read the body
+				// Ktor fails to read the body on GET, DELETE and OPTIONS requests. Because we encode them as Unit,
+				// it's not a problem.
+				In::class == Unit::class -> Unit as In
+				// For any other type, delegate to the ContentNegotiation plugin
+				else -> call.receive()
+			}
 
 			val state = state {
-				operation.validate(this, body, params, context)
+				operation.validate(this, id, body, params, context)
 
-				val responseBuilder = ResponseStateBuilder(this, body, params, call, context)
+				val responseBuilder = ResponseStateBuilder(this, id, body, params, call, context)
 				responseBuilder.block()
 			}.firstResult() // How can we send loading events via HTTP?
 
diff --git a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
index e6afcfe..10d39c4 100644
--- a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
+++ b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
@@ -60,14 +60,12 @@ class ServerTest {
 			}
 
 			route(api.users.id.get, context) {
-				val id = body
 				val user = users.find { it.id == id }
 				ensureFound(id, user != null) { "Could not find the user $id" }
 				emitSuccessful(id, user)
 			}
 
 			route(api.users.id.archive, context) {
-				val (id, _) = body
 				val userIndex = users.indexOfFirst { it.id == id }
 				ensureFound(id, userIndex >= 0) { "Could not find user $id" }
 				val user = users.removeAt(userIndex)
@@ -76,7 +74,6 @@ class ServerTest {
 			}
 
 			route(api.users.id.unarchive, context) {
-				val (id, _) = body
 				val userIndex = users.indexOfFirst { it.id == id }
 				ensureFound(id, userIndex >= 0) { "Could not find user $id" }
 				val user = users.removeAt(userIndex)
@@ -85,7 +82,6 @@ class ServerTest {
 			}
 
 			route(api.users.id.delete, context) {
-				val (id, _) = body
 				val userIndex = users.indexOfFirst { it.id == id }
 				ensureFound(id, userIndex >= 0) { "Could not find user $id" }
 				val user = users.removeAt(userIndex)
@@ -110,7 +106,7 @@ class ServerTest {
 		log.info { "Step 1: query the initial users (empty list)" }
 
 		val params = User.SearchParams().apply { includeArchived = true }
-		val results = client.request(api.users.get, api.users.get.idOf(), api.users.get.idOf(), params, Unit)
+		val results = client.request(api.users.get, api.users.get.idOf(), Unit, params, Unit)
 			.onEach { log.debug(it) { "Received event for" } }
 			.firstResultOrThrow()
 
diff --git a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
index 797f145..67b3658 100644
--- a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
+++ b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/TestApi.kt
@@ -43,9 +43,9 @@ class TestApi : Service("test") {
 	inner class Users : StaticResource<List<Id<User>>, User.SearchParams, Unit>("users") {
 		inner class Unique : DynamicResource<User, Unit>("user") {
 
-			val archive = action<Unit, Parameters.Empty>(Route / "archive")
+			val archive = action<Unit, Unit, Parameters.Empty>(Route / "archive")
 
-			val unarchive = action<Unit, Parameters.Empty>(Route / "reopen")
+			val unarchive = action<Unit, Unit, Parameters.Empty>(Route / "reopen")
 
 			val delete = delete<Unit>()
 		}
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt
index 9e9dfe4..6e006bf 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Id.kt
@@ -11,5 +11,15 @@ data class Id<T>(
 
 	constructor(service: String, resource: Route) : this(Route.Segment(service), resource)
 
+	/**
+	 * Untyped [Id] with the same data as this instance.
+	 *
+	 * Operations that have no resulting data (i.e. only have side effects) are represented by returning [Unit].
+	 * However, it is still useful to return an ID to mark which object caused an error.
+	 * This property is used to obtain an [Id] instance useful in methods that return no result.
+	 */
+	val unit: Id<Unit>
+		get() = Id(service, resource)
+
 	override fun toString() = "$service/$resource"
 }
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
index 85c498a..a221560 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Operation.kt
@@ -2,13 +2,13 @@ package opensavvy.spine
 
 import opensavvy.state.StateBuilder
 
-typealias OperationValidator<In, Out, Params, Context> = suspend StateBuilder<Id<Out>, Out>.(In, parameters: Params, context: Context) -> Unit
+typealias OperationValidator<Resource, In, Out, Params, Context> = suspend StateBuilder<Id<Out>, Out>.(Id<Resource>, In, parameters: Params, context: Context) -> Unit
 
 class Operation<Resource : Any, In : Any, Out : Any, Params : Parameters, Context : Any>(
 	val resource: ResourceGroup.AbstractResource<Resource, Context>,
 	val kind: Kind,
 	val route: Route? = null,
-	val validate: OperationValidator<In, Out, Params, Context>,
+	val validate: OperationValidator<Resource, In, Out, Params, Context>,
 ) {
 
 	/**
diff --git a/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt b/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
index 96a0e7c..e0dbf44 100644
--- a/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
+++ b/spine/src/commonMain/kotlin/opensavvy.spine/Resource.kt
@@ -125,34 +125,34 @@ sealed class ResourceGroup {
 
 		protected fun <In : Any, Out : Any, Params : Parameters> create(
 			route: Route? = null,
-			validate: OperationValidator<In, Out, Params, Context> = { _, _, _ -> },
+			validate: OperationValidator<O, In, Out, Params, Context> = { _, _, _, _ -> },
 		) =
 			Operation(this, Operation.Kind.Create, route, validate)
 
 		protected fun <In : Any, Params : Parameters> edit(
 			route: Route? = null,
-			validate: OperationValidator<Pair<Id<O>, In>, Unit, Params, Context> = { _, _, _ -> },
-		) = Operation(this, Operation.Kind.Edit, route) { (id, it): Pair<Id<O>, In>, params: Params, context ->
+			validate: OperationValidator<O, In, Unit, Params, Context> = { _, _, _, _ -> },
+		) = Operation(this, Operation.Kind.Edit, route) { id: Id<O>, it: In, params: Params, context ->
 			validateId(id, context)
-			validate(id to it, params, context)
+			validate(id, it, params, context)
 		}
 
-		protected fun <In : Any, Params : Parameters> action(
+		protected fun <In : Any, Out : Any, Params : Parameters> action(
 			route: Route,
-			validate: OperationValidator<Pair<Id<O>, In>, Unit, Params, Context> = { _, _, _ -> },
-		) = Operation(this, Operation.Kind.Action, route) { (id, it): Pair<Id<O>, In>, params: Params, context ->
+			validate: OperationValidator<O, In, Out, Params, Context> = { _, _, _, _ -> },
+		) = Operation(this, Operation.Kind.Action, route) { id: Id<O>, it: In, params: Params, context ->
 			validateId(id, context)
-			validate(id to it, params, context)
+			validate(id, it, params, context)
 		}
 
-		protected fun <In : Any> delete(validate: OperationValidator<Pair<Id<O>, In>, Unit, Parameters.Empty, Context> = { _, _, _ -> }) =
+		protected fun <In : Any> delete(validate: OperationValidator<O, In, Unit, Parameters.Empty, Context> = { _, _, _, _ -> }) =
 			Operation(
 				this,
 				Operation.Kind.Delete,
 				route = null
-			) { (id, it): Pair<Id<O>, In>, _: Parameters.Empty, context ->
+			) { id: Id<O>, it: In, _: Parameters.Empty, context ->
 				validateId(id, context)
-				validate(id to it, Parameters.Empty, context)
+				validate(id, it, Parameters.Empty, context)
 			}
 
 		/**
@@ -207,10 +207,11 @@ sealed class ResourceGroup {
 		open suspend fun StateBuilder<Id<O>, O>.validateGetParams(params: GetParams, context: Context) {}
 
 		@Suppress("LeakingThis") // Not dangerous because Operation's constructor does nothing
-		val get = Operation<O, Id<O>, O, GetParams, Context>(this, Operation.Kind.Read) { it, params, context ->
-			validateId(it, context)
-			validateGetParams(params, context)
-		}
+		val get =
+			Operation<O, Unit, O, GetParams, Context>(this, Operation.Kind.Read) { id: Id<O>, _, params, context ->
+				validateId(id, context)
+				validateGetParams(params, context)
+			}
 
 		final override val routeTemplate get() = "${this@ResourceGroup.routeTemplate}/$route"
 
@@ -247,9 +248,9 @@ sealed class ResourceGroup {
 		}
 
 		@Suppress("LeakingThis") // Not dangerous because Operation's constructor does nothing
-		val get = Operation<O, Id<O>, O, Parameters.Empty, Context>(this, Operation.Kind.Read) { it, _, context ->
+		val get = Operation<O, Unit, O, Parameters.Empty, Context>(this, Operation.Kind.Read) { id, _, _, context ->
 			validateId(
-				it,
+				id,
 				context
 			)
 		}
diff --git a/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt b/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt
index 4bcf685..ae25ed6 100644
--- a/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt
+++ b/spine/src/commonTest/kotlin/opensavvy.spine/ServiceTest.kt
@@ -63,13 +63,13 @@ private class Api : Service("v2") {
 		inner class Unique : DynamicResource<User, Context>("user") {
 			inner class Departments : StaticResource<List<Id<Department>>, Parameters.Empty, Context>("departments")
 
-			val join = edit<Unit, Parameters.Empty>(Route / "join")
+			val join = action<Unit, Unit, Parameters.Empty>(Route / "join")
 
-			val leave = edit<Unit, Parameters.Empty>(Route / "leave")
+			val leave = action<Unit, Unit, Parameters.Empty>(Route / "leave")
 
-			val rename = edit<User.Rename, Parameters.Empty>(Route / "name") { (_, newName), _, _ ->
+			val rename = edit<User.Rename, Parameters.Empty>(Route / "name") { id, newName, _, _ ->
 				ensureValid(
-					id = null,
+					id.unit,
 					newName.name.isNotBlank()
 				) { "A user's name may not be empty: '${newName.name}'" }
 			}
@@ -77,10 +77,10 @@ private class Api : Service("v2") {
 			val departments = Departments()
 		}
 
-		val create = create { it: User.New, _: Parameters.Empty, context: Context ->
-			ensureValid(id = null, it.name.isNotBlank()) { "A user's name may not be empty: '${it.name}'" }
+		val create = create { id, it: User.New, _: Parameters.Empty, context: Context ->
+			ensureValid(id.unit, it.name.isNotBlank()) { "A user's name may not be empty: '${it.name}'" }
 			ensureValid(
-				id = null,
+				id.unit,
 				it.name.length < 100
 			) { "A user's name may not be longer than 100 characters, found ${it.name.length} characters: '${it.name}'" }
 			ensureAuthorized(id = null, context.user.requestValue().admin) { "Only admins can create new users" }
@@ -147,7 +147,7 @@ class ServiceTest {
 		assertEquals(
 			successful(id1, User("Employee", false)),
 			state {
-				endpoint.validate(this, id1, Parameters.Empty, employee)
+				endpoint.validate(this, id1, Unit, Parameters.Empty, employee)
 				emitAll(employee.user.request().mapIdentifier { endpoint.idOf((it as Ref.Basic).id) })
 			}.firstResult()
 		)
@@ -162,7 +162,7 @@ class ServiceTest {
 				"The passed identifier refers to the service 'this-is-not-the-correct-service-name', but this resource belongs to the service 'v2'"
 			),
 			state {
-				endpoint.validate(this, id2, Parameters.Empty, employee)
+				endpoint.validate(this, id2, Unit, Parameters.Empty, employee)
 			}.firstResult()
 		)
 
@@ -176,7 +176,7 @@ class ServiceTest {
 				"The passed identifier's URI length is too short for this resource: 'v2/users' for resource 'v2/users/{user}'"
 			),
 			state {
-				endpoint.validate(this, id3, Parameters.Empty, employee)
+				endpoint.validate(this, id3, Unit, Parameters.Empty, employee)
 			}.firstResult()
 		)
 
@@ -190,7 +190,7 @@ class ServiceTest {
 				"The passed identifier's segment #0 doesn't match the resource; expected 'users' but found 'departments'"
 			),
 			state {
-				endpoint.validate(this, id4, Parameters.Empty, employee)
+				endpoint.validate(this, id4, Unit, Parameters.Empty, employee)
 			}.firstResult()
 		)
 
@@ -204,7 +204,7 @@ class ServiceTest {
 				"The passed identifier's URI length is too long for this resource: 'v2/departments/users/0' for resource 'v2/users/{user}'"
 			),
 			state {
-				endpoint.validate(this, id5, Parameters.Empty, employee)
+				endpoint.validate(this, id5, Unit, Parameters.Empty, employee)
 			}.firstResult()
 		)
 	}
@@ -218,7 +218,7 @@ class ServiceTest {
 		val admin = Context(Ref.Basic("1", bone))
 
 		assertEquals(emptyList(), state {
-			endpoint.validate(this, User.New("Third user"), Parameters.Empty, admin)
+			endpoint.validate(this, endpoint.idOf(), User.New("Third user"), Parameters.Empty, admin)
 		}.skipLoading().toList())
 	}
 
@@ -232,7 +232,7 @@ class ServiceTest {
 
 		val id = endpoint.idOf("0")
 		assertEquals(emptyList(), state {
-			endpoint.validate(this, id to User.Rename("Another name"), Parameters.Empty, admin)
+			endpoint.validate(this, id, User.Rename("Another name"), Parameters.Empty, admin)
 		}.skipLoading().toList())
 	}
 
diff --git a/state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt b/state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt
index 9456036..be246c4 100644
--- a/state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt
+++ b/state/src/commonMain/kotlin/opensavvy.state/StateBuilder.kt
@@ -42,6 +42,14 @@ fun <I : Identifier<T>, T> state(block: suspend StateBuilder<I, T>.() -> Unit) =
 			// See https://kotlinlang.org/docs/cancellation-and-timeouts.html#cancellation-is-cooperative
 			is CancellationException -> throw CancellationException("A state builder was cancelled", it)
 
+			is Status.StandardFailure -> emitFailed(
+				id = null,
+				kind = it.kind,
+				message = it.message ?: "Caught a downstream error",
+				progression = Progression.done(),
+				cause = it.cause
+			)
+
 			// All other exceptions are caught into the Kind.Unknown standard failure.
 			else -> emitFailed(
 				id = null,
-- 
2.51.2


From 46e632677afeccabebc94e66f314097a247c9927 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivan=20=E2=80=9CCLOVIS=E2=80=9D=20Canet?=
 <ivan.canet@gmail.com>
Date: Mon, 10 Oct 2022 18:05:57 +0200
Subject: [PATCH 9/9] feat(spine): Handle empty parameters

---
 .../opensavvy.spine.ktor.server/Server.kt     | 17 +++++--
 .../opensavvy.spine.ktor.server/ServerTest.kt | 46 ++++++++++++++++---
 2 files changed, 52 insertions(+), 11 deletions(-)

diff --git a/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
index 0c5371f..c3194a2 100644
--- a/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
+++ b/spine-ktor/spine-ktor-server/src/commonMain/kotlin/opensavvy.spine.ktor.server/Server.kt
@@ -56,11 +56,18 @@ inline fun <Resource : Any, reified In : Any, reified Out : Any, reified Params
 
 			val id = call.generateId(operation.resource)
 
-			val params = Params::class.java
-				.getConstructor()
-				.newInstance() // Created via reflection, assumes the default constructor is present
-			for ((name, values) in call.parameters.entries())
-				params.data[name] = values.first() // if a parameter is added multiple times, only the first one is kept
+			val params: Params = when {
+				Params::class == Parameters.Empty::class -> Parameters.Empty as Params
+				else -> {
+					val params = Params::class.java
+						.getConstructor()
+						.newInstance()
+					for ((name, values) in call.parameters.entries())
+					// if a parameter is added multiple times, only the first one is kept
+						params.data[name] = values.first()
+					params
+				}
+			}
 
 			val body = when {
 				// If the expected input is Unit, don't even try to read the body
diff --git a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
index 10d39c4..b8a76e1 100644
--- a/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
+++ b/spine-ktor/spine-ktor-server/src/commonTest/kotlin/opensavvy.spine.ktor.server/ServerTest.kt
@@ -8,6 +8,10 @@ import kotlinx.coroutines.flow.onEach
 import opensavvy.logger.Logger.Companion.debug
 import opensavvy.logger.Logger.Companion.info
 import opensavvy.logger.loggerFor
+import opensavvy.spine.Id
+import opensavvy.spine.Parameters
+import opensavvy.spine.Route
+import opensavvy.spine.Route.Companion.div
 import opensavvy.spine.ktor.client.request
 import opensavvy.state.emitSuccessful
 import opensavvy.state.ensureFound
@@ -42,9 +46,12 @@ class ServerTest {
 
 		log.info { "Declaring the routes…" }
 		val users = ArrayList<User>() // for the example, we're using a simple list and not a proper database
+		var nextId = 0
 		val context = ContextGenerator {}
 
 		routing {
+			trace { println(it) }
+
 			route(api.users.get, context) {
 				val result = users
 					.filter { parameters.includeArchived || !it.archived }
@@ -54,8 +61,9 @@ class ServerTest {
 
 			route(api.users.create, context) {
 				val name = body.name
-				val newId = api.users.id.idOf(kotlin.random.Random.nextInt().toString())
+				val newId = api.users.id.idOf((nextId++).toString())
 				val new = User(newId, name, archived = false)
+				users += new
 				emitSuccessful(new.id, new)
 			}
 
@@ -105,12 +113,38 @@ class ServerTest {
 
 		log.info { "Step 1: query the initial users (empty list)" }
 
-		val params = User.SearchParams().apply { includeArchived = true }
-		val results = client.request(api.users.get, api.users.get.idOf(), Unit, params, Unit)
-			.onEach { log.debug(it) { "Received event for" } }
-			.firstResultOrThrow()
+		run {
+			val params = User.SearchParams().apply { includeArchived = true }
+			val results = client.request(api.users.get, api.users.get.idOf(), Unit, params, Unit)
+				.onEach { log.debug(it) { "Received event for" } }
+				.firstResultOrThrow()
+
+			assertEquals(emptyList(), results)
+		}
+
+		log.info { "Step 2: creating two users" }
+
+		run {
+			val first =
+				client.request(api.users.create, api.users.create.idOf(), User.New("first"), Parameters.Empty, Unit)
+					.onEach { log.debug(it) { "Received event for" } }
+					.firstResultOrThrow()
 
-		assertEquals(emptyList(), results)
+			val second =
+				client.request(api.users.create, api.users.create.idOf(), User.New("second"), Parameters.Empty, Unit)
+					.onEach { log.debug(it) { "Received event for" } }
+					.firstResultOrThrow()
+
+			assertEquals(User(Id("test", Route / "users" / "0"), "first", archived = false), first)
+			assertEquals(User(Id("test", Route / "users" / "1"), "second", archived = false), second)
+
+			val params = User.SearchParams().apply { includeArchived = true }
+			val results = client.request(api.users.get, api.users.get.idOf(), Unit, params, Unit)
+				.onEach { log.debug(it) { "Received event for" } }
+				.firstResultOrThrow()
+
+			assertEquals(listOf(first.id, second.id), results)
+		}
 
 		//endregion
 	}
-- 
2.51.2