diff --git a/.bazelci/presubmit.yml b/.bazelci/presubmit.yml
index aecde57d75..6d4bfb4177 100644
--- a/.bazelci/presubmit.yml
+++ b/.bazelci/presubmit.yml
@@ -533,6 +533,22 @@ tasks:
     test_targets:
       - "//..."
     build_flags: *aspects_flags
+  crate_universe_local_path_external:
+    name: Crate Universe Local Path External
+    platform: ubuntu2004
+    working_directory: examples/crate_universe_local_path
+    run_targets:
+      - "//:vendor_lazy_static_out_of_tree"
+    test_targets:
+      - "//..."
+  crate_universe_local_path_in_tree:
+    name: Crate Universe Local Path In Tree
+    platform: ubuntu2004
+    working_directory: examples/crate_universe_local_path
+    run_targets:
+      - "//:vendor_lazy_static_in_tree"
+    test_targets:
+      - "//..."
 # See https://github.com/bazelbuild/rules_rust/issues/2186 about re-enabling these.
 #  crate_universe_examples_windows:
 #    name: Crate Universe Examples
diff --git a/crate_universe/extensions.bzl b/crate_universe/extensions.bzl
index 943fb73976..279b9d703e 100644
--- a/crate_universe/extensions.bzl
+++ b/crate_universe/extensions.bzl
@@ -6,6 +6,7 @@ load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 load("//crate_universe/private:crates_vendor.bzl", "CRATES_VENDOR_ATTRS", "generate_config_file", "generate_splicing_manifest")
 load("//crate_universe/private:generate_utils.bzl", "CARGO_BAZEL_GENERATOR_SHA256", "CARGO_BAZEL_GENERATOR_URL", "GENERATOR_ENV_VARS", "render_config")
+load("//crate_universe/private:local_crate_mirror.bzl", "local_crate_mirror")
 load("//crate_universe/private:urls.bzl", "CARGO_BAZEL_SHA256S", "CARGO_BAZEL_URLS")
 load("//rust/platform:triple.bzl", "get_host_triple")
 load("//rust/platform:triple_mappings.bzl", "system_to_binary_ext")
