sqlite-wasm 0.1.0

running 25 tests
test src/modules/core/database.rs - modules::core::database (line 32) ... FAILED
test src/lib.rs - autostart (line 87) ... FAILED
test src/modules/core/bindings.rs - modules::core::bindings (line 43) ... FAILED
test src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_open (line 103) ... FAILED
test src/modules.rs - modules (line 19) ... FAILED
test src/modules/core/database.rs - modules::core::database::close (line 154) ... FAILED
test src/modules/core.rs - modules::core (line 51) ... FAILED
test src/lib.rs - _::__wasm_bindgen_generated_autostart (line 87) ... FAILED
test src/modules/core/bindings.rs - modules::core::bindings::WasmApi (line 74) ... FAILED
test src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_exec (line 196) ... FAILED
test src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_close (line 154) ... FAILED
test src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_is_open (line 316) ... FAILED
test src/modules/core/database.rs - modules::core::database::exec (line 196) ... FAILED
test src/lib.rs - (line 29) ... FAILED
test src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_query (line 265) ... FAILED
test src/modules/core/database.rs - modules::core::database::is_open (line 316) ... FAILED
test src/modules.rs - modules (line 25) ... ok
test src/modules/core/database.rs - modules::core::database::open (line 103) ... FAILED
test src/modules/core/worker.rs - modules::core::worker::initialize_worker (line 93) ... FAILED
test src/modules/core/worker.rs - modules::core::worker::_::__wasm_bindgen_generated_initialize_worker (line 93) ... FAILED
test src/modules/core/worker.rs - modules::core::worker::_::__wasm_bindgen_generated_wait_for_worker (line 180) ... FAILED
test src/modules/core/worker.rs - modules::core::worker (line 36) ... FAILED
test src/modules/core/worker.rs - modules::core::worker::w_msg (line 237) ... FAILED
test src/modules/core/worker.rs - modules::core::worker::wait_for_worker (line 180) ... FAILED
test src/modules/core/database.rs - modules::core::database::query (line 265) ... FAILED

failures:

---- src/modules/core/database.rs - modules::core::database (line 32) stdout ----
error[E0433]: failed to resolve: could not find `core` in `sqlite_wasm`
 --> src/modules/core/database.rs:34:18
  |
5 | use sqlite_wasm::core::database::{open, exec, query, close};
  |                  ^^^^ could not find `core` in `sqlite_wasm`

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:37:22
  |
