floe-python 0.6.6__tar.gz → 0.6.7__tar.gz

{floe_python-0.6.6 → floe_python-0.6.7}/Cargo.lock

@@ -3340,7 +3340,7 @@ dependencies = [
 
 [[package]]
 name = "floe-cli"
-version = "0.6.6"
+version = "0.6.7"
 dependencies = [
  "assert_cmd",
  "clap",
@@ -3353,7 +3353,7 @@ dependencies = [
 
 [[package]]
 name = "floe-core"
-version = "0.6.6"
+version = "0.6.7"
 dependencies = [
  "apache-avro",
  "arrow",
@@ -3399,7 +3399,7 @@ dependencies = [
 
 [[package]]
 name = "floe-python"
-version = "0.6.6"
+version = "0.6.7"
 dependencies = [
  "floe-core",
  "pyo3",

{floe_python-0.6.6 → floe_python-0.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: floe-python
-Version: 0.6.6
+Version: 0.6.7
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "floe-core"
-version = "0.6.6"
+version = "0.6.7"
 edition = "2021"
 description = "Core library for Floe, a YAML-driven technical ingestion tool."
 license = "MIT"

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/src/lib.rs

@@ -38,7 +38,8 @@ pub use config::{
 };
 pub use errors::{FloeError, FloeErrorKind};
 pub use manifest::{
-    build_common_manifest_json, config_from_manifest_json, ManifestOptions, PathMode,
+    build_common_manifest_json, config_from_manifest_json, local_uri_for_env, manifest_runtime,
+    ManifestOptions, PathMode, RuntimeEnv, DEFAULT_WORK_ROOT,
 };
 pub use profile::{
     detect_malformed_placeholder, detect_unresolved_placeholders, parse_profile,
@@ -172,3 +173,13 @@ pub fn extract_config_env_vars(
 pub fn validate_config_for_tests(config: &config::RootConfig) -> FloeResult<()> {
     config::validate_config(config)
 }
+
+/// Test-only accessor for the private manifest-replay path-resolution base (issue #443):
+/// a manifest loaded from a remote URI must resolve local paths under its recorded
+/// `work_root`, never against the manifest's own remote location.
+pub fn manifest_replay_config_base_for_tests(
+    manifest_base: &config::ConfigBase,
+    json: &str,
+) -> config::ConfigBase {
+    run::manifest_replay_config_base(manifest_base, json)
+}

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/src/manifest/builder.rs

@@ -51,6 +51,10 @@ pub struct ManifestOptions {
     pub default_domain: Option<String>,
     /// Controls how the `path` field is set in source and sink entries.
     pub path_mode: PathMode,
+    /// Runtime the manifest targets. `Image` records local `config_uri` / `profile_uri`
+    /// absolute under the container work-root (`/work`), restoring the portable pre-0.6.6
+    /// form; `Cli` keeps them relative / as-typed for cross-checkout reproducibility.
+    pub runtime_env: crate::manifest::RuntimeEnv,
 }
 
 #[derive(Debug)]
@@ -378,10 +382,16 @@ fn build_common_manifest(
         });
     }
 
-    // Use `uri` (the path as typed / resolved remote URI), not the host-absolute
-    // `display`, so config_uri and the manifest_id derived from it do not depend on
-    // where the config file physically lives.
-    let config_uri = config_location.uri.clone();
+    // A manifest is replayed by a different runner than the one that generated it, so
+    // `config_uri` must be absolute. `local_uri_for_env` absolutizes the local path against
+    // the target runtime's work-root: `Image` rebases the relative path under the container
+    // work-root (`local:///work/...`, portable + reproducible across containers), `Cli`
+    // records the host-canonical path. Remote config URIs pass through unchanged.
+    let config_uri = crate::manifest::local_uri_for_env(
+        &config_location.uri,
+        &config_location.path,
+        options.runtime_env,
+    );
     let config_checksum = std::fs::read(&config_location.path)
         .ok()
         .map(|b| sha256_hex(&b));
@@ -423,6 +433,8 @@ fn build_common_manifest(
         manifest_name: options.manifest_name.clone(),
         manifest_id: build_manifest_id(&config_uri, config_checksum.as_deref()),
         manifest_revision: None,
+        runtime_env: options.runtime_env.as_str(),
+        work_root: options.runtime_env.manifest_work_root(),
         config_uri,
         config_checksum,
         profile_uri: options.profile_uri.clone(),

floe_python-0.6.7/crates/floe-core/src/manifest/mod.rs

@@ -0,0 +1,8 @@
+mod builder;
+mod model;
+pub mod reconstruct;
+mod runtime;
+
+pub use builder::{build_common_manifest_json, ManifestOptions, PathMode};
+pub use reconstruct::{config_from_manifest_json, manifest_runtime};
+pub use runtime::{local_uri_for_env, RuntimeEnv, DEFAULT_WORK_ROOT};

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/src/manifest/model.rs

@@ -12,6 +12,14 @@ pub struct CommonManifest {
     pub manifest_id: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub manifest_revision: Option<String>,
+    /// Runtime the manifest targets: `"image"` (local URIs absolute under the container
+    /// work-root) or `"cli"` (local URIs relative / as-typed). Drives how a replaying
+    /// runner resolves local paths. See `RuntimeEnv`.
+    pub runtime_env: &'static str,
+    /// Work-root local paths are resolved under at replay time (e.g. `/work`). `Some` only
+    /// for `runtime_env == "image"`; `None` for `"cli"` (paths are relative, no fixed root).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub work_root: Option<String>,
     pub config_uri: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub config_checksum: Option<String>,

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/src/manifest/reconstruct.rs

@@ -110,6 +110,28 @@ fn deserialize_manifest_section<T: serde::de::DeserializeOwned>(
     }
 }
 
+/// The replay runtime hints recorded by the generator. Deserialized on their own (serde
+/// ignores the rest of the manifest) so a runner can read them without depending on the full
+/// `ManifestForRun` shape parsing cleanly.
+#[derive(Debug, Default, Deserialize)]
+struct ManifestRuntimeHints {
+    #[serde(default)]
+    runtime_env: Option<String>,
+    #[serde(default)]
+    work_root: Option<String>,
+}
+
+/// Parse the replay runtime hints (`runtime_env` / `work_root`) from a manifest JSON string.
+/// Missing or malformed hints map to `(RuntimeEnv::Cli, None)`, so pre-0.6.7 manifests keep
+/// their previous resolution behavior.
+pub fn manifest_runtime(json: &str) -> (crate::manifest::RuntimeEnv, Option<String>) {
+    let hints: ManifestRuntimeHints = serde_json::from_str(json).unwrap_or_default();
+    (
+        crate::manifest::RuntimeEnv::from_manifest_str(hints.runtime_env.as_deref()),
+        hints.work_root,
+    )
+}
+
 /// Parse a manifest JSON string and reconstruct a minimal RootConfig.
 /// Returns (config, report_base_uri).
 pub fn config_from_manifest_json(json: &str) -> FloeResult<(crate::config::RootConfig, String)> {

floe_python-0.6.7/crates/floe-core/src/manifest/runtime.rs

@@ -0,0 +1,139 @@
+use std::path::{Path, PathBuf};
+
+/// Default container work-root. Matches `WORKDIR /work` in every Floe Dockerfile
+/// (`Dockerfile`, `Dockerfile.duckdb`, `Dockerfile.release`).
+pub const DEFAULT_WORK_ROOT: &str = "/work";
+
+/// The runtime environment a generated manifest targets. Controls whether local
+/// `config_uri` / `profile_uri` (and the `manifest_id` derived from them) are recorded
+/// as absolute paths under a fixed container work-root, or kept relative / as-typed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum RuntimeEnv {
+    /// Container image: local paths are recorded absolute under the work-root (`/work`),
+    /// which is both portable for remote replay and reproducible across container runs
+    /// (every container uses the same `/work` mount).
+    Image,
+    /// Local CLI / dev checkout: local paths are recorded host-absolute (the canonicalized
+    /// path on the generating machine), so the manifest is resolvable on that host. It is
+    /// intentionally not reproducible across machines — the reproducible-CI case is served by
+    /// `Image` (fixed `/work`), not by CLI manifests.
+    #[default]
+    Cli,
+}
+
+impl RuntimeEnv {
+    /// Detect the runtime from the environment when the CLI caller did not pass `--runtime`.
+    ///
+    /// Precedence:
+    /// 1. `FLOE_RUNTIME=image|cli` — explicit override.
+    /// 2. Container heuristic: `/.dockerenv` exists, or the current dir is the `/work` mount.
+    /// 3. Otherwise `Cli`.
+    pub fn detect() -> Self {
+        if let Ok(value) = std::env::var("FLOE_RUNTIME") {
+            match value.trim().to_ascii_lowercase().as_str() {
+                "image" => return RuntimeEnv::Image,
+                "cli" => return RuntimeEnv::Cli,
+                _ => {}
+            }
+        }
+        if Path::new("/.dockerenv").exists() {
+            return RuntimeEnv::Image;
+        }
+        if std::env::current_dir()
+            .ok()
+            .is_some_and(|dir| dir == Path::new(DEFAULT_WORK_ROOT))
+        {
+            return RuntimeEnv::Image;
+        }
+        RuntimeEnv::Cli
+    }
+
+    /// String recorded as `runtime_env` in the manifest.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            RuntimeEnv::Image => "image",
+            RuntimeEnv::Cli => "cli",
+        }
+    }
+
+    /// Parse the manifest-recorded `runtime_env` string. Unknown or missing maps to `Cli`,
+    /// which is backward-compatible: manifests generated before this field existed carry
+    /// relative local URIs and must keep resolving as before.
+    pub fn from_manifest_str(value: Option<&str>) -> Self {
+        match value {
+            Some(v) if v.eq_ignore_ascii_case("image") => RuntimeEnv::Image,
+            _ => RuntimeEnv::Cli,
+        }
+    }
+
+    /// Work-root that local paths are recorded relative to (at generation) and resolved
+    /// under (at replay). `Image` → `/work`, overridable via `FLOE_WORK_ROOT`;
+    /// `Cli` → the current working directory.
+    pub fn work_root(self) -> PathBuf {
+        match self {
+            RuntimeEnv::Image => std::env::var("FLOE_WORK_ROOT")
+                .ok()
+                .filter(|value| !value.trim().is_empty())
+                .map(PathBuf::from)
+                .unwrap_or_else(|| PathBuf::from(DEFAULT_WORK_ROOT)),
+            RuntimeEnv::Cli => std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
+        }
+    }
+
+    /// The `work_root` value recorded in the manifest: `Some("/work")` for `Image`
+    /// (so remote replay resolves local paths against the same root), `None` for `Cli`
+    /// (paths are already host-absolute and self-contained, so there is no separate root
+    /// to record).
+    pub fn manifest_work_root(self) -> Option<String> {
+        match self {
+            RuntimeEnv::Image => Some(self.work_root().to_string_lossy().replace('\\', "/")),
+            RuntimeEnv::Cli => None,
+        }
+    }
+}
+
+/// Given the as-typed `local://…` URI recorded for a local config/profile (`uri`) and the
+/// canonicalized absolute path of that file (`canonical_path`), return the absolute form
+/// appropriate for `env`. Remote URIs are passed through unchanged.
+///
+/// Every local path in a manifest must be absolute, because the runner that generates the
+/// manifest is not the one that replays it. The absolute base depends on the target runtime:
+///
+/// - `Image`: a *relative* local path is rebased under the container work-root
+///   (`local://domains/x.yml` → `local:///work/domains/x.yml`) — portable for remote replay
+///   and reproducible across containers (every container mounts `/work`).
+/// - `Cli`: the path is recorded host-absolute from `canonical_path`
+///   (`local:///Users/you/repo/domains/x.yml`) — resolvable on the generating host.
+///
+/// An already-absolute local path (leading `/`, or a Windows drive/UNC prefix) and any remote
+/// URI are returned unchanged, in both modes.
+pub fn local_uri_for_env(uri: &str, canonical_path: &Path, env: RuntimeEnv) -> String {
+    let Some(rel) = uri.strip_prefix("local://") else {
+        // Remote URIs (s3://, gs://, abfs://) are already environment-independent.
+        return uri.to_string();
+    };
+    match env {
+        RuntimeEnv::Cli => {
+            // Always record the canonicalized host-absolute path, regardless of how `-c` was
+            // typed (relative, or absolute with `..`). Resolvable on the generating host.
+            let abs = canonical_path.to_string_lossy().replace('\\', "/");
+            format!("local://{abs}")
+        }
+        RuntimeEnv::Image => {
+            if rel.starts_with('/') || has_drive_prefix(rel) {
+                // Already absolute — portable as-is; do not re-root under the work-root.
+                return uri.to_string();
+            }
+            let root = env.work_root();
+            let root = root.to_string_lossy().replace('\\', "/");
+            let root = root.trim_end_matches('/');
+            format!("local://{root}/{rel}")
+        }
+    }
+}
+
+/// True for a Windows drive prefix such as `C:` at the start of `path`.
+fn has_drive_prefix(path: &str) -> bool {
+    let bytes = path.as_bytes();
+    bytes.len() >= 2 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':'
+}

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/src/run/mod.rs

@@ -107,7 +107,7 @@ pub(crate) fn run_with_manifest_runtime(
     let location = config::resolve_config_location(&manifest_str)?;
     let json = std::fs::read_to_string(&location.path)?;
     let (config, report_base_uri) = crate::manifest::config_from_manifest_json(&json)?;
-    let config_base = location.base.clone();
+    let config_base = manifest_replay_config_base(&location.base, &json);
     if !options.entities.is_empty() {
         validate_entities(&config, &options.entities)?;
     }
@@ -121,6 +121,40 @@ pub(crate) fn run_with_manifest_runtime(
     run_from_context(context, options, runtime)
 }
 
+/// Choose the path-resolution base for manifest replay.
+///
+/// A manifest is self-contained: its source/sink URIs are already resolved and it embeds a
+/// `storages` block. When it is loaded from a **remote** URI, the manifest's own bucket/prefix
+/// must NOT become the resolution base — otherwise a relative path in the manifest (e.g. an
+/// Iceberg sink that did not resolve to an absolute URI) is re-based onto the manifest bucket
+/// and trips the `storage <name> bucket mismatch` guard (issue #443). Instead, resolve local
+/// paths under the target runtime's work-root (manifest `work_root` → `FLOE_WORK_ROOT` →
+/// `RuntimeEnv::detect()` default) and leave `remote_base` unset so remote paths resolve purely
+/// from their storage definitions.
+///
+/// For a **local** manifest file, behavior is unchanged: relative paths resolve against the
+/// manifest file's directory, exactly as before.
+pub(crate) fn manifest_replay_config_base(
+    manifest_base: &config::ConfigBase,
+    json: &str,
+) -> config::ConfigBase {
+    if manifest_base.remote_base().is_none() {
+        return manifest_base.clone();
+    }
+    let (runtime_env, manifest_work_root) = crate::manifest::manifest_runtime(json);
+    let work_root = manifest_work_root
+        .map(std::path::PathBuf::from)
+        .or_else(|| {
+            std::env::var("FLOE_WORK_ROOT")
+                .ok()
+                .filter(|value| !value.trim().is_empty())
+                .map(std::path::PathBuf::from)
+        })
+        .unwrap_or_else(|| runtime_env.work_root());
+    // `local_from_path` uses the parent as the local base dir, so join a sentinel file name.
+    config::ConfigBase::local_from_path(&work_root.join("manifest.json"))
+}
+
 pub fn run_with_runtime(
     config_path: &Path,
     config_base: config::ConfigBase,

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/tests/unit/manifest/mod.rs

@@ -1,6 +1,8 @@
+pub mod runtime;
+
 use floe_core::{
     build_common_manifest_json, config_from_manifest_json, load_config, parse_profile_from_str,
-    resolve_config_location, ManifestOptions, PathMode,
+    resolve_config_location, ManifestOptions, PathMode, RuntimeEnv,
 };
 // `validate_config_for_tests` is only exercised by the duckdb-gated MotherDuck
 // round-trip assertion below; importing it unconditionally would warn (and fail the
@@ -44,10 +46,10 @@ fn manifest_uses_local_uri_for_local_config() {
 }
 
 #[test]
-fn manifest_config_uri_is_not_canonicalized() {
-    // config_uri reflects the path as typed, not the canonical path: a lexical `..`
-    // bounce (which canonicalize() would collapse) surviving in the output proves
-    // the path was preserved as-typed.
+fn manifest_cli_config_uri_is_host_absolute_canonical() {
+    // Under `cli` runtime every local path is recorded host-absolute and canonicalized: a
+    // lexical `..` bounce in the typed path is collapsed, so config_uri is a clean absolute
+    // URI that resolves on the generating host (the definitive "all paths absolute" rule).
     let temp_dir = tempfile::TempDir::new().expect("temp dir");
     let cfg_dir = temp_dir.path().join("cfg");
     std::fs::create_dir_all(&cfg_dir).expect("cfg dir");
@@ -58,7 +60,7 @@ fn manifest_config_uri_is_not_canonicalized() {
     )
     .expect("write config");
 
-    // <cfg_dir>/../cfg/config.yml — canonicalize() would resolve this to
+    // <cfg_dir>/../cfg/config.yml — cli canonicalization resolves this to
     // <cfg_dir>/config.yml, dropping the "/../".
     let bouncy = format!("{}/../cfg/config.yml", cfg_dir.display());
     let loc = resolve_config_location(&bouncy).expect("resolve config location");
@@ -69,10 +71,51 @@ fn manifest_config_uri_is_not_canonicalized() {
 
     let uri = value["config_uri"].as_str().expect("config_uri string");
     assert!(
-        uri.contains("/../cfg/config.yml"),
-        "config_uri was canonicalized (lost the as-typed form): {uri}"
+        uri.starts_with("local:///"),
+        "cli config_uri must be host-absolute: {uri}"
+    );
+    assert!(
+        !uri.contains("/../"),
+        "cli config_uri must be canonicalized (no `..`): {uri}"
     );
     assert!(value["manifest_id"].as_str().unwrap().starts_with("mfv1-"));
+    // Default (no runtime override) auto-detects; in the test env that is `cli`.
+    assert_eq!(value["runtime_env"], "cli");
+    assert!(
+        value.get("work_root").is_none(),
+        "cli must not record work_root"
+    );
+}
+
+#[test]
+fn manifest_image_runtime_records_runtime_env_and_work_root() {
+    // `image` runtime records runtime_env/work_root so a remote runner knows how to resolve
+    // local paths. An absolute config path is already portable, so it is preserved unchanged
+    // (the relative -> /work re-rooting is covered by the runtime module's unit tests and the
+    // CLI `--runtime image` reproducibility test).
+    let temp_dir = tempfile::TempDir::new().expect("temp dir");
+    let cfg_dir = temp_dir.path().join("cfg");
+    std::fs::create_dir_all(&cfg_dir).expect("cfg dir");
+    let config_path = cfg_dir.join("config.yml");
+    std::fs::write(
+        &config_path,
+        "version: \"0.1\"\nentities:\n  - name: orders\n    source:\n      format: csv\n      path: ./in/orders\n    sink:\n      write_mode: overwrite\n      accepted:\n        format: parquet\n        path: ./out/orders\n    policy:\n      severity: warn\n    schema:\n      columns:\n        - name: id\n          type: string\n",
+    )
+    .expect("write config");
+
+    let loc = resolve_config_location(config_path.to_str().expect("utf8")).expect("resolve");
+    let config = load_config(&loc.path).expect("load config");
+    let opts = ManifestOptions {
+        runtime_env: RuntimeEnv::Image,
+        ..ManifestOptions::default()
+    };
+    let payload = build_common_manifest_json(&loc, &config, &[], None, &opts).expect("manifest");
+    let value: Value = serde_json::from_str(&payload).expect("valid json");
+
+    assert_eq!(value["runtime_env"], "image");
+    assert_eq!(value["work_root"], "/work");
+    let uri = value["config_uri"].as_str().expect("config_uri string");
+    assert!(uri.starts_with("local://"), "config_uri: {uri}");
 }
 
 #[test]

floe_python-0.6.7/crates/floe-core/tests/unit/manifest/runtime.rs

@@ -0,0 +1,77 @@
+use floe_core::{local_uri_for_env, RuntimeEnv};
+use std::path::Path;
+
+#[test]
+fn cli_records_host_absolute_canonical_path() {
+    // `Cli` ignores the (relative) as-typed URI and records the canonicalized
+    // host-absolute path, so the manifest is resolvable on the generating host.
+    assert_eq!(
+        local_uri_for_env(
+            "local://domains/orders.yml",
+            Path::new("/home/u/repo/domains/orders.yml"),
+            RuntimeEnv::Cli,
+        ),
+        "local:///home/u/repo/domains/orders.yml"
+    );
+}
+
+#[test]
+fn image_absolutizes_relative_local_uri_under_work_root() {
+    // Default work-root is `/work` (no FLOE_WORK_ROOT set in the test env). `Image` uses
+    // the as-typed relative path and ignores the host-canonical path entirely.
+    assert_eq!(
+        local_uri_for_env(
+            "local://domains/orders.yml",
+            Path::new("/home/u/repo/domains/orders.yml"),
+            RuntimeEnv::Image,
+        ),
+        "local:///work/domains/orders.yml"
+    );
+}
+
+#[test]
+fn already_absolute_local_uri_untouched_in_both_modes() {
+    for env in [RuntimeEnv::Cli, RuntimeEnv::Image] {
+        assert_eq!(
+            local_uri_for_env("local:///abs/orders.yml", Path::new("/abs/orders.yml"), env,),
+            "local:///abs/orders.yml"
+        );
+    }
+}
+
+#[test]
+fn remote_uris_pass_through_in_both_modes() {
+    for env in [RuntimeEnv::Cli, RuntimeEnv::Image] {
+        assert_eq!(
+            local_uri_for_env("s3://bucket/orders.yml", Path::new("/tmp/orders.yml"), env,),
+            "s3://bucket/orders.yml"
+        );
+    }
+}
+
+#[test]
+fn from_manifest_str_maps_image_case_insensitively_else_cli() {
+    assert_eq!(
+        RuntimeEnv::from_manifest_str(Some("image")),
+        RuntimeEnv::Image
+    );
+    assert_eq!(
+        RuntimeEnv::from_manifest_str(Some("IMAGE")),
+        RuntimeEnv::Image
+    );
+    assert_eq!(RuntimeEnv::from_manifest_str(Some("cli")), RuntimeEnv::Cli);
+    assert_eq!(RuntimeEnv::from_manifest_str(None), RuntimeEnv::Cli);
+    assert_eq!(
+        RuntimeEnv::from_manifest_str(Some("weird")),
+        RuntimeEnv::Cli
+    );
+}
+
+#[test]
+fn manifest_work_root_recorded_only_for_image() {
+    assert_eq!(
+        RuntimeEnv::Image.manifest_work_root().as_deref(),
+        Some("/work")
+    );
+    assert_eq!(RuntimeEnv::Cli.manifest_work_root(), None);
+}

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-core/tests/unit/run/mod.rs

@@ -4,5 +4,6 @@ pub mod entity;
 pub mod lineage;
 pub mod normalize;
 pub mod pii;
+pub mod replay_base;
 pub mod report;
 pub mod schema_mismatch;

floe_python-0.6.7/crates/floe-core/tests/unit/run/replay_base.rs

@@ -0,0 +1,41 @@
+use floe_core::config::ConfigBase;
+use floe_core::manifest_replay_config_base_for_tests as manifest_replay_config_base;
+use std::path::{Path, PathBuf};
+
+#[test]
+fn remote_manifest_replay_uses_recorded_work_root_not_manifest_bucket() {
+    // A manifest loaded from a remote URI must NOT resolve its paths against its own
+    // bucket (issue #443). With runtime_env=image/work_root=/work, the replay base is a
+    // local root at /work with no remote_base.
+    let remote = ConfigBase::remote_from_uri(
+        PathBuf::from("/tmp/manifest"),
+        "s3://openlakeforge-ops/floe/manifests/x.manifest.json",
+    )
+    .expect("remote base");
+    let json = r#"{"runtime_env":"image","work_root":"/work"}"#;
+    let base = manifest_replay_config_base(&remote, json);
+    assert!(
+        base.remote_base().is_none(),
+        "remote manifest bucket must not become the resolution base"
+    );
+    assert_eq!(base.local_dir(), Path::new("/work"));
+}
+
+#[test]
+fn remote_manifest_replay_never_keeps_remote_base_even_without_hints() {
+    let remote = ConfigBase::remote_from_uri(
+        PathBuf::from("/tmp/manifest"),
+        "s3://bucket/x.manifest.json",
+    )
+    .expect("remote base");
+    let base = manifest_replay_config_base(&remote, "{}");
+    assert!(base.remote_base().is_none());
+}
+
+#[test]
+fn local_manifest_replay_base_is_unchanged() {
+    let local = ConfigBase::local_from_path(Path::new("/data/manifests/x.json"));
+    let base = manifest_replay_config_base(&local, "{}");
+    assert!(base.remote_base().is_none());
+    assert_eq!(base.local_dir(), Path::new("/data/manifests"));
+}

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "floe-python"
-version = "0.6.6"
+version = "0.6.7"
 edition = "2021"
 description = "Python bindings for floe-core (PyO3-based)"
 license = "Apache-2.0"
@@ -14,7 +14,7 @@ name = "_floe"
 crate-type = ["cdylib"]
 
 [dependencies]
-floe-core = { path = "../floe-core", version = "0.6.6", default-features = false }
+floe-core = { path = "../floe-core", version = "0.6.7", default-features = false }
 pyo3 = { version = "0.29", features = ["extension-module", "abi3-py310"] }
 serde_json = "1"
 

{floe_python-0.6.6 → floe_python-0.6.7}/crates/floe-python/pyproject.duckdb.toml

@@ -22,7 +22,7 @@ build-backend = "maturin"
 
 [project]
 name = "floe-duckdb"
-version = "0.6.6"
+version = "0.6.7"
 description = "DuckDB companion extension for floe — adds the native DuckDB sink to the floe Python package"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -46,7 +46,7 @@ classifiers = [
 # only contributes the compiled DuckDB extension module into that package. Pin to
 # the exact lean version so the companion's `_floe_duckdb` ABI always matches the
 # `floe` package it plugs into.
-dependencies = ["floe-python==0.6.6"]
+dependencies = ["floe-python==0.6.7"]
 
 [project.urls]
 Homepage = "https://github.com/malon64/floe"

{floe_python-0.6.6 → floe_python-0.6.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "floe-python"
-version = "0.6.6"
+version = "0.6.7"
 description = "Python bindings for floe-core — run floe pipelines at Rust speed from Python and notebooks"
 readme = "README.md"
 requires-python = ">=3.10"

floe_python-0.6.6/crates/floe-core/src/manifest/mod.rs

@@ -1,6 +0,0 @@
-mod builder;
-mod model;
-pub mod reconstruct;
-
-pub use builder::{build_common_manifest_json, ManifestOptions, PathMode};
-pub use reconstruct::config_from_manifest_json;