fix(host): finish typed catalog integration address

Author: fffonion

crates/rustscript/tests/lsp_resource_types.rs

@@ -538,6 +538,18 @@ fn signature_help_shows_borrow_resource_and_value_params() {
         label.contains("sql: string"),
         "signature must show the value parameter: {label}"
     );
+    assert!(
+        label.contains("params: array<SqliteValue>"),
+        "signature must show typed SQLite parameters: {label}"
+    );
+    assert!(
+        label.contains("limits: SqliteLimits"),
+        "signature must show typed SQLite limits: {label}"
+    );
+    assert!(
+        label.contains("-> SqliteQueryResult"),
+        "signature must show the typed SQLite query result: {label}"
+    );
 }
 
 // ---------------------------------------------------------------------------

docs/sqlite.md

@@ -16,6 +16,19 @@ The embedding policy controls the allowed database root, unsafe-SQL capability,
 ceilings. Configure that policy before opening a connection. Each operation is asynchronous;
 the VM resumes after the host operation completes.
 
+## Compiler and editor catalog boundary
+
+The typed SQLite catalog is a schema-only surface and does not construct a VM or link
+`rusqlite`. `sqlite_host_catalog` and the SQLite entries in `standard_host_catalog` remain
+available whenever the `runtime` feature is compiled, including builds without the `sqlite`
+feature. Catalog-aware compiler callers and the LSP use these declarations for named-struct
+field access and exact host signatures.
+
+The `sqlite` feature controls the executable SQLite module, generated SQLite namespace and
+callables, the `rusqlite` dependency, and SQLite registration exports. A runtime build without
+that feature can inspect the editor/compiler contract but has no SQLite implementation to bind;
+execution requires a build with `sqlite` enabled and the SQLite module registered.
+
 ## Open options (`SqliteOpenOptions`)
 
 ```rust

tests/typed_host_no_dynamic_contract_tests.rs

@@ -1,25 +1,26 @@
-#![cfg(all(
+use std::any::Any;
+use std::collections::BTreeSet;
+
+#[cfg(all(
+    feature = "runtime",
     feature = "http-client",
-    feature = "sqlite",
     not(target_family = "wasm")
 ))]
-
-use std::collections::BTreeSet;
-
-use vm::{
-    HostApiCatalog, HostStructField, HostTypeSchema, http_host_catalog, jit_host_catalog,
-    sqlite_host_catalog, standard_host_catalog,
-};
+use vm::http_host_catalog;
+#[cfg(all(feature = "runtime", not(target_arch = "wasm32")))]
+use vm::sqlite_host_catalog;
+#[cfg(feature = "runtime")]
+use vm::{HostApiCatalog, jit_host_catalog, standard_host_catalog};
+use vm::{HostStructField, HostTypeSchema};
 
 fn assert_no_public_dynamic_root(path: &str, schema: &HostTypeSchema) {
     fn visit(path: &str, schema: &HostTypeSchema, seen: &mut BTreeSet<String>) {
         match schema {
             HostTypeSchema::Map(_) | HostTypeSchema::Unknown => {
                 panic!("public host schema {path} exposes {schema:?}")
             }
-            HostTypeSchema::Array(inner) | HostTypeSchema::Optional(inner) => {
-                visit(path, inner, seen)
-            }
+            HostTypeSchema::Array(inner) => visit(&format!("{path}[]"), inner, seen),
+            HostTypeSchema::Optional(inner) => visit(&format!("{path}?"), inner, seen),
             HostTypeSchema::Named { name, fields } => {
                 if !seen.insert(name.clone()) {
                     return;
@@ -48,6 +49,88 @@ fn assert_no_public_dynamic_root(path: &str, schema: &HostTypeSchema) {
     visit(path, schema, &mut BTreeSet::new());
 }
 
+fn panic_text(payload: Box<dyn Any + Send>) -> String {
+    if let Some(message) = payload.downcast_ref::<String>() {
+        return message.clone();
+    }
+    if let Some(message) = payload.downcast_ref::<&str>() {
+        return (*message).to_string();
+    }
+    "non-string panic payload".to_string()
+}
+
+fn assert_rejects_dynamic_schema(
+    path: &str,
+    schema: HostTypeSchema,
+    expected_path: &str,
+    expected_kind: &str,
+) {
+    let payload = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        assert_no_public_dynamic_root(path, &schema);
+    }))
+    .expect_err("dynamic schema must be rejected");
+    let message = panic_text(payload);
+    assert!(
+        message.contains(expected_path),
+        "diagnostic should identify {expected_path}, got {message}"
+    );
+    assert!(
+        message.contains(expected_kind),
+        "diagnostic should identify {expected_kind}, got {message}"
+    );
+}
+
+type SchemaWrapper = fn(HostTypeSchema) -> HostTypeSchema;
+
+fn array_of(inner: HostTypeSchema) -> HostTypeSchema {
+    HostTypeSchema::Array(Box::new(inner))
+}
+
+fn optional_of(inner: HostTypeSchema) -> HostTypeSchema {
+    HostTypeSchema::Optional(Box::new(inner))
+}
+
+fn named_field_of(inner: HostTypeSchema) -> HostTypeSchema {
+    HostTypeSchema::named_struct("Envelope", vec![HostStructField::new("payload", inner)])
+}
+
+fn callable_param_of(inner: HostTypeSchema) -> HostTypeSchema {
+    HostTypeSchema::Callable {
+        params: vec![inner],
+        result: Box::new(HostTypeSchema::Int),
+    }
+}
+
+fn callable_result_of(inner: HostTypeSchema) -> HostTypeSchema {
+    HostTypeSchema::Callable {
+        params: vec![HostTypeSchema::Int],
+        result: Box::new(inner),
+    }
+}
+
+const NESTED_DYNAMIC_CASES: &[(&str, SchemaWrapper, &str)] = &[
+    ("array", array_of, "[]"),
+    ("optional", optional_of, "?"),
+    ("named field", named_field_of, ".Envelope.payload"),
+    ("callable param", callable_param_of, ".callback_param[0]"),
+    ("callable result", callable_result_of, ".callback_result"),
+];
+
+#[test]
+fn recursive_walker_rejects_nested_dynamic_schemas_with_paths() {
+    for (kind, dynamic) in [
+        ("Map", HostTypeSchema::Map(Box::new(HostTypeSchema::Int))),
+        ("Unknown", HostTypeSchema::Unknown),
+    ] {
+        for (case, wrap, suffix) in NESTED_DYNAMIC_CASES {
+            let root = format!("nested::{kind}::{case}");
+            let expected_path = format!("{root}{suffix}");
+            assert_rejects_dynamic_schema(&root, wrap(dynamic.clone()), &expected_path, kind);
+        }
+    }
+}
+
+#[cfg(feature = "runtime")]
 fn assert_no_public_dynamic_schema(catalog_name: &str, catalog: &HostApiCatalog) {
     for schema in catalog.structs() {
         for field in &schema.fields {
@@ -92,10 +175,51 @@ fn recursive_named_struct_walk_stops_at_repeated_named_type() {
     assert_no_public_dynamic_root("recursive::node", &recursive_named_schema());
 }
 
+#[cfg(feature = "runtime")]
 #[test]
 fn affected_public_host_catalogs_have_no_reachable_map_or_unknown() {
-    assert_no_public_dynamic_schema("http", &http_host_catalog());
-    assert_no_public_dynamic_schema("sqlite", &sqlite_host_catalog());
     assert_no_public_dynamic_schema("jit", &jit_host_catalog());
     assert_no_public_dynamic_schema("standard", &standard_host_catalog());
+    #[cfg(all(feature = "http-client", not(target_family = "wasm")))]
+    assert_no_public_dynamic_schema("http", &http_host_catalog());
+    #[cfg(all(feature = "sqlite", not(target_arch = "wasm32")))]
+    assert_no_public_dynamic_schema("sqlite", &sqlite_host_catalog());
+}
+
+#[cfg(all(feature = "runtime", not(feature = "sqlite")))]
+#[test]
+fn standard_catalog_keeps_sqlite_editor_schema_without_sqlite_runtime() {
+    let sqlite = sqlite_host_catalog();
+    assert!(
+        sqlite.function("sqlite::query").is_some(),
+        "the standalone editor/compiler catalog must retain SQLite declarations"
+    );
+    let query = sqlite
+        .function("sqlite::query")
+        .expect("SQLite query declaration");
+    let value = sqlite
+        .struct_named("SqliteValue")
+        .expect("SQLite value named struct");
+    assert_eq!(
+        query.params[2].ty,
+        HostTypeSchema::Array(Box::new(value.as_type())),
+        "SQLite query params must stay typed without the runtime feature"
+    );
+    assert_no_public_dynamic_schema("sqlite", &sqlite);
+
+    let catalog = standard_host_catalog();
+    assert!(
+        catalog.function("sqlite::open").is_some(),
+        "the editor/compiler catalog must retain SQLite schema declarations"
+    );
+    assert!(
+        catalog.struct_named("SqliteOpenOptions").is_some(),
+        "the editor/compiler catalog must retain SQLite named structs"
+    );
+    assert!(
+        vm::default_host_callables()
+            .iter()
+            .all(|callable| !callable.name.starts_with("sqlite::")),
+        "the executable default host surface must remain feature-gated"
+    );
 }