add initial jsg rust integration

[anonrig]

Add Rust JSG bindings and comprehensive test coverage

This PR introduces Rust bindings for JSG, enabling
Rust code to interact with V8 and implement JavaScript APIs.

Key changes:

• Add jsg crate with V8 bindings (Local/Global handles, types, resources)
• Add jsg-macros for procedural macros (jsg_struct, jsg_resource, jsg_method)
• Add jsg-test harness with proper Realm initialization for testing
• Implement comprehensive test suite for JSG bindings
• Add support for wrapping/unwrapping Rust resources in V8

The Rust JSG implementation provides type-safe V8 integration and will
enable more Rust-based APIs in workerd.

Example usage:

#[test]
fn objects_can_be_wrapped_and_unwrapped() {
    let harness = crate::Harness::new();
    harness.run_in_context(|isolate| unsafe {
        let mut lock = Lock::from_isolate(isolate);
        let instance = TestStruct {
            str: "test".to_string(),
        };
        let wrapped = instance.wrap(&mut lock);
        let mut obj: v8::Local<'_, v8::Object> = wrapped.into();
        assert!(obj.has(&mut lock, "str"));
        let str_value = obj.get(&mut lock, "str");
        assert!(str_value.unwrap().is_string());
        assert!(!obj.has(&mut lock, "test"));
        let value = "value".to_local(&mut lock);
        assert!(value.is_string());
        obj.set(&mut lock, "test", value);
        assert!(obj.has(&mut lock, "test"));
    });
}

[github-actions]

The generated output of @cloudflare/workers-types matches the snapshot in types/generated-snapshot 🎉

[jasnell]

The C++ bits LGTM. Looked over the Rust bits too and they look fine but would rather have someone who's more of a rust expert to do the sign off.

[Copilot]

Pull request overview

This PR introduces comprehensive Rust bindings for the JSG (JavaScript Glue) system, enabling Rust code to interact with V8 and implement JavaScript APIs. The implementation provides type-safe V8 integration with support for wrapping/unwrapping Rust resources, procedural macros for reducing boilerplate, and a test harness with proper Realm initialization.

Key Changes:

• Added core Rust JSG bindings (jsg crate) with V8 handle types (Local/Global), FFI bridges, and resource management
• Implemented procedural macros (jsg-macros) for #[jsg_struct], #[jsg_resource], and #[jsg_method] to reduce boilerplate
• Created test infrastructure (jsg-test) with proper V8 context setup for testing Rust JSG bindings
• Integrated Rust-backed Node.js DNS implementation as a demonstration, conditionally enabled via autogate
• Added Realm tracking for deterministic cleanup of Rust resources when V8 contexts are disposed

Reviewed changes

Copilot reviewed 30 out of 30 changed files in this pull request and generated 16 comments.

Show a summary per file

File	Description
src/workerd/util/autogate.h	Added RUST_BACKED_NODE_DNS autogate key for feature flagging
src/workerd/util/autogate.c++	Registered the new autogate key with its string representation
src/workerd/jsg/wrappable.h	Added RUST_REALM context slot and WORKERD_RUST_WRAPPABLE_TAG for Rust resources
src/workerd/jsg/setup.h	Exposed getIsolate() method for Rust FFI access to V8 isolate
src/workerd/jsg/BUILD.bazel	Added Rust JSG dependency and visibility for Rust packages
src/workerd/io/worker.c++	Integrated Realm creation/disposal in context lifecycle
src/workerd/api/rtti.c++	Added stub addBuiltinModule overload for future module registration
src/workerd/api/node/node.h	Conditionally registers C++ or Rust DNS implementation based on autogate
src/workerd/api/node/BUILD.bazel	Added Rust API dependency
src/rust/jsg/v8.rs	Core V8 FFI bindings with Local/Global handles and type conversions
src/rust/jsg/modules.rs	Module registration interface for Rust modules
src/rust/jsg/lib.rs	Core JSG types: Lock, Ref, Resource/Struct traits, Realm, and resource lifecycle
src/rust/jsg/jsg.h	C++ wrapper for Rust module registry integration
src/rust/jsg/ffi.h	FFI function declarations for V8 operations
src/rust/jsg/ffi.c++	FFI function implementations bridging Rust and V8 C++ APIs
src/rust/jsg/ffi-inl.h	Template implementations for FFI type conversions
src/rust/jsg/BUILD.bazel	Build configuration for JSG Rust crate and FFI library
src/rust/jsg-test/lib.rs	Test harness and comprehensive integration tests for JSG bindings
src/rust/jsg-test/ffi.h	Test harness interface declarations
src/rust/jsg-test/ffi.c++	Test harness implementation with V8 context setup
src/rust/jsg-test/BUILD.bazel	Build configuration for test infrastructure
src/rust/jsg-macros/lib.rs	Procedural macros for struct/resource/method code generation
src/rust/jsg-macros/README.md	Documentation for macro usage patterns
src/rust/jsg-macros/BUILD.bazel	Build configuration for proc macro crate
src/rust/dns/lib.rs	Added note about temporary duplication during migration
src/rust/api/lib.rs	Module registration entry point for Rust Node.js APIs
src/rust/api/dns.rs	Rust implementation of DNS utility with CAA/NAPTR record parsing
src/rust/api/BUILD.bazel	Build configuration for API crate
patches/v8/0014-Add-another-slot-in-the-isolate-for-embedder.patch	Increased V8 isolate data slots to accommodate Rust realm
compile_flags.txt	Added include paths for new Rust JSG modules

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[guybedford]

Could we put these kinds of unsafe / system calls into a special namespace that is clear that it isn't meant to be used directly in user code?

[anonrig]

Isn't that the whole point of using unsafe keyword in Rust?