[wit-smith] Add implements interface generation

Teach wit-smith to generate `ImplementsInterface` items in worlds,
producing `%label: path;` WIT syntax which encodes as
`[implements=<I>]L` in the component binary. This enables fuzzing of
the implements feature through the existing roundtrip_wit fuzzer.

Also adds a decode roundtrip check in `smith()` to catch edge cases
where metadata custom sections reference interfaces that aren't
properly reconstructed during decoding.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ricochet

crates/wit-parser/src/resolve/mod.rs

@@ -1577,11 +1577,20 @@ package {name} is defined in two different locations:\n\
             for (name, item) in world.imports.iter().chain(world.exports.iter()) {
                 log::debug!("validating world item: {}", self.name_world_key(name));
                 match item {
-                    WorldItem::Interface { id, .. } => {
-                        // anonymous interfaces must belong to the same package
-                        // as the world's package.
+                    WorldItem::Interface {
+                        id, implements, ..
+                    } => {
                         if matches!(name, WorldKey::Name(_)) {
-                            assert_eq!(self.interfaces[*id].package, world.package);
+                            if implements.is_none() {
+                                // Anonymous interfaces must belong to the same
+                                // package as the world's package.
+                                assert_eq!(self.interfaces[*id].package, world.package);
+                            } else {
+                                // Implements items use `WorldKey::Name` but can
+                                // reference interfaces from other packages.
+                                // Verify the target interface exists.
+                                assert!(self.interfaces.get(*id).is_some());
+                            }
                         }
                     }
                     WorldItem::Function(f) => {

crates/wit-smith/src/config.rs

@@ -31,6 +31,8 @@ pub struct Config {
     pub fixed_length_lists: bool,
     #[cfg_attr(feature = "clap", clap(long, default_value_t = Config::default().world_include))]
     pub world_include: bool,
+    #[cfg_attr(feature = "clap", clap(long, default_value_t = Config::default().implements))]
+    pub implements: bool,
 }
 
 impl Default for Config {
@@ -50,6 +52,7 @@ impl Default for Config {
             error_context: false,
             fixed_length_lists: false,
             world_include: false,
+            implements: false,
         }
     }
 }
@@ -71,6 +74,7 @@ impl Arbitrary<'_> for Config {
             error_context: u.arbitrary()?,
             fixed_length_lists: u.arbitrary()?,
             world_include: false,
+            implements: u.arbitrary()?,
         })
     }
 }

crates/wit-smith/src/generate.rs

@@ -647,6 +647,7 @@ impl<'a> InterfaceGenerator<'a> {
             Func(Direction),
             Interface(Direction),
             AnonInterface(Direction),
+            ImplementsInterface(Direction),
             Type,
             Use,
             Include,
@@ -666,9 +667,19 @@ impl<'a> InterfaceGenerator<'a> {
             && u.arbitrary()?
         {
             let kind = u.arbitrary::<ItemKind>()?;
+
+            // Gate config-disabled features early, before consuming any
+            // more random bytes, to keep byte consumption deterministic
+            // when a feature is toggled off.
+            if matches!(kind, ItemKind::ImplementsInterface(_))
+                && !self.generator.config.implements
+            {
+                continue;
+            }
+
             let (direction, named) = match kind {
                 ItemKind::Func(dir) | ItemKind::AnonInterface(dir) => (Some(dir), true),
-                ItemKind::Interface(dir) => (Some(dir), false),
+                ItemKind::Interface(dir) | ItemKind::ImplementsInterface(dir) => (Some(dir), false),
                 ItemKind::Type => (None, true),
                 ItemKind::Use => (None, false),
                 ItemKind::Include => (None, false),
@@ -750,6 +761,30 @@ impl<'a> InterfaceGenerator<'a> {
                     }
                     part.push_str(";");
                 }
+                ItemKind::ImplementsInterface(dir) => {
+                    let names = match dir {
+                        Direction::Import => &mut self.unique_names,
+                        Direction::Export => &mut export_names,
+                    };
+                    let label = gen_unique_name(u, names)?;
+
+                    let mut path_str = String::new();
+                    if self.generator.gen_interface_path(u, self.file, &mut path_str)?.is_none() {
+                        continue;
+                    }
+
+                    self.generator.packages.add_name(
+                        self.package_name.to_string(),
+                        world_name.to_string(),
+                        label.to_string(),
+                    );
+
+                    part.push_str("%");
+                    part.push_str(&label);
+                    part.push_str(": ");
+                    part.push_str(&path_str);
+                    part.push_str(";");
+                }
                 ItemKind::AnonInterface(_) => {
                     let iface =
                         InterfaceGenerator::new(self.generator, self.file, self.package_name, None)

crates/wit-smith/src/lib.rs

@@ -55,5 +55,17 @@ pub fn smith(config: &Config, u: &mut Unstructured<'_>) -> Result<Vec<u8>> {
             return Err(arbitrary::Error::IncorrectFormat);
         }
     }
+
+    // Verify that the encoded binary can be decoded back. In some edge cases
+    // the metadata custom section can reference interfaces that aren't
+    // properly reconstructed during decoding.
+    if let Err(e) = wit_parser::decoding::decode(&wasm) {
+        let msg = e.to_string();
+        if msg.contains("missing interface") || msg.contains("missing world") {
+            log::warn!("skipping input that fails decode roundtrip: {e}");
+            return Err(arbitrary::Error::IncorrectFormat);
+        }
+    }
+
     Ok(wasm)
 }