@tishlang/tish-format 3.12.2 → 3.15.0

package/crates/tish_ffi/src/v2.rs

@@ -0,0 +1,349 @@
+//! # ABI v2 — host accessors delivered as a function-pointer table
+//!
+//! v1 extensions resolve the host's `tish_value_*` symbols at load time, which needs the host
+//! binary to export them (`-export_dynamic`) and keep them alive under LTO + strip. v2 hands the
+//! module a [`TishHostApi`] table instead: the loader calls
+//! `tish_module_register_v2(api: *const TishHostApi) -> *const TishExportTable`, the module keeps
+//! the pointer, and every host access goes through it. No symbol export, no late binding, and
+//! taking the functions' addresses keeps them alive in any host profile.
+//!
+//! Additions over v1: length-delimited UTF-8 strings (interior NUL allowed), object key
+//! enumeration, array set, function handles in both directions ([`TishHostApi::new_function`] /
+//! [`TishHostApi::call`]), and a throw channel ([`TishHostApi::throw_value`] /
+//! [`TishHostApi::take_throw`]). Packed `NumberArray` values read as arrays.
+//!
+//! Ownership follows v1: handles returned by `new_*` / `*_get` / `object_keys` / `call` /
+//! `take_throw` / `clone` are owned by the caller and released with `drop`; `*_push` / `*_set` /
+//! `throw_value` clone their arguments. [`TishHostApi::string_utf8`] returns a pointer *borrowed*
+//! from the handle, valid until that handle is dropped.
+//!
+//! Evolution: fields are only ever appended. A module checks `abi_version` and `size` before
+//! touching a field newer than the version it was built for.
+
+use std::cell::RefCell;
+use std::ffi::c_void;
+use std::sync::Arc;
+
+use tishlang_core::{ObjectData, Value, VmRef};
+
+use crate::{
+    box_value, tish_value_array_new, tish_value_array_push, tish_value_clone, tish_value_drop,
+    tish_value_new_bool, tish_value_new_null, tish_value_new_number, tish_value_object_new,
+    TishValueRef, TISH_TAG_ARRAY, TISH_TAG_BOOL, TISH_TAG_NULL, TISH_TAG_NUMBER, TISH_TAG_OBJECT,
+    TISH_TAG_OTHER, TISH_TAG_STRING,
+};
+
+pub const TISH_FFI_ABI_VERSION: u32 = 2;
+
+/// v2-only tag: a callable value (pass it to [`TishHostApi::call`]). v1's `tag` keeps reporting
+/// functions as `TISH_TAG_OTHER`.
+pub const TISH_TAG_FUNCTION: i32 = 7;
+
+/// A foreign callback wrapped by [`TishHostApi::new_function`]: borrowed argument handles in,
+/// freshly-owned result handle out (same contract as `TishNativeFn`, plus a context pointer).
+pub type TishCallbackFn =
+    extern "C" fn(ctx: *mut c_void, args: *const TishValueRef, argc: usize) -> TishValueRef;
+
+/// Releases a callback context when the last reference to the wrapping function value drops.
+pub type TishCtxDropFn = extern "C" fn(ctx: *mut c_void);
+
+/// The host API table. `#[repr(C)]`; fields are append-only across versions.
+#[repr(C)]
+pub struct TishHostApi {
+    pub abi_version: u32,
+    /// `size_of::<TishHostApi>()` as built by the host.
+    pub size: usize,
+
+    pub new_null: extern "C" fn() -> TishValueRef,
+    pub new_number: extern "C" fn(n: f64) -> TishValueRef,
+    pub new_bool: extern "C" fn(b: bool) -> TishValueRef,
+    pub new_string_utf8: unsafe extern "C" fn(ptr: *const u8, len: usize) -> TishValueRef,
+
+    /// `TISH_TAG_*`, with arrays covering `NumberArray` and [`TISH_TAG_FUNCTION`] for callables.
+    pub tag: unsafe extern "C" fn(r: TishValueRef) -> i32,
+    pub as_number: unsafe extern "C" fn(r: TishValueRef) -> f64,
+    pub as_bool: unsafe extern "C" fn(r: TishValueRef) -> bool,
+    /// Borrowed UTF-8 bytes of a string handle (null if not a string); `*len` receives the length.
+    pub string_utf8: unsafe extern "C" fn(r: TishValueRef, len: *mut usize) -> *const u8,
+
+    pub array_new: extern "C" fn() -> TishValueRef,
+    pub array_push: unsafe extern "C" fn(arr: TishValueRef, elem: TishValueRef),
+    pub array_len: unsafe extern "C" fn(arr: TishValueRef) -> usize,
+    pub array_get: unsafe extern "C" fn(arr: TishValueRef, i: usize) -> TishValueRef,
+    /// Sets element `i`, padding with null when `i >= len`.
+    pub array_set: unsafe extern "C" fn(arr: TishValueRef, i: usize, elem: TishValueRef),
+
+    pub object_new: extern "C" fn() -> TishValueRef,
+    pub object_set_utf8:
+        unsafe extern "C" fn(obj: TishValueRef, key: *const u8, key_len: usize, val: TishValueRef),
+    pub object_get_utf8:
+        unsafe extern "C" fn(obj: TishValueRef, key: *const u8, key_len: usize) -> TishValueRef,
+    /// Array of the object's own string keys, in insertion order.
+    pub object_keys: unsafe extern "C" fn(obj: TishValueRef) -> TishValueRef,
+
+    /// Wrap a foreign callback as a host function value. `drop_ctx` (nullable) runs once when the
+    /// function value is released.
+    pub new_function: unsafe extern "C" fn(
+        func: TishCallbackFn,
+        ctx: *mut c_void,
+        drop_ctx: Option<TishCtxDropFn>,
+    ) -> TishValueRef,
+    /// Call a function handle. If it throws, returns a null handle and parks the thrown value for
+    /// [`TishHostApi::take_throw`] on this thread.
+    pub call:
+        unsafe extern "C" fn(f: TishValueRef, args: *const TishValueRef, argc: usize) -> TishValueRef,
+    /// Raise `val` in the host when the current native call returns.
+    pub throw_value: unsafe extern "C" fn(val: TishValueRef),
+    /// The value thrown by the last failing [`TishHostApi::call`] on this thread, or a null
+    /// pointer if none. Clears it.
+    pub take_throw: extern "C" fn() -> TishValueRef,
+
+    pub clone: unsafe extern "C" fn(r: TishValueRef) -> TishValueRef,
+    pub drop: unsafe extern "C" fn(r: TishValueRef),
+}
+
+/// The host's table, handed to every v2 module the loader registers.
+pub static TISH_HOST_API: TishHostApi = TishHostApi {
+    abi_version: TISH_FFI_ABI_VERSION,
+    size: std::mem::size_of::<TishHostApi>(),
+    new_null: tish_value_new_null,
+    new_number: tish_value_new_number,
+    new_bool: tish_value_new_bool,
+    new_string_utf8: v2_new_string_utf8,
+    tag: v2_tag,
+    as_number: v2_as_number,
+    as_bool: v2_as_bool,
+    string_utf8: v2_string_utf8,
+    array_new: tish_value_array_new,
+    array_push: tish_value_array_push,
+    array_len: v2_array_len,
+    array_get: v2_array_get,
+    array_set: v2_array_set,
+    object_new: tish_value_object_new,
+    object_set_utf8: v2_object_set_utf8,
+    object_get_utf8: v2_object_get_utf8,
+    object_keys: v2_object_keys,
+    new_function: v2_new_function,
+    call: v2_call,
+    throw_value: v2_throw_value,
+    take_throw: v2_take_throw,
+    clone: tish_value_clone,
+    drop: tish_value_drop,
+};
+
+thread_local! {
+    static LAST_CALL_THROW: RefCell<Option<Value>> = const { RefCell::new(None) };
+}
+
+#[inline]
+unsafe fn val<'a>(r: TishValueRef) -> Option<&'a Value> {
+    (r as *const Value).as_ref()
+}
+
+#[inline]
+unsafe fn utf8<'a>(ptr: *const u8, len: usize) -> Option<&'a str> {
+    if ptr.is_null() {
+        return if len == 0 { Some("") } else { None };
+    }
+    std::str::from_utf8(std::slice::from_raw_parts(ptr, len)).ok()
+}
+
+fn object_of(v: &Value) -> Option<VmRef<ObjectData>> {
+    match v {
+        Value::Object(o) => Some(o.clone()),
+        _ => None,
+    }
+}
+
+unsafe extern "C" fn v2_new_string_utf8(ptr: *const u8, len: usize) -> TishValueRef {
+    match utf8(ptr, len) {
+        Some(s) => box_value(Value::String(s.into())),
+        None => box_value(Value::Null),
+    }
+}
+
+unsafe extern "C" fn v2_tag(r: TishValueRef) -> i32 {
+    match val(r) {
+        None | Some(Value::Null) => TISH_TAG_NULL,
+        Some(Value::Number(_)) => TISH_TAG_NUMBER,
+        Some(Value::String(_)) => TISH_TAG_STRING,
+        Some(Value::Bool(_)) => TISH_TAG_BOOL,
+        Some(Value::Array(_)) | Some(Value::NumberArray(_)) => TISH_TAG_ARRAY,
+        Some(Value::Object(_)) => TISH_TAG_OBJECT,
+        Some(Value::Function(_)) => TISH_TAG_FUNCTION,
+        Some(_) => TISH_TAG_OTHER,
+    }
+}
+
+unsafe extern "C" fn v2_as_number(r: TishValueRef) -> f64 {
+    match val(r) {
+        Some(Value::Number(n)) => *n,
+        _ => f64::NAN,
+    }
+}
+
+unsafe extern "C" fn v2_as_bool(r: TishValueRef) -> bool {
+    matches!(val(r), Some(Value::Bool(true)))
+}
+
+unsafe extern "C" fn v2_string_utf8(r: TishValueRef, len: *mut usize) -> *const u8 {
+    let (ptr, n) = match val(r) {
+        Some(Value::String(s)) => (s.as_bytes().as_ptr(), s.as_bytes().len()),
+        _ => (std::ptr::null(), 0),
+    };
+    if !len.is_null() {
+        *len = n;
+    }
+    ptr
+}
+
+unsafe extern "C" fn v2_array_len(arr: TishValueRef) -> usize {
+    match val(arr) {
+        Some(Value::Array(a)) => a.borrow().len(),
+        Some(Value::NumberArray(a)) => a.borrow().len(),
+        _ => 0,
+    }
+}
+
+unsafe extern "C" fn v2_array_get(arr: TishValueRef, i: usize) -> TishValueRef {
+    let v = match val(arr) {
+        Some(Value::Array(a)) => a.borrow().get(i).cloned(),
+        Some(Value::NumberArray(a)) => a.borrow().get(i),
+        _ => None,
+    };
+    box_value(v.unwrap_or(Value::Null))
+}
+
+unsafe extern "C" fn v2_array_set(arr: TishValueRef, i: usize, elem: TishValueRef) {
+    let v = val(elem).cloned().unwrap_or(Value::Null);
+    match val(arr) {
+        Some(Value::Array(a)) => {
+            let mut a = a.borrow_mut();
+            if i >= a.len() {
+                a.resize(i + 1, Value::Null);
+            }
+            a[i] = v;
+        }
+        Some(Value::NumberArray(a)) => {
+            let mut a = a.borrow_mut();
+            let mut vals = a.to_values();
+            if i >= vals.len() {
+                vals.resize(i + 1, Value::Null);
+            }
+            vals[i] = v;
+            *a = tishlang_core::NumArrayBacking::Boxed(vals);
+        }
+        _ => {}
+    }
+}
+
+unsafe extern "C" fn v2_object_set_utf8(
+    obj: TishValueRef,
+    key: *const u8,
+    key_len: usize,
+    v: TishValueRef,
+) {
+    if let (Some(Value::Object(o)), Some(k)) = (val(obj), utf8(key, key_len)) {
+        let v = val(v).cloned().unwrap_or(Value::Null);
+        o.borrow_mut().strings.insert(k.into(), v);
+    }
+}
+
+unsafe extern "C" fn v2_object_get_utf8(
+    obj: TishValueRef,
+    key: *const u8,
+    key_len: usize,
+) -> TishValueRef {
+    let got = match (val(obj).and_then(object_of), utf8(key, key_len)) {
+        (Some(o), Some(k)) => o.borrow().strings.get(k).cloned(),
+        _ => None,
+    };
+    box_value(got.unwrap_or(Value::Null))
+}
+
+unsafe extern "C" fn v2_object_keys(obj: TishValueRef) -> TishValueRef {
+    let keys: Vec<Value> = match val(obj).and_then(object_of) {
+        Some(o) => o
+            .borrow()
+            .strings
+            .keys()
+            .map(|k| Value::String(k.as_ref().into()))
+            .collect(),
+        None => Vec::new(),
+    };
+    box_value(Value::Array(VmRef::new(keys)))
+}
+
+/// A foreign callback + context, owned by the function value wrapping it.
+struct ForeignCallback {
+    func: TishCallbackFn,
+    ctx: *mut c_void,
+    drop_ctx: Option<TishCtxDropFn>,
+}
+
+// SAFETY: the context is opaque to the host; the module that created it owns its thread-safety
+// (the documented contract is that callbacks are invoked on the thread that calls them).
+unsafe impl Send for ForeignCallback {}
+unsafe impl Sync for ForeignCallback {}
+
+impl Drop for ForeignCallback {
+    fn drop(&mut self) {
+        if let Some(d) = self.drop_ctx {
+            d(self.ctx);
+        }
+    }
+}
+
+unsafe extern "C" fn v2_new_function(
+    func: TishCallbackFn,
+    ctx: *mut c_void,
+    drop_ctx: Option<TishCtxDropFn>,
+) -> TishValueRef {
+    let cb = Arc::new(ForeignCallback {
+        func,
+        ctx,
+        drop_ctx,
+    });
+    box_value(Value::native(move |args: &[Value]| {
+        let cb = &cb;
+        crate::call_through_handles(args, |argv, argc| (cb.func)(cb.ctx, argv, argc))
+    }))
+}
+
+unsafe extern "C" fn v2_call(
+    f: TishValueRef,
+    args: *const TishValueRef,
+    argc: usize,
+) -> TishValueRef {
+    let Some(Value::Function(func)) = val(f) else {
+        LAST_CALL_THROW.with(|t| {
+            *t.borrow_mut() = Some(Value::String("ffi: call of non-function".into()))
+        });
+        return box_value(Value::Null);
+    };
+    let argv: Vec<Value> = if args.is_null() {
+        Vec::new()
+    } else {
+        std::slice::from_raw_parts(args, argc)
+            .iter()
+            .map(|h| val(*h).cloned().unwrap_or(Value::Null))
+            .collect()
+    };
+    let out = func.call(&argv);
+    if let Some(thrown) = tishlang_core::take_pending_throw() {
+        LAST_CALL_THROW.with(|t| *t.borrow_mut() = Some(thrown));
+        return box_value(Value::Null);
+    }
+    box_value(out)
+}
+
+unsafe extern "C" fn v2_throw_value(v: TishValueRef) {
+    tishlang_core::set_pending_throw(val(v).cloned().unwrap_or(Value::Null));
+}
+
+extern "C" fn v2_take_throw() -> TishValueRef {
+    match LAST_CALL_THROW.with(|t| t.borrow_mut().take()) {
+        Some(v) => box_value(v),
+        None => std::ptr::null_mut(),
+    }
+}

package/crates/tish_ffi/tests/fixtures/testmod_v2/Cargo.lock

@@ -0,0 +1,282 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "getrandom",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "arcstr"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "indexmap"
+version = "2.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "js-sys"
+version = "0.3.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.190"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "smallvec"
+version = "1.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9395f0f0eee849a9b707b2f06bb92a6a422090e2123bb2ef8e87a0e61892a8e"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tish_ffi_testmod_v2"
+version = "0.0.0"
+dependencies = [
+ "tishlang_core",
+ "tishlang_ffi_guest",
+]
+
+[[package]]
+name = "tishlang_core"
+version = "0.1.0"
+dependencies = [
+ "ahash",
+ "arcstr",
+ "getrandom",
+ "indexmap",
+ "itoa",
+ "ryu",
+ "smallvec",
+]
+
+[[package]]
+name = "tishlang_ffi_guest"
+version = "0.1.0"
+dependencies = [
+ "tishlang_core",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]

package/crates/tish_ffi/tests/fixtures/testmod_v2/Cargo.toml

@@ -0,0 +1,16 @@
+# ABI v2 fixture: links only `tishlang_ffi_guest` (its own tishlang_core copy, no host symbols) and
+# exports `tish_module_register_v2`. Standalone workspace so the main workspace ignores it.
+[package]
+name = "tish_ffi_testmod_v2"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+tishlang_ffi_guest = { path = "../../../../tish_ffi_guest" }
+tishlang_core = { path = "../../../../tish_core" }