@@ -133,6 +134,9 @@ def _generate_hub_and_spokes(*, module_ctx, cargo_bazel, cfg, annotations, cargo
     lockfile_path = tag_path.get_child("lockfile.json")
     module_ctx.file(lockfile_path, "")
 
+    paths_to_track_file = module_ctx.path("paths-to-track")
+    warnings_output_file = module_ctx.path("warnings-output-file")
+
     cargo_bazel([
         "generate",
         "--cargo-lockfile",
@@ -148,8 +152,25 @@ def _generate_hub_and_spokes(*, module_ctx, cargo_bazel, cfg, annotations, cargo
         "--repin",
         "--lockfile",
         lockfile_path,
+        "--nonhermetic-root-bazel-workspace-dir",
+        module_ctx.path(Label("@@//:MODULE.bazel")).dirname,
+        "--paths-to-track",
+        paths_to_track_file,
+        "--warnings-output-path",
+        warnings_output_file,
     ])
 
+    paths_to_track = json.decode(module_ctx.read(paths_to_track_file))
+    for path in paths_to_track:
+        # This read triggers watching the file at this path and invalidates the repository_rule which will get re-run.
+        # Ideally we'd use module_ctx.watch, but it doesn't support files outside of the workspace, and we need to support that.
+        module_ctx.read(path)
+
+    warnings_output_file = json.decode(module_ctx.read(warnings_output_file))
+    for warning in warnings_output_file:
+        # buildifier: disable=print
+        print("WARN: {}".format(warning))
+
     crates_dir = tag_path.get_child(cfg.name)
     _generate_repo(
         name = cfg.name,
@@ -212,6 +233,22 @@ def _generate_hub_and_spokes(*, module_ctx, cargo_bazel, cfg, annotations, cargo
                 strip_prefix = repo.get("strip_prefix", None),
                 **kwargs
             )
+        elif "Path" in repo:
+            options = {
+                "config": rendering_config,
+                "crate_context": crate,
+                "platform_conditions": contents["conditions"],
+                "supported_platform_triples": cfg.supported_platform_triples,
+            }
+            kwargs = {}
+            if len(CARGO_BAZEL_URLS) == 0:
+                kwargs["generator"] = "@cargo_bazel_bootstrap//:cargo-bazel"
+            local_crate_mirror(
+                name = crate_repo_name,
+                options_json = json.encode(options),
+                path = repo["Path"]["path"],
+                **kwargs
+            )
         else:
             fail("Invalid repo: expected Http or Git to exist for crate %s-%s, got %s" % (name, version, repo))
 
diff --git a/crate_universe/private/crates_repository.bzl b/crate_universe/private/crates_repository.bzl
index 4a1952c634..70ce40bfb4 100644
--- a/crate_universe/private/crates_repository.bzl
+++ b/crate_universe/private/crates_repository.bzl
@@ -71,6 +71,9 @@ def _crates_repository_impl(repository_ctx):
             "metadata": metadata_path,
         })
 
+    paths_to_track_file = repository_ctx.path("paths-to-track")
+    warnings_output_file = repository_ctx.path("warnings-output-file")
+
     # Run the generator
     execute_generator(
         repository_ctx = repository_ctx,
@@ -82,10 +85,23 @@ def _crates_repository_impl(repository_ctx):
         repository_dir = repository_ctx.path("."),
         cargo = cargo_path,
         rustc = rustc_path,
+        paths_to_track_file = paths_to_track_file,
+        warnings_output_file = warnings_output_file,
         # sysroot = tools.sysroot,
         **kwargs
     )
 
+    paths_to_track = json.decode(repository_ctx.read(paths_to_track_file))
+    for path in paths_to_track:
+        # This read triggers watching the file at this path and invalidates the repository_rule which will get re-run.
+        # Ideally we'd use repository_ctx.watch, but it doesn't support files outside of the workspace, and we need to support that.
+        repository_ctx.read(path)
+
+    warnings_output_file = json.decode(repository_ctx.read(warnings_output_file))
+    for warning in warnings_output_file:
+        # buildifier: disable=print
+        print("WARN: {}".format(warning))
+
     # Determine the set of reproducible values
     attrs = {attr: getattr(repository_ctx.attr, attr) for attr in dir(repository_ctx.attr)}
     exclude = ["to_json", "to_proto"]
diff --git a/crate_universe/private/crates_vendor.bzl b/crate_universe/private/crates_vendor.bzl
index b8d95627bf..a195f8c20f 100644
--- a/crate_universe/private/crates_vendor.bzl
+++ b/crate_universe/private/crates_vendor.bzl
@@ -34,6 +34,7 @@ ${{_ENVIRON[@]}} \\
 {env} \\
     "{bin}" \\
     {args} \\
+    --nonhermetic-root-bazel-workspace-dir="${{BUILD_WORKSPACE_DIRECTORY}}" \\
     "$@"
 """
 
@@ -42,7 +43,7 @@ _WINDOWS_WRAPPER = """\
 set RUNTIME_PWD=%CD%
 {env}
 
-{bin} {args} %*
+{bin} {args} --nonhermetic-root-bazel-workspace-dir=%BUILD_WORKSPACE_DIRECTORY% %*
 exit %ERRORLEVEL%
 """
 
diff --git a/crate_universe/private/generate_utils.bzl b/crate_universe/private/generate_utils.bzl
index 94dcdd2360..a345b7538f 100644
--- a/crate_universe/private/generate_utils.bzl
+++ b/crate_universe/private/generate_utils.bzl
@@ -433,6 +433,8 @@ def execute_generator(
         repository_dir,
         cargo,
         rustc,
+        paths_to_track_file,
+        warnings_output_file,
         metadata = None):
     """Execute the `cargo-bazel` binary to produce `BUILD` and `.bzl` files.
 
@@ -446,6 +448,8 @@ def execute_generator(
         repository_dir (path): The output path for the Bazel module and BUILD files.
         cargo (path): The path of a Cargo binary.
         rustc (path): The path of a Rustc binary.
+        paths_to_track_file (path): Path to file where generator should write which files should trigger re-generating as a JSON list.
+        warnings_output_file (path): Path to file where generator should write warnings to print.
         metadata (path, optional): The path to a Cargo metadata json file. If this is set, it indicates to
             the generator that repinning is required. This file must be adjacent to a `Cargo.toml` and
             `Cargo.lock` file.
@@ -470,8 +474,20 @@ def execute_generator(
         cargo,
         "--rustc",
         rustc,
+        "--nonhermetic-root-bazel-workspace-dir",
+        repository_ctx.workspace_root,
+        "--paths-to-track",
+        paths_to_track_file,
+        "--warnings-output-path",
+        warnings_output_file,
     ]
 
+    if repository_ctx.attr.generator:
+        args.extend([
+            "--generator",
+            repository_ctx.attr.generator,
+        ])
+
     if lockfile_path:
         args.extend([
             "--lockfile",
diff --git a/crate_universe/private/local_crate_mirror.bzl b/crate_universe/private/local_crate_mirror.bzl
new file mode 100644
index 0000000000..4298e5d8b7
--- /dev/null
+++ b/crate_universe/private/local_crate_mirror.bzl
@@ -0,0 +1,64 @@
+"""`local_crate_mirror` rule implementation."""
+
+load("//crate_universe/private:common_utils.bzl", "execute")
+load("//crate_universe/private:generate_utils.bzl", "get_generator")
+load("//crate_universe/private:urls.bzl", "CARGO_BAZEL_SHA256S", "CARGO_BAZEL_URLS")
+load("//rust/platform:triple.bzl", "get_host_triple")
+
+def _local_crate_mirror_impl(repository_ctx):
+    path = repository_ctx.path(repository_ctx.attr.path)
+
+    host_triple = get_host_triple(repository_ctx)
+
+    generator, _generator_sha256 = get_generator(repository_ctx, host_triple.str)
+
+    # TODO: Work out why we can't just symlink here and actually copy.
+    # illicitonion thinks it may be that symlinks didn't get invalidated properly?
+    for child in repository_ctx.path(path).readdir():
+        repository_ctx.execute(["cp", "-r", child, repository_ctx.path(child.basename)])
+
+    paths_to_track = execute(repository_ctx, ["find", path, "-type", "f"]).stdout.strip().split("\n")
+    for path_to_track in paths_to_track:
+        if path_to_track:
+            repository_ctx.read(path_to_track)
+
+    execute(repository_ctx, [generator, "render", "--options-json", repository_ctx.attr.options_json, "--output-path", repository_ctx.path("BUILD.bazel")])
+
+    repository_ctx.file("WORKSPACE.bazel", "")
+
+local_crate_mirror = repository_rule(
+    doc = """This is a private implementation detail of crate_universe, and should not be relied on in manually written code.
+
+This is effectively a `local_repository` rule impementation, but where the BUILD.bazel file is generated using the `cargo-bazel render` command.""",
+    implementation = _local_crate_mirror_impl,
+    attrs = {
+        "generator": attr.string(
+            doc = (
+                "The absolute label of a generator. Eg. `@cargo_bazel_bootstrap//:cargo-bazel`. " +
+                "This is typically used when bootstrapping"
+            ),
+        ),
+        "generator_sha256s": attr.string_dict(
+            doc = "Dictionary of `host_triple` -> `sha256` for a `cargo-bazel` binary.",
+            default = CARGO_BAZEL_SHA256S,
+        ),
+        "generator_urls": attr.string_dict(
+            doc = (
+                "URL template from which to download the `cargo-bazel` binary. `{host_triple}` and will be " +
+                "filled in according to the host platform."
+            ),
+            default = CARGO_BAZEL_URLS,
+        ),
+        "options_json": attr.string(
+            doc = "JSON serialized instance of a crate_universe::context::SingleBuildFileRenderContext",
+        ),
+        "path": attr.string(
+            # TODO: Verify what happens if this is not an absolute path.
+            doc = "Absolute path to the BUILD.bazel file to generate.",
+        ),
+        "quiet": attr.bool(
+            doc = "If stdout and stderr should not be printed to the terminal.",
+            default = True,
+        ),
+    },
+)
diff --git a/crate_universe/private/srcs.bzl b/crate_universe/private/srcs.bzl
index a96e424466..bea5cc28f9 100644
--- a/crate_universe/private/srcs.bzl
+++ b/crate_universe/private/srcs.bzl
@@ -11,6 +11,7 @@ CARGO_BAZEL_SRCS = [
     Label("//crate_universe:src/cli.rs"),
     Label("//crate_universe:src/cli/generate.rs"),
     Label("//crate_universe:src/cli/query.rs"),
+    Label("//crate_universe:src/cli/render.rs"),
     Label("//crate_universe:src/cli/splice.rs"),
     Label("//crate_universe:src/cli/vendor.rs"),
     Label("//crate_universe:src/config.rs"),
diff --git a/crate_universe/src/cli.rs b/crate_universe/src/cli.rs
index 9172c97f66..19a1fea833 100644
--- a/crate_universe/src/cli.rs
+++ b/crate_universe/src/cli.rs
@@ -2,6 +2,7 @@
 
 mod generate;
 mod query;
+mod render;
 mod splice;
 mod vendor;
 
@@ -15,12 +16,14 @@ use tracing_subscriber::FmtSubscriber;
 
 pub use self::generate::GenerateOptions;
 pub use self::query::QueryOptions;
+pub use self::render::RenderOptions;
 pub use self::splice::SpliceOptions;
 pub use self::vendor::VendorOptions;
 
 // Entrypoints
 pub use generate::generate;
 pub use query::query;
+pub use render::render;
 pub use splice::splice;
 pub use vendor::vendor;
 
@@ -42,6 +45,9 @@ pub enum Options {
 
     /// Vendor BUILD files to the workspace with either repository definitions or `cargo vendor` generated sources.
     Vendor(VendorOptions),
+
+    /// Render a BUILD file for a single crate.
+    Render(RenderOptions),
 }
 
 // Convenience wrappers to avoid dependencies in the binary
@@ -51,7 +57,7 @@ pub fn parse_args() -> Options {
     Options::parse()
 }
 
-const EXPECTED_LOGGER_NAMES: [&str; 4] = ["Generate", "Splice", "Query", "Vendor"];
+const EXPECTED_LOGGER_NAMES: [&str; 5] = ["Generate", "Splice", "Query", "Vendor", "Render"];
 
 /// A wrapper for the tracing-subscriber default [FormatEvent]
 /// that prepends the name of the active CLI option.
diff --git a/crate_universe/src/cli/generate.rs b/crate_universe/src/cli/generate.rs
index 2178f276cb..4ec2638bb4 100644
--- a/crate_universe/src/cli/generate.rs
+++ b/crate_universe/src/cli/generate.rs
@@ -2,18 +2,21 @@
 
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use anyhow::{bail, Context as AnyhowContext, Result};
+use camino::Utf8PathBuf;
 use cargo_lock::Lockfile;
 use clap::Parser;
 
 use crate::config::Config;
 use crate::context::Context;
 use crate::lockfile::{lock_context, write_lockfile};
-use crate::metadata::{load_metadata, Annotations, Cargo};
+use crate::metadata::{load_metadata, Annotations, Cargo, SourceAnnotation};
 use crate::rendering::{write_outputs, Renderer};
 use crate::splicing::SplicingManifest;
 use crate::utils::normalize_cargo_file_paths;
+use crate::utils::starlark::Label;
 
 /// Command line options for the `generate` subcommand
 #[derive(Parser, Debug)]
@@ -63,6 +66,35 @@ pub struct GenerateOptions {
     /// If true, outputs will be printed instead of written to disk.
     #[clap(long)]
     pub dry_run: bool,
+
+    /// The path to the Bazel root workspace (i.e. the directory containing the WORKSPACE.bazel file or similar).
+    /// BE CAREFUL with this value. We never want to include it in a lockfile hash (to keep lockfiles portable),
+    /// which means you also should not use it anywhere that _should_ be guarded by a lockfile hash.
+    /// You basically never want to use this value.
+    #[clap(long)]
+    pub nonhermetic_root_bazel_workspace_dir: Utf8PathBuf,
+
+    /// Path to write a list of files which the repository_rule should watch.
+    /// If any of these paths change, the repository rule should be rerun.
+    /// These files may be outside of the Bazel-managed workspace.
+    /// A (possibly empty) JSON sorted array of strings will be unconditionally written to this file.
+    #[clap(long)]
+    pub paths_to_track: PathBuf,
+
+    /// The label of this binary, if it was built in bootstrap mode.
+    /// BE CAREFUL with this value. We never want to include it in a lockfile hash (to keep lockfiles portable),
+    /// which means you also should not use it anywhere that _should_ be guarded by a lockfile hash.
+    /// You basically never want to use this value.
+    #[clap(long)]
+    pub(crate) generator: Option<Label>,
+
+    /// Path to write a list of warnings which the repository rule should emit.
+    /// A (possibly empty) JSON array of strings will be unconditionally written to this file.
+    /// Each warning should be printed.
+    /// This mechanism exists because this process's output is often hidden by default,
+    /// so this provides a way for the repository rule to force printing.
+    #[clap(long)]
+    pub warnings_output_path: PathBuf,
 }
 
 pub fn generate(opt: GenerateOptions) -> Result<()> {
@@ -75,8 +107,11 @@ pub fn generate(opt: GenerateOptions) -> Result<()> {
             let context = Context::try_from_path(lockfile)?;
 
             // Render build files
-            let outputs = Renderer::new(config.rendering, config.supported_platform_triples)
-                .render(&context)?;
+            let outputs = Renderer::new(
+                Arc::new(config.rendering),
+                Arc::new(config.supported_platform_triples),
+            )
+            .render(&context, opt.generator)?;
 
             // make file paths compatible with bazel labels
             let normalized_outputs = normalize_cargo_file_paths(outputs, &opt.repository_dir);
@@ -84,6 +119,16 @@ pub fn generate(opt: GenerateOptions) -> Result<()> {
             // Write the outputs to disk
             write_outputs(normalized_outputs, opt.dry_run)?;
 
+            write_paths_to_track(
+                &opt.paths_to_track,
+                &opt.warnings_output_path,
+                context
+                    .crates
+                    .values()
+                    .filter_map(|crate_context| crate_context.repository.as_ref()),
+                context.unused_patches.iter(),
+            )?;
+
             return Ok(());
         }
     }
@@ -112,17 +157,29 @@ pub fn generate(opt: GenerateOptions) -> Result<()> {
     let (cargo_metadata, cargo_lockfile) = load_metadata(metadata_path)?;
 
     // Annotate metadata
-    let annotations = Annotations::new(cargo_metadata, cargo_lockfile.clone(), config.clone())?;
+    let annotations = Annotations::new(
+        cargo_metadata,
+        cargo_lockfile.clone(),
+        config.clone(),
+        &opt.nonhermetic_root_bazel_workspace_dir,
+    )?;
+
+    write_paths_to_track(
+        &opt.paths_to_track,
+        &opt.warnings_output_path,
+        annotations.lockfile.crates.values(),
+        cargo_lockfile.patch.unused.iter(),
+    )?;
 
     // Generate renderable contexts for each package
     let context = Context::new(annotations, config.rendering.are_sources_present())?;
 
     // Render build files
     let outputs = Renderer::new(
-        config.rendering.clone(),
-        config.supported_platform_triples.clone(),
+        Arc::new(config.rendering.clone()),
+        Arc::new(config.supported_platform_triples.clone()),
     )
-    .render(&context)?;
+    .render(&context, opt.generator)?;
 
     // make file paths compatible with bazel labels
     let normalized_outputs = normalize_cargo_file_paths(outputs, &opt.repository_dir);
@@ -159,3 +216,44 @@ fn update_cargo_lockfile(path: &Path, cargo_lockfile: Lockfile) -> Result<()> {
 
     Ok(())
 }
+
+fn write_paths_to_track<
+    'a,
+    SourceAnnotations: Iterator<Item = &'a SourceAnnotation>,
+    UnusedPatches: Iterator<Item = &'a cargo_lock::Dependency>,
+>(
+    output_file: &Path,
+    warnings_output_path: &Path,
+    source_annotations: SourceAnnotations,
+    unused_patches: UnusedPatches,
+) -> Result<()> {
+    let paths_to_track: std::collections::BTreeSet<_> = source_annotations
+        .filter_map(|v| {
+            if let SourceAnnotation::Path { path } = v {
+                Some(path.join("Cargo.toml"))
+            } else {
+                None
+            }
+        })
+        .collect();
+    std::fs::write(
+        output_file,
+        serde_json::to_string(&paths_to_track).context("Failed to serialize paths to track")?,
+    )
+    .context("Failed to write paths to track")?;
+
+    let mut warnings = Vec::new();
+    for path_to_track in &paths_to_track {
+        warnings.push(format!("Build is not hermetic - path dependency pulling in crate at {path_to_track} is being used."));
+    }
+    for unused_patch in unused_patches {
+        warnings.push(format!("You have a [patch] Cargo.toml entry that is being ignored by cargo. Unused patch: {} {}{}", unused_patch.name, unused_patch.version, if let Some(source) = unused_patch.source.as_ref() { format!(" ({})", source) } else { String::new() }));
+    }
+
+    std::fs::write(
+        warnings_output_path,
+        serde_json::to_string(&warnings).context("Failed to serialize warnings to track")?,
+    )
+    .context("Failed to write warnings file")?;
+    Ok(())
+}
diff --git a/crate_universe/src/cli/render.rs b/crate_universe/src/cli/render.rs
new file mode 100644
index 0000000000..e715c5be07
--- /dev/null
+++ b/crate_universe/src/cli/render.rs
@@ -0,0 +1,55 @@
+use crate::context::SingleBuildFileRenderContext;
+use crate::rendering::Renderer;
+
+use anyhow::{Context, Result};
+use clap::Parser;
+
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[derive(Parser, Debug)]
+#[clap(about = "Command line options for the `render` subcommand", version)]
+pub struct RenderOptions {
+    #[clap(long)]
+    options_json: String,
+
+    #[clap(long)]
+    output_path: PathBuf,
+}
+
+pub fn render(opt: RenderOptions) -> Result<()> {
+    let RenderOptions {
+        options_json,
+        output_path,
+    } = opt;
+
+    let deserialized_options = serde_json::from_str(&options_json)
+        .with_context(|| format!("Failed to deserialize options_json from '{}'", options_json))?;
+
+    let SingleBuildFileRenderContext {
+        config,
+        supported_platform_triples,
+        platform_conditions,
+        crate_context,
+    } = deserialized_options;
+
+    let renderer = Renderer::new(config, supported_platform_triples);
+    let platforms = renderer.render_platform_labels(Arc::clone(&platform_conditions));
+    let engine = renderer.create_engine(platform_conditions);
+    let output = renderer
+        .render_one_build_file(&engine, &platforms, &crate_context)
+        .with_context(|| {
+            format!(
+                "Failed to render BUILD.bazel file for crate {}",
+                crate_context.name
+            )
+        })?;
+    std::fs::write(&output_path, output.as_bytes()).with_context(|| {
+        format!(
+            "Failed to write BUILD.bazel file to {}",
+            output_path.display()
+        )
+    })?;
+
+    Ok(())
+}
diff --git a/crate_universe/src/cli/vendor.rs b/crate_universe/src/cli/vendor.rs
index 036b47d50d..f80e119447 100644
--- a/crate_universe/src/cli/vendor.rs
+++ b/crate_universe/src/cli/vendor.rs
@@ -5,8 +5,10 @@ use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::{self, ExitStatus};
+use std::sync::Arc;
 
 use anyhow::{bail, Context as AnyhowContext, Result};
+use camino::Utf8PathBuf;
 use clap::Parser;
 
 use crate::config::{Config, VendorMode};
@@ -73,6 +75,13 @@ pub struct VendorOptions {
     /// If true, outputs will be printed instead of written to disk.
     #[clap(long)]
     pub dry_run: bool,
+
+    /// The path to the Bazel root workspace (i.e. the directory containing the WORKSPACE.bazel file or similar).
+    /// BE CAREFUL with this value. We never want to include it in a lockfile hash (to keep lockfiles portable),
+    /// which means you also should not use it anywhere that _should_ be guarded by a lockfile hash.
+    /// You basically never want to use this value.
+    #[clap(long)]
+    pub nonhermetic_root_bazel_workspace_dir: Utf8PathBuf,
 }
 
 /// Run buildifier on a given file.
@@ -165,17 +174,22 @@ pub fn vendor(opt: VendorOptions) -> Result<()> {
         .generate(manifest_path.as_path_buf())?;
 
     // Annotate metadata
-    let annotations = Annotations::new(cargo_metadata, cargo_lockfile.clone(), config.clone())?;
+    let annotations = Annotations::new(
+        cargo_metadata,
+        cargo_lockfile.clone(),
+        config.clone(),
+        &opt.nonhermetic_root_bazel_workspace_dir,
+    )?;
 
     // Generate renderable contexts for earch package
     let context = Context::new(annotations, config.rendering.are_sources_present())?;
 
     // Render build files
     let outputs = Renderer::new(
-        config.rendering.clone(),
-        config.supported_platform_triples.clone(),
+        Arc::new(config.rendering.clone()),
+        Arc::new(config.supported_platform_triples),
     )
-    .render(&context)?;
+    .render(&context, None)?;
 
     // First ensure vendoring and rendering happen in a clean directory
     let vendor_dir_label = render_module_label(&config.rendering.crates_module_template, "BUILD")?;
diff --git a/crate_universe/src/context.rs b/crate_universe/src/context.rs
index 8129c11ef1..fdcfb0f2e4 100644
--- a/crate_universe/src/context.rs
+++ b/crate_universe/src/context.rs
@@ -6,11 +6,12 @@ mod platforms;
 use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 
-use crate::config::CrateId;
+use crate::config::{CrateId, RenderConfig};
 use crate::context::platforms::resolve_cfg_platforms;
 use crate::lockfile::Digest;
 use crate::metadata::{Annotations, Dependency};
@@ -44,6 +45,14 @@ pub(crate) struct Context {
 
     /// A list of crates visible to this bazel module.
     pub(crate) direct_dev_deps: BTreeSet<CrateId>,
+
+    /// A list of `[patch]`` entries from the Cargo.lock file which were not used in the resolve.
+    // TODO: Remove the serde(default) after this has been released for a few versions.
+    // This prevents previous lockfiles (from before this field) from failing to parse with the current version of rules_rust.
+    // After we've supported this (so serialised it in lockfiles) for a few versions,
+    // we can remove the default fallback because existing lockfiles should have the key present.
+    #[serde(default)]
+    pub(crate) unused_patches: BTreeSet<cargo_lock::Dependency>,
 }
 
 impl Context {
@@ -139,6 +148,8 @@ impl Context {
             add_crate_ids(&mut direct_dev_deps, &deps.proc_macro_dev_deps);
         }
 
+        let unused_patches = annotations.lockfile.unused_patches;
+
         Ok(Self {
             checksum: None,
             crates,
@@ -147,6 +158,7 @@ impl Context {
             conditions,
             direct_dev_deps: direct_dev_deps.difference(&direct_deps).cloned().collect(),
             direct_deps,
+            unused_patches,
         })
     }
 
@@ -225,9 +237,26 @@ impl Context {
     }
 }
 
+/// All information needed to render a BUILD file for a single crate.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SingleBuildFileRenderContext {
+    /// The RenderConfig.
+    pub(crate) config: Arc<RenderConfig>,
+
+    /// See crate::config::Config.supported_platform_triples.
+    pub(crate) supported_platform_triples: Arc<BTreeSet<TargetTriple>>,
+
+    /// See Context::conditions.
+    pub(crate) platform_conditions: Arc<BTreeMap<String, BTreeSet<TargetTriple>>>,
+
+    /// The CrateContext for the crate being rendered.
+    pub(crate) crate_context: Arc<CrateContext>,
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
+    use camino::Utf8Path;
     use semver::Version;
 
     use crate::config::Config;
@@ -237,6 +266,7 @@ mod test {
             crate::test::metadata::common(),
             crate::test::lockfile::common(),
             Config::default(),
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap();
 
@@ -248,6 +278,7 @@ mod test {
             crate::test::metadata::alias(),
             crate::test::lockfile::alias(),
             Config::default(),
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap();
 
diff --git a/crate_universe/src/context/crate_context.rs b/crate_universe/src/context/crate_context.rs
index 4976368e55..695bbc1024 100644
--- a/crate_universe/src/context/crate_context.rs
+++ b/crate_universe/src/context/crate_context.rs
@@ -708,6 +708,9 @@ impl CrateContext {
                         patch_tool.clone_from(&crate_extra.patch_tool);
                         patches.clone_from(&crate_extra.patches);
                     }
+                    SourceAnnotation::Path { .. } => {
+                        // We don't support applying patches to local path deps.
+                    }
                 }
             }
 
@@ -847,6 +850,7 @@ impl CrateContext {
 mod test {
     use super::*;
 
+    use camino::Utf8Path;
     use semver::Version;
 
     use crate::config::CrateAnnotations;
@@ -857,6 +861,7 @@ mod test {
             crate::test::metadata::common(),
             crate::test::lockfile::common(),
             crate::config::Config::default(),
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap()
     }
@@ -960,6 +965,7 @@ mod test {
             crate::test::metadata::build_scripts(),
             crate::test::lockfile::build_scripts(),
             crate::config::Config::default(),
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap()
     }
@@ -969,6 +975,7 @@ mod test {
             crate::test::metadata::crate_types(),
             crate::test::lockfile::crate_types(),
             crate::config::Config::default(),
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap()
     }
@@ -1272,6 +1279,7 @@ mod test {
             crate::test::metadata::abspath(),
             crate::test::lockfile::abspath(),
             crate::config::Config::default(),
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap();
 
diff --git a/crate_universe/src/lockfile.rs b/crate_universe/src/lockfile.rs
index eb5ca824e5..68eed11805 100644
--- a/crate_universe/src/lockfile.rs
+++ b/crate_universe/src/lockfile.rs
@@ -245,7 +245,7 @@ mod test {
         );
 
         assert_eq!(
-            Digest("7f8d38b770a838797e24635a9030d4194210ff331f1a5b59c753f23fd197b5d8".to_owned()),
+            Digest("a7064691f0024f1c7baa21e632e6258bfb4bf0b239333d3857462e6c87ec8e8d".to_owned()),
             digest,
         );
     }
@@ -290,7 +290,7 @@ mod test {
         );
 
         assert_eq!(
-            Digest("b500cdfe8efb6c34dca8564e62c5330e0e7e3fe330c6e8399c645db397d76275".to_owned()),
+            Digest("da25032dd6941980501632d9d63bd3daffc6261443ccc3c4dcdbb45a99088cce".to_owned()),
             digest,
         );
     }
@@ -321,7 +321,7 @@ mod test {
         );
 
         assert_eq!(
-            Digest("e81dba9d36276baa8d491373fe09ef38e71e68c12f70e45b7c260ba2c48a87f5".to_owned()),
+            Digest("3c7499d1b8cf0f5a0708354ec7b4e4e203cd1f43b0a9537fc332a4ad6cd67830".to_owned()),
             digest,
         );
     }
@@ -370,7 +370,7 @@ mod test {
         );
 
         assert_eq!(
-            Digest("f1b8ca07d35905bbd8bba79137ca7a02414b4ef01f28c459b78d1807ac3a8191".to_owned()),
+            Digest("d6b428e411f951b55c17b4a67a8fc66a4e4d549fcd8d792c5974750ab0b34900".to_owned()),
             digest,
         );
     }
diff --git a/crate_universe/src/main.rs b/crate_universe/src/main.rs
index e1ab0c9daa..473c831066 100644
--- a/crate_universe/src/main.rs
+++ b/crate_universe/src/main.rs
@@ -25,5 +25,9 @@ fn main() -> cli::Result<()> {
             cli::init_logging("Vendor", verbose_logging);
             cli::vendor(opt)
         }
+        cli::Options::Render(opt) => {
+            cli::init_logging("Render", verbose_logging);
+            cli::render(opt)
+        }
     }
 }
diff --git a/crate_universe/src/metadata/metadata_annotation.rs b/crate_universe/src/metadata/metadata_annotation.rs
index 2de93d10fd..4750ae9ded 100644
--- a/crate_universe/src/metadata/metadata_annotation.rs
+++ b/crate_universe/src/metadata/metadata_annotation.rs
@@ -4,6 +4,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::path::PathBuf;
 
 use anyhow::{bail, Result};
+use camino::{Utf8Path, Utf8PathBuf};
 use cargo_metadata::{Node, Package, PackageId};
 use hex::ToHex;
 use serde::{Deserialize, Serialize};
@@ -162,6 +163,9 @@ pub(crate) enum SourceAnnotation {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         patches: Option<BTreeSet<String>>,
     },
+    Path {
+        path: Utf8PathBuf,
+    },
 }
 
 /// Additional information related to [Cargo.lock](https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html)
@@ -170,10 +174,17 @@ pub(crate) enum SourceAnnotation {
 pub(crate) struct LockfileAnnotation {
     /// A mapping of crates/packages to additional source (network location) information.
     pub(crate) crates: BTreeMap<PackageId, SourceAnnotation>,
+
+    /// A list of `[patch]`` entries from the Cargo.lock file which were not used in the resolve.
+    pub(crate) unused_patches: BTreeSet<cargo_lock::Dependency>,
 }
 
 impl LockfileAnnotation {
-    pub(crate) fn new(lockfile: CargoLockfile, metadata: &CargoMetadata) -> Result<Self> {
+    pub(crate) fn new(
+        lockfile: CargoLockfile,
+        metadata: &CargoMetadata,
+        nonhermetic_root_bazel_workspace_dir: &Utf8Path,
+    ) -> Result<Self> {
         let workspace_metadata = find_workspace_metadata(metadata).unwrap_or_default();
 
         let nodes: Vec<&Node> = metadata
@@ -196,12 +207,18 @@ impl LockfileAnnotation {
                         metadata,
                         &lockfile,
                         &workspace_metadata,
+                        nonhermetic_root_bazel_workspace_dir,
                     )?,
                 ))
             })
             .collect::<Result<BTreeMap<PackageId, SourceAnnotation>>>()?;
 
-        Ok(Self { crates })
+        let unused_patches = lockfile.patch.unused.into_iter().collect();
+
+        Ok(Self {
+            crates,
+            unused_patches,
+        })
     }
 
     /// Resolve all URLs and checksum-like data for each package
@@ -210,6 +227,7 @@ impl LockfileAnnotation {
         metadata: &CargoMetadata,
         lockfile: &CargoLockfile,
         workspace_metadata: &WorkspaceMetadata,
+        nonhermetic_root_bazel_workspace_dir: &Utf8Path,
     ) -> Result<SourceAnnotation> {
         let pkg = &metadata[&node.id];
 
@@ -225,7 +243,7 @@ impl LockfileAnnotation {
         // Check for spliced information about a crate's network source.
         let spliced_source_info = Self::find_source_annotation(lock_pkg, workspace_metadata);
 
-        // Parse it's source info. The check above should prevent a panic
+        // Parse its source info. The check above should prevent a panic
         let source = match lock_pkg.source.as_ref() {
             Some(source) => source,
             None => match spliced_source_info {
@@ -238,11 +256,39 @@ impl LockfileAnnotation {
                         patches: None,
                     })
                 }
-                None => bail!(
-                    "The package '{:?} {:?}' has no source info so no annotation can be made",
-                    lock_pkg.name,
-                    lock_pkg.version
-                ),
+                None => {
+                    // Test for path deps that may look something like path+file:///var/folders/xs/1d3z0l8977v1_kk4r3_py4l80000gn/T/tmp.AIICMiDy#lazy_static@1.5.0
+                    if let Some(path_with_suffix) = node.id.repr.strip_prefix("path+file://") {
+                        if let Some((path_in_lockfile, _suffix)) = path_with_suffix.rsplit_once('#')
+                        {
+                            let path = match Utf8Path::new(path_in_lockfile)
+                                .strip_prefix(&metadata.workspace_root)
+                            {
+                                Ok(suffix) => {
+                                    // Replace path within our temporary cargo workspace we ran `cargo metadata`` in with path within the actual Bazel workspace.
+                                    // This replacement allows in-repo patches sections to work as intended using local_crate_mirror.
+                                    let mut new_path =
+                                        nonhermetic_root_bazel_workspace_dir.to_owned();
+                                    if let Some(prefix) =
+                                        workspace_metadata.workspace_prefix.as_ref()
+                                    {
+                                        new_path.push(prefix);
+                                    }
+                                    new_path.push(suffix);
+                                    new_path
+                                }
+                                Err(_) => Utf8PathBuf::from(path_in_lockfile),
+                            };
+                            return Ok(SourceAnnotation::Path { path });
+                        }
+                    }
+                    bail!(
+                        "The package '{:?} {:?}: {:?}' has no source info so no annotation can be made",
+                        lock_pkg.name,
+                        lock_pkg.version,
+                        node.id.repr
+                    );
+                }
             },
         };
 
@@ -378,8 +424,13 @@ impl Annotations {
         cargo_metadata: CargoMetadata,
         cargo_lockfile: CargoLockfile,
         config: Config,
+        nonhermetic_root_bazel_workspace_dir: &Utf8Path,
     ) -> Result<Self> {
-        let lockfile_annotation = LockfileAnnotation::new(cargo_lockfile, &cargo_metadata)?;
+        let lockfile_annotation = LockfileAnnotation::new(
+            cargo_lockfile,
+            &cargo_metadata,
+            nonhermetic_root_bazel_workspace_dir,
+        )?;
 
         // Annotate the cargo metadata
         let metadata_annotation = MetadataAnnotation::new(cargo_metadata);
@@ -508,7 +559,12 @@ mod test {
 
     #[test]
     fn annotate_lockfile_with_aliases() {
-        LockfileAnnotation::new(test::lockfile::alias(), &test::metadata::alias()).unwrap();
+        LockfileAnnotation::new(
+            test::lockfile::alias(),
+            &test::metadata::alias(),
+            Utf8Path::new("/tmp/bazelworkspace"),
+        )
+        .unwrap();
     }
 
     #[test]
@@ -521,21 +577,30 @@ mod test {
         LockfileAnnotation::new(
             test::lockfile::build_scripts(),
             &test::metadata::build_scripts(),
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap();
     }
 
     #[test]
     fn annotate_lockfile_with_no_deps() {
-        LockfileAnnotation::new(test::lockfile::no_deps(), &test::metadata::no_deps()).unwrap();
+        LockfileAnnotation::new(
+            test::lockfile::no_deps(),
+            &test::metadata::no_deps(),
+            Utf8Path::new("/tmp/bazelworkspace"),
+        )
+        .unwrap();
     }
 
     #[test]
     fn detects_strip_prefix_for_git_repo() {
-        let crates =
-            LockfileAnnotation::new(test::lockfile::git_repos(), &test::metadata::git_repos())
-                .unwrap()
-                .crates;
+        let crates = LockfileAnnotation::new(
+            test::lockfile::git_repos(),
+            &test::metadata::git_repos(),
+            Utf8Path::new("/tmp/bazelworkspace"),
+        )
+        .unwrap()
+        .crates;
         let tracing_core = crates
             .iter()
             .find(|(k, _)| k.repr.contains("#tracing-core@"))
@@ -556,10 +621,13 @@ mod test {
 
     #[test]
     fn resolves_commit_from_branches_and_tags() {
-        let crates =
-            LockfileAnnotation::new(test::lockfile::git_repos(), &test::metadata::git_repos())
-                .unwrap()
-                .crates;
+        let crates = LockfileAnnotation::new(
+            test::lockfile::git_repos(),
+            &test::metadata::git_repos(),
+            Utf8Path::new("/tmp/bazelworkspace"),
+        )
+        .unwrap()
+        .crates;
 
         let package_id = PackageId {
             repr: "git+https://github.com/tokio-rs/tracing.git?branch=master#tracing@0.2.0".into(),
@@ -586,7 +654,12 @@ mod test {
             CrateAnnotations::default(),
         );
 
-        let result = Annotations::new(test::metadata::no_deps(), test::lockfile::no_deps(), config);
+        let result = Annotations::new(
+            test::metadata::no_deps(),
+            test::lockfile::no_deps(),
+            config,
+            Utf8Path::new("/tmp/bazelworkspace"),
+        );
         assert!(result.is_err());
 
         let result_str = format!("{result:?}");
@@ -623,6 +696,7 @@ mod test {
             test::metadata::has_package_metadata(),
             test::lockfile::has_package_metadata(),
             config,
+            Utf8Path::new("/tmp/bazelworkspace"),
         )
         .unwrap();
 
diff --git a/crate_universe/src/rendering.rs b/crate_universe/src/rendering.rs
index 5abb068e20..7fdf846b00 100644
--- a/crate_universe/src/rendering.rs
+++ b/crate_universe/src/rendering.rs
@@ -6,6 +6,7 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
 use std::path::PathBuf;
 use std::str::FromStr;
+use std::sync::Arc;
 
 use anyhow::{bail, Context as AnyhowContext, Result};
 use itertools::Itertools;
@@ -29,30 +30,34 @@ use crate::utils::{self, sanitize_repository_name};
 pub(crate) type Platforms = BTreeMap<String, BTreeSet<String>>;
 
 pub(crate) struct Renderer {
-    config: RenderConfig,
-    supported_platform_triples: BTreeSet<TargetTriple>,
-    engine: TemplateEngine,
+    config: Arc<RenderConfig>,
+    supported_platform_triples: Arc<BTreeSet<TargetTriple>>,
 }
 
 impl Renderer {
     pub(crate) fn new(
-        config: RenderConfig,
-        supported_platform_triples: BTreeSet<TargetTriple>,
+        config: Arc<RenderConfig>,
+        supported_platform_triples: Arc<BTreeSet<TargetTriple>>,
     ) -> Self {
-        let engine = TemplateEngine::new(&config);
         Self {
             config,
             supported_platform_triples,
-            engine,
         }
     }
 
-    pub(crate) fn render(&self, context: &Context) -> Result<BTreeMap<PathBuf, String>> {
+    pub(crate) fn render(
+        &self,
+        context: &Context,
+        generator: Option<Label>,
+    ) -> Result<BTreeMap<PathBuf, String>> {
+        let conditions = Arc::new(context.conditions.clone());
+        let engine = self.create_engine(Arc::clone(&conditions));
+
         let mut output = BTreeMap::new();
 
-        let platforms = self.render_platform_labels(context);
-        output.extend(self.render_build_files(context, &platforms)?);
-        output.extend(self.render_crates_module(context, &platforms)?);
+        let platforms = self.render_platform_labels(conditions);
+        output.extend(self.render_build_files(&engine, context, &platforms)?);
+        output.extend(self.render_crates_module(&engine, context, &platforms, generator)?);
 
         if let Some(vendor_mode) = &self.config.vendor_mode {
             match vendor_mode {
@@ -60,7 +65,7 @@ impl Renderer {
                     // Nothing to do for local vendor crate
                 }
                 crate::config::VendorMode::Remote => {
-                    output.extend(self.render_vendor_support_files(context)?);
+                    output.extend(self.render_vendor_support_files(&engine, context)?);
                 }
             }
         }
@@ -68,9 +73,22 @@ impl Renderer {
         Ok(output)
     }
 
-    fn render_platform_labels(&self, context: &Context) -> BTreeMap<String, BTreeSet<String>> {
-        context
-            .conditions
+    pub(crate) fn create_engine(
+        &self,
+        conditions: Arc<BTreeMap<String, BTreeSet<TargetTriple>>>,
+    ) -> TemplateEngine {
+        TemplateEngine::new(
+            Arc::clone(&self.config),
+            Arc::clone(&self.supported_platform_triples),
+            Arc::clone(&conditions),
+        )
+    }
+
+    pub(crate) fn render_platform_labels(
+        &self,
+        conditions: Arc<BTreeMap<String, BTreeSet<TargetTriple>>>,
+    ) -> BTreeMap<String, BTreeSet<String>> {
+        conditions
             .iter()
             .map(|(cfg, target_triples)| {
                 (
@@ -91,8 +109,10 @@ impl Renderer {
 
     fn render_crates_module(
         &self,
+        engine: &TemplateEngine,
         context: &Context,
         platforms: &Platforms,
+        generator: Option<Label>,
     ) -> Result<BTreeMap<PathBuf, String>> {
         let module_label = render_module_label(&self.config.crates_module_template, "defs.bzl")
             .context("Failed to resolve string to module file label")?;
@@ -106,11 +126,11 @@ impl Renderer {
         let mut map = BTreeMap::new();
         map.insert(
             Renderer::label_to_path(&module_label),
-            self.engine.render_module_bzl(context, platforms)?,
+            engine.render_module_bzl(context, platforms, generator)?,
         );
         map.insert(
             Renderer::label_to_path(&module_build_label),
-            self.render_module_build_file(context)?,
+            self.render_module_build_file(engine, context)?,
         );
         map.insert(
             Renderer::label_to_path(&module_alias_rules_label),
@@ -124,11 +144,15 @@ impl Renderer {
         Ok(map)
     }
 
-    fn render_module_build_file(&self, context: &Context) -> Result<String> {
+    fn render_module_build_file(
+        &self,
+        engine: &TemplateEngine,
+        context: &Context,
+    ) -> Result<String> {
         let mut starlark = Vec::new();
 
         // Banner comment for top of the file.
-        let header = self.engine.render_header()?;
+        let header = engine.render_header()?;
         starlark.push(Starlark::Verbatim(header));
 
         // Load any `alias_rule`s.
@@ -268,6 +292,7 @@ impl Renderer {
 
     fn render_build_files(
         &self,
+        engine: &TemplateEngine,
         context: &Context,
         platforms: &Platforms,
     ) -> Result<BTreeMap<PathBuf, String>> {
@@ -290,17 +315,22 @@ impl Renderer {
                 };
 
                 let filename = Renderer::label_to_path(&label);
-                let content = self.render_one_build_file(platforms, &context.crates[id])?;
+                let content = self.render_one_build_file(engine, platforms, &context.crates[id])?;
                 Ok((filename, content))
             })
             .collect()
     }
 
-    fn render_one_build_file(&self, platforms: &Platforms, krate: &CrateContext) -> Result<String> {
+    pub(crate) fn render_one_build_file(
+        &self,
+        engine: &TemplateEngine,
+        platforms: &Platforms,
+        krate: &CrateContext,
+    ) -> Result<String> {
         let mut starlark = Vec::new();
 
         // Banner comment for top of the file.
-        let header = self.engine.render_header()?;
+        let header = engine.render_header()?;
         starlark.push(Starlark::Verbatim(header));
 
         // Loads: map of bzl file to set of items imported from that file. These
@@ -763,14 +793,18 @@ impl Renderer {
         )
     }
 
-    fn render_vendor_support_files(&self, context: &Context) -> Result<BTreeMap<PathBuf, String>> {
+    fn render_vendor_support_files(
+        &self,
+        engine: &TemplateEngine,
+        context: &Context,
+    ) -> Result<BTreeMap<PathBuf, String>> {
         let module_label = render_module_label(&self.config.crates_module_template, "crates.bzl")
             .context("Failed to resolve string to module file label")?;
 
         let mut map = BTreeMap::new();
         map.insert(
             Renderer::label_to_path(&module_label),
-            self.engine.render_vendor_module_file(context)?,
+            engine.render_vendor_module_file(context)?,
         );
 
         Ok(map)
@@ -919,6 +953,7 @@ fn make_data(
 mod test {
     use super::*;
 
+    use camino::Utf8Path;
     use indoc::indoc;
 
     use crate::config::{Config, CrateId};
@@ -937,17 +972,17 @@ mod test {
         }
     }
 
-    fn mock_render_config(vendor_mode: Option<VendorMode>) -> RenderConfig {
-        RenderConfig {
+    fn mock_render_config(vendor_mode: Option<VendorMode>) -> Arc<RenderConfig> {
+        Arc::new(RenderConfig {
             repository_name: "test_rendering".to_owned(),
             regen_command: "cargo_bazel_regen_command".to_owned(),
             vendor_mode,
             ..RenderConfig::default()
-        }
+        })
     }
 
-    fn mock_supported_platform_triples() -> BTreeSet<TargetTriple> {
-        BTreeSet::from([
+    fn mock_supported_platform_triples() -> Arc<BTreeSet<TargetTriple>> {
+        Arc::new(BTreeSet::from([
             TargetTriple::from_bazel("aarch64-apple-darwin".to_owned()),
             TargetTriple::from_bazel("aarch64-apple-ios".to_owned()),
             TargetTriple::from_bazel("aarch64-linux-android".to_owned()),
@@ -970,7 +1005,7 @@ mod test {
             TargetTriple::from_bazel("x86_64-pc-windows-msvc".to_owned()),
             TargetTriple::from_bazel("x86_64-unknown-freebsd".to_owned()),
             TargetTriple::from_bazel("x86_64-unknown-linux-gnu".to_owned()),
-        ])
+        ]))
     }
 
     #[test]
@@ -1000,7 +1035,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1038,7 +1073,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1079,7 +1114,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1121,7 +1156,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1159,7 +1194,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1199,7 +1234,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1214,12 +1249,17 @@ mod test {
             generate_binaries: true,
             ..Config::default()
         };
-        let annotations =
-            Annotations::new(test::metadata::alias(), test::lockfile::alias(), config).unwrap();
+        let annotations = Annotations::new(
+            test::metadata::alias(),
+            test::lockfile::alias(),
+            config,
+            Utf8Path::new("/tmp/bazelworkspace"),
+        )
+        .unwrap();
         let context = Context::new(annotations, false).unwrap();
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output.get(&PathBuf::from("BUILD.bazel")).unwrap();
 
@@ -1254,7 +1294,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let defs_module = output.get(&PathBuf::from("defs.bzl")).unwrap();
 
@@ -1292,7 +1332,7 @@ mod test {
             mock_render_config(Some(VendorMode::Remote)),
             mock_supported_platform_triples(),
         );
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let defs_module = output.get(&PathBuf::from("defs.bzl")).unwrap();
         assert!(defs_module.contains("def crate_repositories():"));
@@ -1332,7 +1372,7 @@ mod test {
             mock_render_config(Some(VendorMode::Local)),
             mock_supported_platform_triples(),
         );
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         // Local vendoring does not produce a `crate_repositories` macro
         let defs_module = output.get(&PathBuf::from("defs.bzl")).unwrap();
@@ -1384,7 +1424,7 @@ mod test {
             mock_render_config(Some(VendorMode::Local)),
             mock_supported_platform_triples(),
         );
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1421,11 +1461,20 @@ mod test {
         let metadata = test::metadata::multi_cfg_dep();
         let lockfile = test::lockfile::multi_cfg_dep();
 
-        let annotations = Annotations::new(metadata, lockfile, config.clone()).unwrap();
+        let annotations = Annotations::new(
+            metadata,
+            lockfile,
+            config.clone(),
+            Utf8Path::new("/tmp/bazelworkspace"),
+        )
+        .unwrap();
         let context = Context::new(annotations, false).unwrap();
 
-        let renderer = Renderer::new(config.rendering, config.supported_platform_triples);
-        let output = renderer.render(&context).unwrap();
+        let renderer = Renderer::new(
+            Arc::new(config.rendering),
+            Arc::new(config.supported_platform_triples),
+        );
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.cpufeatures-0.2.7.bazel"))
@@ -1491,7 +1540,7 @@ mod test {
         );
 
         let renderer = Renderer::new(mock_render_config(None), mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1538,9 +1587,11 @@ mod test {
         );
 
         let mut render_config = mock_render_config(None);
-        render_config.generate_rules_license_metadata = true;
+        Arc::get_mut(&mut render_config)
+            .unwrap()
+            .generate_rules_license_metadata = true;
         let renderer = Renderer::new(render_config, mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1591,9 +1642,11 @@ mod test {
         );
 
         let mut render_config = mock_render_config(None);
-        render_config.generate_rules_license_metadata = true;
+        Arc::get_mut(&mut render_config)
+            .unwrap()
+            .generate_rules_license_metadata = true;
         let renderer = Renderer::new(render_config, mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1655,9 +1708,11 @@ mod test {
         );
 
         let mut render_config = mock_render_config(None);
-        render_config.generate_rules_license_metadata = true;
+        Arc::get_mut(&mut render_config)
+            .unwrap()
+            .generate_rules_license_metadata = true;
         let renderer = Renderer::new(render_config, mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
 
         let build_file_content = output
             .get(&PathBuf::from("BUILD.mock_crate-0.1.0.bazel"))
@@ -1727,11 +1782,12 @@ mod test {
 
         let mut config = mock_render_config(Some(VendorMode::Local));
         // change templates so it matches local vendor
-        config.build_file_template = "//{name}-{version}:BUILD.bazel".into();
+        Arc::get_mut(&mut config).unwrap().build_file_template =
+            "//{name}-{version}:BUILD.bazel".into();
 
         // Enable local vendor mode
         let renderer = Renderer::new(config, mock_supported_platform_triples());
-        let output = renderer.render(&context).unwrap();
+        let output = renderer.render(&context, None).unwrap();
         eprintln!("output before {:?}", output.keys());
         // Local vendoring does not produce a `crate_repositories` macro
         let defs_module = output.get(&PathBuf::from("defs.bzl")).unwrap();
diff --git a/crate_universe/src/rendering/template_engine.rs b/crate_universe/src/rendering/template_engine.rs
index 03a85a62bc..3411a90888 100644
--- a/crate_universe/src/rendering/template_engine.rs
+++ b/crate_universe/src/rendering/template_engine.rs
@@ -1,18 +1,21 @@
 //! A template engine backed by [tera::Tera] for rendering Files.
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::sync::Arc;
 
 use anyhow::{Context as AnyhowContext, Result};
 use serde_json::{from_value, to_value, Value};
 
 use crate::config::RenderConfig;
-use crate::context::Context;
+use crate::context::{Context, SingleBuildFileRenderContext};
 use crate::rendering::{
     render_crate_bazel_label, render_crate_bazel_repository, render_crate_build_file,
-    render_module_label, Platforms,
+    render_module_label, CrateContext, Platforms,
 };
 use crate::select::Select;
 use crate::utils::sanitize_repository_name;
+use crate::utils::starlark::Label;
+use crate::utils::target_triple::TargetTriple;
 
 pub(crate) struct TemplateEngine {
     engine: tera::Tera,
@@ -20,7 +23,11 @@ pub(crate) struct TemplateEngine {
 }
 
 impl TemplateEngine {
-    pub(crate) fn new(render_config: &RenderConfig) -> Self {
+    pub(crate) fn new(
+        render_config: Arc<RenderConfig>,
+        supported_platform_triples: Arc<BTreeSet<TargetTriple>>,
+        platform_conditions: Arc<BTreeMap<String, BTreeSet<TargetTriple>>>,
+    ) -> Self {
         let mut tera = tera::Tera::default();
         tera.add_raw_templates(vec![
             (
@@ -97,6 +104,14 @@ impl TemplateEngine {
             "crates_module_label",
             module_label_fn_generator(render_config.crates_module_template.clone()),
         );
+        tera.register_function(
+            "local_crate_mirror_options_json",
+            local_crate_mirror_options_json_fn_generator(
+                Arc::clone(&render_config),
+                supported_platform_triples,
+                platform_conditions,
+            ),
+        );
 
         let mut context = tera::Context::new();
         context.insert("default_select_list", &Select::<String>::default());
@@ -136,10 +151,12 @@ impl TemplateEngine {
         &self,
         data: &Context,
         platforms: &Platforms,
+        generator: Option<Label>,
     ) -> Result<String> {
         let mut context = self.new_tera_ctx();
         context.insert("context", data);
         context.insert("platforms", platforms);
+        context.insert("generator", &generator);
 
         self.engine
             .render("module_bzl.j2", &context)
@@ -254,3 +271,32 @@ fn crate_repository_fn_generator(template: String, repository_name: String) -> i
         },
     )
 }
+
+fn local_crate_mirror_options_json_fn_generator(
+    config: Arc<RenderConfig>,
+    supported_platform_triples: Arc<BTreeSet<TargetTriple>>,
+    platform_conditions: Arc<BTreeMap<String, BTreeSet<TargetTriple>>>,
+) -> impl tera::Function {
+    Box::new(
+        move |args: &HashMap<String, Value>| -> tera::Result<Value> {
+            let config = Arc::clone(&config);
+            let supported_platform_triples = Arc::clone(&supported_platform_triples);
+            let platform_conditions = Arc::clone(&platform_conditions);
+            let crate_context = Arc::new(parse_tera_param!("crate_context", CrateContext, args));
+            let context = SingleBuildFileRenderContext {
+                config,
+                supported_platform_triples,
+                platform_conditions,
+                crate_context,
+            };
+            serde_json::to_string(&context)
+                .and_then(to_value)
+                .map_err(|err| {
+                    tera::Error::msg(format!(
+                        "Failed to serialize SingleBuildFileRenderContext: {:?}",
+                        err
+                    ))
+                })
+        },
+    )
+}
diff --git a/crate_universe/src/rendering/templates/module_bzl.j2 b/crate_universe/src/rendering/templates/module_bzl.j2
index 28cfcf2aae..4e39d43ea8 100644
--- a/crate_universe/src/rendering/templates/module_bzl.j2
+++ b/crate_universe/src/rendering/templates/module_bzl.j2
@@ -18,6 +18,7 @@ load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
 load("@bazel_skylib//lib:selects.bzl", "selects")
+load("@rules_rust//crate_universe/private:local_crate_mirror.bzl", "local_crate_mirror")
 
 ###############################################################################
 # MACROS API
@@ -337,6 +338,17 @@ def crate_repositories():
 {% include "partials/module/repo_http.j2" %}
 {%- elif repository_type in ["Git"] %}
 {% include "partials/module/repo_git.j2" %}
+{%- elif repository_type in ["Path"] %}
+
+    local_crate_mirror(
+        name = "{{ crate_repository(name = crate.name, version = crate.version) }}",
+        {%- if generator %}
+        generator = "{{ generator }}",
+        {%- endif %}
+        options_json = "{{ local_crate_mirror_options_json(crate_context = crate) | replace(from='\', to='\\') | replace(from='"', to='\"') }}",
+        path = "{{attrs.path}}",
+    )
+
 {%- else %}
     {{ throw(message = "Unsupported checksum type: " ~ repository_type) }}
 {%- endif %}
diff --git a/examples/.bazelignore b/examples/.bazelignore
index 79bbe13c03..69123eaf38 100644
--- a/examples/.bazelignore
+++ b/examples/.bazelignore
@@ -7,6 +7,7 @@ bazel-testlogs
 bzlmod
 cargo_manifest_dir/external_crate
 crate_universe
+crate_universe_local_path
 crate_universe_unnamed
 ios
 ios_build
diff --git a/examples/bzlmod/hello_world/MODULE.bazel.lock b/examples/bzlmod/hello_world/MODULE.bazel.lock
index d3cc393f46..8b418b448d 100644
--- a/examples/bzlmod/hello_world/MODULE.bazel.lock
+++ b/examples/bzlmod/hello_world/MODULE.bazel.lock
@@ -5144,7 +5144,7 @@
     },
     "@@rules_rust~//rust/private:internal_extensions.bzl%i": {
       "general": {
-        "bzlTransitiveDigest": "PAqLfLf0+yk8PtOlnr757wtrg/sF1iJLRXgpiIAdgb4=",
+        "bzlTransitiveDigest": "Zcf8owqwf4FiEBD75TPleF8pOtoeYtI+GU0/JF0IyRI=",
         "usagesDigest": "edPDvecLR+flm9OqqOdF4+Oi/C3zTe+8WbukXr4PMxQ=",
         "recordedFileInputs": {},
         "recordedDirentsInputs": {},
diff --git a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_none.json b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_none.json
index 71227b0e54..c9575d47e8 100644
--- a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_none.json
+++ b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_none.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "bf52630c6230479a00ebb0519ec2378d6d2c33e8b2bde18dd96760dea9b2ba29",
+  "checksum": "bf92dd550985ad7bd866b70ccc8639599d55c1db5fccccac085f03afbc4e9aa3",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -220,5 +220,6 @@
   "direct_deps": [
     "test_data_passing_crate 0.1.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_opt.json b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_opt.json
index b4c1d70b0f..696af81139 100644
--- a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_opt.json
+++ b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_alias_annotation_opt.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "1b603ad96cdf8e0ea7ba6d947ce7d2d82f676345b1d2b134c7229cf4691066c2",
+  "checksum": "ddf0b5fb99742a3f6462fd40e81382629e17c33cf73b37ad8632800722f4ebb1",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -221,5 +221,6 @@
   "direct_deps": [
     "test_data_passing_crate 0.1.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_custom_annotation_none.json b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_custom_annotation_none.json
index 6b12000951..b079a80a09 100644
--- a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_custom_annotation_none.json
+++ b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_custom_annotation_none.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "5bfa17ee325988ab0fd4e16df76deed2598ebd4b7be5c43a60380a87ff28cc97",
+  "checksum": "feab89eaa1026abef3fbdd4759753b4721c89c40b60777e3e4e481a2c11db2ef",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -220,5 +220,6 @@
   "direct_deps": [
     "test_data_passing_crate 0.1.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_dbg_annotation_fastbuild.json b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_dbg_annotation_fastbuild.json
index bc0eb32501..507161b2b2 100644
--- a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_dbg_annotation_fastbuild.json
+++ b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_dbg_annotation_fastbuild.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "69cd46e3fc1ce60888eafde3564498e426dec36b4651f62587dc687eb0b3c2f9",
+  "checksum": "2ceb3059bc8039b218645fc9e85fa0df1a6e6959d8118dfd8e088859ab245962",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -221,5 +221,6 @@
   "direct_deps": [
     "test_data_passing_crate 0.1.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_alias.json b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_alias.json
index 51f4b7d349..56fd9dc0dd 100644
--- a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_alias.json
+++ b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_alias.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "9b0ee98f3a7a11ac67cfc8d6c9454a86db0212c64e95095c4fbb46fb2ce29703",
+  "checksum": "45e1290ebd0a736bac19eabee86e9386410c941d550179c221edbca4b8d5e6f6",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -221,5 +221,6 @@
   "direct_deps": [
     "test_data_passing_crate 0.1.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_dbg.json b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_dbg.json
index 36c272a1a0..f31eb7e483 100644
--- a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_dbg.json
+++ b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_dbg.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "8bf391ab2f4512c09fa23a2cb03428e67d8f3b46ed95451068df3c5707ada61f",
+  "checksum": "67381b436df8a688c931402315f0a521d2dc7a856c9c734330a0749ef3147f2f",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -221,5 +221,6 @@
   "direct_deps": [
     "test_data_passing_crate 0.1.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_none.json b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_none.json
index d4d2a1b5b2..7ae7b76b12 100644
--- a/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_none.json
+++ b/examples/crate_universe/alias_rule/cargo-bazel-lock_global_opt_annotation_none.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "e383af5faa233af2539370a9529e45cbe0164b4d61612232f47b94ec8a8086f5",
+  "checksum": "3d1971d2c03351f2b6d9ffdc78ace206e952773414bd20c0815ccfe606fcdc95",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -220,5 +220,6 @@
   "direct_deps": [
     "test_data_passing_crate 0.1.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/cargo_aliases/cargo-bazel-lock.json b/examples/crate_universe/cargo_aliases/cargo-bazel-lock.json
index addf747753..35e1fdbd74 100644
--- a/examples/crate_universe/cargo_aliases/cargo-bazel-lock.json
+++ b/examples/crate_universe/cargo_aliases/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "302c37ca9329628c036fbc4839261329949c480d269ffa45c537f485da55d6a3",
+  "checksum": "5ed02b2b2f95b27a442e73cc92a802c24e0db36a09d1daf03198bcf538b30087",
   "crates": {
     "aho-corasick 0.7.20": {
       "name": "aho-corasick",
@@ -3217,5 +3217,6 @@
   ],
   "direct_dev_deps": [
     "env_logger 0.9.3"
-  ]
+  ],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/cargo_conditional_deps/cargo-bazel-lock.json b/examples/crate_universe/cargo_conditional_deps/cargo-bazel-lock.json
index c920c8f2a1..f051de7dd0 100644
--- a/examples/crate_universe/cargo_conditional_deps/cargo-bazel-lock.json
+++ b/examples/crate_universe/cargo_conditional_deps/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "37f03db7ce7f90dfb1bd9b823ab34cffb4cbac54c1b70c91eba3c7a1cffa1566",
+  "checksum": "c3b7b22da137040aab45b4d7fca22113423c089a7eb5cbc5ab743cd52c990813",
   "crates": {
     "autocfg 1.1.0": {
       "name": "autocfg",
@@ -619,5 +619,6 @@
   "direct_deps": [
     "nix 0.26.2"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/cargo_workspace/cargo-bazel-lock.json b/examples/crate_universe/cargo_workspace/cargo-bazel-lock.json
index 4c173800e9..51c782a45d 100644
--- a/examples/crate_universe/cargo_workspace/cargo-bazel-lock.json
+++ b/examples/crate_universe/cargo_workspace/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "4e0956b6c2f3558d412152466b93c63ac7d855625445a92c25e5ea9a209c1617",
+  "checksum": "30ce6b66e2eea8ea9f16127685336d3311e1a215db619e60076c7394ade17b4b",
   "crates": {
     "ansi_term 0.12.1": {
       "name": "ansi_term",
@@ -2044,5 +2044,6 @@
     "ferris-says 0.2.1",
     "rand 0.7.3"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/complicated_dependencies/cargo-bazel-lock.json b/examples/crate_universe/complicated_dependencies/cargo-bazel-lock.json
index 63ba5590c5..c17655d056 100644
--- a/examples/crate_universe/complicated_dependencies/cargo-bazel-lock.json
+++ b/examples/crate_universe/complicated_dependencies/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "33fb44e14dab568acd00662671fc0954a1fdff66100d69e91bec0f27b90ff710",
+  "checksum": "eaec2c21b83d6d902964adcfd1e91f34b1abaf419bdcabe3a600b344646cafc6",
   "crates": {
     "aho-corasick 1.1.3": {
       "name": "aho-corasick",
@@ -3105,5 +3105,6 @@
     "boring 3.1.0",
     "libz-ng-sys 1.1.15"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/multi_package/cargo-bazel-lock.json b/examples/crate_universe/multi_package/cargo-bazel-lock.json
index 115fa9d6d1..d618316dad 100644
--- a/examples/crate_universe/multi_package/cargo-bazel-lock.json
+++ b/examples/crate_universe/multi_package/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "3aaf5d493a950efdf45c8ebbde98bbc7c5e2c3edf04393883bd584840e19b4f1",
+  "checksum": "31a6b4a55dc26934915bfc2171ed4995b4953c622232ed7f423090bfa56dd346",
   "crates": {
     "aho-corasick 0.7.20": {
       "name": "aho-corasick",
@@ -16228,5 +16228,6 @@
   "direct_dev_deps": [
     "hex-literal 0.3.4",
     "httpmock 0.6.7"
-  ]
+  ],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/no_cargo_manifests/cargo-bazel-lock.json b/examples/crate_universe/no_cargo_manifests/cargo-bazel-lock.json
index 9b034730b2..b60a21be2d 100644
--- a/examples/crate_universe/no_cargo_manifests/cargo-bazel-lock.json
+++ b/examples/crate_universe/no_cargo_manifests/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "86b6e08fe8d8eb9d20bcd652977b287934be90b20c4ce7e0fbc70d1a8bd3a101",
+  "checksum": "ed414e4ed65d5991b4fa58676dcedbbb139b7002aac2d102dec314845b9f7532",
   "crates": {
     "async-trait 0.1.64": {
       "name": "async-trait",
@@ -6419,5 +6419,6 @@
     "tracing 0.1.37",
     "tracing-subscriber 0.3.16"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/override_target/cargo-bazel-lock.json b/examples/crate_universe/override_target/cargo-bazel-lock.json
index 12a9e8442e..a0ab57e667 100644
--- a/examples/crate_universe/override_target/cargo-bazel-lock.json
+++ b/examples/crate_universe/override_target/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "91be35feb3f89397258a9e18faafff427482fa07dda20fd51578162bd655dbd9",
+  "checksum": "da37b7c99c7b8dc2d9ad9ac85f8406b111a64917f3d69569552bf5270c0d8049",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -194,5 +194,6 @@
   "direct_deps": [
     "foo 0.0.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/using_cxx/cargo-bazel-lock.json b/examples/crate_universe/using_cxx/cargo-bazel-lock.json
index 178145f62d..c38b176dc4 100644
--- a/examples/crate_universe/using_cxx/cargo-bazel-lock.json
+++ b/examples/crate_universe/using_cxx/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "550eb42997db55d9a3cd9f5edf569bb0fef17de78d92235f813645141bc1cade",
+  "checksum": "a002e03956b53a02d02140d0ff8befe0ef69a36f2dd32edf5517ac1c8233ba73",
   "crates": {
     "cc 1.0.82": {
       "name": "cc",
@@ -807,5 +807,6 @@
   "direct_deps": [
     "cxx 1.0.109"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe/using_cxx/cxxbridge-cmd.Cargo.Bazel.lock b/examples/crate_universe/using_cxx/cxxbridge-cmd.Cargo.Bazel.lock
index 9745e0ba6b..204aa7da32 100644
--- a/examples/crate_universe/using_cxx/cxxbridge-cmd.Cargo.Bazel.lock
+++ b/examples/crate_universe/using_cxx/cxxbridge-cmd.Cargo.Bazel.lock
@@ -1,5 +1,5 @@
 {
-  "checksum": "1bfe374f81cdfc7748f6456fa03c0bc8119a5bbeb2dde6d71cafc033e7abfde3",
+  "checksum": "cba3188b84cdfad1cd0019b1ca89793c8db9c86f1ff2c483a47def462b2ce3d4",
   "crates": {
     "anstyle 1.0.1": {
       "name": "anstyle",
@@ -1077,5 +1077,6 @@
     "quote 1.0.32",
     "syn 2.0.28"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/crate_universe_local_path/.gitignore b/examples/crate_universe_local_path/.gitignore
new file mode 100644
index 0000000000..a6ef824c1f
--- /dev/null
+++ b/examples/crate_universe_local_path/.gitignore
@@ -0,0 +1 @@
+/bazel-*
diff --git a/examples/crate_universe_local_path/BUILD.bazel b/examples/crate_universe_local_path/BUILD.bazel
new file mode 100644
index 0000000000..6f156bf432
--- /dev/null
+++ b/examples/crate_universe_local_path/BUILD.bazel
@@ -0,0 +1,12 @@
+sh_binary(
+    name = "vendor_lazy_static_out_of_tree",
+    srcs = ["vendor_lazy_static.sh"],
+)
+
+sh_binary(
+    name = "vendor_lazy_static_in_tree",
+    srcs = ["vendor_lazy_static.sh"],
+    args = [
+        "vendored_lazy_static",
+    ],
+)
diff --git a/examples/crate_universe_local_path/MODULE.bazel b/examples/crate_universe_local_path/MODULE.bazel
new file mode 100644
index 0000000000..34fdf16a8e
--- /dev/null
+++ b/examples/crate_universe_local_path/MODULE.bazel
@@ -0,0 +1,27 @@
+bazel_dep(name = "rules_rust", version = "0.54.1")
+local_path_override(
+    module_name = "rules_rust",
+    path = "../..",
+)
+
+rust = use_extension("@rules_rust//rust:extensions.bzl", "rust")
+rust.toolchain(edition = "2021")
+use_repo(
+    rust,
+    "rust_toolchains",
+)
+
+register_toolchains("@rust_toolchains//:all")
+
+crate = use_extension(
+    "@rules_rust//crate_universe:extension.bzl",
+    "crate",
+)
+crate.from_cargo(
+    name = "bzlmod_crates_from_cargo_workspace",
+    cargo_lockfile = "//crates_from_workspace:Cargo.lock",
+    manifests = [
+        "//crates_from_workspace:Cargo.toml",
+    ],
+)
+use_repo(crate, "bzlmod_crates_from_cargo_workspace")
diff --git a/examples/crate_universe_local_path/README.md b/examples/crate_universe_local_path/README.md
new file mode 100644
index 0000000000..9b83a746a2
--- /dev/null
+++ b/examples/crate_universe_local_path/README.md
@@ -0,0 +1,11 @@
+# crate_universe_local_path
+
+This example does some slightly weird things. It tests that we can patch upstream crates.
+
+The local crate in this dir depends on lazy_static, and assumes it can access a symbol named VENDORED_BY.
+
+VENDORED_BY does not exist in the real lazy_static crate.
+
+We have checked in a copy of lazy_static. On CI, we make a copy of our checked in copy of lazy_static adding the VENDORED_BY symbol, and update our Cargo.toml file to enable the `[patch]`.
+
+We then run a test which tries to use the VENDORED_BY symbol. If we weren't successfully patching lazy_static, our test would fail to compile. If we successfully use the patch, the test compiles and everything's fine.
diff --git a/examples/crate_universe_local_path/WORKSPACE.bazel b/examples/crate_universe_local_path/WORKSPACE.bazel
new file mode 100644
index 0000000000..d03b8bcfd2
--- /dev/null
+++ b/examples/crate_universe_local_path/WORKSPACE.bazel
@@ -0,0 +1,31 @@
+local_repository(
+    name = "rules_rust",
+    path = "../../",
+)
+
+load("@rules_rust//rust:repositories.bzl", "rules_rust_dependencies", "rust_register_toolchains")
+
+rules_rust_dependencies()
+
+rust_register_toolchains(
+    edition = "2018",
+)
+
+load("@rules_rust//crate_universe:repositories.bzl", "crate_universe_dependencies")
+
+crate_universe_dependencies(bootstrap = True)
+
+load("@rules_rust//crate_universe:defs.bzl", "crates_repository")
+
+crates_repository(
+    name = "workspace_crates_from_cargo_workspace",
+    cargo_lockfile = "//crates_from_workspace:Cargo.lock",
+    # `generator` is not necessary in official releases.
+    # See load satement for `cargo_bazel_bootstrap`.
+    generator = "@cargo_bazel_bootstrap//:cargo-bazel",
+    manifests = ["//crates_from_workspace:Cargo.toml"],
+)
+
+load("@workspace_crates_from_cargo_workspace//:defs.bzl", "crate_repositories")
+
+crate_repositories()
diff --git a/examples/crate_universe_local_path/crates_from_workspace/BUILD.bazel b/examples/crate_universe_local_path/crates_from_workspace/BUILD.bazel
new file mode 100644
index 0000000000..bdcf43e1df
--- /dev/null
+++ b/examples/crate_universe_local_path/crates_from_workspace/BUILD.bazel
@@ -0,0 +1,15 @@
+load("@bzlmod_crates_from_cargo_workspace//:defs.bzl", bzlmod_all_crate_deps = "all_crate_deps")
+load("@rules_rust//rust:defs.bzl", "rust_test")
+load("@workspace_crates_from_cargo_workspace//:defs.bzl", workspace_all_crate_deps = "all_crate_deps")
+
+rust_test(
+    name = "bzlmod_test",
+    srcs = ["test.rs"],
+    deps = bzlmod_all_crate_deps(),
+)
+
+rust_test(
+    name = "workspace_test",
+    srcs = ["test.rs"],
+    deps = workspace_all_crate_deps(),
+)
diff --git a/examples/crate_universe_local_path/crates_from_workspace/Cargo.lock b/examples/crate_universe_local_path/crates_from_workspace/Cargo.lock
new file mode 100644
index 0000000000..d006a3d0ae
--- /dev/null
+++ b/examples/crate_universe_local_path/crates_from_workspace/Cargo.lock
@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "workspace"
+version = "0.1.0"
+dependencies = [
+ "lazy_static",
+]
diff --git a/examples/crate_universe_local_path/crates_from_workspace/Cargo.toml b/examples/crate_universe_local_path/crates_from_workspace/Cargo.toml
new file mode 100644
index 0000000000..6c8b9d12e6
--- /dev/null
+++ b/examples/crate_universe_local_path/crates_from_workspace/Cargo.toml
@@ -0,0 +1,18 @@
+# TODO: This [workspace] section shouldn't be needed, but we currently treat any path dependency as a sign of being in a workspace.
+# Ideally we should be able to remove this section.
+[workspace]
+members = ["."]
+[package]
+name = "workspace"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "fake.rs"
+
+[dependencies]
+# Note: This is NOT expected to work out of the box.
+# The expectation is that you will `bazel run //:vendor_lazy_static` to set up a patch replacing this.
+lazy_static = "1.5.0"
+
+[patch.crates-io]
diff --git a/examples/crate_universe_local_path/crates_from_workspace/test.rs b/examples/crate_universe_local_path/crates_from_workspace/test.rs
new file mode 100644
index 0000000000..75503fc18d
--- /dev/null
+++ b/examples/crate_universe_local_path/crates_from_workspace/test.rs
@@ -0,0 +1,19 @@
+use std::collections::HashMap;
+use lazy_static::lazy_static;
+
+// This macro is a usage of the base features of the forked crate - it would work whether we were using upstream or the local fork.
+lazy_static! {
+    static ref HASHMAP: HashMap<&'static str, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert("raw", "abc123");
+        // This const is only available in our modified local fork, and does not appear upstream.
+        m.insert("vendored_by", lazy_static::VENDORED_BY);
+        m
+    };
+}
+
+#[test]
+fn get_value() {
+    assert_eq!("abc123", *HASHMAP.get("raw").unwrap());
+    assert_eq!("rules_rust", *HASHMAP.get("vendored_by").unwrap());
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/.github/workflows/rust.yml b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/.github/workflows/rust.yml
new file mode 100644
index 0000000000..e5ccb61c17
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/.github/workflows/rust.yml
@@ -0,0 +1,60 @@
+name: Rust
+
+on: [push, pull_request]
+
+env:
+  CARGO_TERM_COLOR: always
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    name: "Tests"
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        channel:
+        - stable
+        - beta
+        - nightly
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+
+    - name: Install Rust Toolchain
+      run: rustup default ${{ matrix.channel }}
+
+    - name: Install cargo-hack
+      run: cargo install cargo-hack
+
+    - name: Powerset
+      run: cargo hack test --feature-powerset --lib
+
+  miri:
+    name: "Miri"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Miri
+        run: |
+          rustup toolchain install nightly --component miri
+          cargo +nightly miri setup
+      - name: Default features
+        run: cargo +nightly miri test
+
+  embedded:
+    name: Build (embedded)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab
+
+      - name: Install Rust toolchain
+        run: |
+          rustup default nightly
+          rustup target add thumbv7em-none-eabi
+
+      - name: Default features
+        run: cargo build -Z avoid-dev-deps --features spin_no_std --target thumbv7em-none-eabi
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/.gitignore b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/.gitignore
new file mode 100644
index 0000000000..23b8f5eb55
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/.gitignore
@@ -0,0 +1,5 @@
+target
+doc
+Cargo.lock
+.cargo
+wip
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/Cargo.toml b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/Cargo.toml
new file mode 100644
index 0000000000..3de0e4b952
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "lazy_static"
+# NB: When modifying, also modify html_root_url in lib.rs
+version = "1.5.0"
+authors = ["Marvin Löbel <loebel.marvin@gmail.com>"]
+license = "MIT OR Apache-2.0"
+
+description = "A macro for declaring lazily evaluated statics in Rust."
+readme = "README.md"
+documentation = "https://docs.rs/lazy_static"
+
+repository = "https://github.com/rust-lang-nursery/lazy-static.rs"
+keywords = ["macro", "lazy", "static"]
+categories = [ "no-std", "rust-patterns", "memory-management" ]
+exclude = [".github"]
+
+[dependencies.spin]
+version = "0.9.8"
+default-features = false
+features = ["once"]
+optional = true
+
+[features]
+spin_no_std = ["spin"]
+
+[dev-dependencies]
+doc-comment = "0.3.1"
+trybuild = "1"
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/LICENSE-APACHE b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/LICENSE-APACHE
new file mode 100644
index 0000000000..16fe87b06e
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/LICENSE-MIT b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/LICENSE-MIT
new file mode 100644
index 0000000000..25597d5838
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2010 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/README.md b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/README.md
new file mode 100644
index 0000000000..93edbe8a6b
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/README.md
@@ -0,0 +1,105 @@
+lazy-static.rs
+==============
+
+A macro for declaring lazily evaluated statics in Rust.
+
+Using this macro, it is possible to have `static`s that require code to be
+executed at runtime in order to be initialized.
+This includes anything requiring heap allocations, like vectors or hash maps,
+as well as anything that requires non-const function calls to be computed.
+
+[![Rust](https://github.com/rust-lang-nursery/lazy-static.rs/actions/workflows/rust.yml/badge.svg)](https://github.com/rust-lang-nursery/lazy-static.rs/actions/workflows/rust.yml)
+[![Latest version](https://img.shields.io/crates/v/lazy_static.svg)](https://crates.io/crates/lazy_static)
+[![Documentation](https://docs.rs/lazy_static/badge.svg)](https://docs.rs/lazy_static)
+[![License](https://img.shields.io/crates/l/lazy_static.svg)](https://github.com/rust-lang-nursery/lazy-static.rs#license)
+
+## Minimum supported `rustc`
+
+`1.40.0+`
+
+This version is explicitly tested in CI and may only be bumped in new minor versions. Any changes to the supported minimum version will be called out in the release notes.
+
+
+# Getting Started
+
+[lazy-static.rs is available on crates.io](https://crates.io/crates/lazy_static).
+It is recommended to look there for the newest released version, as well as links to the newest builds of the docs.
+
+At the point of the last update of this README, the latest published version could be used like this:
+
+Add the following dependency to your Cargo manifest...
+
+```toml
+[dependencies]
+lazy_static = "1.5.0"
+```
+
+...and see the [docs](https://docs.rs/lazy_static) for how to use it.
+
+# Example
+
+```rust
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+
+lazy_static! {
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        m
+    };
+}
+
+fn main() {
+    // First access to `HASHMAP` initializes it
+    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
+
+    // Any further access to `HASHMAP` just returns the computed value
+    println!("The entry for `1` is \"{}\".", HASHMAP.get(&1).unwrap());
+}
+```
+
+# Standard library
+
+It is now possible to easily replicate this crate's functionality in Rust's standard library with [`std::sync::OnceLock`](https://doc.rust-lang.org/std/sync/struct.OnceLock.html). The example above could be also be written as:
+
+```rust
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+fn hashmap() -> &'static HashMap<u32, &'static str> {
+    static HASHMAP: OnceLock<HashMap<u32, &str>> = OnceLock::new();
+    HASHMAP.get_or_init(|| {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        m
+    })
+}
+
+fn main() {
+    // First access to `HASHMAP` initializes it
+    println!("The entry for `0` is \"{}\".", hashmap().get(&0).unwrap());
+
+    // Any further access to `HASHMAP` just returns the computed value
+    println!("The entry for `1` is \"{}\".", hashmap().get(&1).unwrap());
+}
+```
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or https://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or https://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
+additional terms or conditions.
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/examples/mutex_map.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/examples/mutex_map.rs
new file mode 100644
index 0000000000..92b07ab9d4
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/examples/mutex_map.rs
@@ -0,0 +1,23 @@
+//! This example shows how to wrap a data structure in a mutex to achieve safe mutability.
+extern crate lazy_static;
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+lazy_static! {
+    static ref MUTEX_MAP: Mutex<HashMap<u32, &'static str>> = {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        Mutex::new(m)
+    };
+}
+
+fn main() {
+    MUTEX_MAP.lock().unwrap().insert(0, "boo");
+    println!(
+        "The entry for `0` is \"{}\".",
+        MUTEX_MAP.lock().unwrap().get(&0).unwrap()
+    );
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/core_lazy.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/core_lazy.rs
new file mode 100644
index 0000000000..e2f16bcde8
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/core_lazy.rs
@@ -0,0 +1,32 @@
+// Copyright 2016 lazy-static.rs Developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// https://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+extern crate spin;
+
+use self::spin::Once;
+
+pub struct Lazy<T: Sync>(Once<T>);
+
+impl<T: Sync> Lazy<T> {
+    pub const INIT: Self = Lazy(Once::INIT);
+
+    #[inline(always)]
+    pub fn get<F>(&'static self, builder: F) -> &T
+    where
+        F: FnOnce() -> T,
+    {
+        self.0.call_once(builder)
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::INIT;
+    };
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/inline_lazy.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/inline_lazy.rs
new file mode 100644
index 0000000000..36d52d347b
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/inline_lazy.rs
@@ -0,0 +1,48 @@
+// Copyright 2016 lazy-static.rs Developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// https://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+extern crate core;
+extern crate std;
+
+use self::std::cell::Cell;
+use self::std::mem::MaybeUninit;
+use self::std::prelude::v1::*;
+use self::std::sync::Once;
+#[allow(deprecated)]
+pub use self::std::sync::ONCE_INIT;
+
+#[allow(dead_code)] // Used in macros
+pub struct Lazy<T: Sync>(Cell<MaybeUninit<T>>, Once);
+
+impl<T: Sync> Lazy<T> {
+    #[allow(deprecated)]
+    pub const INIT: Self = Lazy(Cell::new(MaybeUninit::uninit()), ONCE_INIT);
+
+    #[inline(always)]
+    pub fn get<F>(&'static self, f: F) -> &T
+    where
+        F: FnOnce() -> T,
+    {
+        self.1.call_once(|| {
+            self.0.set(MaybeUninit::new(f()));
+        });
+
+        // `self.0` is guaranteed to be initialized by this point
+        // The `Once` will catch and propagate panics
+        unsafe { &*(*self.0.as_ptr()).as_ptr() }
+    }
+}
+
+unsafe impl<T: Sync> Sync for Lazy<T> {}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::INIT;
+    };
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/lib.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/lib.rs
new file mode 100644
index 0000000000..5003fa2c99
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/src/lib.rs
@@ -0,0 +1,208 @@
+// Copyright 2016 lazy-static.rs Developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// https://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+/*!
+A macro for declaring lazily evaluated statics.
+
+Using this macro, it is possible to have `static`s that require code to be
+executed at runtime in order to be initialized.
+This includes anything requiring heap allocations, like vectors or hash maps,
+as well as anything that requires function calls to be computed.
+
+# Syntax
+
+```ignore
+lazy_static! {
+    [pub] static ref NAME_1: TYPE_1 = EXPR_1;
+    [pub] static ref NAME_2: TYPE_2 = EXPR_2;
+    ...
+    [pub] static ref NAME_N: TYPE_N = EXPR_N;
+}
+```
+
+Attributes (including doc comments) are supported as well:
+
+```rust
+use lazy_static::lazy_static;
+
+# fn main() {
+lazy_static! {
+    /// This is an example for using doc comment attributes
+    static ref EXAMPLE: u8 = 42;
+}
+# }
+```
+
+# Semantics
+
+For a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that
+implements `Deref<TYPE>` and stores it in a static with name `NAME`. (Attributes end up
+attaching to this type.)
+
+On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs
+can return a reference to the same object. Note that this can lead to deadlocks
+if you have multiple lazy statics that depend on each other in their initialization.
+
+Apart from the lazy initialization, the resulting "static ref" variables
+have generally the same properties as regular "static" variables:
+
+- Any type in them needs to fulfill the `Sync` trait.
+- If the type has a destructor, then it will not run when the process exits.
+
+# Example
+
+Using the macro:
+
+```rust
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+
+lazy_static! {
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        m
+    };
+    static ref COUNT: usize = HASHMAP.len();
+    static ref NUMBER: u32 = times_two(21);
+}
+
+fn times_two(n: u32) -> u32 { n * 2 }
+
+fn main() {
+    println!("The map has {} entries.", *COUNT);
+    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
+    println!("A expensive calculation on a static results in: {}.", *NUMBER);
+}
+```
+
+# Implementation details
+
+The `Deref` implementation uses a hidden static variable that is guarded by an atomic check on each access.
+
+# Cargo features
+
+This crate provides one cargo feature:
+
+- `spin_no_std`: This allows using this crate in a no-std environment, by depending on the standalone `spin` crate.
+
+*/
+
+#![doc(html_root_url = "https://docs.rs/lazy_static/1.5.0")]
+#![no_std]
+
+#[cfg(doctest)]
+#[macro_use]
+extern crate doc_comment;
+
+#[cfg(doctest)]
+doctest!("../README.md");
+
+#[cfg_attr(feature = "spin_no_std", path = "core_lazy.rs")]
+#[cfg_attr(not(feature = "spin_no_std"), path = "inline_lazy.rs")]
+#[doc(hidden)]
+pub mod lazy;
+
+#[doc(hidden)]
+pub use core::ops::Deref as __Deref;
+
+#[macro_export(local_inner_macros)]
+#[doc(hidden)]
+macro_rules! __lazy_static_internal {
+    // optional visibility restrictions are wrapped in `()` to allow for
+    // explicitly passing otherwise implicit information about private items
+    ($(#[$attr:meta])* ($($vis:tt)*) static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        __lazy_static_internal!(@MAKE TY, $(#[$attr])*, ($($vis)*), $N);
+        __lazy_static_internal!(@TAIL, $N : $T = $e);
+        lazy_static!($($t)*);
+    };
+    (@TAIL, $N:ident : $T:ty = $e:expr) => {
+        impl $crate::__Deref for $N {
+            type Target = $T;
+            fn deref(&self) -> &$T {
+                #[inline(always)]
+                fn __static_ref_initialize() -> $T { $e }
+
+                #[inline(always)]
+                fn __stability() -> &'static $T {
+                    __lazy_static_create!(LAZY, $T);
+                    LAZY.get(__static_ref_initialize)
+                }
+                __stability()
+            }
+        }
+        impl $crate::LazyStatic for $N {
+            fn initialize(lazy: &Self) {
+                let _ = &**lazy;
+            }
+        }
+    };
+    // `vis` is wrapped in `()` to prevent parsing ambiguity
+    (@MAKE TY, $(#[$attr:meta])*, ($($vis:tt)*), $N:ident) => {
+        #[allow(missing_copy_implementations)]
+        #[allow(non_camel_case_types)]
+        #[allow(dead_code)]
+        $(#[$attr])*
+        $($vis)* struct $N {__private_field: ()}
+        #[doc(hidden)]
+        #[allow(non_upper_case_globals)]
+        $($vis)* static $N: $N = $N {__private_field: ()};
+    };
+    () => ()
+}
+
+#[macro_export(local_inner_macros)]
+macro_rules! lazy_static {
+    ($(#[$attr:meta])* static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        // use `()` to explicitly forward the information about private items
+        __lazy_static_internal!($(#[$attr])* () static ref $N : $T = $e; $($t)*);
+    };
+    ($(#[$attr:meta])* pub static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        __lazy_static_internal!($(#[$attr])* (pub) static ref $N : $T = $e; $($t)*);
+    };
+    ($(#[$attr:meta])* pub ($($vis:tt)+) static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        __lazy_static_internal!($(#[$attr])* (pub ($($vis)+)) static ref $N : $T = $e; $($t)*);
+    };
+    () => ()
+}
+
+/// Support trait for enabling a few common operation on lazy static values.
+///
+/// This is implemented by each defined lazy static, and
+/// used by the free functions in this crate.
+pub trait LazyStatic {
+    #[doc(hidden)]
+    fn initialize(lazy: &Self);
+}
+
+/// Takes a shared reference to a lazy static and initializes
+/// it if it has not been already.
+///
+/// This can be used to control the initialization point of a lazy static.
+///
+/// Example:
+///
+/// ```rust
+/// use lazy_static::lazy_static;
+///
+/// lazy_static! {
+///     static ref BUFFER: Vec<u8> = (0..255).collect();
+/// }
+///
+/// fn main() {
+///     lazy_static::initialize(&BUFFER);
+///
+///     // ...
+///     work_with_initialized_data(&BUFFER);
+/// }
+/// # fn work_with_initialized_data(_: &[u8]) {}
+/// ```
+pub fn initialize<T: LazyStatic>(lazy: &T) {
+    LazyStatic::initialize(lazy);
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/incorrect_visibility_restriction.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/incorrect_visibility_restriction.rs
new file mode 100644
index 0000000000..5d44f02dcb
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/incorrect_visibility_restriction.rs
@@ -0,0 +1,8 @@
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    pub(nonsense) static ref WRONG: () = ();
+}
+
+fn main() { }
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/incorrect_visibility_restriction.stderr b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/incorrect_visibility_restriction.stderr
new file mode 100644
index 0000000000..045ce14b8f
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/incorrect_visibility_restriction.stderr
@@ -0,0 +1,10 @@
+error[E0704]: incorrect visibility restriction
+ --> tests/compile_fail/incorrect_visibility_restriction.rs:5:9
+  |
+5 |     pub(nonsense) static ref WRONG: () = ();
+  |         ^^^^^^^^ help: make this visible only to module `nonsense` with `in`: `in nonsense`
+  |
+  = help: some possible visibility restrictions are:
+          `pub(crate)`: visible only on the current crate
+          `pub(super)`: visible only in the current module's parent
+          `pub(in path::to::module)`: visible only on the specified path
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_private.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_private.rs
new file mode 100644
index 0000000000..4486f013d3
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_private.rs
@@ -0,0 +1,14 @@
+#[macro_use]
+extern crate lazy_static;
+
+mod outer {
+    pub mod inner {
+        lazy_static! {
+            pub(in outer) static ref FOO: () = ();
+        }
+    }
+}
+
+fn main() {
+    assert_eq!(*outer::inner::FOO, ());
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_private.stderr b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_private.stderr
new file mode 100644
index 0000000000..38007d475e
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_private.stderr
@@ -0,0 +1,14 @@
+error[E0603]: static `FOO` is private
+  --> tests/compile_fail/static_is_private.rs:13:31
+   |
+13 |     assert_eq!(*outer::inner::FOO, ());
+   |                               ^^^ private static
+   |
+note: the static `FOO` is defined here
+  --> tests/compile_fail/static_is_private.rs:6:9
+   |
+6  | /         lazy_static! {
+7  | |             pub(in outer) static ref FOO: () = ();
+8  | |         }
+   | |_________^
+   = note: this error originates in the macro `lazy_static` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_sized.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_sized.rs
new file mode 100644
index 0000000000..69a9a06228
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_sized.rs
@@ -0,0 +1,9 @@
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    pub static ref FOO: str = panic!();
+}
+
+
+fn main() { }
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_sized.stderr b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_sized.stderr
new file mode 100644
index 0000000000..49407ab6a6
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/compile_fail/static_is_sized.stderr
@@ -0,0 +1,64 @@
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> tests/compile_fail/static_is_sized.rs:4:1
+  |
+4 | / lazy_static! {
+5 | |     pub static ref FOO: str = panic!();
+6 | | }
+  | |_^ doesn't have a size known at compile-time
+  |
+  = help: the trait `Sized` is not implemented for `str`
+note: required by an implicit `Sized` bound in `Lazy`
+ --> src/inline_lazy.rs
+  |
+  | pub struct Lazy<T: Sync>(Cell<MaybeUninit<T>>, Once);
+  |                 ^ required by the implicit `Sized` requirement on this type parameter in `Lazy`
+  = note: this error originates in the macro `__lazy_static_create` which comes from the expansion of the macro `lazy_static` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> tests/compile_fail/static_is_sized.rs:4:1
+  |
+4 | / lazy_static! {
+5 | |     pub static ref FOO: str = panic!();
+6 | | }
+  | |_^ doesn't have a size known at compile-time
+  |
+  = help: the trait `Sized` is not implemented for `str`
+note: required by an implicit `Sized` bound in `Lazy`
+ --> src/inline_lazy.rs
+  |
+  | pub struct Lazy<T: Sync>(Cell<MaybeUninit<T>>, Once);
+  |                 ^ required by the implicit `Sized` requirement on this type parameter in `Lazy`
+  = note: this error originates in the macro `__lazy_static_create` which comes from the expansion of the macro `lazy_static` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> tests/compile_fail/static_is_sized.rs:5:25
+  |
+5 |     pub static ref FOO: str = panic!();
+  |                         ^^^ doesn't have a size known at compile-time
+  |
+  = help: the trait `Sized` is not implemented for `str`
+  = note: the return type of a function must have a statically known size
+
+error[E0599]: the method `get` exists for struct `Lazy<str>`, but its trait bounds were not satisfied
+ --> tests/compile_fail/static_is_sized.rs:4:1
+  |
+4 | / lazy_static! {
+5 | |     pub static ref FOO: str = panic!();
+6 | | }
+  | |_^ method cannot be called on `Lazy<str>` due to unsatisfied trait bounds
+  |
+  = note: the following trait bounds were not satisfied:
+          `str: Sized`
+  = note: this error originates in the macro `__lazy_static_internal` which comes from the expansion of the macro `lazy_static` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> tests/compile_fail/static_is_sized.rs:4:1
+  |
+4 | / lazy_static! {
+5 | |     pub static ref FOO: str = panic!();
+6 | | }
+  | |_^ doesn't have a size known at compile-time
+  |
+  = help: the trait `Sized` is not implemented for `str`
+  = note: the return type of a function must have a statically known size
+  = note: this error originates in the macro `__lazy_static_internal` which comes from the expansion of the macro `lazy_static` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/no_std.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/no_std.rs
new file mode 100644
index 0000000000..e3324949a1
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/no_std.rs
@@ -0,0 +1,19 @@
+#![cfg(feature = "spin_no_std")]
+#![no_std]
+
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    /// Documentation!
+    pub static ref NUMBER: u32 = times_two(3);
+}
+
+fn times_two(n: u32) -> u32 {
+    n * 2
+}
+
+#[test]
+fn test_basic() {
+    assert_eq!(*NUMBER, 6);
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/test.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/test.rs
new file mode 100644
index 0000000000..eb659d426d
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/test.rs
@@ -0,0 +1,185 @@
+#![deny(warnings)]
+
+#[macro_use]
+extern crate lazy_static;
+use std::collections::HashMap;
+
+lazy_static! {
+    /// Documentation!
+    pub static ref NUMBER: u32 = times_two(3);
+
+    static ref ARRAY_BOXES: [Box<u32>; 3] = [Box::new(1), Box::new(2), Box::new(3)];
+
+    /// More documentation!
+    #[allow(unused_variables)]
+    #[derive(Copy, Clone, Debug)]
+    pub static ref STRING: String = "hello".to_string();
+
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "abc");
+        m.insert(1, "def");
+        m.insert(2, "ghi");
+        m
+    };
+
+    // This should not compile if the unsafe is removed.
+    static ref UNSAFE: u32 = unsafe {
+        std::mem::transmute::<i32, u32>(-1)
+    };
+}
+
+lazy_static! {
+    static ref S1: &'static str = "a";
+    static ref S2: &'static str = "b";
+}
+lazy_static! {
+    static ref S3: String = [*S1, *S2].join("");
+}
+
+lazy_static! {
+    #[allow(non_upper_case_globals)]
+    pub static ref string: String = "hello".to_string();
+}
+
+#[test]
+fn s3() {
+    assert_eq!(&*S3, "ab");
+}
+
+fn times_two(n: u32) -> u32 {
+    n * 2
+}
+
+#[test]
+fn test_basic() {
+    assert_eq!(&**STRING, "hello");
+    assert_eq!(*NUMBER, 6);
+    assert!(HASHMAP.get(&1).is_some());
+    assert!(HASHMAP.get(&3).is_none());
+    assert_eq!(&*ARRAY_BOXES, &[Box::new(1), Box::new(2), Box::new(3)]);
+    assert_eq!(*UNSAFE, std::u32::MAX);
+}
+
+#[test]
+fn test_repeat() {
+    assert_eq!(*NUMBER, 6);
+    assert_eq!(*NUMBER, 6);
+    assert_eq!(*NUMBER, 6);
+}
+
+#[test]
+fn test_meta() {
+    // this would not compile if STRING were not marked #[derive(Copy, Clone)]
+    let copy_of_string = STRING;
+    // just to make sure it was copied
+    assert!(&STRING as *const _ != &copy_of_string as *const _);
+
+    // this would not compile if STRING were not marked #[derive(Debug)]
+    assert_eq!(
+        format!("{:?}", STRING),
+        "STRING { __private_field: () }".to_string()
+    );
+}
+
+mod visibility {
+    lazy_static! {
+        pub static ref FOO: Box<u32> = Box::new(0);
+        static ref BAR: Box<u32> = Box::new(98);
+    }
+
+    pub mod inner {
+        lazy_static! {
+            pub(in visibility) static ref BAZ: Box<u32> = Box::new(42);
+            pub(crate) static ref BAG: Box<u32> = Box::new(37);
+        }
+    }
+
+    #[test]
+    fn sub_test() {
+        assert_eq!(**FOO, 0);
+        assert_eq!(**BAR, 98);
+        assert_eq!(**inner::BAZ, 42);
+        assert_eq!(**inner::BAG, 37);
+    }
+}
+
+#[test]
+fn test_visibility() {
+    assert_eq!(*visibility::FOO, Box::new(0));
+    assert_eq!(*visibility::inner::BAG, Box::new(37));
+}
+
+// This should not cause a warning about a missing Copy implementation
+lazy_static! {
+    pub static ref VAR: i32 = 0;
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+struct X;
+struct Once(X);
+const ONCE_INIT: Once = Once(X);
+static DATA: X = X;
+static ONCE: X = X;
+fn require_sync() -> X {
+    X
+}
+fn transmute() -> X {
+    X
+}
+fn __static_ref_initialize() -> X {
+    X
+}
+fn test(_: Vec<X>) -> X {
+    X
+}
+
+// All these names should not be shadowed
+lazy_static! {
+    static ref ITEM_NAME_TEST: X = {
+        test(vec![X, Once(X).0, ONCE_INIT.0, DATA, ONCE,
+                  require_sync(), transmute(),
+                  // Except this, which will sadly be shadowed by internals:
+                  // __static_ref_initialize()
+                  ])
+    };
+}
+
+#[test]
+fn item_name_shadowing() {
+    assert_eq!(*ITEM_NAME_TEST, X);
+}
+
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering::SeqCst;
+#[allow(deprecated)]
+use std::sync::atomic::ATOMIC_BOOL_INIT;
+
+#[allow(deprecated)]
+static PRE_INIT_FLAG: AtomicBool = ATOMIC_BOOL_INIT;
+
+lazy_static! {
+    static ref PRE_INIT: () = {
+        PRE_INIT_FLAG.store(true, SeqCst);
+        ()
+    };
+}
+
+#[test]
+fn pre_init() {
+    assert_eq!(PRE_INIT_FLAG.load(SeqCst), false);
+    lazy_static::initialize(&PRE_INIT);
+    assert_eq!(PRE_INIT_FLAG.load(SeqCst), true);
+}
+
+lazy_static! {
+    static ref LIFETIME_NAME: for<'a> fn(&'a u8) = {
+        fn f(_: &u8) {}
+        f
+    };
+}
+
+#[test]
+fn lifetime_name() {
+    let _ = LIFETIME_NAME;
+}
diff --git a/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/ui.rs b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/ui.rs
new file mode 100644
index 0000000000..af007cd274
--- /dev/null
+++ b/examples/crate_universe_local_path/lazy_static_1.5.0_copy/tests/ui.rs
@@ -0,0 +1,6 @@
+#[test]
+#[cfg(not(miri))]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/compile_fail/*.rs");
+}
diff --git a/examples/crate_universe_local_path/vendor_lazy_static.sh b/examples/crate_universe_local_path/vendor_lazy_static.sh
new file mode 100755
index 0000000000..8621b7a457
--- /dev/null
+++ b/examples/crate_universe_local_path/vendor_lazy_static.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+set -eou pipefail
+set -x
+
+cd "${BUILD_WORKSPACE_DIRECTORY}"
+
+if [[ "$#" -eq 0 ]]; then
+    copy_to="$(mktemp -d)"
+    path_dep_path="${copy_to}"
+elif [[ "$#" -eq 1 ]]; then
+    path_dep_path="$1"
+    copy_to="crates_from_workspace/$1"
+    mkdir -p "${copy_to}"
+else
+    echo >&2 "Usage: $0 [/path/to/copy/to]"
+    echo >&2 "If no arg is passed, a tempdir will be created"
+    exit 1
+fi
+
+cp -r "lazy_static_1.5.0_copy/"* "${copy_to}/"
+
+echo "pub const VENDORED_BY: &'static str = \"rules_rust\";" >> "${copy_to}/src/lib.rs"
+
+cargo_toml_to_update="crates_from_workspace/Cargo.toml"
+echo "lazy_static = { path = \"${path_dep_path}\" }" >> "${cargo_toml_to_update}"
+
+echo "Copied to ${copy_to} and updated ${cargo_toml_to_update}"
diff --git a/examples/musl_cross_compiling/Cargo.Bazel.lock.json b/examples/musl_cross_compiling/Cargo.Bazel.lock.json
index 3602d37b42..d41d97d262 100644
--- a/examples/musl_cross_compiling/Cargo.Bazel.lock.json
+++ b/examples/musl_cross_compiling/Cargo.Bazel.lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "99e1870a03011adb71cbd618798bc7aa3d250451e51d2924d6895a1eda0d875f",
+  "checksum": "71b37f1de53a4c1484c2b12eef5f283383f0ca642ff3d9bb8ac900ac405b2c69",
   "crates": {
     "aes 0.8.4": {
       "name": "aes",
@@ -10856,5 +10856,6 @@
     "keyring 2.3.3",
     "syn 1.0.109"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/examples/nix_cross_compiling/bazel/cargo/cargo-bazel-lock.json b/examples/nix_cross_compiling/bazel/cargo/cargo-bazel-lock.json
index f45582fd55..65ca57ad50 100644
--- a/examples/nix_cross_compiling/bazel/cargo/cargo-bazel-lock.json
+++ b/examples/nix_cross_compiling/bazel/cargo/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "e36682ffb786d66fbf9c3473487d25bbe537af2d9554ed2f0c0f7e537ff4b565",
+  "checksum": "5147ce2fd3b3a2e46bcbbf584a5a0ccc4a3d28d7e1df935691d35fbc1e6d9e3d",
   "crates": {
     "addr2line 0.21.0": {
       "name": "addr2line",
@@ -2442,5 +2442,6 @@
     "anyhow 1.0.75",
     "tokio 1.34.0"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }
diff --git a/test/no_std/cargo-bazel-lock.json b/test/no_std/cargo-bazel-lock.json
index 73c0b5f584..f1c0bdade7 100644
--- a/test/no_std/cargo-bazel-lock.json
+++ b/test/no_std/cargo-bazel-lock.json
@@ -1,5 +1,5 @@
 {
-  "checksum": "acc8fe8d4a6e8442960b89343e23c7fcb85b3d5ddd92ad5a28739a492fa07ea3",
+  "checksum": "072c4ec54cd164cdc309dfc5703fe04e15797556f2d139e15c758ec60f6f30ef",
   "crates": {
     "direct-cargo-bazel-deps 0.0.1": {
       "name": "direct-cargo-bazel-deps",
@@ -191,5 +191,6 @@
   "direct_deps": [
     "libc_alloc 1.0.4"
   ],
-  "direct_dev_deps": []
+  "direct_dev_deps": [],
+  "unused_patches": []
 }