@tishlang/tish-format 3.10.4 → 3.10.11

package/crates/tish_eval/src/timers.rs

@@ -26,13 +26,38 @@ fn next_id() -> u64 {
     NEXT_ID.fetch_add(1, Ordering::SeqCst)
 }
 
+/// Maximum number of LIVE (registered, not-yet-fired) timers per worker thread. A program that keeps
+/// scheduling `setTimeout`/`setInterval` without them draining would otherwise grow the registry (and
+/// its retained callbacks + closed-over data) without bound (#384, ported to this twin by #699). Past
+/// the cap a new timer is dropped rather than registered. Override with `TISH_MAX_TIMERS`; default
+/// 100k — far above any real timer workload, low enough to bound memory.
+fn max_live_timers() -> usize {
+    // Read per call (timer registration is not a hot path, and the cap exists precisely to bound the
+    // pathological caller): keeps the limit overridable per test without a process-global cache.
+    std::env::var("TISH_MAX_TIMERS")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .filter(|&n| n > 0)
+        .unwrap_or(100_000)
+}
+
+#[cfg(test)]
+fn registry_len() -> usize {
+    REGISTRY.with(|r| r.borrow().len())
+}
+
 /// Register a one-shot timer. Returns immediately with timer id.
 #[allow(non_snake_case)]
 pub fn setTimeout(callback: Value, args: Vec<Value>, delay_ms: u64) -> u64 {
     let id = next_id();
     let due = Instant::now() + Duration::from_millis(delay_ms);
     REGISTRY.with(|r| {
-        r.borrow_mut().insert(
+        let mut reg = r.borrow_mut();
+        // #384: bound the live-timer count so a runaway scheduler can't grow the registry unbounded.
+        if reg.len() >= max_live_timers() {
+            return;
+        }
+        reg.insert(
             id,
             TimerEntry {
                 due,
@@ -51,7 +76,12 @@ pub fn setInterval(callback: Value, args: Vec<Value>, delay_ms: u64) -> u64 {
     let id = next_id();
     let due = Instant::now() + Duration::from_millis(delay_ms);
     REGISTRY.with(|r| {
-        r.borrow_mut().insert(
+        let mut reg = r.borrow_mut();
+        // #384: bound the live-timer count (see setTimeout).
+        if reg.len() >= max_live_timers() {
+            return;
+        }
+        reg.insert(
             id,
             TimerEntry {
                 due,
@@ -91,6 +121,10 @@ pub fn take_due_timers() -> Vec<(u64, Value, Vec<Value>, u64)> {
 }
 
 /// Re-register an interval timer (called after running its callback).
+///
+/// Deliberately uncapped, matching the tish_runtime twin: this re-inserts an entry the drain
+/// phase just removed, so it cannot grow the registry beyond what registration allowed, and
+/// capping it would silently kill a live interval whenever the registry sits at the cap.
 pub fn re_register_interval(id: u64, callback: Value, args: Vec<Value>, interval_ms: u64) {
     let due = Instant::now() + Duration::from_millis(interval_ms);
     REGISTRY.with(|r| {
@@ -118,3 +152,33 @@ pub fn next_due_instant() -> Option<Instant> {
         reg.values().map(|e| e.due).min()
     })
 }
+
+#[cfg(test)]
+mod timer_cap_tests_699 {
+    use super::*;
+
+    fn noop_callback() -> Value {
+        Value::Native(|_| Ok(Value::Null))
+    }
+
+    #[test]
+    fn registration_is_bounded_by_max_timers() {
+        // Each `#[test]` runs on its own thread, so REGISTRY (thread_local) starts empty here.
+        // One test (not one per entry point): TISH_MAX_TIMERS is process-global, and parallel
+        // tests mutating it would race.
+        std::env::set_var("TISH_MAX_TIMERS", "5");
+        for _ in 0..20 {
+            let _ = setTimeout(noop_callback(), Vec::new(), 10_000);
+        }
+        assert_eq!(
+            registry_len(),
+            5,
+            "live timers must be capped at TISH_MAX_TIMERS"
+        );
+        for _ in 0..20 {
+            let _ = setInterval(noop_callback(), Vec::new(), 10_000);
+        }
+        assert_eq!(registry_len(), 5, "setInterval must honor the same cap");
+        std::env::remove_var("TISH_MAX_TIMERS");
+    }
+}

package/crates/tish_ffi/src/lib.rs

@@ -43,8 +43,7 @@ pub const TISH_TAG_OTHER: i32 = 6;
 
 /// An `extern "C"` native function: receives a borrowed array of argument handles (owned by the
 /// host for the call) and returns a freshly-owned result handle (the host drops it).
-pub type TishNativeFn =
-    extern "C" fn(args: *const TishValueRef, argc: usize) -> TishValueRef;
+pub type TishNativeFn = extern "C" fn(args: *const TishValueRef, argc: usize) -> TishValueRef;
 
 /// One named export in a module's table.
 #[repr(C)]
@@ -304,6 +303,33 @@ pub fn wrap_native_fn(func: TishNativeFn) -> Value {
     })
 }
 
+/// Cached exports of one loaded module: name → C-ABI fn pointer. Fn pointers — unlike `Value`,
+/// whose containers may be `Rc` — are `Send + Sync`, so the process-global cache stores the raw
+/// export list and re-wraps it into fresh `Value::native`s per `load_module` call.
+#[cfg(not(target_arch = "wasm32"))]
+type CachedExports = Vec<(String, TishNativeFn)>;
+
+/// Process-global module cache keyed by RESOLVED path (#711): repeated loads of the same cdylib in
+/// one process (an embedder host running programs back to back) reuse the first dlopen mapping
+/// instead of leaking a freshly forgotten `Library` handle per call, and canonicalizing the key
+/// collapses distinct spellings of one path into one entry.
+#[cfg(not(target_arch = "wasm32"))]
+fn module_cache(
+) -> &'static std::sync::Mutex<std::collections::HashMap<std::path::PathBuf, CachedExports>> {
+    static LOADED_MODULES: std::sync::OnceLock<
+        std::sync::Mutex<std::collections::HashMap<std::path::PathBuf, CachedExports>>,
+    > = std::sync::OnceLock::new();
+    LOADED_MODULES.get_or_init(Default::default)
+}
+
+/// Number of distinct modules in the process-global cache. Test-only accessor (the integration
+/// loader test asserts a re-spelled path hits the cache instead of re-mapping).
+#[cfg(not(target_arch = "wasm32"))]
+#[doc(hidden)]
+pub fn loaded_module_count() -> usize {
+    module_cache().lock().unwrap().len()
+}
+
 /// Load a native C-ABI extension (`cdylib`) and return its exports as a name→`Value::native` map,
 /// ready for the interpreter's `with_modules` or the VM's `register_native_module`. The module
 /// must export `extern "C" fn tish_module_register() -> *const TishExportTable`.
@@ -311,12 +337,33 @@ pub fn wrap_native_fn(func: TishNativeFn) -> Value {
 /// The extension imports the host's `tish_value_*` accessors, so the host must export them at link
 /// time (`-rdynamic` / `-Wl,-export_dynamic`). The loaded library is intentionally leaked so the
 /// function pointers stay valid for the process — the load-once model (matches the JIT module).
+/// "Once" is enforced by [`module_cache`]: only the first load of a given resolved path maps the
+/// library; every later call re-wraps the cached export list (#711).
 #[cfg(not(target_arch = "wasm32"))]
 pub fn load_module(path: &str) -> Result<tishlang_core::ObjectMap, String> {
     use tishlang_core::ObjectMap;
+
+    fn wrap_exports(exports: &CachedExports) -> ObjectMap {
+        let mut map = ObjectMap::default();
+        for (name, func) in exports {
+            map.insert(name.as_str().into(), wrap_native_fn(*func));
+        }
+        map
+    }
+
+    // #711: key on the RESOLVED path so `./lib.dylib` and its absolute spelling share one entry.
+    // When canonicalize fails (e.g. a bare dyld/ld.so-searched name), the literal path is still a
+    // correct — merely less collapsing — key. Failed loads are never cached.
+    let key = std::fs::canonicalize(path).unwrap_or_else(|_| std::path::PathBuf::from(path));
+
+    if let Some(cached) = module_cache().lock().unwrap().get(&key) {
+        return Ok(wrap_exports(cached));
+    }
+
     // SAFETY: dlopen of a caller-supplied path; the export table is validated (null checks) and the
-    // function pointers are wrapped behind the marshaling shim.
-    unsafe {
+    // function pointers are wrapped behind the marshaling shim. The dlopen runs WITHOUT the cache
+    // lock held — it may execute arbitrary static initializers.
+    let exports: CachedExports = unsafe {
         let lib =
             libloading::Library::new(path).map_err(|e| format!("ffi: load {}: {}", path, e))?;
         let register: libloading::Symbol<unsafe extern "C" fn() -> *const TishExportTable> = lib
@@ -330,20 +377,29 @@ pub fn load_module(path: &str) -> Result<tishlang_core::ObjectMap, String> {
         if table.count > 0 && table.exports.is_null() {
             return Err(format!("ffi: {}: null export table", path));
         }
-        let exports = std::slice::from_raw_parts(table.exports, table.count);
-        let mut map = ObjectMap::default();
-        for exp in exports {
+        let raw = std::slice::from_raw_parts(table.exports, table.count);
+        let mut exports = CachedExports::with_capacity(raw.len());
+        for exp in raw {
             if exp.name.is_null() {
                 continue;
             }
             let name = CStr::from_ptr(exp.name)
                 .to_str()
                 .map_err(|_| format!("ffi: {}: non-UTF-8 export name", path))?;
-            map.insert(name.into(), wrap_native_fn(exp.func));
+            exports.push((name.to_owned(), exp.func));
         }
+        // Still deliberate: the cached fn pointers must outlive every wrapped value, and dlopened
+        // extensions are immortal by contract. The #711 fix is not re-leaking a fresh mapping per
+        // call, not making the first one reclaimable.
         std::mem::forget(lib); // keep symbols live for the process lifetime
-        Ok(map)
-    }
+        exports
+    };
+
+    // Re-check under the lock: a concurrent first load of the same path only bumps the OS dlopen
+    // refcount, and whichever insert wins becomes the canonical copy.
+    let mut cache = module_cache().lock().unwrap();
+    let entry = cache.entry(key).or_insert(exports);
+    Ok(wrap_exports(entry))
 }
 
 #[cfg(test)]
@@ -463,8 +519,14 @@ mod tests {
             tish_value_drop(b);
             // A module table referencing it type-checks (the `tish_module_register` shape).
             let name = CString::new("add").unwrap();
-            let exports = [TishExport { name: name.as_ptr(), func: add_fn }];
-            let table = TishExportTable { exports: exports.as_ptr(), count: 1 };
+            let exports = [TishExport {
+                name: name.as_ptr(),
+                func: add_fn,
+            }];
+            let table = TishExportTable {
+                exports: exports.as_ptr(),
+                count: 1,
+            };
             assert_eq!(table.count, 1);
         }
     }

package/crates/tish_ffi/tests/loader.rs

@@ -63,3 +63,38 @@ fn load_and_call_real_cdylib() {
         other => panic!("make_pair export = {other:?}"),
     }
 }
+
+// #711: repeated loads of one library — including under a distinct spelling of its path — must
+// hit the process-global cache rather than dlopen (and leak) a fresh mapping per call.
+#[test]
+fn repeated_loads_share_one_cache_entry() {
+    let lib = build_and_locate_fixture();
+    let first = tishlang_ffi::load_module(lib.to_str().unwrap())
+        .unwrap_or_else(|e| panic!("first load_module: {e}"));
+    let cached_modules = tishlang_ffi::loaded_module_count();
+
+    // Same file, different spelling: `<dir>/./<name>` canonicalizes to the same resolved path.
+    let respelled = lib
+        .parent()
+        .expect("fixture path has a parent")
+        .join(".")
+        .join(lib.file_name().expect("fixture path has a file name"));
+    let second = tishlang_ffi::load_module(respelled.to_str().unwrap())
+        .unwrap_or_else(|e| panic!("re-spelled load_module: {e}"));
+    assert_eq!(
+        tishlang_ffi::loaded_module_count(),
+        cached_modules,
+        "a re-spelled path of an already-loaded library must not add a cache entry"
+    );
+
+    // Exports wrapped from the cached copy still call through correctly.
+    for module in [&first, &second] {
+        match module.get("triple") {
+            Some(Value::Function(f)) => match f.call(&[Value::Number(7.0)]) {
+                Value::Number(n) => assert_eq!(n, 21.0),
+                other => panic!("triple(7) = {other:?}"),
+            },
+            other => panic!("triple export = {other:?}"),
+        }
+    }
+}

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "3.10.4"
+version = "3.10.11"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_lsp/src/main.rs

@@ -447,7 +447,10 @@ impl LanguageServer for Backend {
         // files so an externally edited declaration (`.d.tish`) or source file refreshes the
         // workspace-symbol index without a server restart (#161). The client only delivers these
         // events for globs the server registers; a `.tish` glob does NOT cover `.d.tish` (it has a
-        // compound extension), so both are registered explicitly.
+        // compound extension), so both are registered explicitly. Also watch the manifests that
+        // drive `cargo:` resolution — `tish.rustDependencies` lives in package.json, and a path
+        // dep resolves through its Cargo.toml/Cargo.lock — so a dependency edit can invalidate
+        // `cargo_src_cache` (#714); without these globs no event could ever reach it.
         let watchers = |glob: &str| FileSystemWatcher {
             glob_pattern: GlobPattern::String(glob.to_string()),
             kind: None, // create | change | delete
@@ -456,7 +459,13 @@ impl LanguageServer for Backend {
             id: "tish-watch-d-tish".to_string(),
             method: "workspace/didChangeWatchedFiles".to_string(),
             register_options: serde_json::to_value(DidChangeWatchedFilesRegistrationOptions {
-                watchers: vec![watchers("**/*.tish"), watchers("**/*.d.tish")],
+                watchers: vec![
+                    watchers("**/*.tish"),
+                    watchers("**/*.d.tish"),
+                    watchers("**/package.json"),
+                    watchers("**/Cargo.toml"),
+                    watchers("**/Cargo.lock"),
+                ],
             })
             .ok(),
         };
@@ -485,6 +494,10 @@ impl LanguageServer for Backend {
             let mut roots = self.roots.write().unwrap();
             apply_workspace_folder_changes(&mut roots, &params.event);
         }
+        // The cargo-crate-root cache goes with the old folder set (#714): `cargo:` resolution is
+        // root-relative, entries are cheap to recompute on the next goto-definition/hover, and
+        // clearing here mirrors how the folder change already re-scopes the symbol index.
+        self.cargo_src_cache.write().unwrap().clear();
         self.client
             .log_message(MessageType::INFO, "tish-lsp: workspace folders updated")
             .await;
@@ -510,6 +523,25 @@ impl LanguageServer for Backend {
                 }
             }
         }
+        // #714: a manifest change re-routes `cargo:` resolution — `tish.rustDependencies` lives in
+        // package.json, and a path dep resolves through its Cargo.toml/Cargo.lock — so drop the
+        // whole cargo-crate-root cache when any watched manifest changes. Whole-cache rather than
+        // per-root pruning: a path dep's manifest may live outside every project root, entries are
+        // a few hundred bytes, and they are recomputed per (human-rate) goto-definition/hover.
+        let manifest_changed = params.changes.iter().any(|change| {
+            change
+                .uri
+                .to_file_path()
+                .ok()
+                .and_then(|p| {
+                    p.file_name()
+                        .map(|f| f == "package.json" || f == "Cargo.toml" || f == "Cargo.lock")
+                })
+                .unwrap_or(false)
+        });
+        if manifest_changed {
+            self.cargo_src_cache.write().unwrap().clear();
+        }
         // Re-lint any OPEN buffer whose declarations may now have changed. A `.d.tish` supplies
         // ambient `declare` bindings other buffers depend on, so a change there can flip
         // unresolved-name diagnostics; recompute open docs against the new on-disk state.
@@ -2558,6 +2590,63 @@ mod jsonrpc_integration_tests {
         std::fs::remove_dir_all(&dir).ok();
     }
 
+    /// Seed `cargo_src_cache` the way a successful goto-definition would.
+    fn seed_cargo_src_cache(service: &LspService<Backend>) {
+        service.inner().cargo_src_cache.write().unwrap().insert(
+            (PathBuf::from("/proj"), "cargo:serde".to_string()),
+            PathBuf::from("/old/crate/root"),
+        );
+    }
+
+    fn cargo_src_cache_len(service: &LspService<Backend>) -> usize {
+        service.inner().cargo_src_cache.read().unwrap().len()
+    }
+
+    fn did_change_watched_files_request(uri: &str) -> Request {
+        Request::build("workspace/didChangeWatchedFiles")
+            .params(serde_json::json!({ "changes": [ { "uri": uri, "type": 2 } ] }))
+            .finish()
+    }
+
+    // #714: a workspace-folder change must drop the cargo-crate-root cache along with the roots
+    // rewrite — previously nothing ever invalidated it, so a stale crate root was served for the
+    // rest of the session.
+    #[tokio::test]
+    async fn workspace_folder_change_clears_cargo_src_cache() {
+        let mut service = new_service();
+        initialize(&mut service).await;
+        seed_cargo_src_cache(&service);
+
+        let dir = crate::test_fs::unique_temp_dir("cargocache");
+        let uri = Url::from_file_path(&dir).unwrap().to_string();
+        let _ = call(&mut service, did_change_workspace_folders(&[&uri], &[])).await;
+        assert_eq!(cargo_src_cache_len(&service), 0, "folder change must clear the cargo src cache");
+
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    // #714: a watched manifest change (package.json / Cargo.toml / Cargo.lock — the files that
+    // drive `cargo:` resolution) must drop the cargo-crate-root cache; a plain `.tish` change
+    // must leave it alone.
+    #[tokio::test]
+    async fn manifest_change_clears_cargo_src_cache() {
+        let mut service = new_service();
+        initialize(&mut service).await;
+
+        // A `.tish` event leaves the cargo cache untouched…
+        seed_cargo_src_cache(&service);
+        let _ = call(&mut service, did_change_watched_files_request("file:///proj/a.tish")).await;
+        assert_eq!(cargo_src_cache_len(&service), 1, "a .tish change must not clear the cargo src cache");
+
+        // …while any manifest event drops it.
+        for name in ["package.json", "Cargo.toml", "Cargo.lock"] {
+            seed_cargo_src_cache(&service);
+            let req = did_change_watched_files_request(&format!("file:///proj/{name}"));
+            let _ = call(&mut service, req).await;
+            assert_eq!(cargo_src_cache_len(&service), 0, "a {name} change must clear the cargo src cache");
+        }
+    }
+
     // #162 protocol edge cases the client is allowed to send: adding the same folder twice must not
     // change the result, and removing a folder that was never added must not evict a tracked root.
     #[tokio::test]

package/crates/tish_pg/src/lib.rs

@@ -10,6 +10,9 @@ use tishlang_runtime::VmRef;
 mod error;
 pub use error::{format_pg_error, format_tish_pg_error, Result, TishPgError};
 
+#[cfg(feature = "tish-bindings")]
+mod statement_registry;
+
 use deadpool_postgres::{Manager, Pool, Runtime};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Map, Value as JsonValue};
@@ -537,10 +540,15 @@ mod tish_sync {
     // worker threads each doing thousands of QPS, the prior `Mutex<Slab>`
     // serialised every query through one global lock; `RwLock` lets all
     // concurrent reads run lock-free against each other.
+    use crate::statement_registry::StatementRegistry;
     use std::sync::RwLock;
     static CLIENTS: Lazy<RwLock<Slab<PerWorkerClient>>> = Lazy::new(|| RwLock::new(Slab::new()));
-    static STATEMENTS: Lazy<RwLock<Slab<(usize, Statement)>>> =
-        Lazy::new(|| RwLock::new(Slab::new()));
+    // Statement lifecycle (see statement_registry.rs and tishlang/tish#712):
+    // entries are interned per (client, sql), validated against the owning
+    // client on every lookup, swept by `close`, and individually freed by
+    // `unprepare`.
+    static STATEMENTS: Lazy<RwLock<StatementRegistry<Statement>>> =
+        Lazy::new(|| RwLock::new(StatementRegistry::new()));
 
     /// Drive a future on our tokio runtime without panicking when called from
     /// inside another runtime's worker thread.
@@ -709,9 +717,13 @@ mod tish_sync {
         g.get(id as usize).cloned()
     }
 
-    fn get_statement(id: f64) -> Option<(usize, Statement)> {
+    /// Resolve a statement handle **for a specific client**. A handle whose
+    /// stored client id does not match is a miss: after `close()` recycles a
+    /// CLIENTS slab index, a stale statement handle must not be replayed
+    /// against whichever new connection reused that index.
+    fn get_statement(id: f64, client_id: f64) -> Option<Statement> {
         let g = STATEMENTS.read().unwrap();
-        g.get(id as usize).cloned()
+        g.get(id as usize, client_id as usize)
     }
 
     /// `prepare(client_handle, sql) -> statement_handle`.
@@ -726,10 +738,23 @@ mod tish_sync {
             return tish_err("prepare: unknown client handle");
         };
         let sql = sql.to_string();
+        // Idempotent per (client, sql): re-preparing identical SQL returns
+        // the interned handle without a server round-trip, so the statement
+        // table is bounded by distinct SQL text instead of prepare() calls.
+        {
+            let g = STATEMENTS.read().unwrap();
+            if let Some(id) = g.lookup(*client_id as usize, &sql) {
+                return TishValue::Number(id as f64);
+            }
+        }
         match block_on(client.prepare(&sql)) {
             Ok(stmt) => {
                 let mut g = STATEMENTS.write().unwrap();
-                let id = g.insert((*client_id as usize, stmt));
+                // insert() re-checks the intern map under the write lock: if
+                // a concurrent identical prepare won the race, its handle is
+                // reused and this fresh Statement drops (emitting the
+                // server-side DEALLOCATE).
+                let id = g.insert(*client_id as usize, &sql, stmt);
                 TishValue::Number(id as f64)
             }
             Err(e) => tish_err(format!("prepare: {}", crate::format_tish_pg_error(&e))),
@@ -752,7 +777,7 @@ mod tish_sync {
         let Some(client) = get_client(*client_id) else {
             return tish_err("queryPrepared: unknown client");
         };
-        let Some((_cid, stmt)) = get_statement(*stmt_id) else {
+        let Some(stmt) = get_statement(*stmt_id, *client_id) else {
             return tish_err("queryPrepared: unknown statement");
         };
         // Fast path: build `Value::Object` rows directly from `Row` so we
@@ -792,7 +817,7 @@ mod tish_sync {
                 let Some(TishValue::Number(stmt_id)) = pair_b.first() else {
                     return tish_err("queryAll: spec[0] must be a statement handle");
                 };
-                let Some((_cid, stmt)) = get_statement(*stmt_id) else {
+                let Some(stmt) = get_statement(*stmt_id, *client_id) else {
                     return tish_err("queryAll: unknown statement");
                 };
                 let params = match pair_b.get(1) {
@@ -821,8 +846,18 @@ mod tish_sync {
     }
 
     /// `close(client_handle) -> null`.
+    ///
+    /// Also sweeps the client's prepared statements. The sweep runs first,
+    /// while the connection is still alive, so each dropped `Statement`
+    /// emits its server-side `DEALLOCATE`; purging the intern entries keeps
+    /// a later client that reuses this slab index from inheriting stale
+    /// handles.
     pub fn close(args: &[TishValue]) -> TishValue {
         if let Some(TishValue::Number(id)) = args.first() {
+            {
+                let mut s = STATEMENTS.write().unwrap();
+                s.sweep_client(*id as usize);
+            }
             let mut g = CLIENTS.write().unwrap();
             if g.contains(*id as usize) {
                 g.remove(*id as usize);
@@ -831,6 +866,22 @@ mod tish_sync {
         TishValue::Null
     }
 
+    /// `unprepare(statement_handle) -> null`.
+    ///
+    /// Frees one prepared-statement entry. Dropping the `Statement` sends
+    /// the server-side `DEALLOCATE` (tokio-postgres emits a `Close` message
+    /// on drop) as long as the owning connection is still alive; if the
+    /// client was already closed the drop is inert and the server reclaimed
+    /// the statement on disconnect. Unknown handles are ignored, mirroring
+    /// `close`.
+    pub fn unprepare(args: &[TishValue]) -> TishValue {
+        if let Some(TishValue::Number(id)) = args.first() {
+            let mut g = STATEMENTS.write().unwrap();
+            g.remove(*id as usize);
+        }
+        TishValue::Null
+    }
+
     /// `migrate(client_handle, dir) -> { ok, applied: [name, …], error? }`.
     ///
     /// Reads `dir` for files matching `^\d+_.+\.sql$`, sorted lexically
@@ -940,7 +991,7 @@ mod tish_sync {
 // the Rust side (camelCase `queryAll` in .tish -> snake `query_all` here).
 #[cfg(feature = "tish-bindings")]
 pub use tish_sync::{
-    close, connect, migrate, per_worker_client, prepare, query_all, query_prepared,
+    close, connect, migrate, per_worker_client, prepare, query_all, query_prepared, unprepare,
 };
 
 #[cfg(test)]