wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/wit-parser-0.212.0/src/decoding.rs

@@ -0,0 +1,1798 @@
+use crate::*;
+use anyhow::{anyhow, bail};
+use indexmap::IndexSet;
+use std::mem;
+use std::slice;
+use std::{collections::HashMap, io::Read};
+use wasmparser::Chunk;
+use wasmparser::{
+    names::{ComponentName, ComponentNameKind},
+    types,
+    types::ComponentAnyTypeId,
+    ComponentExternalKind, Parser, Payload, PrimitiveValType, ValidPayload, Validator,
+    WasmFeatures,
+};
+
+/// Represents information about a decoded WebAssembly component.
+struct ComponentInfo {
+    /// Wasmparser-defined type information learned after a component is fully
+    /// validated.
+    types: types::Types,
+    /// List of all imports and exports from this component.
+    externs: Vec<(String, Extern)>,
+    /// Decoded package metadata
+    package_metadata: Option<PackageMetadata>,
+}
+
+struct DecodingExport {
+    name: String,
+    kind: ComponentExternalKind,
+    index: u32,
+}
+
+enum Extern {
+    Import(String),
+    Export(DecodingExport),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum WitEncodingVersion {
+    V1,
+    V2,
+}
+
+impl ComponentInfo {
+    /// Creates a new component info by parsing the given WebAssembly component bytes.
+
+    fn from_reader(mut reader: impl Read) -> Result<Self> {
+        let mut validator = Validator::new_with_features(WasmFeatures::all());
+        let mut externs = Vec::new();
+        let mut depth = 1;
+        let mut types = None;
+        let mut _package_metadata = None;
+        let mut cur = Parser::new(0);
+        let mut eof = false;
+        let mut stack = Vec::new();
+        let mut buffer = Vec::new();
+
+        loop {
+            let chunk = cur.parse(&buffer, eof)?;
+            let (payload, consumed) = match chunk {
+                Chunk::NeedMoreData(hint) => {
+                    assert!(!eof); // otherwise an error would be returned
+
+                    // Use the hint to preallocate more space, then read
+                    // some more data into our buffer.
+                    //
+                    // Note that the buffer management here is not ideal,
+                    // but it's compact enough to fit in an example!
+                    let len = buffer.len().clone();
+                    buffer.extend((0..hint).map(|_| 0u8));
+                    let n = reader.read(&mut buffer[len..])?;
+                    buffer.truncate(len + n);
+                    eof = n == 0;
+                    continue;
+                }
+
+                Chunk::Parsed { consumed, payload } => (payload, consumed),
+            };
+            match validator.payload(&payload)? {
+                ValidPayload::Ok => {}
+                ValidPayload::Parser(_) => depth += 1,
+                ValidPayload::End(t) => {
+                    depth -= 1;
+                    if depth == 0 {
+                        types = Some(t);
+                    }
+                }
+                ValidPayload::Func(..) => {}
+            }
+
+            match payload {
+                Payload::ComponentImportSection(s) if depth == 1 => {
+                    for import in s {
+                        let import = import?;
+                        externs.push((
+                            import.name.0.to_string(),
+                            Extern::Import(import.name.0.to_string()),
+                        ));
+                    }
+                }
+                Payload::ComponentExportSection(s) if depth == 1 => {
+                    for export in s {
+                        let export = export?;
+                        externs.push((
+                            export.name.0.to_string(),
+                            Extern::Export(DecodingExport {
+                                name: export.name.0.to_string(),
+                                kind: export.kind,
+                                index: export.index,
+                            }),
+                        ));
+                    }
+                }
+                #[cfg(feature = "serde")]
+                Payload::CustomSection(s) if s.name() == PackageMetadata::SECTION_NAME => {
+                    if _package_metadata.is_some() {
+                        bail!("multiple {:?} sections", PackageMetadata::SECTION_NAME);
+                    }
+                    _package_metadata = Some(PackageMetadata::decode(s.data())?);
+                }
+                Payload::ModuleSection { parser, .. }
+                | Payload::ComponentSection { parser, .. } => {
+                    stack.push(cur.clone());
+                    cur = parser.clone();
+                }
+                Payload::End(_) => {
+                    if let Some(parent_parser) = stack.pop() {
+                        cur = parent_parser.clone();
+                    } else {
+                        break;
+                    }
+                }
+                _ => {}
+            }
+
+            // once we're done processing the payload we can forget the
+            // original.
+            buffer.drain(..consumed);
+        }
+
+        Ok(Self {
+            types: types.unwrap(),
+            externs,
+            package_metadata: _package_metadata,
+        })
+    }
+
+    fn is_wit_package(&self) -> Option<WitEncodingVersion> {
+        // all wit package exports must be component types, and there must be at
+        // least one
+        if self.externs.is_empty() {
+            return None;
+        }
+
+        if !self.externs.iter().all(|(_, item)| {
+            let export = match item {
+                Extern::Export(e) => e,
+                _ => return false,
+            };
+            match export.kind {
+                ComponentExternalKind::Type => matches!(
+                    self.types.component_any_type_at(export.index),
+                    types::ComponentAnyTypeId::Component(_)
+                ),
+                _ => false,
+            }
+        }) {
+            return None;
+        }
+
+        // The distinction between v1 and v2 encoding formats is the structure of the export
+        // strings for each component. The v1 format uses "<namespace>:<package>/wit" as the name
+        // for the top-level exports, while the v2 format uses the unqualified name of the encoded
+        // entity.
+        match ComponentName::new(&self.externs[0].0, 0).ok()?.kind() {
+            ComponentNameKind::Interface(name) if name.interface().as_str() == "wit" => {
+                Some(WitEncodingVersion::V1)
+            }
+            ComponentNameKind::Label(_) => Some(WitEncodingVersion::V2),
+            _ => None,
+        }
+    }
+
+    fn decode_wit_v1_package(&self) -> Result<(Resolve, PackageId)> {
+        let mut decoder = WitPackageDecoder::new(&self.types);
+
+        let mut pkg = None;
+        for (name, item) in self.externs.iter() {
+            let export = match item {
+                Extern::Export(e) => e,
+                _ => unreachable!(),
+            };
+            let id = self.types.component_type_at(export.index);
+            let ty = &self.types[id];
+            if pkg.is_some() {
+                bail!("more than one top-level exported component type found");
+            }
+            let name = ComponentName::new(name, 0).unwrap();
+            pkg = Some(
+                decoder
+                    .decode_v1_package(&name, ty)
+                    .with_context(|| format!("failed to decode document `{name}`"))?,
+            );
+        }
+
+        let pkg = pkg.ok_or_else(|| anyhow!("no exported component type found"))?;
+        let (mut resolve, package) = decoder.finish(pkg);
+        if let Some(package_metadata) = &self.package_metadata {
+            package_metadata.inject(&mut resolve, package)?;
+        }
+        Ok((resolve, package))
+    }
+
+    fn decode_wit_v2_package(&self) -> Result<(Resolve, PackageId)> {
+        let mut decoder = WitPackageDecoder::new(&self.types);
+
+        let mut pkg_name = None;
+
+        let mut interfaces = IndexMap::new();
+        let mut worlds = IndexMap::new();
+        let mut fields = PackageFields {
+            interfaces: &mut interfaces,
+            worlds: &mut worlds,
+        };
+
+        for (_, item) in self.externs.iter() {
+            let export = match item {
+                Extern::Export(e) => e,
+                _ => unreachable!(),
+            };
+
+            let index = export.index;
+            let id = self.types.component_type_at(index);
+            let component = &self.types[id];
+
+            // The single export of this component will determine if it's a world or an interface:
+            // worlds export a component, while interfaces export an instance.
+            if component.exports.len() != 1 {
+                bail!(
+                    "Expected a single export, but found {} instead",
+                    component.exports.len()
+                );
+            }
+
+            let name = component.exports.keys().nth(0).unwrap();
+
+            let name = match component.exports[name] {
+                types::ComponentEntityType::Component(ty) => {
+                    let package_name =
+                        decoder.decode_world(name.as_str(), &self.types[ty], &mut fields)?;
+                    package_name
+                }
+                types::ComponentEntityType::Instance(ty) => {
+                    let package_name = decoder.decode_interface(
+                        name.as_str(),
+                        &component.imports,
+                        &self.types[ty],
+                        &mut fields,
+                    )?;
+                    package_name
+                }
+                _ => unreachable!(),
+            };
+
+            if let Some(pkg_name) = pkg_name.as_ref() {
+                // TODO: when we have fully switched to the v2 format, we should switch to parsing
+                // multiple wit documents instead of bailing.
+                if pkg_name != &name {
+                    bail!("item defined with mismatched package name")
+                }
+            } else {
+                pkg_name.replace(name);
+            }
+        }
+
+        let pkg = if let Some(name) = pkg_name {
+            Package {
+                name,
+                docs: Docs::default(),
+                interfaces,
+                worlds,
+            }
+        } else {
+            bail!("no exported component type found");
+        };
+
+        let (mut resolve, package) = decoder.finish(pkg);
+        if let Some(package_metadata) = &self.package_metadata {
+            package_metadata.inject(&mut resolve, package)?;
+        }
+        Ok((resolve, package))
+    }
+
+    fn decode_component(&self) -> Result<(Resolve, WorldId)> {
+        assert!(self.is_wit_package().is_none());
+        let mut decoder = WitPackageDecoder::new(&self.types);
+        // Note that this name is arbitrarily chosen. We may one day perhaps
+        // want to encode this in the component binary format itself, but for
+        // now it shouldn't be an issue to have a defaulted name here.
+        let world_name = "root";
+        let world = decoder.resolve.worlds.alloc(World {
+            name: world_name.to_string(),
+            docs: Default::default(),
+            imports: Default::default(),
+            exports: Default::default(),
+            package: None,
+            includes: Default::default(),
+            include_names: Default::default(),
+            stability: Default::default(),
+        });
+        let mut package = Package {
+            // Similar to `world_name` above this is arbitrarily chosen as it's
+            // not otherwise encoded in a binary component. This theoretically
+            // shouldn't cause issues, however.
+            name: PackageName {
+                namespace: "root".to_string(),
+                version: None,
+                name: "component".to_string(),
+            },
+            docs: Default::default(),
+            worlds: [(world_name.to_string(), world)].into_iter().collect(),
+            interfaces: Default::default(),
+        };
+
+        let mut fields = PackageFields {
+            worlds: &mut package.worlds,
+            interfaces: &mut package.interfaces,
+        };
+
+        for (_name, item) in self.externs.iter() {
+            match item {
+                Extern::Import(import) => {
+                    decoder.decode_component_import(import, world, &mut fields)?
+                }
+                Extern::Export(export) => {
+                    decoder.decode_component_export(export, world, &mut fields)?
+                }
+            }
+        }
+
+        let (resolve, _) = decoder.finish(package);
+        Ok((resolve, world))
+    }
+}
+
+/// Result of the [`decode`] function.
+pub enum DecodedWasm {
+    /// The input to [`decode`] was one or more binary-encoded WIT package(s).
+    ///
+    /// The full resolve graph is here plus the identifier of the packages that
+    /// were encoded. Note that other packages may be within the resolve if any
+    /// of the main packages refer to other, foreign packages.
+    WitPackages(Resolve, Vec<PackageId>),
+
+    /// The input to [`decode`] was a component and its interface is specified
+    /// by the world here.
+    Component(Resolve, WorldId),
+}
+
+impl DecodedWasm {
+    /// Returns the [`Resolve`] for WIT types contained.
+    pub fn resolve(&self) -> &Resolve {
+        match self {
+            DecodedWasm::WitPackages(resolve, _) => resolve,
+            DecodedWasm::Component(resolve, _) => resolve,
+        }
+    }
+
+    /// Returns the main packages of what was decoded.
+    pub fn packages(&self) -> &[PackageId] {
+        match self {
+            DecodedWasm::WitPackages(_, ids) => ids,
+            DecodedWasm::Component(resolve, world) => {
+                slice::from_ref(&resolve.worlds[*world].package.as_ref().unwrap())
+            }
+        }
+    }
+}
+
+/// Decode for incremental reading
+pub fn decode_reader(reader: impl Read) -> Result<DecodedWasm> {
+    let info = ComponentInfo::from_reader(reader)?;
+
+    if let Some(version) = info.is_wit_package() {
+        match version {
+            WitEncodingVersion::V1 => {
+                log::debug!("decoding a v1 WIT package encoded as wasm");
+                let (resolve, pkg) = info.decode_wit_v1_package()?;
+                Ok(DecodedWasm::WitPackages(resolve, vec![pkg]))
+            }
+            WitEncodingVersion::V2 => {
+                log::debug!("decoding a v2 WIT package encoded as wasm");
+                let (resolve, pkg) = info.decode_wit_v2_package()?;
+                Ok(DecodedWasm::WitPackages(resolve, vec![pkg]))
+            }
+        }
+    } else {
+        log::debug!("inferring the WIT of a concrete component");
+        let (resolve, world) = info.decode_component()?;
+        Ok(DecodedWasm::Component(resolve, world))
+    }
+}
+/// Decodes an in-memory WebAssembly binary into a WIT [`Resolve`] and
+/// associated metadata.
+///
+/// The WebAssembly binary provided here can either be a
+/// WIT-package-encoded-as-binary or an actual component itself. A [`Resolve`]
+/// is always created and the return value indicates which was detected.
+pub fn decode(bytes: &[u8]) -> Result<DecodedWasm> {
+    decode_reader(bytes)
+}
+
+/// Decodes the single component type `world` specified as a WIT world.
+///
+/// The `world` should be an exported component type. The `world` must have been
+/// previously created via `encode_world` meaning that it is a component that
+/// itself imports nothing and exports a single component, and the single
+/// component export represents the world. The name of the export is also the
+/// name of the package/world/etc.
+pub fn decode_world(wasm: &[u8]) -> Result<(Resolve, WorldId)> {
+    let mut validator = Validator::new_with_features(WasmFeatures::all());
+    let mut exports = Vec::new();
+    let mut depth = 1;
+    let mut types = None;
+
+    for payload in Parser::new(0).parse_all(wasm) {
+        let payload = payload?;
+
+        match validator.payload(&payload)? {
+            ValidPayload::Ok => {}
+            ValidPayload::Parser(_) => depth += 1,
+            ValidPayload::End(t) => {
+                depth -= 1;
+                if depth == 0 {
+                    types = Some(t);
+                }
+            }
+            ValidPayload::Func(..) => {}
+        }
+
+        match payload {
+            Payload::ComponentExportSection(s) if depth == 1 => {
+                for export in s {
+                    exports.push(export?);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    if exports.len() != 1 {
+        bail!("expected one export in component");
+    }
+    if exports[0].kind != ComponentExternalKind::Type {
+        bail!("expected an export of a type");
+    }
+    if exports[0].ty.is_some() {
+        bail!("expected an un-ascribed exported type");
+    }
+    let types = types.as_ref().unwrap();
+    let world = match types.component_any_type_at(exports[0].index) {
+        ComponentAnyTypeId::Component(c) => c,
+        _ => bail!("expected an exported component type"),
+    };
+
+    let mut decoder = WitPackageDecoder::new(types);
+    let mut interfaces = IndexMap::new();
+    let mut worlds = IndexMap::new();
+    let ty = &types[world];
+    assert_eq!(ty.imports.len(), 0);
+    assert_eq!(ty.exports.len(), 1);
+    let name = ty.exports.keys().nth(0).unwrap();
+    let ty = match ty.exports[0] {
+        types::ComponentEntityType::Component(ty) => ty,
+        _ => unreachable!(),
+    };
+    let name = decoder.decode_world(
+        name,
+        &types[ty],
+        &mut PackageFields {
+            interfaces: &mut interfaces,
+            worlds: &mut worlds,
+        },
+    )?;
+    let (resolve, pkg) = decoder.finish(Package {
+        name,
+        interfaces,
+        worlds,
+        docs: Default::default(),
+    });
+    // The package decoded here should only have a single world so extract that
+    // here to return.
+    let world = *resolve.packages[pkg].worlds.iter().next().unwrap().1;
+    Ok((resolve, world))
+}
+
+struct PackageFields<'a> {
+    interfaces: &'a mut IndexMap<String, InterfaceId>,
+    worlds: &'a mut IndexMap<String, WorldId>,
+}
+
+struct WitPackageDecoder<'a> {
+    resolve: Resolve,
+    types: &'a types::Types,
+    foreign_packages: IndexMap<String, Package>,
+    iface_to_package_index: HashMap<InterfaceId, usize>,
+    named_interfaces: HashMap<String, InterfaceId>,
+
+    /// A map which tracks named resources to what their corresponding `TypeId`
+    /// is. This first layer of key in this map is the owner scope of a
+    /// resource, more-or-less the `world` or `interface` that it's defined
+    /// within. The second layer of this map is keyed by name of the resource
+    /// and points to the actual ID of the resource.
+    ///
+    /// This map is populated in `register_type_export`.
+    resources: HashMap<TypeOwner, HashMap<String, TypeId>>,
+
+    /// A map from a type id to what it's been translated to.
+    type_map: HashMap<types::ComponentAnyTypeId, TypeId>,
+}
+
+impl WitPackageDecoder<'_> {
+    fn new<'a>(types: &'a types::Types) -> WitPackageDecoder<'a> {
+        WitPackageDecoder {
+            resolve: Resolve::default(),
+            types,
+            type_map: HashMap::new(),
+            foreign_packages: Default::default(),
+            iface_to_package_index: Default::default(),
+            named_interfaces: Default::default(),
+            resources: Default::default(),
+        }
+    }
+
+    fn decode_v1_package(
+        &mut self,
+        name: &ComponentName,
+        ty: &types::ComponentType,
+    ) -> Result<Package> {
+        // Process all imports for this package first, where imports are
+        // importing from remote packages.
+        for (name, ty) in ty.imports.iter() {
+            let ty = match ty {
+                types::ComponentEntityType::Instance(idx) => &self.types[*idx],
+                _ => bail!("import `{name}` is not an instance"),
+            };
+            self.register_import(name, ty)
+                .with_context(|| format!("failed to process import `{name}`"))?;
+        }
+
+        let mut package = Package {
+            // The name encoded for packages must be of the form `foo:bar/wit`
+            // where "wit" is just a placeholder for now. The package name in
+            // this case would be `foo:bar`.
+            name: match name.kind() {
+                ComponentNameKind::Interface(name) if name.interface().as_str() == "wit" => {
+                    name.to_package_name()
+                }
+                _ => bail!("package name is not a valid id: {name}"),
+            },
+            docs: Default::default(),
+            interfaces: Default::default(),
+            worlds: Default::default(),
+        };
+
+        let mut fields = PackageFields {
+            interfaces: &mut package.interfaces,
+            worlds: &mut package.worlds,
+        };
+
+        for (name, ty) in ty.exports.iter() {
+            match ty {
+                types::ComponentEntityType::Instance(idx) => {
+                    let ty = &self.types[*idx];
+                    self.register_interface(name.as_str(), ty, &mut fields)
+                        .with_context(|| format!("failed to process export `{name}`"))?;
+                }
+                types::ComponentEntityType::Component(idx) => {
+                    let ty = &self.types[*idx];
+                    self.register_world(name.as_str(), ty, &mut fields)
+                        .with_context(|| format!("failed to process export `{name}`"))?;
+                }
+                _ => bail!("component export `{name}` is not an instance or component"),
+            }
+        }
+        Ok(package)
+    }
+
+    fn decode_interface<'a>(
+        &mut self,
+        name: &str,
+        imports: &wasmparser::collections::IndexMap<String, types::ComponentEntityType>,
+        ty: &types::ComponentInstanceType,
+        fields: &mut PackageFields<'a>,
+    ) -> Result<PackageName> {
+        let component_name = self
+            .parse_component_name(name)
+            .context("expected world name to have an ID form")?;
+
+        let package = match component_name.kind() {
+            ComponentNameKind::Interface(name) => name.to_package_name(),
+            _ => bail!("expected world name to be fully qualified"),
+        };
+
+        for (name, ty) in imports.iter() {
+            let ty = match ty {
+                types::ComponentEntityType::Instance(idx) => &self.types[*idx],
+                _ => bail!("import `{name}` is not an instance"),
+            };
+            self.register_import(name, ty)
+                .with_context(|| format!("failed to process import `{name}`"))?;
+        }
+
+        let _ = self.register_interface(name, ty, fields)?;
+
+        Ok(package)
+    }
+
+    fn decode_world<'a>(
+        &mut self,
+        name: &str,
+        ty: &types::ComponentType,
+        fields: &mut PackageFields<'a>,
+    ) -> Result<PackageName> {
+        let kebab_name = self
+            .parse_component_name(name)
+            .context("expected world name to have an ID form")?;
+
+        let package = match kebab_name.kind() {
+            ComponentNameKind::Interface(name) => name.to_package_name(),
+            _ => bail!("expected world name to be fully qualified"),
+        };
+
+        let _ = self.register_world(name, ty, fields)?;
+
+        Ok(package)
+    }
+
+    fn decode_component_import<'a>(
+        &mut self,
+        name: &str,
+        world: WorldId,
+        package: &mut PackageFields<'a>,
+    ) -> Result<()> {
+        log::debug!("decoding component import `{name}`");
+        let ty = self.types.component_entity_type_of_import(name).unwrap();
+        let owner = TypeOwner::World(world);
+        let (name, item) = match ty {
+            types::ComponentEntityType::Instance(i) => {
+                let ty = &self.types[i];
+                let (name, id) = if name.contains('/') {
+                    let id = self.register_import(name, ty)?;
+                    (WorldKey::Interface(id), id)
+                } else {
+                    self.register_interface(name, ty, package)
+                        .with_context(|| format!("failed to decode WIT from import `{name}`"))?
+                };
+                (
+                    name,
+                    WorldItem::Interface {
+                        id,
+                        stability: Default::default(),
+                    },
+                )
+            }
+            types::ComponentEntityType::Func(i) => {
+                let ty = &self.types[i];
+                let func = self
+                    .convert_function(name, ty, owner)
+                    .with_context(|| format!("failed to decode function from import `{name}`"))?;
+                (WorldKey::Name(name.to_string()), WorldItem::Function(func))
+            }
+            types::ComponentEntityType::Type {
+                referenced,
+                created,
+            } => {
+                let id = self
+                    .register_type_export(name, owner, referenced, created)
+                    .with_context(|| format!("failed to decode type from export `{name}`"))?;
+                (WorldKey::Name(name.to_string()), WorldItem::Type(id))
+            }
+            // All other imports do not form part of the component's world
+            _ => return Ok(()),
+        };
+        self.resolve.worlds[world].imports.insert(name, item);
+        Ok(())
+    }
+
+    fn decode_component_export<'a>(
+        &mut self,
+        export: &DecodingExport,
+        world: WorldId,
+        package: &mut PackageFields<'a>,
+    ) -> Result<()> {
+        let name = &export.name;
+        log::debug!("decoding component export `{name}`");
+        let types = &self.types;
+        let ty = types.component_entity_type_of_export(name).unwrap();
+        let (name, item) = match ty {
+            types::ComponentEntityType::Func(i) => {
+                let ty = &types[i];
+                let func = self
+                    .convert_function(name, ty, TypeOwner::World(world))
+                    .with_context(|| format!("failed to decode function from export `{name}`"))?;
+
+                (WorldKey::Name(name.to_string()), WorldItem::Function(func))
+            }
+            types::ComponentEntityType::Instance(i) => {
+                let ty = &types[i];
+                let (name, id) = if name.contains('/') {
+                    let id = self.register_import(name, ty)?;
+                    (WorldKey::Interface(id), id)
+                } else {
+                    self.register_interface(name, ty, package)
+                        .with_context(|| format!("failed to decode WIT from export `{name}`"))?
+                };
+                (
+                    name,
+                    WorldItem::Interface {
+                        id,
+                        stability: Default::default(),
+                    },
+                )
+            }
+            _ => {
+                bail!("component export `{name}` was not a function or instance")
+            }
+        };
+        self.resolve.worlds[world].exports.insert(name, item);
+        Ok(())
+    }
+
+    /// Registers that the `name` provided is either imported interface from a
+    /// foreign package or  referencing a previously defined interface in this
+    /// package.
+    ///
+    /// This function will internally ensure that `name` is well-structured and
+    /// will fill in any information as necessary. For example with a foreign
+    /// dependency the foreign package structure, types, etc, all need to be
+    /// created. For a local dependency it's instead ensured that all the types
+    /// line up with the previous definitions.
+    fn register_import(
+        &mut self,
+        name: &str,
+        ty: &types::ComponentInstanceType,
+    ) -> Result<InterfaceId> {
+        let (is_local, interface) = match self.named_interfaces.get(name) {
+            Some(id) => (true, *id),
+            None => (false, self.extract_dep_interface(name)?),
+        };
+        let owner = TypeOwner::Interface(interface);
+        for (name, ty) in ty.exports.iter() {
+            log::debug!("decoding import instance export `{name}`");
+            match *ty {
+                types::ComponentEntityType::Type {
+                    referenced,
+                    created,
+                } => {
+                    match self.resolve.interfaces[interface]
+                        .types
+                        .get(name.as_str())
+                        .copied()
+                    {
+                        // If this name is already defined as a type in the
+                        // specified interface then that's ok. For package-local
+                        // interfaces that's expected since the interface was
+                        // fully defined. For remote interfaces it means we're
+                        // using something that was already used elsewhere. In
+                        // both cases continue along.
+                        //
+                        // Notably for the remotely defined case this will also
+                        // walk over the structure of the type and register
+                        // internal wasmparser ids with wit-parser ids. This is
+                        // necessary to ensure that anonymous types like
+                        // `list<u8>` defined in original definitions are
+                        // unified with anonymous types when duplicated inside
+                        // of worlds. Overall this prevents, for example, extra
+                        // `list<u8>` types from popping up when decoding. This
+                        // is not strictly necessary but assists with
+                        // roundtripping assertions during fuzzing.
+                        Some(id) => {
+                            log::debug!("type already exist");
+                            match referenced {
+                                types::ComponentAnyTypeId::Defined(ty) => {
+                                    self.register_defined(id, &self.types[ty])?;
+                                }
+                                types::ComponentAnyTypeId::Resource(_) => {}
+                                _ => unreachable!(),
+                            }
+                            let prev = self.type_map.insert(created, id);
+                            assert!(prev.is_none());
+                        }
+
+                        // If the name is not defined, however, then there's two
+                        // possibilities:
+                        //
+                        // * For package-local interfaces this is an error
+                        //   because the package-local interface defined
+                        //   everything already and this is referencing
+                        //   something that isn't defined.
+                        //
+                        // * For remote interfaces they're never fully declared
+                        //   so it's lazily filled in here. This means that the
+                        //   view of remote interfaces ends up being the minimal
+                        //   slice needed for this resolve, which is what's
+                        //   intended.
+                        None => {
+                            if is_local {
+                                bail!("instance type export `{name}` not defined in interface");
+                            }
+                            let id = self.register_type_export(
+                                name.as_str(),
+                                owner,
+                                referenced,
+                                created,
+                            )?;
+                            let prev = self.resolve.interfaces[interface]
+                                .types
+                                .insert(name.to_string(), id);
+                            assert!(prev.is_none());
+                        }
+                    }
+                }
+
+                // This has similar logic to types above where we lazily fill in
+                // functions for remote dependencies and otherwise assert
+                // they're already defined for local dependencies.
+                types::ComponentEntityType::Func(ty) => {
+                    let def = &self.types[ty];
+                    if self.resolve.interfaces[interface]
+                        .functions
+                        .contains_key(name.as_str())
+                    {
+                        // TODO: should ideally verify that function signatures
+                        // match.
+                        continue;
+                    }
+                    if is_local {
+                        bail!("instance function export `{name}` not defined in interface");
+                    }
+                    let func = self.convert_function(name.as_str(), def, owner)?;
+                    let prev = self.resolve.interfaces[interface]
+                        .functions
+                        .insert(name.to_string(), func);
+                    assert!(prev.is_none());
+                }
+
+                _ => bail!("instance type export `{name}` is not a type"),
+            }
+        }
+
+        Ok(interface)
+    }
+
+    fn find_alias(&self, id: types::ComponentAnyTypeId) -> Option<TypeId> {
+        // Consult `type_map` for `referenced` or anything in its
+        // chain of aliases to determine what it maps to. This may
+        // bottom out in `None` in the case that this type is
+        // just now being defined, but this should otherwise follow
+        // chains of aliases to determine what exactly this was a
+        // `use` of if it exists.
+        let mut prev = None;
+        let mut cur = id;
+        while prev.is_none() {
+            prev = self.type_map.get(&cur).copied();
+            cur = match self.types.peel_alias(cur) {
+                Some(next) => next,
+                None => break,
+            };
+        }
+        prev
+    }
+
+    /// This will parse the `name_string` as a component model ID string and
+    /// ensure that there's an `InterfaceId` corresponding to its components.
+    fn extract_dep_interface(&mut self, name_string: &str) -> Result<InterfaceId> {
+        let name = ComponentName::new(name_string, 0).unwrap();
+        let name = match name.kind() {
+            ComponentNameKind::Interface(name) => name,
+            _ => bail!("package name is not a valid id: {name_string}"),
+        };
+        let package_name = name.to_package_name();
+        // Lazily create a `Package` as necessary, along with the interface.
+        let package = self
+            .foreign_packages
+            .entry(package_name.to_string())
+            .or_insert_with(|| Package {
+                name: package_name.clone(),
+                docs: Default::default(),
+                interfaces: Default::default(),
+                worlds: Default::default(),
+            });
+        let interface = *package
+            .interfaces
+            .entry(name.interface().to_string())
+            .or_insert_with(|| {
+                self.resolve.interfaces.alloc(Interface {
+                    name: Some(name.interface().to_string()),
+                    docs: Default::default(),
+                    types: IndexMap::default(),
+                    functions: IndexMap::new(),
+                    package: None,
+                    stability: Default::default(),
+                })
+            });
+
+        // Record a mapping of which foreign package this interface belongs to
+        self.iface_to_package_index.insert(
+            interface,
+            self.foreign_packages
+                .get_full(&package_name.to_string())
+                .unwrap()
+                .0,
+        );
+        Ok(interface)
+    }
+
+    /// A general-purpose helper function to translate a component instance
+    /// into a WIT interface.
+    ///
+    /// This is one of the main workhorses of this module. This handles
+    /// interfaces both at the type level, for concrete components, and
+    /// internally within worlds as well.
+    ///
+    /// The `name` provided is the contextual ID or name of the interface. This
+    /// could be a kebab-name in the case of a world import or export or it can
+    /// also be an ID. This is used to guide insertion into various maps.
+    ///
+    /// The `ty` provided is the actual component type being decoded.
+    ///
+    /// The `package` is where to insert the final interface if `name` is an ID
+    /// meaning it's registered as a named standalone item within the package.
+    fn register_interface<'a>(
+        &mut self,
+        name: &str,
+        ty: &types::ComponentInstanceType,
+        package: &mut PackageFields<'a>,
+    ) -> Result<(WorldKey, InterfaceId)> {
+        // If this interface's name is already known then that means this is an
+        // interface that's both imported and exported.  Use `register_import`
+        // to draw connections between types and this interface's types.
+        if self.named_interfaces.contains_key(name) {
+            let id = self.register_import(name, ty)?;
+            return Ok((WorldKey::Interface(id), id));
+        }
+
+        // If this is a bare kebab-name for an interface then the interface's
+        // listed name is `None` and the name goes out through the key.
+        // Otherwise this name is extracted from `name` interpreted as an ID.
+        let interface_name = self.extract_interface_name_from_component_name(name)?;
+
+        let mut interface = Interface {
+            name: interface_name.clone(),
+            docs: Default::default(),
+            types: IndexMap::default(),
+            functions: IndexMap::new(),
+            package: None,
+            stability: Default::default(),
+        };
+
+        let owner = TypeOwner::Interface(self.resolve.interfaces.next_id());
+        for (name, ty) in ty.exports.iter() {
+            match *ty {
+                types::ComponentEntityType::Type {
+                    referenced,
+                    created,
+                } => {
+                    let ty = self
+                        .register_type_export(name.as_str(), owner, referenced, created)
+                        .with_context(|| format!("failed to register type export '{name}'"))?;
+                    let prev = interface.types.insert(name.to_string(), ty);
+                    assert!(prev.is_none());
+                }
+
+                types::ComponentEntityType::Func(ty) => {
+                    let ty = &self.types[ty];
+                    let func = self
+                        .convert_function(name.as_str(), ty, owner)
+                        .with_context(|| format!("failed to convert function '{name}'"))?;
+                    let prev = interface.functions.insert(name.to_string(), func);
+                    assert!(prev.is_none());
+                }
+                _ => bail!("instance type export `{name}` is not a type or function"),
+            };
+        }
+        let id = self.resolve.interfaces.alloc(interface);
+        let key = match interface_name {
+            // If this interface is named then it's part of the package, so
+            // insert it. Additionally register it in `named_interfaces` so
+            // further use comes back to this original definition.
+            Some(interface_name) => {
+                let prev = package.interfaces.insert(interface_name, id);
+                assert!(prev.is_none(), "duplicate interface added for {name:?}");
+                let prev = self.named_interfaces.insert(name.to_string(), id);
+                assert!(prev.is_none());
+                WorldKey::Interface(id)
+            }
+
+            // If this interface isn't named then its key is always a
+            // kebab-name.
+            None => WorldKey::Name(name.to_string()),
+        };
+        Ok((key, id))
+    }
+
+    fn parse_component_name(&self, name: &str) -> Result<ComponentName> {
+        ComponentName::new(name, 0)
+            .with_context(|| format!("cannot extract item name from: {name}"))
+    }
+
+    fn extract_interface_name_from_component_name(&self, name: &str) -> Result<Option<String>> {
+        let component_name = self.parse_component_name(name)?;
+        match component_name.kind() {
+            ComponentNameKind::Interface(name) => Ok(Some(name.interface().to_string())),
+            ComponentNameKind::Label(_name) => Ok(None),
+            _ => bail!("cannot extract item name from: {name}"),
+        }
+    }
+
+    fn register_type_export(
+        &mut self,
+        name: &str,
+        owner: TypeOwner,
+        referenced: types::ComponentAnyTypeId,
+        created: types::ComponentAnyTypeId,
+    ) -> Result<TypeId> {
+        let kind = match self.find_alias(referenced) {
+            // If this `TypeId` points to a type which has
+            // previously been defined, meaning we're aliasing a
+            // prior definition.
+            Some(prev) => {
+                log::debug!("type export for `{name}` is an alias");
+                TypeDefKind::Type(Type::Id(prev))
+            }
+
+            // ... or this `TypeId`'s source definition has never
+            // been seen before, so declare the full type.
+            None => {
+                log::debug!("type export for `{name}` is a new type");
+                match referenced {
+                    types::ComponentAnyTypeId::Defined(ty) => self
+                        .convert_defined(&self.types[ty])
+                        .context("failed to convert unaliased type")?,
+                    types::ComponentAnyTypeId::Resource(_) => TypeDefKind::Resource,
+                    _ => unreachable!(),
+                }
+            }
+        };
+        let ty = self.resolve.types.alloc(TypeDef {
+            name: Some(name.to_string()),
+            kind,
+            docs: Default::default(),
+            stability: Default::default(),
+            owner,
+        });
+
+        // If this is a resource then doubly-register it in `self.resources` so
+        // the ID allocated here can be looked up via name later on during
+        // `convert_function`.
+        if let TypeDefKind::Resource = self.resolve.types[ty].kind {
+            let prev = self
+                .resources
+                .entry(owner)
+                .or_insert(HashMap::new())
+                .insert(name.to_string(), ty);
+            assert!(prev.is_none());
+        }
+
+        let prev = self.type_map.insert(created, ty);
+        assert!(prev.is_none());
+        Ok(ty)
+    }
+
+    fn register_world<'a>(
+        &mut self,
+        name: &str,
+        ty: &types::ComponentType,
+        package: &mut PackageFields<'a>,
+    ) -> Result<WorldId> {
+        let name = self
+            .extract_interface_name_from_component_name(name)?
+            .context("expected world name to have an ID form")?;
+        let mut world = World {
+            name: name.clone(),
+            docs: Default::default(),
+            imports: Default::default(),
+            exports: Default::default(),
+            includes: Default::default(),
+            include_names: Default::default(),
+            package: None,
+            stability: Default::default(),
+        };
+
+        let owner = TypeOwner::World(self.resolve.worlds.next_id());
+        for (name, ty) in ty.imports.iter() {
+            let (name, item) = match ty {
+                types::ComponentEntityType::Instance(idx) => {
+                    let ty = &self.types[*idx];
+                    let (name, id) = if name.contains('/') {
+                        // If a name is an interface import then it is either to
+                        // a package-local or foreign interface, and both
+                        // situations are handled in `register_import`.
+                        let id = self.register_import(name, ty)?;
+                        (WorldKey::Interface(id), id)
+                    } else {
+                        // A plain kebab-name indicates an inline interface that
+                        // wasn't declared explicitly elsewhere with a name, and
+                        // `register_interface` will create a new `Interface`
+                        // with no name.
+                        self.register_interface(name, ty, package)?
+                    };
+                    (
+                        name,
+                        WorldItem::Interface {
+                            id,
+                            stability: Default::default(),
+                        },
+                    )
+                }
+                types::ComponentEntityType::Type {
+                    created,
+                    referenced,
+                } => {
+                    let ty =
+                        self.register_type_export(name.as_str(), owner, *referenced, *created)?;
+                    (WorldKey::Name(name.to_string()), WorldItem::Type(ty))
+                }
+                types::ComponentEntityType::Func(idx) => {
+                    let ty = &self.types[*idx];
+                    let func = self.convert_function(name.as_str(), ty, owner)?;
+                    (WorldKey::Name(name.to_string()), WorldItem::Function(func))
+                }
+                _ => bail!("component import `{name}` is not an instance, func, or type"),
+            };
+            world.imports.insert(name, item);
+        }
+
+        for (name, ty) in ty.exports.iter() {
+            let (name, item) = match ty {
+                types::ComponentEntityType::Instance(idx) => {
+                    let ty = &self.types[*idx];
+                    let (name, id) = if name.contains('/') {
+                        // Note that despite this being an export this is
+                        // calling `register_import`. With a URL this interface
+                        // must have been previously defined so this will
+                        // trigger the logic of either filling in a remotely
+                        // defined interface or connecting items to local
+                        // definitions of our own interface.
+                        let id = self.register_import(name, ty)?;
+                        (WorldKey::Interface(id), id)
+                    } else {
+                        self.register_interface(name, ty, package)?
+                    };
+                    (
+                        name,
+                        WorldItem::Interface {
+                            id,
+                            stability: Default::default(),
+                        },
+                    )
+                }
+
+                types::ComponentEntityType::Func(idx) => {
+                    let ty = &self.types[*idx];
+                    let func = self.convert_function(name.as_str(), ty, owner)?;
+                    (WorldKey::Name(name.to_string()), WorldItem::Function(func))
+                }
+
+                _ => bail!("component export `{name}` is not an instance or function"),
+            };
+            world.exports.insert(name, item);
+        }
+        let id = self.resolve.worlds.alloc(world);
+        let prev = package.worlds.insert(name, id);
+        assert!(prev.is_none());
+        Ok(id)
+    }
+
+    fn convert_function(
+        &mut self,
+        name: &str,
+        ty: &types::ComponentFuncType,
+        owner: TypeOwner,
+    ) -> Result<Function> {
+        let name = ComponentName::new(name, 0).unwrap();
+        let params = ty
+            .params
+            .iter()
+            .map(|(name, ty)| Ok((name.to_string(), self.convert_valtype(ty)?)))
+            .collect::<Result<Vec<_>>>()
+            .context("failed to convert params")?;
+        let results = if ty.results.len() == 1 && ty.results[0].0.is_none() {
+            Results::Anon(
+                self.convert_valtype(&ty.results[0].1)
+                    .context("failed to convert anonymous result type")?,
+            )
+        } else {
+            Results::Named(
+                ty.results
+                    .iter()
+                    .map(|(name, ty)| {
+                        Ok((
+                            name.as_ref().unwrap().to_string(),
+                            self.convert_valtype(ty)?,
+                        ))
+                    })
+                    .collect::<Result<Vec<_>>>()
+                    .context("failed to convert named result types")?,
+            )
+        };
+        Ok(Function {
+            docs: Default::default(),
+            stability: Default::default(),
+            kind: match name.kind() {
+                ComponentNameKind::Label(_) => FunctionKind::Freestanding,
+                ComponentNameKind::Constructor(resource) => {
+                    FunctionKind::Constructor(self.resources[&owner][resource.as_str()])
+                }
+                ComponentNameKind::Method(name) => {
+                    FunctionKind::Method(self.resources[&owner][name.resource().as_str()])
+                }
+                ComponentNameKind::Static(name) => {
+                    FunctionKind::Static(self.resources[&owner][name.resource().as_str()])
+                }
+
+                // Functions shouldn't have ID-based names at this time.
+                ComponentNameKind::Interface(_)
+                | ComponentNameKind::Url(_)
+                | ComponentNameKind::Hash(_)
+                | ComponentNameKind::Dependency(_) => unreachable!(),
+            },
+
+            // Note that this name includes "name mangling" such as
+            // `[method]foo.bar` which is intentional. The `FunctionKind`
+            // discriminant calculated above indicates how to interpret this
+            // name.
+            name: name.to_string(),
+            params,
+            results,
+        })
+    }
+
+    fn convert_valtype(&mut self, ty: &types::ComponentValType) -> Result<Type> {
+        let id = match ty {
+            types::ComponentValType::Primitive(ty) => return Ok(self.convert_primitive(*ty)),
+            types::ComponentValType::Type(id) => *id,
+        };
+
+        // Don't create duplicate types for anything previously created.
+        if let Some(ret) = self.type_map.get(&id.into()) {
+            return Ok(Type::Id(*ret));
+        }
+
+        // Otherwise create a new `TypeDef` without a name since this is an
+        // anonymous valtype. Note that this is invalid for some types so return
+        // errors on those types, but eventually the `bail!` here  is
+        // more-or-less unreachable due to expected validation to be added to
+        // the component model binary format itself.
+        let def = &self.types[id];
+        let kind = self.convert_defined(def)?;
+        match &kind {
+            TypeDefKind::Type(_)
+            | TypeDefKind::List(_)
+            | TypeDefKind::Tuple(_)
+            | TypeDefKind::Option(_)
+            | TypeDefKind::Result(_)
+            | TypeDefKind::Handle(_) => {}
+
+            TypeDefKind::Resource
+            | TypeDefKind::Record(_)
+            | TypeDefKind::Enum(_)
+            | TypeDefKind::Variant(_)
+            | TypeDefKind::Flags(_)
+            | TypeDefKind::Future(_)
+            | TypeDefKind::Stream(_) => {
+                bail!("unexpected unnamed type of kind '{}'", kind.as_str());
+            }
+            TypeDefKind::Unknown => unreachable!(),
+        }
+        let ty = self.resolve.types.alloc(TypeDef {
+            name: None,
+            docs: Default::default(),
+            stability: Default::default(),
+            owner: TypeOwner::None,
+            kind,
+        });
+        let prev = self.type_map.insert(id.into(), ty);
+        assert!(prev.is_none());
+        Ok(Type::Id(ty))
+    }
+
+    /// Converts a wasmparser `ComponentDefinedType`, the definition of a type
+    /// in the component model, to a WIT `TypeDefKind` to get inserted into the
+    /// types arena by the caller.
+    fn convert_defined(&mut self, ty: &types::ComponentDefinedType) -> Result<TypeDefKind> {
+        match ty {
+            types::ComponentDefinedType::Primitive(t) => {
+                Ok(TypeDefKind::Type(self.convert_primitive(*t)))
+            }
+
+            types::ComponentDefinedType::List(t) => {
+                let t = self.convert_valtype(t)?;
+                Ok(TypeDefKind::List(t))
+            }
+
+            types::ComponentDefinedType::Tuple(t) => {
+                let types = t
+                    .types
+                    .iter()
+                    .map(|t| self.convert_valtype(t))
+                    .collect::<Result<_>>()?;
+                Ok(TypeDefKind::Tuple(Tuple { types }))
+            }
+
+            types::ComponentDefinedType::Option(t) => {
+                let t = self.convert_valtype(t)?;
+                Ok(TypeDefKind::Option(t))
+            }
+
+            types::ComponentDefinedType::Result { ok, err } => {
+                let ok = match ok {
+                    Some(t) => Some(self.convert_valtype(t)?),
+                    None => None,
+                };
+                let err = match err {
+                    Some(t) => Some(self.convert_valtype(t)?),
+                    None => None,
+                };
+                Ok(TypeDefKind::Result(Result_ { ok, err }))
+            }
+
+            types::ComponentDefinedType::Record(r) => {
+                let fields = r
+                    .fields
+                    .iter()
+                    .map(|(name, ty)| {
+                        Ok(Field {
+                            name: name.to_string(),
+                            ty: self.convert_valtype(ty).with_context(|| {
+                                format!("failed to convert record field '{name}'")
+                            })?,
+                            docs: Default::default(),
+                        })
+                    })
+                    .collect::<Result<_>>()?;
+                Ok(TypeDefKind::Record(Record { fields }))
+            }
+
+            types::ComponentDefinedType::Variant(v) => {
+                let cases = v
+                    .cases
+                    .iter()
+                    .map(|(name, case)| {
+                        if case.refines.is_some() {
+                            bail!("unimplemented support for `refines`");
+                        }
+                        Ok(Case {
+                            name: name.to_string(),
+                            ty: match &case.ty {
+                                Some(ty) => Some(self.convert_valtype(ty)?),
+                                None => None,
+                            },
+                            docs: Default::default(),
+                        })
+                    })
+                    .collect::<Result<_>>()?;
+                Ok(TypeDefKind::Variant(Variant { cases }))
+            }
+
+            types::ComponentDefinedType::Flags(f) => {
+                let flags = f
+                    .iter()
+                    .map(|name| Flag {
+                        name: name.to_string(),
+                        docs: Default::default(),
+                    })
+                    .collect();
+                Ok(TypeDefKind::Flags(Flags { flags }))
+            }
+
+            types::ComponentDefinedType::Enum(e) => {
+                let cases = e
+                    .iter()
+                    .cloned()
+                    .map(|name| EnumCase {
+                        name: name.into(),
+                        docs: Default::default(),
+                    })
+                    .collect();
+                Ok(TypeDefKind::Enum(Enum { cases }))
+            }
+
+            types::ComponentDefinedType::Own(id) => {
+                let id = self.type_map[&(*id).into()];
+                Ok(TypeDefKind::Handle(Handle::Own(id)))
+            }
+
+            types::ComponentDefinedType::Borrow(id) => {
+                let id = self.type_map[&(*id).into()];
+                Ok(TypeDefKind::Handle(Handle::Borrow(id)))
+            }
+        }
+    }
+
+    fn convert_primitive(&self, ty: PrimitiveValType) -> Type {
+        match ty {
+            PrimitiveValType::U8 => Type::U8,
+            PrimitiveValType::S8 => Type::S8,
+            PrimitiveValType::U16 => Type::U16,
+            PrimitiveValType::S16 => Type::S16,
+            PrimitiveValType::U32 => Type::U32,
+            PrimitiveValType::S32 => Type::S32,
+            PrimitiveValType::U64 => Type::U64,
+            PrimitiveValType::S64 => Type::S64,
+            PrimitiveValType::Bool => Type::Bool,
+            PrimitiveValType::Char => Type::Char,
+            PrimitiveValType::String => Type::String,
+            PrimitiveValType::F32 => Type::F32,
+            PrimitiveValType::F64 => Type::F64,
+        }
+    }
+
+    fn register_defined(&mut self, id: TypeId, def: &types::ComponentDefinedType) -> Result<()> {
+        Registrar {
+            types: &self.types,
+            type_map: &mut self.type_map,
+            resolve: &self.resolve,
+        }
+        .defined(id, def)
+    }
+
+    /// Completes the decoding of this resolve by finalizing all packages into
+    /// their topological ordering within the returned `Resolve`.
+    ///
+    /// Takes the root package as an argument to insert.
+    fn finish(mut self, package: Package) -> (Resolve, PackageId) {
+        // Build a topological ordering is then calculated by visiting all the
+        // transitive dependencies of packages.
+        let mut order = IndexSet::new();
+        for i in 0..self.foreign_packages.len() {
+            self.visit_package(i, &mut order);
+        }
+
+        // Using the topological ordering create a temporary map from
+        // index-in-`foreign_packages` to index-in-`order`
+        let mut idx_to_pos = vec![0; self.foreign_packages.len()];
+        for (pos, idx) in order.iter().enumerate() {
+            idx_to_pos[*idx] = pos;
+        }
+        // .. and then using `idx_to_pos` sort the `foreign_packages` array based
+        // on the position it's at in the topological ordering
+        let mut deps = mem::take(&mut self.foreign_packages)
+            .into_iter()
+            .enumerate()
+            .collect::<Vec<_>>();
+        deps.sort_by_key(|(idx, _)| idx_to_pos[*idx]);
+
+        // .. and finally insert the packages, in their final topological
+        // ordering, into the returned array.
+        for (_idx, (_url, pkg)) in deps {
+            self.insert_package(pkg);
+        }
+
+        let id = self.insert_package(package);
+        assert!(self.resolve.worlds.iter().all(|(_, w)| w.package.is_some()));
+        assert!(self
+            .resolve
+            .interfaces
+            .iter()
+            .all(|(_, i)| i.package.is_some()));
+        (self.resolve, id)
+    }
+
+    fn insert_package(&mut self, package: Package) -> PackageId {
+        let Package {
+            name,
+            interfaces,
+            worlds,
+            docs,
+        } = package;
+
+        // Most of the time the `package` being inserted is not already present
+        // in `self.resolve`, but in the case of the top-level `decode_world`
+        // function this isn't the case. This shouldn't in general be a problem
+        // so union-up the packages here while asserting that nothing gets
+        // replaced by accident which would indicate a bug.
+        let pkg = self
+            .resolve
+            .package_names
+            .get(&name)
+            .copied()
+            .unwrap_or_else(|| {
+                let id = self.resolve.packages.alloc(Package {
+                    name: name.clone(),
+                    interfaces: Default::default(),
+                    worlds: Default::default(),
+                    docs,
+                });
+                let prev = self.resolve.package_names.insert(name, id);
+                assert!(prev.is_none());
+                id
+            });
+
+        for (name, id) in interfaces {
+            let prev = self.resolve.packages[pkg].interfaces.insert(name, id);
+            assert!(prev.is_none());
+            self.resolve.interfaces[id].package = Some(pkg);
+        }
+
+        for (name, id) in worlds {
+            let prev = self.resolve.packages[pkg].worlds.insert(name, id);
+            assert!(prev.is_none());
+            let world = &mut self.resolve.worlds[id];
+            world.package = Some(pkg);
+            for (name, item) in world.imports.iter().chain(world.exports.iter()) {
+                if let WorldKey::Name(_) = name {
+                    if let WorldItem::Interface { id, .. } = item {
+                        self.resolve.interfaces[*id].package = Some(pkg);
+                    }
+                }
+            }
+        }
+
+        pkg
+    }
+
+    fn visit_package(&self, idx: usize, order: &mut IndexSet<usize>) {
+        if order.contains(&idx) {
+            return;
+        }
+
+        let (_name, pkg) = self.foreign_packages.get_index(idx).unwrap();
+        let interfaces = pkg.interfaces.values().copied().chain(
+            pkg.worlds
+                .values()
+                .flat_map(|w| {
+                    let world = &self.resolve.worlds[*w];
+                    world.imports.values().chain(world.exports.values())
+                })
+                .filter_map(|item| match item {
+                    WorldItem::Interface { id, .. } => Some(*id),
+                    WorldItem::Function(_) | WorldItem::Type(_) => None,
+                }),
+        );
+        for iface in interfaces {
+            for dep in self.resolve.interface_direct_deps(iface) {
+                let dep_idx = self.iface_to_package_index[&dep];
+                if dep_idx != idx {
+                    self.visit_package(dep_idx, order);
+                }
+            }
+        }
+
+        assert!(order.insert(idx));
+    }
+}
+
+/// Helper type to register the structure of a wasm-defined type against a
+/// wit-defined type.
+struct Registrar<'a> {
+    types: &'a types::Types,
+    type_map: &'a mut HashMap<types::ComponentAnyTypeId, TypeId>,
+    resolve: &'a Resolve,
+}
+
+impl Registrar<'_> {
+    /// Verifies that the wasm structure of `def` matches the wit structure of
+    /// `id` and recursively registers types.
+    fn defined(&mut self, id: TypeId, def: &types::ComponentDefinedType) -> Result<()> {
+        match def {
+            types::ComponentDefinedType::Primitive(_) => Ok(()),
+
+            types::ComponentDefinedType::List(t) => {
+                let ty = match &self.resolve.types[id].kind {
+                    TypeDefKind::List(r) => r,
+                    // Note that all cases below have this match and the general
+                    // idea is that once a type is named or otherwise identified
+                    // here there's no need to recurse. The purpose of this
+                    // registrar is to build connections for anonymous types
+                    // that don't otherwise have a name to ensure that they're
+                    // decoded to reuse the same constructs consistently. For
+                    // that reason once something is named we can bail out.
+                    TypeDefKind::Type(Type::Id(_)) => return Ok(()),
+                    _ => bail!("expected a list"),
+                };
+                self.valtype(t, ty)
+            }
+
+            types::ComponentDefinedType::Tuple(t) => {
+                let ty = match &self.resolve.types[id].kind {
+                    TypeDefKind::Tuple(r) => r,
+                    TypeDefKind::Type(Type::Id(_)) => return Ok(()),
+                    _ => bail!("expected a tuple"),
+                };
+                if ty.types.len() != t.types.len() {
+                    bail!("mismatched number of tuple fields");
+                }
+                for (a, b) in t.types.iter().zip(ty.types.iter()) {
+                    self.valtype(a, b)?;
+                }
+                Ok(())
+            }
+
+            types::ComponentDefinedType::Option(t) => {
+                let ty = match &self.resolve.types[id].kind {
+                    TypeDefKind::Option(r) => r,
+                    TypeDefKind::Type(Type::Id(_)) => return Ok(()),
+                    _ => bail!("expected an option"),
+                };
+                self.valtype(t, ty)
+            }
+
+            types::ComponentDefinedType::Result { ok, err } => {
+                let ty = match &self.resolve.types[id].kind {
+                    TypeDefKind::Result(r) => r,
+                    TypeDefKind::Type(Type::Id(_)) => return Ok(()),
+                    _ => bail!("expected a result"),
+                };
+                match (ok, &ty.ok) {
+                    (Some(a), Some(b)) => self.valtype(a, b)?,
+                    (None, None) => {}
+                    _ => bail!("disagreement on result structure"),
+                }
+                match (err, &ty.err) {
+                    (Some(a), Some(b)) => self.valtype(a, b)?,
+                    (None, None) => {}
+                    _ => bail!("disagreement on result structure"),
+                }
+                Ok(())
+            }
+
+            types::ComponentDefinedType::Record(def) => {
+                let ty = match &self.resolve.types[id].kind {
+                    TypeDefKind::Record(r) => r,
+                    TypeDefKind::Type(Type::Id(_)) => return Ok(()),
+                    _ => bail!("expected a record"),
+                };
+                if def.fields.len() != ty.fields.len() {
+                    bail!("mismatched number of record fields");
+                }
+                for ((name, ty), field) in def.fields.iter().zip(&ty.fields) {
+                    if name.as_str() != field.name {
+                        bail!("mismatched field order");
+                    }
+                    self.valtype(ty, &field.ty)?;
+                }
+                Ok(())
+            }
+
+            types::ComponentDefinedType::Variant(def) => {
+                let ty = match &self.resolve.types[id].kind {
+                    TypeDefKind::Variant(r) => r,
+                    TypeDefKind::Type(Type::Id(_)) => return Ok(()),
+                    _ => bail!("expected a variant"),
+                };
+                if def.cases.len() != ty.cases.len() {
+                    bail!("mismatched number of variant cases");
+                }
+                for ((name, ty), case) in def.cases.iter().zip(&ty.cases) {
+                    if name.as_str() != case.name {
+                        bail!("mismatched case order");
+                    }
+                    match (&ty.ty, &case.ty) {
+                        (Some(a), Some(b)) => self.valtype(a, b)?,
+                        (None, None) => {}
+                        _ => bail!("disagreement on case type"),
+                    }
+                }
+                Ok(())
+            }
+
+            // These have no recursive structure so they can bail out.
+            types::ComponentDefinedType::Flags(_)
+            | types::ComponentDefinedType::Enum(_)
+            | types::ComponentDefinedType::Own(_)
+            | types::ComponentDefinedType::Borrow(_) => Ok(()),
+        }
+    }
+
+    fn valtype(&mut self, wasm: &types::ComponentValType, wit: &Type) -> Result<()> {
+        let wasm = match wasm {
+            types::ComponentValType::Type(wasm) => *wasm,
+            types::ComponentValType::Primitive(_wasm) => {
+                assert!(!matches!(wit, Type::Id(_)));
+                return Ok(());
+            }
+        };
+        let wit = match wit {
+            Type::Id(id) => *id,
+            _ => bail!("expected id-based type"),
+        };
+        let prev = match self.type_map.insert(wasm.into(), wit) {
+            Some(prev) => prev,
+            None => {
+                let wasm = &self.types[wasm];
+                return self.defined(wit, wasm);
+            }
+        };
+        // If `wit` matches `prev` then we've just rediscovered what we already
+        // knew which is that the `wasm` id maps to the `wit` id.
+        //
+        // If, however, `wit` is not equal to `prev` then that's more
+        // interesting. Consider a component such as:
+        //
+        // ```wasm
+        // (component
+        //   (import (interface "a:b/name") (instance
+        //      (type $l (list string))
+        //      (type $foo (variant (case "l" $l)))
+        //      (export "foo" (type (eq $foo)))
+        //   ))
+        //   (component $c
+        //     (type $l (list string))
+        //     (type $bar (variant (case "n" u16) (case "l" $l)))
+        //     (export "bar" (type $bar))
+        //     (type $foo (variant (case "l" $l)))
+        //     (export "foo" (type $foo))
+        //   )
+        //   (instance $i (instantiate $c))
+        //   (export (interface "a:b/name") (instance $i))
+        // )
+        // ```
+        //
+        // This roughly corresponds to:
+        //
+        // ```wit
+        // package a:b
+        //
+        // interface name {
+        //   variant bar {
+        //     n(u16),
+        //     l(list<string>),
+        //   }
+        //
+        //   variant foo {
+        //     l(list<string>),
+        //   }
+        // }
+        //
+        // world module {
+        //   import name
+        //   export name
+        // }
+        // ```
+        //
+        // In this situation first we'll see the `import` which records type
+        // information for the `foo` type in `interface name`. Later on the full
+        // picture of `interface name` becomes apparent with the export of a
+        // component which has full type information. When walking over this
+        // first `bar` is seen and its recursive structure.
+        //
+        // The problem arises when walking over the `foo` type. In this
+        // situation the code path we're currently on will be hit because
+        // there's a preexisting definition of `foo` from the import and it's
+        // now going to be unified with what we've seen in the export. When
+        // visiting the `list<string>` case of the `foo` variant this ends up
+        // being different than the `list<string>` used by the `bar` variant. The
+        // reason for this is that when visiting `bar` the wasm-defined `(list
+        // string)` hasn't been seen before so a new type is allocated. Later
+        // though this same wasm type is unified with the first `(list string)`
+        // type in the `import`.
+        //
+        // All-in-all this ends up meaning that it's possible for `prev` to not
+        // match `wit`. In this situation it means the decoded WIT interface
+        // will have duplicate definitions of `list<string>`. This is,
+        // theoretically, not that big of a problem because the same underlying
+        // definition is still there and the meaning of the type is the same.
+        // This can, however, perhaps be a problem for consumers where it's
+        // assumed that all `list<string>` are equal and there's only one. For
+        // example a bindings generator for C may assume that `list<string>`
+        // will only appear once and generate a single name for it, but with two
+        // different types in play here it may generate two types of the same
+        // name (or something like that).
+        //
+        // For now though this is left for a future refactoring. Fixing this
+        // issue would require tracking anonymous types during type translation
+        // so the decoding process for the `bar` export would reuse the
+        // `list<string>` type created from decoding the `foo` import. That's
+        // somewhat nontrivial at this time, so it's left for a future
+        // refactoring.
+        let _ = prev;
+        Ok(())
+    }
+}
+
+pub(crate) trait InterfaceNameExt {
+    fn to_package_name(&self) -> PackageName;
+}
+
+impl InterfaceNameExt for wasmparser::names::InterfaceName<'_> {
+    fn to_package_name(&self) -> PackageName {
+        PackageName {
+            namespace: self.namespace().to_string(),
+            name: self.package().to_string(),
+            version: self.version(),
+        }
+    }
+}