diff --git a/build/assembly/product_assembly_configuration.gni b/build/assembly/product_assembly_configuration.gni
index 7f9f399..2043a32 100644
--- a/build/assembly/product_assembly_configuration.gni
+++ b/build/assembly/product_assembly_configuration.gni
@@ -126,9 +126,20 @@
         packages.cache = []
       }
 
-      packages.base += rebase_path(files.base_package_manifests, root_build_dir)
-      packages.cache +=
-          rebase_path(files.cache_package_manifests, root_build_dir)
+      foreach(manifest_path, files.base_package_manifests) {
+        packages.base += [
+          {
+            manifest = rebase_path(manifest_path, root_build_dir)
+          },
+        ]
+      }
+      foreach(manifest_path, files.cache_package_manifests) {
+        packages.cache += [
+          {
+            manifest = rebase_path(manifest_path, root_build_dir)
+          },
+        ]
+      }
     }
   }
 
diff --git a/build/assembly/scripts/compare_image_assembly_config_contents.py b/build/assembly/scripts/compare_image_assembly_config_contents.py
index 2962d1f..c246f32 100644
--- a/build/assembly/scripts/compare_image_assembly_config_contents.py
+++ b/build/assembly/scripts/compare_image_assembly_config_contents.py
@@ -205,16 +205,25 @@
     errors = []
     errors.extend(
         compare_pkg_sets(
-            legacy.base | set(product_packages.get('base', [])), generated.base,
-            "base"))
+            legacy.base | set(
+                [
+                    entry["manifest"]
+                    for entry in product_packages.get('base', [])
+                ]), generated.base, "base"))
     errors.extend(
         compare_pkg_sets(
-            legacy.cache | set(product_packages.get('cache', [])),
-            generated.cache, "cache"))
+            legacy.cache | set(
+                [
+                    entry["manifest"]
+                    for entry in product_packages.get('cache', [])
+                ]), generated.cache, "cache"))
     errors.extend(
         compare_pkg_sets(
-            legacy.system | set(product_packages.get('system', [])),
-            generated.system, "system"))
+            legacy.system | set(
+                [
+                    entry["manifest"]
+                    for entry in product_packages.get('system', [])
+                ]), generated.system, "system"))
 
     errors.extend(
         compare_file_entry_sets(
diff --git a/build/assembly/scripts/generated_assembly_inputs.py b/build/assembly/scripts/generated_assembly_inputs.py
index 7940d5c..5fdeab2 100644
--- a/build/assembly/scripts/generated_assembly_inputs.py
+++ b/build/assembly/scripts/generated_assembly_inputs.py
@@ -10,6 +10,8 @@
 
 from depfile import DepFile
 
+from typing import Dict, Optional
+
 
 def main():
     parser = argparse.ArgumentParser(
@@ -50,13 +52,18 @@
     # Add a package and all the included blobs.
     manifests_for_depfile = []
 
-    def add_package(manifest):
+    def add_package(entry: Dict):
+        manifest = entry["manifest"]
         manifests_for_depfile.append(manifest)
         add_source(manifest)
         with open(manifest, 'r') as f:
             manifest = json.load(f)
             for blob in manifest.get("blobs", []):
                 add_source(blob["source_path"])
+        config_data: Optional[Dict[str, str]] = entry.get("config_data")
+        if config_data:
+            for (_dest, source) in config_data.items():
+                add_source(source)
 
     # Add the product config.
     add_source(args.product_config.name)
diff --git a/src/developer/ffx/plugins/assembly/BUILD.gn b/src/developer/ffx/plugins/assembly/BUILD.gn
index 1b482c2..e0f414e 100644
--- a/src/developer/ffx/plugins/assembly/BUILD.gn
+++ b/src/developer/ffx/plugins/assembly/BUILD.gn
@@ -50,6 +50,7 @@
     "//src/lib/assembly/images_manifest",
     "//src/lib/assembly/minfs",
     "//src/lib/assembly/package_list",
+    "//src/lib/assembly/package_utils",
     "//src/lib/assembly/partitions_config",
     "//src/lib/assembly/structured_config",
     "//src/lib/assembly/test_keys",
diff --git a/src/developer/ffx/plugins/assembly/src/operations/product/assembly_builder.rs b/src/developer/ffx/plugins/assembly/src/operations/product/assembly_builder.rs
index e3198a1..5b3f5191 100644
--- a/src/developer/ffx/plugins/assembly/src/operations/product/assembly_builder.rs
+++ b/src/developer/ffx/plugins/assembly/src/operations/product/assembly_builder.rs
@@ -163,10 +163,10 @@
     /// flagged as being the issue (and not the platform being the issue).
     pub fn add_product_packages(&mut self, packages: &ProductPackagesConfig) -> Result<()> {
         for p in &packages.base {
-            self.base.add_package_from_path(p)?
+            self.base.add_package_from_path(p.manifest.as_std_path())?
         }
         for p in &packages.cache {
-            self.cache.add_package_from_path(p)?
+            self.cache.add_package_from_path(p.manifest.as_std_path())?
         }
         Ok(())
     }
@@ -469,22 +469,24 @@
 #[cfg(test)]
 mod tests {
     use super::*;
+    use assembly_package_utils::PackageManifestPathBuf;
     use camino::Utf8PathBuf;
     use fuchsia_pkg::{PackageBuilder, PackageManifest};
     use std::fs::File;
     use tempfile::TempDir;
 
-    fn write_empty_pkg(path: impl AsRef<Path>, name: &str) -> Utf8PathBuf {
+    fn write_empty_pkg(path: impl AsRef<Path>, name: &str) -> PackageManifestPathBuf {
         let path = path.as_ref();
         let mut builder = PackageBuilder::new(name);
         let manifest_path = path.join(name);
         builder.manifest_path(&manifest_path);
         builder.build(path, path.join(format!("{}_meta.far", name))).unwrap();
-        Utf8PathBuf::from_path_buf(manifest_path).unwrap()
+        Utf8PathBuf::from_path_buf(manifest_path).unwrap().into()
     }
 
     fn make_test_assembly_bundle(bundle_path: &Path) -> AssemblyInputBundle {
-        let write_empty_bundle_pkg = |name: &str| write_empty_pkg(bundle_path, name).into();
+        let write_empty_bundle_pkg =
+            |name: &str| write_empty_pkg(bundle_path, name).clone().into_std_path_buf();
         AssemblyInputBundle {
             image_assembly: image_assembly_config::PartialImageAssemblyConfig {
                 base: vec![write_empty_bundle_pkg("base_package0")],
@@ -604,8 +606,14 @@
         let outdir = TempDir::new().unwrap();
 
         let packages = ProductPackagesConfig {
-            base: vec![write_empty_pkg(&outdir, "base_a"), write_empty_pkg(&outdir, "base_b")],
-            cache: vec![write_empty_pkg(&outdir, "cache_a"), write_empty_pkg(&outdir, "cache_b")],
+            base: vec![
+                write_empty_pkg(&outdir, "base_a").into(),
+                write_empty_pkg(&outdir, "base_b").into(),
+            ],
+            cache: vec![
+                write_empty_pkg(&outdir, "cache_a").into(),
+                write_empty_pkg(&outdir, "cache_b").into(),
+            ],
         };
         let minimum_bundle = AssemblyInputBundle {
             image_assembly: image_assembly_config::PartialImageAssemblyConfig {
@@ -647,7 +655,7 @@
         let outdir = TempDir::new().unwrap();
 
         let packages = ProductPackagesConfig {
-            base: vec![write_empty_pkg(&outdir, "base_a")],
+            base: vec![write_empty_pkg(&outdir, "base_a").into()],
             ..ProductPackagesConfig::default()
         };
         let minimum_bundle = AssemblyInputBundle {
diff --git a/src/lib/assembly/BUILD.gn b/src/lib/assembly/BUILD.gn
index a706b66..a102217 100644
--- a/src/lib/assembly/BUILD.gn
+++ b/src/lib/assembly/BUILD.gn
@@ -14,6 +14,7 @@
       "images_config:host_tests",
       "images_manifest:host_tests",
       "minfs:host_tests",
+      "package_utils:host_tests",
       "partitions_config:host_tests",
       "structured_config:host_tests",
       "test_util:host_tests",
diff --git a/src/lib/assembly/config/BUILD.gn b/src/lib/assembly/config/BUILD.gn
index a7cda17..5f7a5a0 100644
--- a/src/lib/assembly/config/BUILD.gn
+++ b/src/lib/assembly/config/BUILD.gn
@@ -14,6 +14,7 @@
       "//sdk/fidl/fuchsia.logger:fuchsia.logger-rustc",
       "//src/developer/ffx/config:lib",
       "//src/lib/assembly/fvm",
+      "//src/lib/assembly/package_utils",
       "//src/lib/assembly/util",
       "//third_party/rust_crates:anyhow",
       "//third_party/rust_crates:assert_matches",
diff --git a/src/lib/assembly/config/src/product_config.rs b/src/lib/assembly/config/src/product_config.rs
index 84f4ee1..89951b6 100644
--- a/src/lib/assembly/config/src/product_config.rs
+++ b/src/lib/assembly/config/src/product_config.rs
@@ -5,6 +5,7 @@
 use crate as image_assembly_config;
 use crate::FileEntry;
 use anyhow::ensure;
+use assembly_package_utils::{PackageInternalPathBuf, PackageManifestPathBuf, SourcePathBuf};
 use camino::Utf8PathBuf;
 use fidl_fuchsia_logger::MAX_TAGS;
 use serde::{Deserialize, Serialize};
@@ -68,15 +69,65 @@
 }
 
 /// Packages provided by the product, to add to the assembled images.
+///
+/// This also includes configuration for those packages:
+///
+/// ```json5
+///   packages: {
+///     base: [
+///       {
+///         manifest: "path/to/package_a/package_manifest.json",
+///       },
+///       {
+///         manifest: "path/to/package_b/package_manifest.json",
+///         config_data: {
+///           "foo.cfg": "path/to/some/source/file/foo.cfg",
+///           "bar/more/data.json": "path/to/some.json",
+///         },
+///       },
+///     ],
+///     cache: []
+///   }
+/// ```
+///
 #[derive(Debug, Default, Deserialize, Serialize)]
 pub struct ProductPackagesConfig {
-    /// Paths to package manifests for packages to add to the 'base' package set.
+    /// Paths to package manifests, or more detailed json entries for packages
+    /// to add to the 'base' package set.
     #[serde(default)]
-    pub base: Vec<Utf8PathBuf>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub base: Vec<ProductPackageDetails>,
 
-    /// Paths to package manifests for packages to add to the 'cache' package set.
+    /// Paths to package manifests, or more detailed json entries for packages
+    /// to add to the 'cache' package set.
     #[serde(default)]
-    pub cache: Vec<Utf8PathBuf>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub cache: Vec<ProductPackageDetails>,
+}
+
+/// Describes in more detail a package to add to the assembly.
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+pub struct ProductPackageDetails {
+    /// Path to the package manifest for this package.
+    pub manifest: PackageManifestPathBuf,
+
+    /// Map of config_data entries for this package, from the destination path
+    /// within the package, to the path where the source file is to be found.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub config_data: BTreeMap<PackageInternalPathBuf, SourcePathBuf>,
+}
+
+impl From<PackageManifestPathBuf> for ProductPackageDetails {
+    fn from(manifest: PackageManifestPathBuf) -> Self {
+        Self { manifest, config_data: BTreeMap::default() }
+    }
+}
+
+impl From<&str> for ProductPackageDetails {
+    fn from(s: &str) -> Self {
+        ProductPackageDetails { manifest: s.into(), config_data: BTreeMap::default() }
+    }
 }
 
 const BASE_CONSOLE_ALLOWED_TAGS: &[&str] = &[
@@ -300,10 +351,10 @@
               product: {
                   packages: {
                       base: [
-                          "path/to/base/package_manifest.json"
+                          { manifest: "path/to/base/package_manifest.json" }
                       ],
                       cache: [
-                          "path/to/cache/package_manifest.json"
+                          { manifest: "path/to/cache/package_manifest.json" }
                       ]
                   }
               },
@@ -313,8 +364,118 @@
         let mut cursor = std::io::Cursor::new(json5);
         let config: ProductAssemblyConfig = util::from_reader(&mut cursor).unwrap();
         assert_eq!(config.platform.build_type, BuildType::Eng);
-        assert_eq!(config.product.packages.base, vec!["path/to/base/package_manifest.json"]);
-        assert_eq!(config.product.packages.cache, vec!["path/to/cache/package_manifest.json"]);
+        assert_eq!(
+            config.product.packages.base,
+            vec![ProductPackageDetails {
+                manifest: "path/to/base/package_manifest.json".into(),
+                config_data: BTreeMap::default()
+            }]
+        );
+        assert_eq!(
+            config.product.packages.cache,
+            vec![ProductPackageDetails {
+                manifest: "path/to/cache/package_manifest.json".into(),
+                config_data: BTreeMap::default()
+            }]
+        );
+    }
+
+    #[test]
+    fn test_product_provided_config_data() {
+        let json5 = r#"
+            {
+                base: [
+                    {
+                        manifest: "path/to/base/package_manifest.json"
+                    },
+                    {
+                        manifest: "some/other/manifest.json",
+                        config_data: {
+                            "dest/path/cfg.txt": "source/path/cfg.txt",
+                            "other_data.json": "source_other_data.json",
+                        }
+                    }
+                  ],
+                cache: [
+                    {
+                        manifest: "path/to/cache/package_manifest.json"
+                    }
+                ]
+            }
+        "#;
+
+        let mut cursor = std::io::Cursor::new(json5);
+        let packages: ProductPackagesConfig = util::from_reader(&mut cursor).unwrap();
+        assert_eq!(
+            packages.base,
+            vec![
+                ProductPackageDetails::from("path/to/base/package_manifest.json"),
+                ProductPackageDetails {
+                    manifest: "some/other/manifest.json".into(),
+                    config_data: BTreeMap::from([
+                        ("dest/path/cfg.txt".into(), "source/path/cfg.txt".into()),
+                        ("other_data.json".into(), "source_other_data.json".into())
+                    ])
+                }
+            ]
+        );
+        assert_eq!(packages.cache, vec!["path/to/cache/package_manifest.json".into()]);
+    }
+
+    #[test]
+    fn product_package_details_deserialization() {
+        let json5 = r#"
+            {
+                manifest: "some/other/manifest.json",
+                config_data: {
+                    "dest/path/cfg.txt": "source/path/cfg.txt",
+                    "other_data.json": "source_other_data.json",
+                }
+            }
+        "#;
+        let expected = ProductPackageDetails {
+            manifest: "some/other/manifest.json".into(),
+            config_data: BTreeMap::from([
+                ("dest/path/cfg.txt".into(), "source/path/cfg.txt".into()),
+                ("other_data.json".into(), "source_other_data.json".into()),
+            ]),
+        };
+        let mut cursor = std::io::Cursor::new(json5);
+        let details: ProductPackageDetails = util::from_reader(&mut cursor).unwrap();
+        assert_eq!(details, expected);
+    }
+
+    #[test]
+    fn product_package_details_serialization() {
+        let entries = vec![
+            ProductPackageDetails {
+                manifest: "path/to/manifest.json".into(),
+                config_data: BTreeMap::default(),
+            },
+            ProductPackageDetails {
+                manifest: "another/path/to/a/manifest.json".into(),
+                config_data: BTreeMap::from([
+                    ("dest/path/A".into(), "source/path/A".into()),
+                    ("dest/path/B".into(), "source/path/B".into()),
+                ]),
+            },
+        ];
+        let serialized = serde_json::to_value(&entries).unwrap();
+        let expected = serde_json::json!(
+            [
+                {
+                    "manifest": "path/to/manifest.json"
+                },
+                {
+                    "manifest": "another/path/to/a/manifest.json",
+                    "config_data": {
+                        "dest/path/A": "source/path/A",
+                        "dest/path/B": "source/path/B"
+                    }
+                }
+            ]
+        );
+        assert_eq!(serialized, expected);
     }
 
     #[test]
diff --git a/src/lib/assembly/package_utils/BUILD.gn b/src/lib/assembly/package_utils/BUILD.gn
new file mode 100644
index 0000000..db9267e
--- /dev/null
+++ b/src/lib/assembly/package_utils/BUILD.gn
@@ -0,0 +1,30 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/rust/rustc_library.gni")
+
+rustc_library("package_utils") {
+  edition = "2021"
+  name = "assembly_package_utils"
+  version = "0.1.0"
+  with_unit_tests = true
+  deps = [
+    "//src/lib/assembly/util",
+    "//third_party/rust_crates:anyhow",
+    "//third_party/rust_crates:serde",
+  ]
+  test_deps = [
+    "//third_party/rust_crates:serde_json",
+    "//third_party/rust_crates:serde_json5",
+  ]
+  sources = [
+    "src/lib.rs",
+    "src/package_utils.rs",
+  ]
+}
+
+group("host_tests") {
+  testonly = true
+  deps = [ ":package_utils_test" ]
+}
diff --git a/src/lib/assembly/package_utils/src/lib.rs b/src/lib/assembly/package_utils/src/lib.rs
new file mode 100644
index 0000000..cb291c7
--- /dev/null
+++ b/src/lib/assembly/package_utils/src/lib.rs
@@ -0,0 +1,9 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/// 'package_utils' is a crate of utility types and fns for working with
+/// fuchsia-packages.
+pub use package_utils::{PackageInternalPathBuf, PackageManifestPathBuf, SourcePathBuf};
+
+mod package_utils;
diff --git a/src/lib/assembly/package_utils/src/package_utils.rs b/src/lib/assembly/package_utils/src/package_utils.rs
new file mode 100644
index 0000000..ce905bd9
--- /dev/null
+++ b/src/lib/assembly/package_utils/src/package_utils.rs
@@ -0,0 +1,43 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use assembly_util::{impl_path_type_marker, PathTypeMarker, TypedPathBuf};
+use serde::{Deserialize, Serialize};
+
+/// PackageIdentity is an opaque type that allows for the string that's used as
+/// a package's identity to be evolved over time, compared with other instances,
+/// and used as a key in maps / sets.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
+struct PackageIdentity(String);
+
+impl std::str::FromStr for PackageIdentity {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(s.to_owned()))
+    }
+}
+
+/// The marker trait for paths within a package
+pub struct InternalPathMarker {}
+impl_path_type_marker!(InternalPathMarker);
+
+/// The semantic type for paths within a package
+pub type PackageInternalPathBuf = TypedPathBuf<InternalPathMarker>;
+
+/// The marker trait for the source path when that's ambiguous (like in a list
+/// of source to destination paths)
+pub struct SourcePathMarker {}
+impl_path_type_marker!(SourcePathMarker);
+
+/// The semantic type for paths that are the path to the source of a file to use
+/// in some context.  Such as the source file for a blob in a package.
+pub type SourcePathBuf = TypedPathBuf<SourcePathMarker>;
+
+/// The marker trait for paths to a PackageManifest
+pub struct PackageManifestPathMarker {}
+impl_path_type_marker!(PackageManifestPathMarker);
+
+/// The semantic type for paths that are the path to a package manifest.
+pub type PackageManifestPathBuf = TypedPathBuf<PackageManifestPathMarker>;
diff --git a/src/lib/assembly/util/src/lib.rs b/src/lib/assembly/util/src/lib.rs
index 8bbe51c..7f58baf7 100644
--- a/src/lib/assembly/util/src/lib.rs
+++ b/src/lib/assembly/util/src/lib.rs
@@ -8,13 +8,14 @@
 
 mod insert_unique;
 mod path_to_string;
+
 mod paths;
 
 pub use insert_unique::{DuplicateKeyError, InsertAllUniqueExt, InsertUniqueExt, MapEntry};
 pub use path_to_string::PathToStringExt;
 pub use paths::{
     normalize_path, path_relative_from, path_relative_from_file, resolve_path,
-    resolve_path_from_file,
+    resolve_path_from_file, PathTypeMarker, TypedPathBuf,
 };
 
 use anyhow::{Context as _, Result};
diff --git a/src/lib/assembly/util/src/paths.rs b/src/lib/assembly/util/src/paths.rs
index 4936eb5..8270175 100644
--- a/src/lib/assembly/util/src/paths.rs
+++ b/src/lib/assembly/util/src/paths.rs
@@ -3,8 +3,189 @@
 // found in the LICENSE file.
 
 use anyhow::{anyhow, Context, Result};
+use camino::Utf8PathBuf;
 use pathdiff::diff_paths;
-use std::path::{Component, Path, PathBuf};
+use serde::{Deserialize, Serialize};
+use std::{
+    hash::Hash,
+    marker::PhantomData,
+    path::{Component, Path, PathBuf},
+};
+
+/// A base trait for TypePath's marker traits.
+pub trait PathTypeMarker {
+    /// A reference to an object that implements Display, and gives the
+    /// displayable semantic type for this path.  This is used by the Debug
+    /// implementation of `TypedPathBuf` to display the semantic type for the
+    /// path:
+    ///
+    /// ```
+    /// struct MarkerStructType;
+    /// impl_path_type_marker!(MarkerStructType);
+    ///
+    /// let typed_path = TypedPathBuf<MarkerStructType>::from("some/path");
+    /// println!("{:?}", typed_path);
+    /// ```
+    /// will print:
+    ///
+    /// ```text
+    /// TypedPathBuf<MarkerStructType>("some/path")
+    /// ```
+    fn path_type_display() -> &'static dyn std::fmt::Display;
+}
+
+/// Implement the `PathTypeMarker` trait for a given marker-type struct.  This
+/// mainly simplifies the creation of a display-string for the type.
+#[macro_export]
+macro_rules! impl_path_type_marker {
+    // This macro takes an argument of the marker struct's type name, and then
+    // provides an implementation of 'PathTypeMarker' for it.
+    ($struct_name:ident) => {
+        impl PathTypeMarker for $struct_name {
+            fn path_type_display() -> &'static dyn std::fmt::Display {
+                &stringify!($struct_name)
+            }
+        }
+    };
+}
+
+/// A path, in valid utf-8, which carries a marker for what kind of path it is.
+#[derive(Clone, Serialize, Deserialize)]
+#[repr(transparent)]
+#[serde(transparent)]
+pub struct TypedPathBuf<P: PathTypeMarker> {
+    #[serde(flatten)]
+    inner: Utf8PathBuf,
+
+    #[serde(skip)]
+    _marker: PhantomData<P>,
+}
+
+/// This derefs into the typed version of utf8 path, not utf8 path itself, so
+/// that it is easier to use in typed contexts, and makes the switchover to
+/// a non-typed context more explicit.
+///
+/// This also causes any path manipulations (join, etc.) to be done without the
+/// semantic type, so that the caller has to be explicit that it's still the
+/// semantic type (using 'into()', for instance).
+impl<P: PathTypeMarker> std::ops::Deref for TypedPathBuf<P> {
+    type Target = Utf8PathBuf;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<P: PathTypeMarker> TypedPathBuf<P> {
+    /// Convert this TypedPathBuf into a standard (OsStr-based) `PathBuf`.  This
+    /// both strips it of semantic type and that it's known to be Utf-8.
+    pub fn into_std_path_buf(self) -> PathBuf {
+        self.inner.into_std_path_buf()
+    }
+}
+
+/// The Debug implementation displays like a type-struct that carries the marker
+/// type for the path:
+///
+/// ```text
+/// TypedPathBuf<MarkerStructType>("some/path")
+/// ```
+impl<P: PathTypeMarker> std::fmt::Debug for TypedPathBuf<P> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple(&format!("TypedPathBuf<{}>", P::path_type_display()))
+            .field(&self.inner.to_string())
+            .finish()
+    }
+}
+
+/// The Display implementation defers to the wrapped path.
+impl<P: PathTypeMarker> std::fmt::Display for TypedPathBuf<P> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+/// Implement From<> for path-like sources.  Note that these also will infer the
+/// semantic type, which while useful in some contexts, can cause issues in
+/// places where multiple different type markers are used:
+///
+/// ```
+/// fn some_func(source: TypedPathBuf<Source>, TypedPathBuf<Destination>);
+///
+/// // This infers the types of the paths:
+/// some_func("source_path".into(), "destination_path".into());
+///
+/// // allowing this error:
+/// some_func("destination_path".into(), "source_path",into());
+///
+/// // In these cases, it's best to strongly type one or both of them:
+/// some_func(TypedPathBuf<Source>::from("source_path"), "destination_path".into());
+///
+/// // or (better)
+/// some_func(TypedPathBuf<Source>::from("source_path"),
+///           TypedPathBuf<Destination>::from("destination_path"));
+/// ```
+// inner module used to group impls and to add above documentation.
+mod from_impls {
+    use super::*;
+
+    impl<P: PathTypeMarker> From<Utf8PathBuf> for TypedPathBuf<P> {
+        fn from(path: Utf8PathBuf) -> Self {
+            Self { inner: path, _marker: PhantomData }
+        }
+    }
+
+    impl<P: PathTypeMarker> From<String> for TypedPathBuf<P> {
+        fn from(s: String) -> TypedPathBuf<P> {
+            TypedPathBuf::from(Utf8PathBuf::from(s))
+        }
+    }
+
+    impl<P: PathTypeMarker> From<&str> for TypedPathBuf<P> {
+        fn from(s: &str) -> TypedPathBuf<P> {
+            TypedPathBuf::from(Utf8PathBuf::from(s))
+        }
+    }
+
+    impl<P: PathTypeMarker> std::str::FromStr for TypedPathBuf<P> {
+        type Err = String;
+
+        fn from_str(s: &str) -> Result<Self, Self::Err> {
+            Ok(Self::from(s))
+        }
+    }
+}
+
+// These comparison implementations are required because #[derive(...)] will not
+// derive these if `P` doesn't implement them, but `P` has no reason to
+// implement them, so these implementations just pass through to the Utf8PathBuf
+// implementations.
+
+impl<P: PathTypeMarker> PartialOrd for TypedPathBuf<P> {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.inner.partial_cmp(&other.inner)
+    }
+}
+
+impl<P: PathTypeMarker> Ord for TypedPathBuf<P> {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.inner.cmp(&other.inner)
+    }
+}
+
+impl<P: PathTypeMarker> PartialEq for TypedPathBuf<P> {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner == other.inner
+    }
+}
+
+impl<P: PathTypeMarker> Eq for TypedPathBuf<P> {}
+
+impl<P: PathTypeMarker> Hash for TypedPathBuf<P> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.inner.hash(state);
+    }
+}
 
 /// Helper to make one path relative to a directory.
 ///
@@ -165,8 +346,72 @@
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::str::FromStr;
     use std::{iter::FromIterator, path::PathBuf};
 
+    struct TestPathType {}
+    impl_path_type_marker!(TestPathType);
+
+    #[test]
+    fn make_typed_path_from_string() {
+        let original: String = "/this/is/a/string".to_string();
+        let typed = TypedPathBuf::<TestPathType>::from_str(&original).unwrap();
+        assert_eq!(typed.to_string(), original);
+    }
+
+    #[test]
+    fn make_typed_path_from_str() {
+        let original: &str = "/this/is/a/string";
+        let typed = TypedPathBuf::<TestPathType>::from_str(&original).unwrap();
+        assert_eq!(typed.to_string(), original);
+    }
+
+    #[test]
+    fn path_type_deserialization() {
+        #[derive(Debug, Deserialize)]
+        struct Sample {
+            pub path: TypedPathBuf<TestPathType>,
+        }
+        let parsed: Sample = serde_json::from_str("{ \"path\": \"this/is/a/path\"}").unwrap();
+        assert_eq!(parsed.path, TypedPathBuf::<TestPathType>::from("this/is/a/path"));
+    }
+
+    #[test]
+    fn path_type_serialization() {
+        #[derive(Debug, Serialize)]
+        struct Sample {
+            pub path: TypedPathBuf<TestPathType>,
+        }
+        let sample = Sample { path: "this/is/a/path".into() };
+        let expected = serde_json::json!({ "path": "this/is/a/path"});
+        assert_eq!(serde_json::to_value(sample).unwrap(), expected);
+    }
+
+    #[test]
+    fn typed_path_debug_impl() {
+        let typed = TypedPathBuf::<TestPathType>::from("some/path");
+        assert_eq!(format!("{:?}", typed), "TypedPathBuf<TestPathType>(\"some/path\")");
+    }
+
+    #[test]
+    fn typed_path_display_impl() {
+        let typed = TypedPathBuf::<TestPathType>::from("some/path");
+        assert_eq!(format!("{}", typed), "some/path");
+    }
+
+    #[test]
+    fn typed_path_buf_into_path_buf() {
+        let typed = TypedPathBuf::<TestPathType>::from("some/path");
+        assert_eq!(typed.into_std_path_buf(), PathBuf::from("some/path"));
+    }
+
+    #[test]
+    fn typed_path_derefs_into_utf8_path() {
+        let typed = TypedPathBuf::<TestPathType>::from("some/path");
+        let utf8_path = Utf8PathBuf::from("some/path");
+        assert_eq!(*typed, utf8_path);
+    }
+
     #[test]
     fn resolve_path_from_file_simple() {
         let result = resolve_path_from_file("an/internal/path", "path/to/manifest.txt").unwrap();