4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_32_0() {
  |                                      ---------------------------------------------------- this is not `async`
...
8 | open("mydb.sqlite3").await?;
  |                      ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:40:60
   |
 4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_32_0() {
   |                                      ---------------------------------------------------- this is not `async`
...
11 | exec("CREATE TABLE users (id INTEGER, name TEXT)", vec![]).await?;
   |                                                            ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:43:73
   |
 4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_32_0() {
   |                                      ---------------------------------------------------- this is not `async`
...
14 | exec("INSERT INTO users VALUES (?, ?)", vec![1.into(), "Alice".into()]).await?;
   |                                                                         ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:46:51
   |
 4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_32_0() {
   |                                      ---------------------------------------------------- this is not `async`
...
17 | let result = query("SELECT * FROM users", vec![]).await?;
   |                                                   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:49:9
   |
 4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_32_0() {
   |                                      ---------------------------------------------------- this is not `async`
...
20 | close().await?;
   |         ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 6 previous errors

Some errors have detailed explanations: E0433, E0728.
For more information about an error, try `rustc --explain E0433`.
Couldn't compile the test.
---- src/lib.rs - autostart (line 87) stdout ----
error[E0425]: cannot find function `autostart` in this scope
 --> src/lib.rs:89:10
  |
4 | let db = autostart("/sqlite.org/sqlite3-worker1.js").await?;
  |          ^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::autostart;
  |

error[E0425]: cannot find function `open` in this scope
 --> src/lib.rs:92:1
  |
7 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/lib.rs:89:54
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_lib_rs_87_0() {
  |                                      ---------------------------------- this is not `async`
3 | // Rust usage - initialize worker
4 | let db = autostart("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                      ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/lib.rs:92:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_lib_rs_87_0() {
  |                                      ---------------------------------- this is not `async`
...
7 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/lib.rs:95:52
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_lib_rs_87_0() {
   |                                      ---------------------------------- this is not `async`
...
10 | db.exec("CREATE TABLE users (id INTEGER)", vec![]).await?;
   |                                                    ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 5 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/bindings.rs - modules::core::bindings (line 43) stdout ----
error[E0425]: cannot find function `get_api` in this scope
 --> src/modules/core/bindings.rs:45:11
  |
4 | let api = get_api();
  |           ^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::modules::core::bindings::get_api;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/bindings.rs:46:66
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_bindings_rs_43_0() {
  |                                      ---------------------------------------------------- this is not `async`
...
5 | let result = api.exec("CREATE TABLE users (id INTEGER)", vec![]).await?;
  |                                                                  ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_open (line 103) stdout ----
error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:105:1
  |
4 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:108:1
  |
7 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:105:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_103_1() {
  |                                      ----------------------------------------------------- this is not `async`
3 | // Simple open
4 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:108:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_103_1() {
  |                                      ----------------------------------------------------- this is not `async`
...
7 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 4 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules.rs - modules (line 19) stdout ----
error[E0433]: failed to resolve: unresolved import
 --> src/modules.rs:20:12
  |
3 | use crate::modules::core::{worker, database, bindings};
  |            ^^^^^^^
  |            |
  |            unresolved import
  |            help: a similar path exists: `sqlite_wasm::modules`

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0433`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::close (line 154) stdout ----
error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:155:1
  |
3 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0425]: cannot find function `close` in this scope
 --> src/modules/core/database.rs:157:1
  |
5 | close().await?;
  | ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::close;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:155:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_154_0() {
  |                                      ----------------------------------------------------- this is not `async`
3 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:157:9
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_154_0() {
  |                                      ----------------------------------------------------- this is not `async`
...
5 | close().await?;
  |         ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 4 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core.rs - modules::core (line 51) stdout ----
error[E0433]: failed to resolve: unresolved import
 --> src/modules/core.rs:52:12
  |
3 | use crate::modules::core::{worker, database, bindings};
  |            ^^^^^^^
  |            |
  |            unresolved import
  |            help: a similar path exists: `sqlite_wasm::modules`

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core.rs:55:41
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_rs_51_0() {
  |                                      ------------------------------------------- this is not `async`
...
6 | worker::initialize_worker("/worker.js").await?;
  |                                         ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core.rs:56:27
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_rs_51_0() {
  |                                      ------------------------------------------- this is not `async`
...
7 | worker::wait_for_worker().await?;
  |                           ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core.rs:59:28
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_rs_51_0() {
   |                                      ------------------------------------------- this is not `async`
...
10 | database::open("myapp.db").await?;
   |                            ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core.rs:60:61
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_rs_51_0() {
   |                                      ------------------------------------------- this is not `async`
...
11 | let result = database::query("SELECT * FROM users", vec![]).await?;
   |                                                             ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 5 previous errors

Some errors have detailed explanations: E0433, E0728.
For more information about an error, try `rustc --explain E0433`.
Couldn't compile the test.
---- src/lib.rs - _::__wasm_bindgen_generated_autostart (line 87) stdout ----
error[E0425]: cannot find function `autostart` in this scope
 --> src/lib.rs:89:10
  |
4 | let db = autostart("/sqlite.org/sqlite3-worker1.js").await?;
  |          ^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::autostart;
  |

error[E0425]: cannot find function `open` in this scope
 --> src/lib.rs:92:1
  |
7 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/lib.rs:89:54
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_lib_rs_87_1() {
  |                                      ---------------------------------- this is not `async`
3 | // Rust usage - initialize worker
4 | let db = autostart("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                      ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/lib.rs:92:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_lib_rs_87_1() {
  |                                      ---------------------------------- this is not `async`
...
7 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/lib.rs:95:52
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_lib_rs_87_1() {
   |                                      ---------------------------------- this is not `async`
...
10 | db.exec("CREATE TABLE users (id INTEGER)", vec![]).await?;
   |                                                    ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 5 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/bindings.rs - modules::core::bindings::WasmApi (line 74) stdout ----
error[E0425]: cannot find function `get_api` in this scope
 --> src/modules/core/bindings.rs:75:11
  |
3 | let api = get_api();
  |           ^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::modules::core::bindings::get_api;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/bindings.rs:76:71
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_bindings_rs_74_0() {
  |                                      ---------------------------------------------------- this is not `async`
3 | let api = get_api();
4 | api.exec("INSERT INTO users (name) VALUES (?)", vec!["Alice".into()]).await?;
  |                                                                       ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/bindings.rs:77:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_bindings_rs_74_0() {
  |                                      ---------------------------------------------------- this is not `async`
...
5 | let rows = api.query("SELECT * FROM users", vec![]).await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 3 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_exec (line 196) stdout ----
error[E0425]: cannot find function `exec` in this scope
 --> src/modules/core/database.rs:198:1
  |
4 | exec("CREATE TABLE users (id INTEGER, name TEXT)", vec![]).await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::exec;
  |

error[E0425]: cannot find function `exec` in this scope
 --> src/modules/core/database.rs:201:1
  |
7 | exec(
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::exec;
  |

error[E0425]: cannot find function `exec` in this scope
  --> src/modules/core/database.rs:207:1
   |
13 | exec(
   | ^^^^ not found in this scope
   |
help: consider importing this function
   |
 2 + use sqlite_wasm::exec;
   |

error[E0425]: cannot find function `exec` in this scope
  --> src/modules/core/database.rs:213:1
   |
19 | exec("DELETE FROM users WHERE id = ?", vec![1.into()]).await?;
   | ^^^^ not found in this scope
   |
help: consider importing this function
   |
 2 + use sqlite_wasm::exec;
   |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:198:60
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_1() {
  |                                      ----------------------------------------------------- this is not `async`
3 | // Create table
4 | exec("CREATE TABLE users (id INTEGER, name TEXT)", vec![]).await?;
  |                                                            ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:204:3
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_1() {
   |                                      ----------------------------------------------------- this is not `async`
...
10 | ).await?;
   |   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:210:3
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_1() {
   |                                      ----------------------------------------------------- this is not `async`
...
16 | ).await?;
   |   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:213:56
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_1() {
   |                                      ----------------------------------------------------- this is not `async`
...
19 | exec("DELETE FROM users WHERE id = ?", vec![1.into()]).await?;
   |                                                        ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 8 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_close (line 154) stdout ----
error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:155:1
  |
3 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0425]: cannot find function `close` in this scope
 --> src/modules/core/database.rs:157:1
  |
5 | close().await?;
  | ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::close;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:155:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_154_1() {
  |                                      ----------------------------------------------------- this is not `async`
3 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:157:9
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_154_1() {
  |                                      ----------------------------------------------------- this is not `async`
...
5 | close().await?;
  |         ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 4 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_is_open (line 316) stdout ----
error[E0425]: cannot find function `is_open` in this scope
 --> src/modules/core/database.rs:317:4
  |
3 | if is_open() {
  |    ^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::is_open;
  |

error[E0425]: cannot find function `query` in this scope
 --> src/modules/core/database.rs:319:18
  |
5 |     let result = query("SELECT * FROM users", vec![]).await?;
  |                  ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::query;
  |

error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:321:5
  |
7 |     open("app.sqlite3").await?;
  |     ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:319:55
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_316_1() {
  |                                      ----------------------------------------------------- this is not `async`
...
5 |     let result = query("SELECT * FROM users", vec![]).await?;
  |                                                       ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:321:25
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_316_1() {
  |                                      ----------------------------------------------------- this is not `async`
...
7 |     open("app.sqlite3").await?;
  |                         ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 5 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::exec (line 196) stdout ----
error[E0425]: cannot find function `exec` in this scope
 --> src/modules/core/database.rs:198:1
  |
4 | exec("CREATE TABLE users (id INTEGER, name TEXT)", vec![]).await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::exec;
  |

error[E0425]: cannot find function `exec` in this scope
 --> src/modules/core/database.rs:201:1
  |
7 | exec(
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::exec;
  |

error[E0425]: cannot find function `exec` in this scope
  --> src/modules/core/database.rs:207:1
   |
13 | exec(
   | ^^^^ not found in this scope
   |
help: consider importing this function
   |
 2 + use sqlite_wasm::exec;
   |

error[E0425]: cannot find function `exec` in this scope
  --> src/modules/core/database.rs:213:1
   |
19 | exec("DELETE FROM users WHERE id = ?", vec![1.into()]).await?;
   | ^^^^ not found in this scope
   |
help: consider importing this function
   |
 2 + use sqlite_wasm::exec;
   |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:198:60
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_0() {
  |                                      ----------------------------------------------------- this is not `async`
3 | // Create table
4 | exec("CREATE TABLE users (id INTEGER, name TEXT)", vec![]).await?;
  |                                                            ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:204:3
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_0() {
   |                                      ----------------------------------------------------- this is not `async`
...
10 | ).await?;
   |   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:210:3
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_0() {
   |                                      ----------------------------------------------------- this is not `async`
...
16 | ).await?;
   |   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:213:56
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_196_0() {
   |                                      ----------------------------------------------------- this is not `async`
...
19 | exec("DELETE FROM users WHERE id = ?", vec![1.into()]).await?;
   |                                                        ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 8 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/lib.rs - (line 29) stdout ----
error: cannot find attribute `wasm_bindgen` in this scope
 --> src/lib.rs:33:3
  |
6 | #[wasm_bindgen]
  |   ^^^^^^^^^^^^
  |
  = note: `wasm_bindgen` is in scope, but it is a crate, not an attribute
help: `wasm_bindgen` is an attribute that can be used by the derive macro `BindgenedStruct`, you might be missing a `derive` attribute
  |
7 + #[derive(BindgenedStruct)]
8 | pub async fn main() -> Result<(), JsValue> {
  |
help: consider importing this attribute macro
  |
4 + use wasm_bindgen::prelude::wasm_bindgen;
  |

error[E0412]: cannot find type `JsValue` in this scope
 --> src/lib.rs:34:35
  |
7 | pub async fn main() -> Result<(), JsValue> {
  |                                   ^^^^^^^ not found in this scope
  |
help: consider importing this struct
  |
4 + use wasm_bindgen::JsValue;
  |

error[E0752]: `main` function is not allowed to be `async`
 --> src/lib.rs:34:1
  |
7 | pub async fn main() -> Result<(), JsValue> {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `main` function is not allowed to be `async`

error: aborting due to 3 previous errors

Some errors have detailed explanations: E0412, E0752.
For more information about an error, try `rustc --explain E0412`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_query (line 265) stdout ----
error[E0425]: cannot find function `query` in this scope
 --> src/modules/core/database.rs:267:14
  |
4 | let result = query("SELECT * FROM users", vec![]).await?;
  |              ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::query;
  |

error[E0425]: cannot find function `query` in this scope
 --> src/modules/core/database.rs:270:14
  |
7 | let result = query(
  |              ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::query;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:267:51
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_1() {
  |                                      ----------------------------------------------------- this is not `async`
3 | // Simple query
4 | let result = query("SELECT * FROM users", vec![]).await?;
  |                                                   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:273:3
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_1() {
   |                                      ----------------------------------------------------- this is not `async`
...
10 | ).await?;
   |   ^^^^^ only allowed inside `async` functions and blocks

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src/modules/core/database.rs:279:58
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_1() {
   |                                      ----------------------------------------------------- this function should return `Result` or `Option` to accept `?`
...
16 |         let id = js_sys::Reflect::get(&row, &"id".into())?;
   |                                                          ^ cannot use the `?` operator in a function that returns `()`
   |
help: consider adding return type
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_1() -> Result<(), Box<dyn std::error::Error>> {
   |                                                                                            +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src/modules/core/database.rs:280:62
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_1() {
   |                                      ----------------------------------------------------- this function should return `Result` or `Option` to accept `?`
...
17 |         let name = js_sys::Reflect::get(&row, &"name".into())?;
   |                                                              ^ cannot use the `?` operator in a function that returns `()`
   |
help: consider adding return type
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_1() -> Result<(), Box<dyn std::error::Error>> {
   |                                                                                            +++++++++++++++++++++++++++++++++++++++++

error: aborting due to 6 previous errors

Some errors have detailed explanations: E0277, E0425, E0728.
For more information about an error, try `rustc --explain E0277`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::is_open (line 316) stdout ----
error[E0425]: cannot find function `is_open` in this scope
 --> src/modules/core/database.rs:317:4
  |
3 | if is_open() {
  |    ^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::is_open;
  |

error[E0425]: cannot find function `query` in this scope
 --> src/modules/core/database.rs:319:18
  |
5 |     let result = query("SELECT * FROM users", vec![]).await?;
  |                  ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::query;
  |

error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:321:5
  |
7 |     open("app.sqlite3").await?;
  |     ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:319:55
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_316_0() {
  |                                      ----------------------------------------------------- this is not `async`
...
5 |     let result = query("SELECT * FROM users", vec![]).await?;
  |                                                       ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:321:25
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_316_0() {
  |                                      ----------------------------------------------------- this is not `async`
...
7 |     open("app.sqlite3").await?;
  |                         ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 5 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::open (line 103) stdout ----
error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:105:1
  |
4 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0425]: cannot find function `open` in this scope
 --> src/modules/core/database.rs:108:1
  |
7 | open("app.sqlite3").await?;
  | ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::open;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:105:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_103_0() {
  |                                      ----------------------------------------------------- this is not `async`
3 | // Simple open
4 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:108:21
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_103_0() {
  |                                      ----------------------------------------------------- this is not `async`
...
7 | open("app.sqlite3").await?;
  |                     ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 4 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/worker.rs - modules::core::worker::initialize_worker (line 93) stdout ----
error[E0425]: cannot find function `initialize_worker` in this scope
 --> src/modules/core/worker.rs:95:1
  |
4 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  | ^^^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::initialize_worker;
  |

error[E0425]: cannot find function `initialize_worker` in this scope
 --> src/modules/core/worker.rs:98:1
  |
7 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  | ^^^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::initialize_worker;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:95:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_93_0() {
  |                                      -------------------------------------------------- this is not `async`
3 | // Basic initialization
4 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:98:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_93_0() {
  |                                      -------------------------------------------------- this is not `async`
...
7 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 4 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/worker.rs - modules::core::worker::_::__wasm_bindgen_generated_initialize_worker (line 93) stdout ----
error[E0425]: cannot find function `initialize_worker` in this scope
 --> src/modules/core/worker.rs:95:1
  |
4 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  | ^^^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::initialize_worker;
  |

error[E0425]: cannot find function `initialize_worker` in this scope
 --> src/modules/core/worker.rs:98:1
  |
7 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  | ^^^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::initialize_worker;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:95:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_93_1() {
  |                                      -------------------------------------------------- this is not `async`
3 | // Basic initialization
4 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:98:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_93_1() {
  |                                      -------------------------------------------------- this is not `async`
...
7 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 4 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/worker.rs - modules::core::worker::_::__wasm_bindgen_generated_wait_for_worker (line 180) stdout ----
error[E0425]: cannot find function `initialize_worker` in this scope
 --> src/modules/core/worker.rs:181:1
  |
3 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  | ^^^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::initialize_worker;
  |

error[E0425]: cannot find function `wait_for_worker` in this scope
 --> src/modules/core/worker.rs:182:1
  |
4 | wait_for_worker().await?; // Waits efficiently
  | ^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::wait_for_worker;
  |

error[E0425]: cannot find function `w_msg` in this scope
 --> src/modules/core/worker.rs:185:1
  |
7 | w_msg("open".to_string(), args).await?;
  | ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::modules::core::worker::w_msg;
  |

error[E0425]: cannot find value `args` in this scope
 --> src/modules/core/worker.rs:185:27
  |
7 | w_msg("open".to_string(), args).await?;
  |                           ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use std::env::args;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:181:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_180_1() {
  |                                      --------------------------------------------------- this is not `async`
3 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:182:19
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_180_1() {
  |                                      --------------------------------------------------- this is not `async`
3 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
4 | wait_for_worker().await?; // Waits efficiently
  |                   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:185:33
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_180_1() {
  |                                      --------------------------------------------------- this is not `async`
...
7 | w_msg("open".to_string(), args).await?;
  |                                 ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 7 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/worker.rs - modules::core::worker (line 36) stdout ----
error[E0433]: failed to resolve: could not find `core` in `sqlite_wasm`
 --> src/modules/core/worker.rs:38:18
  |
5 | use sqlite_wasm::core::worker::{initialize_worker, wait_for_worker, w_msg};
  |                  ^^^^ could not find `core` in `sqlite_wasm`

error[E0425]: cannot find value `args` in this scope
  --> src/modules/core/worker.rs:47:42
   |
14 | let response = w_msg("open".to_string(), args).await?;
   |                                          ^^^^ not found in this scope
   |
help: consider importing this function
   |
 2 + use std::env::args;
   |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:41:53
  |
4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_36_0() {
  |                                      -------------------------------------------------- this is not `async`
...
8 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/worker.rs:44:19
   |
 4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_36_0() {
   |                                      -------------------------------------------------- this is not `async`
...
11 | wait_for_worker().await?;
   |                   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/worker.rs:47:48
   |
 4 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_36_0() {
   |                                      -------------------------------------------------- this is not `async`
...
14 | let response = w_msg("open".to_string(), args).await?;
   |                                                ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 5 previous errors

Some errors have detailed explanations: E0425, E0433, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/worker.rs - modules::core::worker::w_msg (line 237) stdout ----
error: cannot find macro `object` in this scope
 --> src/modules/core/worker.rs:239:17
  |
4 | let open_args = object!({ filename: "mydb.sqlite3", vfs: "opfs" });
  |                 ^^^^^^

error: cannot find macro `object` in this scope
 --> src/modules/core/worker.rs:243:18
  |
8 | let query_args = object!({ sql: "SELECT * FROM users" });
  |                  ^^^^^^

error[E0425]: cannot find function `w_msg` in this scope
 --> src/modules/core/worker.rs:240:16
  |
5 | let response = w_msg("open".to_string(), open_args).await?;
  |                ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::modules::core::worker::w_msg;
  |

error[E0425]: cannot find function `w_msg` in this scope
 --> src/modules/core/worker.rs:244:12
  |
9 | let rows = w_msg("exec".to_string(), query_args).await?;
  |            ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::modules::core::worker::w_msg;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:240:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_237_0() {
  |                                      --------------------------------------------------- this is not `async`
...
5 | let response = w_msg("open".to_string(), open_args).await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:244:50
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_237_0() {
  |                                      --------------------------------------------------- this is not `async`
...
9 | let rows = w_msg("exec".to_string(), query_args).await?;
  |                                                  ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 6 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/worker.rs - modules::core::worker::wait_for_worker (line 180) stdout ----
error[E0425]: cannot find function `initialize_worker` in this scope
 --> src/modules/core/worker.rs:181:1
  |
3 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  | ^^^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::initialize_worker;
  |

error[E0425]: cannot find function `wait_for_worker` in this scope
 --> src/modules/core/worker.rs:182:1
  |
4 | wait_for_worker().await?; // Waits efficiently
  | ^^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::wait_for_worker;
  |

error[E0425]: cannot find function `w_msg` in this scope
 --> src/modules/core/worker.rs:185:1
  |
7 | w_msg("open".to_string(), args).await?;
  | ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::modules::core::worker::w_msg;
  |

error[E0425]: cannot find value `args` in this scope
 --> src/modules/core/worker.rs:185:27
  |
7 | w_msg("open".to_string(), args).await?;
  |                           ^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use std::env::args;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:181:53
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_180_0() {
  |                                      --------------------------------------------------- this is not `async`
3 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
  |                                                     ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:182:19
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_180_0() {
  |                                      --------------------------------------------------- this is not `async`
3 | initialize_worker("/sqlite.org/sqlite3-worker1.js").await?;
4 | wait_for_worker().await?; // Waits efficiently
  |                   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/worker.rs:185:33
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_worker_rs_180_0() {
  |                                      --------------------------------------------------- this is not `async`
...
7 | w_msg("open".to_string(), args).await?;
  |                                 ^^^^^ only allowed inside `async` functions and blocks

error: aborting due to 7 previous errors

Some errors have detailed explanations: E0425, E0728.
For more information about an error, try `rustc --explain E0425`.
Couldn't compile the test.
---- src/modules/core/database.rs - modules::core::database::query (line 265) stdout ----
error[E0425]: cannot find function `query` in this scope
 --> src/modules/core/database.rs:267:14
  |
4 | let result = query("SELECT * FROM users", vec![]).await?;
  |              ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::query;
  |

error[E0425]: cannot find function `query` in this scope
 --> src/modules/core/database.rs:270:14
  |
7 | let result = query(
  |              ^^^^^ not found in this scope
  |
help: consider importing this function
  |
2 + use sqlite_wasm::query;
  |

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/modules/core/database.rs:267:51
  |
2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_0() {
  |                                      ----------------------------------------------------- this is not `async`
3 | // Simple query
4 | let result = query("SELECT * FROM users", vec![]).await?;
  |                                                   ^^^^^ only allowed inside `async` functions and blocks

error[E0728]: `await` is only allowed inside `async` functions and blocks
  --> src/modules/core/database.rs:273:3
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_0() {
   |                                      ----------------------------------------------------- this is not `async`
...
10 | ).await?;
   |   ^^^^^ only allowed inside `async` functions and blocks

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src/modules/core/database.rs:279:58
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_0() {
   |                                      ----------------------------------------------------- this function should return `Result` or `Option` to accept `?`
...
16 |         let id = js_sys::Reflect::get(&row, &"id".into())?;
   |                                                          ^ cannot use the `?` operator in a function that returns `()`
   |
help: consider adding return type
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_0() -> Result<(), Box<dyn std::error::Error>> {
   |                                                                                            +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src/modules/core/database.rs:280:62
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_0() {
   |                                      ----------------------------------------------------- this function should return `Result` or `Option` to accept `?`
...
17 |         let name = js_sys::Reflect::get(&row, &"name".into())?;
   |                                                              ^ cannot use the `?` operator in a function that returns `()`
   |
help: consider adding return type
   |
 2 | fn main() { #[allow(non_snake_case)] fn _doctest_main_src_modules_core_database_rs_265_0() -> Result<(), Box<dyn std::error::Error>> {
   |                                                                                            +++++++++++++++++++++++++++++++++++++++++

error: aborting due to 6 previous errors

Some errors have detailed explanations: E0277, E0425, E0728.
For more information about an error, try `rustc --explain E0277`.
Couldn't compile the test.

failures:
    src/lib.rs - (line 29)
    src/lib.rs - _::__wasm_bindgen_generated_autostart (line 87)
    src/lib.rs - autostart (line 87)
    src/modules.rs - modules (line 19)
    src/modules/core.rs - modules::core (line 51)
    src/modules/core/bindings.rs - modules::core::bindings (line 43)
    src/modules/core/bindings.rs - modules::core::bindings::WasmApi (line 74)
    src/modules/core/database.rs - modules::core::database (line 32)
    src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_close (line 154)
    src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_exec (line 196)
    src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_is_open (line 316)
    src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_open (line 103)
    src/modules/core/database.rs - modules::core::database::_::__wasm_bindgen_generated_query (line 265)
    src/modules/core/database.rs - modules::core::database::close (line 154)
    src/modules/core/database.rs - modules::core::database::exec (line 196)
    src/modules/core/database.rs - modules::core::database::is_open (line 316)
    src/modules/core/database.rs - modules::core::database::open (line 103)
    src/modules/core/database.rs - modules::core::database::query (line 265)
    src/modules/core/worker.rs - modules::core::worker (line 36)
    src/modules/core/worker.rs - modules::core::worker::_::__wasm_bindgen_generated_initialize_worker (line 93)
    src/modules/core/worker.rs - modules::core::worker::_::__wasm_bindgen_generated_wait_for_worker (line 180)
    src/modules/core/worker.rs - modules::core::worker::initialize_worker (line 93)
    src/modules/core/worker.rs - modules::core::worker::w_msg (line 237)
    src/modules/core/worker.rs - modules::core::worker::wait_for_worker (line 180)

test result: FAILED. 1 passed; 24 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.17s

all doctests ran in 0.27s; merged doctests compilation took 0.10s