@kromatv/sdk 0.1.40-canary.2 → 0.1.40-canary.3

package/dist/cli.js

@@ -23829,7 +23829,7 @@ async function serverPlatform(server) {
   const res = await fetch(`${server.url}/api/admin/store/platform`, {
     headers: { authorization: `Bearer ${server.token}` }
   });
-  if (res.status === 404)
+  if (UNANSWERED.has(res.status))
     return null;
   if (!res.ok)
     throw new Error(`${server.url}: GET /api/admin/store/platform failed (${res.status})`);
@@ -23859,11 +23859,12 @@ async function uploadBundle(server, path) {
     throw new Error(`install failed (${res.status}): ${body}`);
   return body;
 }
-var DEFAULT_SERVER = "http://localhost:4040", Platform;
+var DEFAULT_SERVER = "http://localhost:4040", Platform, UNANSWERED;
 var init_server = __esm(() => {
   init_zod();
   init_config();
   Platform = exports_external.object({ target: exports_external.string(), serverVersion: exports_external.string() });
+  UNANSWERED = new Set([404, 405]);
 });
 
 // src/commands/build.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kromatv/sdk",
-  "version": "0.1.40-canary.2",
+  "version": "0.1.40-canary.3",
   "description": "Build KROMA modules: the SDK, the design system types, the Rust crates and the kroma CLI in one package.",
   "author": "Maxime Scharwath <maxscharwath@gmail.com>",
   "license": "GPL-2.0-or-later",

package/rust/Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
 resolver = "2"
-members = ["kroma-module-sdk", "kroma-module-runtime", "kroma-module-host", "kroma-module-manifest", "kroma-module-macros", "kroma-domain", "kroma-http", "kroma-db", "kroma-primitives", "kroma-testing"]
+members = ["kroma-module-sdk", "kroma-module-runtime", "kroma-module-host", "kroma-module-manifest", "kroma-module-macros", "kroma-module-wire", "kroma-sqlite", "kroma-http", "kroma-primitives", "kroma-testing"]

package/rust/kroma-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kroma-http"
-version = "0.1.40-canary.2"
+version = "0.1.40-canary.3"
 edition = "2021"
 rust-version = "1.88"
 description = "KROMA's two HTTP transports: a curl process per call for the outside world, and a pooled client for the loopback seam between the core and its module sidecars"

package/rust/kroma-module-host/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kroma-module-host"
-version = "0.1.40-canary.2"
+version = "0.1.40-canary.3"
 edition = "2021"
 rust-version = "1.88"
 description = "The host seam: the narrow HostCtx contract + shared HTTP extractors a module crate's backend needs, without depending on the whole app (kroma-engine)."
@@ -10,21 +10,21 @@ license = "MIT"
 # Compiles `testing::{StubHost, Recording}`, the shared HostCtx doubles. Off by
 # default so nothing reaches a release build; crates that test against the seam
 # turn it on in their dev-dependencies.
-testing = ["dep:kroma-testing", "storage", "test-serve"]
+testing = ["dep:kroma-testing", "storage", "test-serve", "kroma-sqlite/testing"]
 # `test_serve::{serve, blocking}` alone: an axum router on an ephemeral localhost
 # port. Separate from `testing` because a port contract's round-trip test needs
 # the wire and not a database.
 test-serve = []
 # The `storage` capability: `HostStorage`, the two pools, and the `query` helper.
 # Off by default, and that default is the point -- a module that declares no
-# storage must not link `kroma-db`, which is what drags the whole bundled SQLite
-# amalgamation (1.5 MB of machine code) into a sidecar that never opens a
-# database. Enabled through `kroma-module-sdk/storage` by the modules that do.
-storage = ["dep:kroma-db"]
+# storage must not link SQLite, whose bundled amalgamation is 1.5 MB of machine
+# code in a sidecar that never opens a database. Enabled through
+# `kroma-module-sdk/storage` by the modules that do.
+storage = ["dep:kroma-sqlite"]
 
 [dependencies]
-kroma-domain = { path = "../kroma-domain" }
-kroma-db = { path = "../kroma-db", optional = true }
+kroma-module-wire = { path = "../kroma-module-wire" }
+kroma-sqlite = { path = "../kroma-sqlite", optional = true }
 kroma-http = { path = "../kroma-http" }
 kroma-testing = { path = "../kroma-testing", optional = true }
 axum = { version = "0.8", features = ["macros", "ws"] }

package/rust/kroma-module-host/src/auth.rs

@@ -6,7 +6,7 @@ use axum::http::request::Parts;
 use axum::http::StatusCode;
 use axum::response::Response;
 
-use kroma_domain::User;
+use kroma_module_wire::User;
 
 use super::{json_error, HostCtx};
 

package/rust/kroma-module-host/src/host_ctx.rs

@@ -8,8 +8,9 @@ use std::sync::Arc;
 use axum::http::StatusCode;
 use axum::response::Response;
 
-use kroma_domain::metadata::{EpisodeInfo, MatchCandidate};
-use kroma_domain::{Audience, NotificationSpec, Permission, User};
+use kroma_module_wire::{
+    Audience, EpisodeInfo, MatchCandidate, NotificationSpec, Permission, User,
+};
 
 use super::{Contribution, Event, LibraryFolders};
 
@@ -180,7 +181,7 @@ mod tests {
 
     use super::*;
 
-    use kroma_domain::NotificationEvent;
+    use kroma_module_wire::NotificationEvent;
 
     use crate::testing;
 

package/rust/kroma-module-host/src/lib.rs

@@ -37,7 +37,7 @@ use axum::response::{IntoResponse, Response};
 use axum::Json;
 
 pub use async_trait::async_trait;
-pub use kroma_domain::{
+pub use kroma_module_wire::{
     ActionKind, ActionSpec, ActionStyle, Audience, NotificationCategory, NotificationEvent,
     NotificationSpec, PushCategory,
 };

package/rust/kroma-module-host/src/storage.rs

@@ -8,7 +8,7 @@
 //! declares no storage neither links SQLite nor can reach a row.
 
 use axum::response::Response;
-use kroma_db::Pool;
+use kroma_sqlite::Pool;
 
 use crate::{blocking, HostCtx};
 
@@ -56,7 +56,7 @@ mod tests {
 
     #[tokio::test]
     async fn query_hands_the_closure_its_own_pool() {
-        let pool = kroma_db::testing::temp_pool("host-query");
+        let pool = kroma_sqlite::testing::temp_pool("host-query");
         let n: Result<i64, Response> = query(&pool, |p| {
             let conn = p.get()?;
             let v: i64 = conn.query_row("SELECT 1 + 1", [], |r| r.get(0))?;

package/rust/kroma-module-host/src/testing/log.rs

@@ -4,7 +4,7 @@
 use std::collections::BTreeMap;
 use std::sync::Mutex;
 
-use kroma_domain::{Audience, NotificationSpec};
+use kroma_module_wire::{Audience, NotificationSpec};
 
 /// One thing that went onto the event bus: the addressee (`None` for a
 /// broadcast) and the event's topic.

package/rust/kroma-module-host/src/testing/mod.rs

@@ -20,8 +20,9 @@ pub use stub::StubHost;
 
 #[cfg(test)]
 mod fixtures {
-    use kroma_domain::metadata::{EpisodeInfo, MatchCandidate};
-    use kroma_domain::{NotificationEvent, NotificationSpec, User};
+    use kroma_module_wire::{
+        EpisodeInfo, MatchCandidate, NotificationEvent, NotificationSpec, User,
+    };
 
     pub fn candidate() -> MatchCandidate {
         MatchCandidate {

package/rust/kroma-module-host/src/testing/recording.rs

@@ -8,8 +8,8 @@ use std::sync::Arc;
 
 use axum::http::StatusCode;
 use axum::response::Response;
-use kroma_db::Pool;
-use kroma_domain::{Audience, NotificationSpec, Permission, User};
+use kroma_sqlite::Pool;
+use kroma_module_wire::{Audience, NotificationSpec, Permission, User};
 
 use super::log::{records_into_log, Log, Published};
 use crate::{Event, HostCtx, HostStorage, LibraryFolders};
@@ -114,7 +114,7 @@ impl<H: HostCtx> HostCtx for Recording<H> {
         query: &str,
         kind: &str,
         year: Option<u32>,
-    ) -> Vec<kroma_domain::metadata::MatchCandidate> {
+    ) -> Vec<kroma_module_wire::MatchCandidate> {
         self.inner.metadata_candidates(query, kind, year)
     }
 
@@ -122,7 +122,7 @@ impl<H: HostCtx> HostCtx for Recording<H> {
         &self,
         tmdb_id: u64,
         season: u32,
-    ) -> Vec<kroma_domain::metadata::EpisodeInfo> {
+    ) -> Vec<kroma_module_wire::EpisodeInfo> {
         self.inner.metadata_episodes(tmdb_id, season)
     }
     fn contributions(&self, point: &str) -> Vec<crate::Contribution> {
@@ -203,7 +203,7 @@ mod tests {
         host.db()
             .get()
             .unwrap()
-            .execute("SELECT 1 FROM users LIMIT 0", [])
+            .execute("CREATE TABLE seen (id TEXT PRIMARY KEY)", [])
             .unwrap();
     }
 }

package/rust/kroma-module-host/src/testing/stub.rs

@@ -8,9 +8,11 @@ use std::sync::{Arc, Mutex};
 
 use axum::http::StatusCode;
 use axum::response::Response;
-use kroma_db::Pool;
-use kroma_domain::metadata::{EpisodeInfo, MatchCandidate};
-use kroma_domain::{Audience, NotificationSpec, Permission, User};
+use kroma_sqlite::testing::TempPool;
+use kroma_sqlite::Pool;
+use kroma_module_wire::{
+    Audience, EpisodeInfo, MatchCandidate, NotificationSpec, Permission, User,
+};
 use kroma_testing::TempDir;
 
 use super::log::{records_into_log, Log, Published};
@@ -69,16 +71,18 @@ impl StubHost {
         Self::in_dir(kroma_testing::temp_dir("stub-host"))
     }
 
-    /// A host over a real, empty, migrated SQLite database inside this host's
-    /// own scratch directory, plus the module-private store beside it. `tag` only
-    /// shapes that directory's name, to make a stray one identifiable.
+    /// A host over a real, empty SQLite database inside this host's own scratch
+    /// directory, plus the module-private store beside it. Neither carries a
+    /// schema: a test that needs the core tables hands a migrated pool to
+    /// [`with_pool`](Self::with_pool). `tag` only shapes that directory's name,
+    /// to make a stray one identifiable.
     pub fn with_db(tag: &str) -> Self {
         let data_dir = kroma_testing::temp_dir(tag);
-        let db = kroma_db::init(&data_dir.path().join("kroma.db")).expect("init test db");
+        let db = kroma_sqlite::open(&data_dir.path().join("kroma.db")).expect("open test db");
         // `open`, like the real runtime: a module's own file carries no core
         // schema, only what its own migrations put there.
         let store =
-            kroma_db::open(&data_dir.path().join("module.sqlite")).expect("open test store");
+            kroma_sqlite::open(&data_dir.path().join("module.sqlite")).expect("open test store");
         Self {
             db: Some(db),
             store: Some(store),
@@ -106,29 +110,28 @@ impl StubHost {
         }
     }
 
-    /// A host over a pool the caller already built. For a module whose tests
-    /// need their OWN migrations applied on top of the core schema, which
-    /// [`with_db`](Self::with_db) does not know about.
-    pub fn with_pool(pool: Pool) -> Self {
-        let store = kroma_db::open(
-            &kroma_testing::temp_dir("stub-store")
-                .path()
-                .join("module.sqlite"),
-        )
-        .expect("open test store");
+    /// A host over a core database the caller built, with the module-private
+    /// store beside it. The core schema is not this crate's to know: a test that
+    /// needs it hands over `kroma_db::testing::temp_pool`, whose directory this
+    /// host then keeps for as long as it lives.
+    pub fn with_core(core: TempPool) -> Self {
+        let (db, data_dir) = core.into_parts();
+        let store =
+            kroma_sqlite::open(&data_dir.path().join("module.sqlite")).expect("open test store");
         Self {
-            db: Some(pool),
+            db: Some(db),
             store: Some(store),
-            ..Self::new()
+            ..Self::in_dir(data_dir)
         }
     }
 
-    /// A host whose MODULE store is `pool`, with a fresh core database beside it.
-    /// For a module testing its own tables: those live in its own file, so a test
-    /// that seeded them has to hand them over as the store and not as the core.
+    /// A host whose MODULE store is `pool`, with a fresh, empty core database
+    /// beside it. For a module testing its own tables: those live in its own file,
+    /// so a test that seeded them has to hand them over as the store and not as
+    /// the core.
     pub fn with_store(pool: Pool) -> Self {
         let data_dir = kroma_testing::temp_dir("stub-core");
-        let db = kroma_db::init(&data_dir.path().join("kroma.db")).expect("init test db");
+        let db = kroma_sqlite::open(&data_dir.path().join("kroma.db")).expect("open test db");
         Self {
             db: Some(db),
             store: Some(pool),
@@ -136,9 +139,8 @@ impl StubHost {
         }
     }
 
-    /// Answer `session_user(token)` with `user`. Without a seeded token the host
-    /// falls back to a real lookup against its core pool, so a test that created
-    /// a genuine session still authenticates through the seam.
+    /// Answer `session_user(token)` with `user`. A token nobody seeded is an
+    /// unknown session, the way the real host answers one.
     pub fn with_session(self, token: &str, user: User) -> Self {
         self.sessions
             .lock()
@@ -282,12 +284,7 @@ impl HostCtx for StubHost {
         self.data_dir.path()
     }
     fn session_user(&self, token: &str) -> Option<User> {
-        if let Some(u) = self.sessions.lock().unwrap().get(token) {
-            return Some(u.clone());
-        }
-        kroma_db::session_user(self.db.as_ref()?, token)
-            .ok()
-            .flatten()
+        self.sessions.lock().unwrap().get(token).cloned()
     }
     fn require(&self, _user: &User, _perm: Permission) -> Result<(), Response> {
         Ok(())
@@ -511,24 +508,19 @@ mod tests {
     }
 
     #[test]
-    fn with_db_hands_out_a_migrated_pool_and_never_the_same_file_twice() {
+    fn with_db_hands_out_a_writable_pool_and_never_the_same_file_twice() {
         let a = StubHost::with_db("selftest");
         let b = StubHost::with_db("selftest");
-        // Migrated: a core table is queryable.
-        a.db()
-            .get()
-            .unwrap()
-            .execute("SELECT 1 FROM users LIMIT 0", [])
-            .unwrap();
+        let ddl = "CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT NOT NULL)";
+        for host in [&a, &b] {
+            host.db().get().unwrap().execute(ddl, []).unwrap();
+        }
         // Separate: a row in one is not in the other. Two tests running in
         // parallel threads of one process must not share a database.
         a.db()
             .get()
             .unwrap()
-            .execute(
-                "INSERT INTO settings (key, value, updated_at) VALUES ('k', 'v', 'now')",
-                [],
-            )
+            .execute("INSERT INTO settings (key, value) VALUES ('k', 'v')", [])
             .unwrap();
         let n: i64 = b
             .db()

package/rust/kroma-module-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kroma-module-macros"
-version = "0.1.40-canary.2"
+version = "0.1.40-canary.3"
 edition = "2021"
 rust-version = "1.88"
 description = "Proc-macros for KROMA modules: embedded_module!() discovers a module's module.json + icon at compile time so the MODULE const is one line."

package/rust/kroma-module-manifest/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kroma-module-manifest"
-version = "0.1.40-canary.2"
+version = "0.1.40-canary.3"
 edition = "2021"
 rust-version = "1.88"
 description = "Low-level module manifest/registry/embedded types (below kroma-engine). Modules use the kroma-module-sdk facade; this is the shared manifest layer engine/kernel/wasm build on."

package/rust/kroma-module-runtime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kroma-module-runtime"
-version = "0.1.40-canary.2"
+version = "0.1.40-canary.3"
 edition = "2021"
 rust-version = "1.88"
 description = "The out-of-process module runtime: each module ships as its own native binary that opens the shared SQLite, serves its routes on a local port, and reaches the host over a small IPC. `serve(...)` is the whole main()."
@@ -8,9 +8,9 @@ license = "MIT"
 
 [features]
 # The `storage` capability: the module's own database plus the scoped core one.
-# Off by default -- a module that declares no storage must not link `kroma-db`,
-# and it is `kroma-db` that drags the bundled SQLite amalgamation into a sidecar.
-storage = ["dep:kroma-db", "kroma-module-host/storage"]
+# Off by default -- a module that declares no storage must not link SQLite, whose
+# bundled amalgamation is most of a sidecar's size.
+storage = ["dep:kroma-sqlite", "kroma-module-host/storage"]
 
 [dependencies]
 # The host contract the module code is written against (HostCtx / ServerModule /
@@ -20,9 +20,9 @@ kroma-module-host = { path = "../kroma-module-host" }
 # Only under `storage`: the module's own database, and the core one behind the
 # grant its manifest declared. WAL is multi-process, so both are opened here
 # rather than proxied.
-kroma-db = { path = "../kroma-db", optional = true }
+kroma-sqlite = { path = "../kroma-sqlite", optional = true }
 # User / Permission for local require() checks.
-kroma-domain = { path = "../kroma-domain" }
+kroma-module-wire = { path = "../kroma-module-wire" }
 kroma-http = { path = "../kroma-http" }
 axum = { version = "0.8", features = ["macros", "ws"] }
 tokio = { version = "1", features = ["full"] }

package/rust/kroma-module-runtime/src/lib.rs

@@ -15,7 +15,7 @@ use std::sync::{Arc, RwLock};
 
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
-use kroma_domain::{Permission, User};
+use kroma_module_wire::{Permission, User};
 use kroma_module_host::host_token::{require_host_token, HostToken};
 use kroma_module_host::{json_error, Event, HostCtx, ServerModule};
 
@@ -49,13 +49,13 @@ impl Env {
     /// Absent or unreadable is the empty grant: a pool that answers nothing,
     /// never an unscoped one.
     #[cfg(feature = "storage")]
-    fn grant(&self) -> kroma_db::Grant {
+    fn grant(&self) -> kroma_sqlite::Grant {
         let Ok(json) = std::env::var("KROMA_MODULE_GRANT") else {
-            return kroma_db::Grant::none();
+            return kroma_sqlite::Grant::none();
         };
         serde_json::from_str(&json).unwrap_or_else(|error| {
             tracing::error!(%error, "core sent a storage grant this build cannot read; denying all");
-            kroma_db::Grant::none()
+            kroma_sqlite::Grant::none()
         })
     }
 
@@ -82,9 +82,9 @@ struct Inner {
     module_id: String,
     data_dir: PathBuf,
     #[cfg(feature = "storage")]
-    store: kroma_db::Pool,
+    store: kroma_sqlite::Pool,
     #[cfg(feature = "storage")]
-    core: kroma_db::Pool,
+    core: kroma_sqlite::Pool,
     core_url: String,
     host_token: String,
     services: RwLock<HashMap<TypeId, Arc<dyn Any + Send + Sync>>>,
@@ -102,9 +102,9 @@ impl RemoteHost {
                 // `open`, not `init`: the module's own file has no core schema
                 // in it, only whatever its own `migrations()` create below.
                 #[cfg(feature = "storage")]
-                store: kroma_db::open(&env.store_path())?,
+                store: kroma_sqlite::open(&env.store_path())?,
                 #[cfg(feature = "storage")]
-                core: kroma_db::init_scoped(&env.db_path, &env.module_id, &env.grant())?,
+                core: kroma_sqlite::init_scoped(&env.db_path, &env.module_id, &env.grant())?,
                 core_url: env.core_url.clone(),
                 host_token: env.host_token.clone(),
                 services: RwLock::new(HashMap::new()),
@@ -143,11 +143,11 @@ impl RemoteHost {
 
 #[cfg(feature = "storage")]
 impl kroma_module_host::HostStorage for RemoteHost {
-    fn db(&self) -> &kroma_db::Pool {
+    fn db(&self) -> &kroma_sqlite::Pool {
         &self.inner.core
     }
 
-    fn store(&self) -> &kroma_db::Pool {
+    fn store(&self) -> &kroma_sqlite::Pool {
         &self.inner.store
     }
 }
@@ -319,12 +319,12 @@ impl HostCtx for RemoteHost {
         query: &str,
         kind: &str,
         year: Option<u32>,
-    ) -> Vec<kroma_domain::metadata::MatchCandidate> {
+    ) -> Vec<kroma_module_wire::MatchCandidate> {
         let mut call = self.callback().query("q", query).query("kind", kind);
         if let Some(year) = year {
             call = call.query("year", year.to_string());
         }
-        call.get_json::<Vec<kroma_domain::metadata::MatchCandidate>>(
+        call.get_json::<Vec<kroma_module_wire::MatchCandidate>>(
             &self.host_url("metadata-search"),
         )
         .unwrap_or_default()
@@ -334,11 +334,11 @@ impl HostCtx for RemoteHost {
         &self,
         tmdb_id: u64,
         season: u32,
-    ) -> Vec<kroma_domain::metadata::EpisodeInfo> {
+    ) -> Vec<kroma_module_wire::EpisodeInfo> {
         self.callback()
             .query("tmdbId", tmdb_id.to_string())
             .query("season", season.to_string())
-            .get_json::<Vec<kroma_domain::metadata::EpisodeInfo>>(&self.host_url("metadata-episodes"))
+            .get_json::<Vec<kroma_module_wire::EpisodeInfo>>(&self.host_url("metadata-episodes"))
             .unwrap_or_default()
     }
 
@@ -541,7 +541,7 @@ fn apply_module_migrations(
         let migrations = module.migrations();
         if !migrations.is_empty() {
             let conn = host.store().get()?;
-            kroma_db::apply_migrations(&conn, migrations)?;
+            kroma_sqlite::apply_migrations(&conn, migrations)?;
         }
     }
     Ok(())

package/rust/kroma-module-sdk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kroma-module-sdk"
-version = "0.1.40-canary.2"
+version = "0.1.40-canary.3"
 edition = "2021"
 rust-version = "1.88"
 description = "The KROMA module SDK: the single crate every server module depends on. Re-exports the manifest layer plus the engine/host/domain/http/db surface, so modules never depend on core crates directly."
@@ -13,12 +13,10 @@ kroma-module-manifest = { path = "../kroma-module-manifest" }
 kroma-module-macros = { path = "../kroma-module-macros" }
 # Host contract: ServerModule, HostCtx, service/port resolution, async_trait.
 kroma-module-host = { path = "../kroma-module-host" }
-# The application surface modules build against. Both are optional and both are
-# off by default: between them they are the whole core, and a sidecar that only
-# publishes an mDNS beacon has no business linking it.
-kroma-domain = { path = "../kroma-domain" }
+# What a sidecar links: the wire types, the HTTP client, the SQLite pool.
+kroma-module-wire = { path = "../kroma-module-wire" }
 kroma-http = { path = "../kroma-http" }
-kroma-db = { path = "../kroma-db", optional = true }
+kroma-sqlite = { path = "../kroma-sqlite", optional = true }
 kroma-primitives = { path = "../kroma-primitives" }
 # `testing::{TempDir, temp_dir}`, the scratch dir every module test writes in.
 kroma-testing = { path = "../kroma-testing", optional = true }
@@ -35,15 +33,11 @@ anyhow = { version = "1" }
 # Everything a module's tests reach: the `StubHost` double, `test_serve`, a
 # throwaway pool and a self-deleting scratch dir. Never `engine`: a round-trip
 # test must not link the whole core.
-testing = ["kroma-module-host/testing", "storage", "kroma-db/testing", "dep:kroma-testing"]
+testing = ["kroma-module-host/testing", "storage", "kroma-sqlite/testing", "dep:kroma-testing"]
 # The `storage` capability: `host::HostStorage` and the `db` facade. A module
 # enables it when its `module.json` declares `storage`, and only then does its
 # binary link SQLite -- which is 1.5 MB of the 3.3 MB a sidecar used to be.
-storage = ["dep:kroma-db", "kroma-module-host/storage"]
-# The `engine` facade (`engine::services`, `engine::model`): the core's own
-# business logic, for the two modules that orchestrate it. It pulls `kroma-db`
-# with it, because the services it exposes are written against the pool.
-
+storage = ["dep:kroma-sqlite", "kroma-module-host/storage"]
 
 [lints.rust]
-unexpected_cfgs = { level = "allow", check-cfg = ['cfg(feature, values("engine"))'] }
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(feature, values("core"))', 'cfg(feature, values("domain"))', 'cfg(feature, values("engine"))'] }

package/rust/kroma-module-sdk/src/lib.rs

@@ -1,7 +1,7 @@
 //! The KROMA module SDK: the ONE crate a server module depends on.
 //!
-//! A module must not depend on `kroma-engine`, `kroma-db`, `kroma-domain` or
-//! `kroma-http` directly. This facade re-exports the manifest layer at the crate
+//! A module must not depend on `kroma-engine`, `kroma-db`, `kroma-domain`,
+//! `kroma-sqlite`, `kroma-module-wire` or `kroma-http` directly. This facade re-exports the manifest layer at the crate
 //! root (`EmbeddedModule`, `ModuleManifest`, `Registry`, ...) and mirrors the
 //! host / engine / domain / http / db / primitives surface under submodules, so a
 //! module writes `kroma_module_sdk::engine::state::SharedState` instead of
@@ -36,9 +36,14 @@ pub mod engine {
     pub use kroma_engine::*;
 }
 
-/// Domain types: permissions and the shared DTOs.
+/// What the host and a module exchange: the session user and its permissions,
+/// notifications and their audience, metadata answers. Behind the `domain`
+/// feature, the whole of `kroma-domain` on top, for a first-party module that
+/// reads the core's own shapes.
 pub mod domain {
+    #[cfg(feature = "domain")]
     pub use kroma_domain::*;
+    pub use kroma_module_wire::*;
 }
 
 /// The outbound HTTP client (`Fetch`, `Response`).
@@ -46,12 +51,24 @@ pub mod http {
     pub use kroma_http::*;
 }
 
-/// Direct SQLite access. Behind the `storage` feature, which a module turns on
-/// when its `module.json` declares `storage`; the pools themselves come from
-/// `host::HostStorage`, not from here.
+/// Direct SQLite access: the pool, the grant and a module's own migrations.
+/// Behind the `storage` feature, which a module turns on when its `module.json`
+/// declares `storage`; the pools themselves come from `host::HostStorage`, not
+/// from here. Under `engine`, every query the core makes of its own database as
+/// well.
 #[cfg(feature = "storage")]
 pub mod db {
+    #[cfg(feature = "engine")]
     pub use kroma_db::*;
+    pub use kroma_sqlite::{
+        apply_migrations, init_scoped, open, open_with, Grant, Pool, PoolInner, PooledConn,
+    };
+    #[cfg(all(any(test, feature = "testing"), not(feature = "core")))]
+    pub use kroma_sqlite::testing;
+    /// `temp_pool` stamps the core schema, for a grant test that has to run
+    /// against the real tables rather than a copy of them.
+    #[cfg(all(any(test, feature = "testing"), feature = "core"))]
+    pub use kroma_db::testing;
 }
 
 /// Small shared primitives (`now_ms`, ...).

package/rust/kroma-module-wire/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "kroma-module-wire"
+version = "0.1.40-canary.3"
+edition = "2021"
+rust-version = "1.88"
+description = "The JSON a module and the host exchange: the session user, notifications and their audience, metadata answers. Serde only."
+license = "MIT"
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }