chore(legacy): comment-out legacy v1 exports (nyash_plugin_invoke/abi/init) across first-party plugins; retain only TypeBox v2 path; remove legacy plugin loader and C-ABI nyash-file

plugins/nyash-encoding-plugin/src/lib.rs

@@ -42,6 +42,7 @@ pub extern "C" fn nyash_plugin_init() -> i32 {
     OK
 }
 
+/* legacy v1 entry removed
 #[no_mangle]
 pub extern "C" fn nyash_plugin_invoke(
     type_id: u32,
@@ -148,6 +149,101 @@ pub extern "C" fn nyash_plugin_invoke(
         }
     }
 }
+*/
+
+// ===== TypeBox ABI v2 (resolve/invoke_id) =====
+#[repr(C)]
+pub struct NyashTypeBoxFfi {
+    pub abi_tag: u32,        // 'TYBX'
+    pub version: u16,        // 1
+    pub struct_size: u16,    // sizeof(NyashTypeBoxFfi)
+    pub name: *const std::os::raw::c_char,
+    pub resolve: Option<extern "C" fn(*const std::os::raw::c_char) -> u32>,
+    pub invoke_id: Option<extern "C" fn(u32, u32, *const u8, usize, *mut u8, *mut usize) -> i32>,
+    pub capabilities: u64,
+}
+unsafe impl Sync for NyashTypeBoxFfi {}
+
+use std::ffi::CStr;
+extern "C" fn encoding_resolve(name: *const std::os::raw::c_char) -> u32 {
+    if name.is_null() { return 0; }
+    let s = unsafe { CStr::from_ptr(name) }.to_string_lossy();
+    match s.as_ref() {
+        "toUtf8Bytes" => M_TO_UTF8_BYTES,
+        "fromUtf8Bytes" => M_FROM_UTF8_BYTES,
+        "base64Encode" => M_BASE64_ENC,
+        "base64Decode" => M_BASE64_DEC,
+        "hexEncode" => M_HEX_ENC,
+        "hexDecode" => M_HEX_DEC,
+        "birth" => M_BIRTH,
+        "fini" => M_FINI,
+        _ => 0,
+    }
+}
+
+extern "C" fn encoding_invoke_id(
+    instance_id: u32,
+    method_id: u32,
+    args: *const u8,
+    args_len: usize,
+    result: *mut u8,
+    result_len: *mut usize,
+) -> i32 {
+    unsafe {
+        match method_id {
+            M_BIRTH => {
+                if result_len.is_null() { return E_ARGS; }
+                if preflight(result, result_len, 4) { return E_SHORT; }
+                let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
+                if let Ok(mut m) = INST.lock() { m.insert(id, EncInstance); } else { return E_PLUGIN; }
+                let b = id.to_le_bytes();
+                std::ptr::copy_nonoverlapping(b.as_ptr(), result, 4);
+                *result_len = 4; OK
+            }
+            M_FINI => { if let Ok(mut m) = INST.lock() { m.remove(&instance_id); OK } else { E_PLUGIN } }
+            M_TO_UTF8_BYTES => {
+                let s = match read_arg_string(args, args_len, 0) { Some(v) => v, None => return E_ARGS };
+                write_tlv_bytes(s.as_bytes(), result, result_len)
+            }
+            M_FROM_UTF8_BYTES => {
+                let bytes = match read_arg_bytes(args, args_len, 0) { Some(v) => v, None => return E_ARGS };
+                match String::from_utf8(bytes) { Ok(s) => write_tlv_string(&s, result, result_len), Err(_) => write_tlv_string("", result, result_len) }
+            }
+            M_BASE64_ENC => {
+                if let Some(b) = read_arg_bytes(args, args_len, 0) { let s = base64::encode(b); return write_tlv_string(&s, result, result_len); }
+                let s = match read_arg_string(args, args_len, 0) { Some(v) => v, None => return E_ARGS };
+                let enc = base64::encode(s.as_bytes());
+                write_tlv_string(&enc, result, result_len)
+            }
+            M_BASE64_DEC => {
+                let s = match read_arg_string(args, args_len, 0) { Some(v) => v, None => return E_ARGS };
+                match base64::decode(s.as_bytes()) { Ok(b) => write_tlv_bytes(&b, result, result_len), Err(_) => write_tlv_bytes(&[], result, result_len) }
+            }
+            M_HEX_ENC => {
+                if let Some(b) = read_arg_bytes(args, args_len, 0) { let s = hex::encode(b); return write_tlv_string(&s, result, result_len); }
+                let s = match read_arg_string(args, args_len, 0) { Some(v) => v, None => return E_ARGS };
+                let enc = hex::encode(s.as_bytes());
+                write_tlv_string(&enc, result, result_len)
+            }
+            M_HEX_DEC => {
+                let s = match read_arg_string(args, args_len, 0) { Some(v) => v, None => return E_ARGS };
+                match hex::decode(s.as_bytes()) { Ok(b) => write_tlv_bytes(&b, result, result_len), Err(_) => write_tlv_bytes(&[], result, result_len) }
+            }
+            _ => E_METHOD,
+        }
+    }
+}
+
+#[no_mangle]
+pub static nyash_typebox_EncodingBox: NyashTypeBoxFfi = NyashTypeBoxFfi {
+    abi_tag: 0x54594258,
+    version: 1,
+    struct_size: std::mem::size_of::<NyashTypeBoxFfi>() as u16,
+    name: b"EncodingBox\0".as_ptr() as *const std::os::raw::c_char,
+    resolve: Some(encoding_resolve),
+    invoke_id: Some(encoding_invoke_id),
+    capabilities: 0,
+};
 
 fn preflight(result: *mut u8, result_len: *mut usize, needed: usize) -> bool {
     unsafe {