@lix-js/sdk 0.6.0-preview.5 → 0.6.1

package/dist-engine-src/src/sql2/filesystem_planner.rs

@@ -1,1485 +0,0 @@
-#![allow(dead_code)]
-
-use std::collections::{BTreeMap, BTreeSet};
-
-use serde::Deserialize;
-use serde_json::{json, Map as JsonMap, Value as JsonValue};
-
-use crate::common::{
-    directory_ancestor_paths, directory_name_from_path, normalize_directory_path,
-    parent_directory_path, stable_content_fingerprint_hex, ParsedFilePath,
-};
-use crate::entity_pk::EntityPk;
-use crate::live_state::MaterializedLiveStateRow;
-use crate::LixError;
-use crate::GLOBAL_BRANCH_ID;
-
-use super::filesystem_visibility::VisibleFilesystem;
-use crate::transaction::types::{TransactionFileData, TransactionJson, TransactionWriteRow};
-
-pub(crate) const FILE_DESCRIPTOR_SCHEMA_KEY: &str = "lix_file_descriptor";
-pub(crate) const DIRECTORY_DESCRIPTOR_SCHEMA_KEY: &str = "lix_directory_descriptor";
-pub(crate) const BLOB_REF_SCHEMA_KEY: &str = "lix_binary_blob_ref";
-
-/// Planned filesystem write output after SQL surface columns have been lowered
-/// into state rows and optional file payload writes.
-///
-/// Providers should emit this shape; transaction/commit code should not need
-/// to know whether a row came from `lix_file`, `lix_directory`, or a future
-/// filesystem write surface.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub(crate) struct FilesystemWritePlan {
-    pub(crate) rows: Vec<TransactionWriteRow>,
-    pub(crate) file_data: Vec<TransactionFileData>,
-    pub(crate) count: u64,
-}
-
-/// Planned filesystem delete output after SQL predicates have selected rows
-/// and the surface delete has been lowered into tombstone state rows.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub(crate) struct FilesystemDeletePlan {
-    pub(crate) rows: Vec<TransactionWriteRow>,
-    pub(crate) count: u64,
-}
-
-/// Common state-row lane fields shared by filesystem descriptor/blob rows.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct FilesystemRowContext {
-    pub(crate) branch_id: String,
-    pub(crate) global: bool,
-    pub(crate) untracked: bool,
-    pub(crate) file_id: Option<String>,
-    pub(crate) metadata: Option<TransactionJson>,
-}
-
-impl FilesystemRowContext {
-    pub(crate) fn active_branch(branch_id: impl Into<String>) -> Self {
-        Self {
-            branch_id: branch_id.into(),
-            global: false,
-            untracked: false,
-            file_id: None,
-            metadata: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct DirectoryDescriptorRowInput {
-    pub(crate) id: String,
-    pub(crate) parent_id: Option<String>,
-    pub(crate) name: String,
-    pub(crate) hidden: bool,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct FileDescriptorRowInput {
-    pub(crate) id: String,
-    pub(crate) directory_id: Option<String>,
-    pub(crate) name: String,
-    pub(crate) hidden: bool,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct DirectoryDescriptorWriteIntent {
-    pub(crate) id: Option<String>,
-    pub(crate) parent_id: Option<String>,
-    pub(crate) name: String,
-    pub(crate) hidden: Option<bool>,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct FileDescriptorWriteIntent {
-    pub(crate) id: Option<String>,
-    pub(crate) directory_id: Option<String>,
-    pub(crate) name: String,
-    pub(crate) hidden: Option<bool>,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BlobRefRowInput {
-    pub(crate) file_id: String,
-    pub(crate) data: Vec<u8>,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct FilePathWriteInput {
-    pub(crate) id: Option<String>,
-    pub(crate) path: String,
-    pub(crate) data: Option<Vec<u8>>,
-    pub(crate) hidden: Option<bool>,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct FileDeleteInput {
-    pub(crate) file_id: String,
-    pub(crate) has_blob_ref: bool,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct DirectoryDeleteInput {
-    pub(crate) directory_id: String,
-    pub(crate) context: FilesystemRowContext,
-}
-
-#[derive(Debug, Deserialize)]
-struct DirectoryDescriptorSnapshot {
-    id: String,
-    parent_id: Option<String>,
-    name: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct FileDescriptorSnapshot {
-    id: String,
-    directory_id: Option<String>,
-    name: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-enum FilesystemNamespaceEntry {
-    Directory(String),
-    File(String),
-}
-
-/// Resolves directory paths while planning filesystem writes.
-///
-/// The resolver is seeded from the transaction-visible filesystem state and is
-/// then updated as the current statement stages implicit directories. That is
-/// what prevents path inserts from restaging committed ancestors or duplicating
-/// an ancestor created earlier in the same SQL batch.
-#[derive(Debug, Clone, Default)]
-pub(crate) struct DirectoryPathResolver {
-    directory_ids_by_path: BTreeMap<String, String>,
-    entries_by_parent_and_name: BTreeMap<(Option<String>, String), FilesystemNamespaceEntry>,
-}
-
-impl DirectoryPathResolver {
-    pub(crate) fn from_existing(
-        existing_directories: impl IntoIterator<Item = (String, String)>,
-    ) -> Result<Self, LixError> {
-        Self::from_existing_filesystem(existing_directories, std::iter::empty())
-    }
-
-    pub(crate) fn from_existing_filesystem(
-        existing_directories: impl IntoIterator<Item = (String, String)>,
-        existing_files: impl IntoIterator<Item = (Option<String>, String, String)>,
-    ) -> Result<Self, LixError> {
-        let mut directory_ids_by_path = BTreeMap::new();
-        for (path, id) in existing_directories {
-            directory_ids_by_path.insert(normalize_directory_path(&path)?, id);
-        }
-
-        let mut resolver = Self {
-            directory_ids_by_path,
-            entries_by_parent_and_name: BTreeMap::new(),
-        };
-        let mut paths = resolver
-            .directory_ids_by_path
-            .iter()
-            .map(|(path, id)| (path.clone(), id.clone()))
-            .collect::<Vec<_>>();
-        paths.sort_by_key(|(path, _)| path.len());
-        for (path, id) in paths {
-            let parent_id = parent_directory_path(&path)
-                .and_then(|parent_path| resolver.directory_ids_by_path.get(&parent_path).cloned());
-            let name = directory_name_from_path(&path).ok_or_else(|| {
-                LixError::new(
-                    "LIX_ERROR_UNKNOWN",
-                    format!("directory path '{path}' does not contain a directory name"),
-                )
-            })?;
-            resolver.reserve_directory(parent_id, name, id)?;
-        }
-        for (directory_id, entry_name, file_id) in existing_files {
-            resolver.reserve_file(directory_id, entry_name, file_id)?;
-        }
-        Ok(resolver)
-    }
-
-    pub(crate) fn directory_id(&self, path: &str) -> Result<Option<&str>, LixError> {
-        Ok(self
-            .directory_ids_by_path
-            .get(&normalize_directory_path(path)?)
-            .map(String::as_str))
-    }
-
-    /// Stages only the missing descriptors needed for `directory_path`.
-    ///
-    /// Existing directories keep their original ids. Missing directories receive
-    /// deterministic ids so repeated planning of the same transaction-visible
-    /// path resolves to the same descriptor identity.
-    pub(crate) fn ensure_directory_path(
-        &mut self,
-        directory_path: &str,
-        context: FilesystemRowContext,
-        hidden: bool,
-        generate_directory_id: &mut dyn FnMut() -> String,
-    ) -> Result<Vec<TransactionWriteRow>, LixError> {
-        self.ensure_directory_path_with_leaf_id(
-            directory_path,
-            None,
-            context,
-            hidden,
-            generate_directory_id,
-        )
-    }
-
-    pub(crate) fn ensure_directory_path_with_leaf_id(
-        &mut self,
-        directory_path: &str,
-        leaf_id: Option<String>,
-        context: FilesystemRowContext,
-        hidden: bool,
-        generate_directory_id: &mut dyn FnMut() -> String,
-    ) -> Result<Vec<TransactionWriteRow>, LixError> {
-        self.plan_directory_path(
-            directory_path,
-            leaf_id,
-            context,
-            hidden,
-            generate_directory_id,
-            false,
-        )
-    }
-
-    pub(crate) fn create_directory_path_with_leaf_id(
-        &mut self,
-        directory_path: &str,
-        leaf_id: Option<String>,
-        context: FilesystemRowContext,
-        hidden: bool,
-        generate_directory_id: &mut dyn FnMut() -> String,
-    ) -> Result<Vec<TransactionWriteRow>, LixError> {
-        self.plan_directory_path(
-            directory_path,
-            leaf_id,
-            context,
-            hidden,
-            generate_directory_id,
-            true,
-        )
-    }
-
-    fn plan_directory_path(
-        &mut self,
-        directory_path: &str,
-        leaf_id: Option<String>,
-        context: FilesystemRowContext,
-        hidden: bool,
-        generate_directory_id: &mut dyn FnMut() -> String,
-        reject_existing_leaf: bool,
-    ) -> Result<Vec<TransactionWriteRow>, LixError> {
-        let directory_path = normalize_directory_path(directory_path)?;
-        if directory_path == "/" {
-            if reject_existing_leaf {
-                return Err(duplicate_directory_path_error(&directory_path));
-            }
-            return Ok(Vec::new());
-        }
-
-        let mut paths = directory_ancestor_paths(&directory_path);
-        paths.push(directory_path.clone());
-
-        let mut rows = Vec::new();
-        for path in paths {
-            if self.directory_ids_by_path.contains_key(&path) {
-                if reject_existing_leaf && path == directory_path {
-                    return Err(duplicate_directory_path_error(&directory_path));
-                }
-                continue;
-            }
-
-            let id = if path == directory_path {
-                leaf_id.clone().unwrap_or_else(&mut *generate_directory_id)
-            } else {
-                generate_directory_id()
-            };
-            let parent_id = parent_directory_path(&path)
-                .and_then(|parent_path| self.directory_ids_by_path.get(&parent_path).cloned());
-            let name = directory_name_from_path(&path).ok_or_else(|| {
-                LixError::new(
-                    "LIX_ERROR_UNKNOWN",
-                    format!("directory path '{path}' does not contain a directory name"),
-                )
-            })?;
-            self.reserve_directory(parent_id.clone(), name.clone(), id.clone())?;
-
-            rows.push(directory_descriptor_row(DirectoryDescriptorRowInput {
-                id: id.clone(),
-                parent_id,
-                name,
-                hidden,
-                context: FilesystemRowContext {
-                    // Directory descriptors are their own filesystem state row,
-                    // even when they are implicitly planned from a file insert.
-                    file_id: None,
-                    ..context.clone()
-                },
-            }));
-            self.directory_ids_by_path.insert(path, id);
-        }
-
-        Ok(rows)
-    }
-
-    pub(crate) fn reserve_directory(
-        &mut self,
-        parent_id: Option<String>,
-        name: String,
-        directory_id: String,
-    ) -> Result<(), LixError> {
-        let key = (parent_id, name);
-        match self.entries_by_parent_and_name.get(&key) {
-            Some(FilesystemNamespaceEntry::Directory(existing_id))
-                if existing_id == &directory_id =>
-            {
-                Ok(())
-            }
-            Some(existing) => Err(filesystem_namespace_conflict_error(
-                &key.0, &key.1, existing,
-            )),
-            None => {
-                self.entries_by_parent_and_name
-                    .insert(key, FilesystemNamespaceEntry::Directory(directory_id));
-                Ok(())
-            }
-        }
-    }
-
-    pub(crate) fn reserve_file(
-        &mut self,
-        directory_id: Option<String>,
-        entry_name: String,
-        file_id: String,
-    ) -> Result<(), LixError> {
-        let key = (directory_id, entry_name);
-        match self.entries_by_parent_and_name.get(&key) {
-            Some(FilesystemNamespaceEntry::File(existing_id)) if existing_id == &file_id => Ok(()),
-            Some(existing) => Err(filesystem_namespace_conflict_error(
-                &key.0, &key.1, existing,
-            )),
-            None => {
-                self.entries_by_parent_and_name
-                    .insert(key, FilesystemNamespaceEntry::File(file_id));
-                Ok(())
-            }
-        }
-    }
-}
-
-fn duplicate_directory_path_error(path: &str) -> LixError {
-    LixError::new(
-        LixError::CODE_UNIQUE,
-        format!("unique constraint violation on lix_directory.path for value {path:?}"),
-    )
-}
-
-fn filesystem_namespace_conflict_error(
-    parent_id: &Option<String>,
-    entry_name: &str,
-    existing: &FilesystemNamespaceEntry,
-) -> LixError {
-    let parent = parent_id.as_deref().unwrap_or("<root>");
-    let existing_kind = match existing {
-        FilesystemNamespaceEntry::Directory(_) => "directory",
-        FilesystemNamespaceEntry::File(_) => "file",
-    };
-    LixError::new(
-        LixError::CODE_UNIQUE,
-        format!(
-            "filesystem namespace conflict: parent {parent:?} already contains {existing_kind} entry {entry_name:?}"
-        ),
-    )
-}
-
-pub(crate) fn directory_descriptor_row(input: DirectoryDescriptorRowInput) -> TransactionWriteRow {
-    directory_descriptor_write_row(DirectoryDescriptorWriteIntent {
-        id: Some(input.id),
-        parent_id: input.parent_id,
-        name: input.name,
-        hidden: Some(input.hidden),
-        context: input.context,
-    })
-}
-
-pub(crate) fn file_descriptor_row(input: FileDescriptorRowInput) -> TransactionWriteRow {
-    file_descriptor_write_row(FileDescriptorWriteIntent {
-        id: Some(input.id),
-        directory_id: input.directory_id,
-        name: input.name,
-        hidden: Some(input.hidden),
-        context: input.context,
-    })
-}
-
-pub(crate) fn directory_descriptor_write_row(
-    input: DirectoryDescriptorWriteIntent,
-) -> TransactionWriteRow {
-    let mut snapshot = JsonMap::new();
-    if let Some(id) = input.id.as_ref() {
-        snapshot.insert("id".to_string(), JsonValue::String(id.clone()));
-    }
-    snapshot.insert(
-        "parent_id".to_string(),
-        input
-            .parent_id
-            .clone()
-            .map(JsonValue::String)
-            .unwrap_or(JsonValue::Null),
-    );
-    snapshot.insert("name".to_string(), JsonValue::String(input.name));
-    if let Some(hidden) = input.hidden {
-        snapshot.insert("hidden".to_string(), JsonValue::Bool(hidden));
-    }
-
-    partial_state_row(
-        input.id,
-        DIRECTORY_DESCRIPTOR_SCHEMA_KEY,
-        Some(JsonValue::Object(snapshot)),
-        input.context,
-    )
-}
-
-pub(crate) fn file_descriptor_write_row(input: FileDescriptorWriteIntent) -> TransactionWriteRow {
-    let mut snapshot = JsonMap::new();
-    if let Some(id) = input.id.as_ref() {
-        snapshot.insert("id".to_string(), JsonValue::String(id.clone()));
-    }
-    snapshot.insert(
-        "directory_id".to_string(),
-        input
-            .directory_id
-            .clone()
-            .map(JsonValue::String)
-            .unwrap_or(JsonValue::Null),
-    );
-    snapshot.insert("name".to_string(), JsonValue::String(input.name));
-    if let Some(hidden) = input.hidden {
-        snapshot.insert("hidden".to_string(), JsonValue::Bool(hidden));
-    }
-
-    partial_state_row(
-        input.id,
-        FILE_DESCRIPTOR_SCHEMA_KEY,
-        Some(JsonValue::Object(snapshot)),
-        input.context,
-    )
-}
-
-pub(crate) fn blob_ref_row(input: BlobRefRowInput) -> Result<TransactionWriteRow, LixError> {
-    let size_bytes = u64::try_from(input.data.len()).map_err(|_| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!(
-                "binary blob size exceeds supported range for file '{}' branch '{}'",
-                input.file_id, input.context.branch_id
-            ),
-        )
-    })?;
-    let snapshot = json!({
-        "id": input.file_id.clone(),
-        "blob_hash": stable_content_fingerprint_hex(&input.data),
-        "size_bytes": size_bytes,
-    });
-
-    Ok(state_row(
-        input.file_id.clone(),
-        BLOB_REF_SCHEMA_KEY,
-        Some(snapshot),
-        FilesystemRowContext {
-            file_id: Some(input.file_id),
-            ..input.context
-        },
-    ))
-}
-
-pub(crate) fn plan_file_path_write(
-    resolver: &mut DirectoryPathResolver,
-    input: FilePathWriteInput,
-    generate_directory_id: &mut dyn FnMut() -> String,
-) -> Result<FilesystemWritePlan, LixError> {
-    let parsed = ParsedFilePath::try_from_path(&input.path)?;
-    let mut rows = Vec::new();
-    let file_id = input.id.unwrap_or_else(&mut *generate_directory_id);
-
-    let directory_id = match parsed.directory_path.as_ref() {
-        Some(directory_path) => {
-            rows.extend(resolver.ensure_directory_path(
-                directory_path.as_str(),
-                input.context.clone(),
-                false,
-                generate_directory_id,
-            )?);
-            resolver
-                .directory_id(directory_path.as_str())?
-                .map(ToOwned::to_owned)
-        }
-        None => None,
-    };
-
-    resolver.reserve_file(directory_id.clone(), parsed.name.clone(), file_id.clone())?;
-    rows.push(file_descriptor_row(FileDescriptorRowInput {
-        id: file_id.clone(),
-        directory_id,
-        name: parsed.name.clone(),
-        hidden: input.hidden.unwrap_or(false),
-        context: input.context.clone(),
-    }));
-
-    let mut file_data = Vec::new();
-    if let Some(data) = input.data {
-        rows.push(blob_ref_row(BlobRefRowInput {
-            file_id: file_id.clone(),
-            data: data.clone(),
-            context: FilesystemRowContext {
-                file_id: None,
-                metadata: None,
-                ..input.context.clone()
-            },
-        })?);
-        file_data.push(TransactionFileData {
-            file_id,
-            branch_id: input.context.branch_id,
-            untracked: input.context.untracked,
-            data,
-        });
-    }
-
-    Ok(FilesystemWritePlan {
-        rows,
-        file_data,
-        count: 1,
-    })
-}
-
-pub(crate) fn plan_file_path_update(
-    resolver: &mut DirectoryPathResolver,
-    existing_file_id: String,
-    new_path: String,
-    existing_hidden: bool,
-    _existing_data: Option<Vec<u8>>,
-    context: FilesystemRowContext,
-    generate_directory_id: &mut dyn FnMut() -> String,
-) -> Result<FilesystemWritePlan, LixError> {
-    let parsed = ParsedFilePath::try_from_path(&new_path)?;
-    let mut rows = Vec::new();
-
-    let directory_id = match parsed.directory_path.as_ref() {
-        Some(directory_path) => {
-            rows.extend(resolver.ensure_directory_path(
-                directory_path.as_str(),
-                context.clone(),
-                false,
-                generate_directory_id,
-            )?);
-            resolver
-                .directory_id(directory_path.as_str())?
-                .map(ToOwned::to_owned)
-        }
-        None => None,
-    };
-
-    resolver.reserve_file(
-        directory_id.clone(),
-        parsed.name.clone(),
-        existing_file_id.clone(),
-    )?;
-    rows.push(file_descriptor_row(FileDescriptorRowInput {
-        id: existing_file_id,
-        directory_id,
-        name: parsed.name.clone(),
-        hidden: existing_hidden,
-        context,
-    }));
-
-    // Data/blob-ref state is intentionally left untouched for path-only
-    // updates. A provider should plan blob rows only when `data` is assigned.
-    Ok(FilesystemWritePlan {
-        rows,
-        file_data: Vec::new(),
-        count: 1,
-    })
-}
-
-pub(crate) fn plan_file_delete(input: FileDeleteInput) -> FilesystemDeletePlan {
-    let mut rows = vec![tombstone_row(
-        input.file_id.clone(),
-        FILE_DESCRIPTOR_SCHEMA_KEY,
-        FilesystemRowContext {
-            file_id: None,
-            ..input.context.clone()
-        },
-    )];
-
-    if input.has_blob_ref {
-        rows.push(tombstone_row(
-            input.file_id.clone(),
-            BLOB_REF_SCHEMA_KEY,
-            FilesystemRowContext {
-                file_id: Some(input.file_id),
-                metadata: None,
-                ..input.context
-            },
-        ));
-    }
-
-    FilesystemDeletePlan { rows, count: 1 }
-}
-
-pub(crate) fn plan_directory_delete(input: DirectoryDeleteInput) -> FilesystemDeletePlan {
-    FilesystemDeletePlan {
-        rows: vec![tombstone_row(
-            input.directory_id,
-            DIRECTORY_DESCRIPTOR_SCHEMA_KEY,
-            FilesystemRowContext {
-                file_id: None,
-                ..input.context
-            },
-        )],
-        count: 1,
-    }
-}
-
-pub(crate) fn plan_recursive_directory_delete(
-    root_directory_id: &str,
-    visible_filesystem: &VisibleFilesystem,
-    context: FilesystemRowContext,
-) -> FilesystemDeletePlan {
-    let mut rows = Vec::new();
-    let mut count = 0;
-
-    collect_recursive_directory_delete(
-        root_directory_id,
-        visible_filesystem,
-        &context,
-        &mut rows,
-        &mut count,
-    );
-
-    FilesystemDeletePlan { rows, count }
-}
-
-pub(crate) fn directory_path_resolvers_from_state_rows(
-    rows: Vec<MaterializedLiveStateRow>,
-) -> Result<BTreeMap<String, DirectoryPathResolver>, LixError> {
-    let mut directory_rows = BTreeMap::<String, BTreeMap<String, DirectoryDescriptorSeed>>::new();
-    let mut file_rows = BTreeMap::<String, Vec<(Option<String>, String, String)>>::new();
-    for row in rows {
-        let Some(snapshot_content) = row.snapshot_content.as_deref() else {
-            continue;
-        };
-        let storage_branch_id = if row.global {
-            GLOBAL_BRANCH_ID
-        } else {
-            row.branch_id.as_str()
-        };
-        let resolver_key = filesystem_storage_scope_key(
-            storage_branch_id,
-            row.global,
-            row.untracked,
-            row.file_id.as_deref(),
-        );
-        match row.schema_key.as_str() {
-            DIRECTORY_DESCRIPTOR_SCHEMA_KEY => {
-                let snapshot: DirectoryDescriptorSnapshot = serde_json::from_str(snapshot_content)
-                    .map_err(|error| {
-                        LixError::new(
-                            "LIX_ERROR_UNKNOWN",
-                            format!("invalid lix_directory_descriptor snapshot JSON: {error}"),
-                        )
-                    })?;
-                directory_rows.entry(resolver_key).or_default().insert(
-                    snapshot.id.clone(),
-                    DirectoryDescriptorSeed {
-                        id: snapshot.id,
-                        parent_id: snapshot.parent_id,
-                        name: snapshot.name,
-                    },
-                );
-            }
-            FILE_DESCRIPTOR_SCHEMA_KEY => {
-                let snapshot: FileDescriptorSnapshot = serde_json::from_str(snapshot_content)
-                    .map_err(|error| {
-                        LixError::new(
-                            "LIX_ERROR_UNKNOWN",
-                            format!("invalid lix_file_descriptor snapshot JSON: {error}"),
-                        )
-                    })?;
-                file_rows.entry(resolver_key).or_default().push((
-                    snapshot.directory_id,
-                    snapshot.name,
-                    snapshot.id,
-                ));
-            }
-            _ => {}
-        }
-    }
-
-    let mut resolvers = BTreeMap::new();
-    for (branch_id, records) in directory_rows {
-        let mut paths = BTreeMap::<String, String>::new();
-        for directory_id in records.keys() {
-            resolve_directory_seed_path(directory_id, &records, &mut paths, &mut BTreeSet::new())?;
-        }
-        let seeds = paths
-            .into_iter()
-            .map(|(directory_id, path)| (path, directory_id))
-            .collect::<Vec<_>>();
-        let files = file_rows.remove(&branch_id).unwrap_or_default();
-        resolvers.insert(
-            branch_id,
-            DirectoryPathResolver::from_existing_filesystem(seeds, files)?,
-        );
-    }
-    for (branch_id, files) in file_rows {
-        resolvers.insert(
-            branch_id,
-            DirectoryPathResolver::from_existing_filesystem(std::iter::empty(), files)?,
-        );
-    }
-    Ok(resolvers)
-}
-
-pub(crate) fn filesystem_storage_scope_key(
-    branch_id: &str,
-    global: bool,
-    untracked: bool,
-    file_id: Option<&str>,
-) -> String {
-    format!(
-        "branch={branch_id}\0global={global}\0untracked={untracked}\0file_id={}",
-        file_id.unwrap_or("<null>")
-    )
-}
-
-#[derive(Debug, Clone)]
-struct DirectoryDescriptorSeed {
-    id: String,
-    parent_id: Option<String>,
-    name: String,
-}
-
-fn resolve_directory_seed_path(
-    directory_id: &str,
-    records: &BTreeMap<String, DirectoryDescriptorSeed>,
-    paths: &mut BTreeMap<String, String>,
-    visiting: &mut BTreeSet<String>,
-) -> Result<Option<String>, LixError> {
-    if let Some(path) = paths.get(directory_id) {
-        return Ok(Some(path.clone()));
-    }
-    if !visiting.insert(directory_id.to_string()) {
-        return Err(directory_parent_cycle_error(directory_id));
-    }
-    let Some(row) = records.get(directory_id) else {
-        visiting.remove(directory_id);
-        return Ok(None);
-    };
-    let path = match row.parent_id.as_deref() {
-        Some(parent_id) => {
-            let Some(parent_path) =
-                resolve_directory_seed_path(parent_id, records, paths, visiting)?
-            else {
-                visiting.remove(directory_id);
-                return Ok(None);
-            };
-            format!("{parent_path}{}/", row.name)
-        }
-        None => format!("/{}/", row.name),
-    };
-    visiting.remove(directory_id);
-    paths.insert(row.id.clone(), path.clone());
-    Ok(Some(path))
-}
-
-fn directory_parent_cycle_error(directory_id: &str) -> LixError {
-    LixError::new(
-        LixError::CODE_CONSTRAINT_VIOLATION,
-        format!(
-            "lix_directory_descriptor parent_id cycle detected while resolving directory '{directory_id}'"
-        ),
-    )
-}
-
-fn state_row(
-    entity_pk: String,
-    schema_key: &str,
-    snapshot: Option<JsonValue>,
-    context: FilesystemRowContext,
-) -> TransactionWriteRow {
-    partial_state_row(Some(entity_pk), schema_key, snapshot, context)
-}
-
-fn partial_state_row(
-    entity_pk: Option<String>,
-    schema_key: &str,
-    snapshot: Option<JsonValue>,
-    context: FilesystemRowContext,
-) -> TransactionWriteRow {
-    let snapshot = snapshot.map(TransactionJson::from_value_unchecked);
-    TransactionWriteRow {
-        entity_pk: entity_pk.map(EntityPk::single),
-        schema_key: schema_key.to_string(),
-        file_id: context.file_id,
-        snapshot,
-        metadata: context.metadata,
-        origin: None,
-        created_at: None,
-        updated_at: None,
-        global: context.global,
-        change_id: None,
-        commit_id: None,
-        untracked: context.untracked,
-        branch_id: context.branch_id,
-    }
-}
-
-fn tombstone_row(
-    entity_pk: String,
-    schema_key: &str,
-    context: FilesystemRowContext,
-) -> TransactionWriteRow {
-    state_row(entity_pk, schema_key, None, context)
-}
-
-fn collect_recursive_directory_delete(
-    directory_id: &str,
-    visible_filesystem: &VisibleFilesystem,
-    context: &FilesystemRowContext,
-    rows: &mut Vec<TransactionWriteRow>,
-    count: &mut u64,
-) {
-    if let Some(child_ids) = visible_filesystem
-        .directory_children_by_parent_id
-        .get(&Some(directory_id.to_string()))
-    {
-        for child_id in child_ids {
-            collect_recursive_directory_delete(child_id, visible_filesystem, context, rows, count);
-        }
-    }
-
-    if let Some(files) = visible_filesystem
-        .files_by_directory_id
-        .get(&Some(directory_id.to_string()))
-    {
-        for file_id in files.keys() {
-            let plan = plan_file_delete(FileDeleteInput {
-                file_id: file_id.clone(),
-                has_blob_ref: visible_filesystem
-                    .blob_refs_by_file_id
-                    .contains_key(file_id),
-                context: context.clone(),
-            });
-            rows.extend(plan.rows);
-            *count += plan.count;
-        }
-    }
-
-    let plan = plan_directory_delete(DirectoryDeleteInput {
-        directory_id: directory_id.to_string(),
-        context: context.clone(),
-    });
-    rows.extend(plan.rows);
-    *count += plan.count;
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::{BTreeMap, BTreeSet};
-
-    use serde_json::Value as JsonValue;
-
-    use super::{
-        blob_ref_row, directory_descriptor_row, file_descriptor_row, plan_file_path_update,
-        plan_file_path_write, BlobRefRowInput, DirectoryDeleteInput, DirectoryDescriptorRowInput,
-        DirectoryPathResolver, FileDeleteInput, FileDescriptorRowInput, FilePathWriteInput,
-        FilesystemRowContext,
-    };
-    use crate::sql2::filesystem_visibility::{
-        VisibleBlobRef, VisibleDirectory, VisibleFile, VisibleFilesystem,
-    };
-    use crate::{entity_pk::EntityPk, live_state::MaterializedLiveStateRow};
-
-    fn test_id_generator(ids: &'static [&'static str]) -> impl FnMut() -> String {
-        let mut ids = ids.iter();
-        move || ids.next().expect("test id should exist").to_string()
-    }
-
-    #[test]
-    fn directory_descriptor_row_builds_state_row() {
-        let row = directory_descriptor_row(DirectoryDescriptorRowInput {
-            id: "dir-docs".to_string(),
-            parent_id: None,
-            name: "docs".to_string(),
-            hidden: false,
-            context: FilesystemRowContext::active_branch("branch-a"),
-        });
-
-        assert_eq!(
-            row.entity_pk.as_ref(),
-            Some(&crate::entity_pk::EntityPk::single("dir-docs"))
-        );
-        assert_eq!(row.schema_key, "lix_directory_descriptor");
-        assert_eq!(row.branch_id, "branch-a");
-        let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["id"], "dir-docs");
-        assert_eq!(snapshot["parent_id"], JsonValue::Null);
-        assert_eq!(snapshot["name"], "docs");
-        assert_eq!(snapshot["hidden"], false);
-    }
-
-    #[test]
-    fn file_descriptor_row_builds_state_row() {
-        let row = file_descriptor_row(FileDescriptorRowInput {
-            id: "file-readme".to_string(),
-            directory_id: Some("dir-docs".to_string()),
-            name: "readme.md".to_string(),
-            hidden: false,
-            context: FilesystemRowContext::active_branch("branch-a"),
-        });
-
-        assert_eq!(
-            row.entity_pk.as_ref(),
-            Some(&crate::entity_pk::EntityPk::single("file-readme"))
-        );
-        assert_eq!(row.schema_key, "lix_file_descriptor");
-        let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["directory_id"], "dir-docs");
-        assert_eq!(snapshot["name"], "readme.md");
-    }
-
-    #[test]
-    fn blob_ref_row_builds_state_row() {
-        let row = blob_ref_row(BlobRefRowInput {
-            file_id: "file-readme".to_string(),
-            data: b"Hello".to_vec(),
-            context: FilesystemRowContext::active_branch("branch-a"),
-        })
-        .expect("blob ref row should build");
-
-        assert_eq!(
-            row.entity_pk.as_ref(),
-            Some(&crate::entity_pk::EntityPk::single("file-readme"))
-        );
-        assert_eq!(row.file_id.as_deref(), Some("file-readme"));
-        assert_eq!(row.schema_key, "lix_binary_blob_ref");
-        let snapshot: JsonValue = row.snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["id"], "file-readme");
-        assert_eq!(snapshot["size_bytes"], 5);
-        assert!(snapshot["blob_hash"]
-            .as_str()
-            .is_some_and(|hash| !hash.is_empty()));
-    }
-
-    #[test]
-    fn directory_path_resolver_reuses_existing_ancestor() {
-        let mut resolver =
-            DirectoryPathResolver::from_existing([("/docs/".to_string(), "dir-docs".to_string())])
-                .expect("existing directories should normalize");
-
-        let rows = resolver
-            .ensure_directory_path(
-                "/docs/nested/",
-                FilesystemRowContext::active_branch("branch-a"),
-                false,
-                &mut test_id_generator(&["dir-generated-nested"]),
-            )
-            .expect("directory path should plan");
-
-        assert_eq!(rows.len(), 1);
-        assert_eq!(resolver.directory_id("/docs/").unwrap(), Some("dir-docs"));
-        assert_eq!(
-            resolver.directory_id("/docs/nested/").unwrap(),
-            Some("dir-generated-nested")
-        );
-
-        let snapshot: JsonValue = rows[0].snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["id"], "dir-generated-nested");
-        assert_eq!(snapshot["parent_id"], "dir-docs");
-        assert_eq!(snapshot["name"], "nested");
-    }
-
-    #[test]
-    fn directory_path_resolver_reuses_ancestor_staged_in_same_batch() {
-        let mut resolver =
-            DirectoryPathResolver::from_existing([]).expect("empty resolver should build");
-
-        let docs_rows = resolver
-            .ensure_directory_path(
-                "/docs/",
-                FilesystemRowContext::active_branch("branch-a"),
-                false,
-                &mut test_id_generator(&["dir-generated-docs"]),
-            )
-            .expect("top-level directory should plan");
-        assert_eq!(docs_rows.len(), 1);
-
-        let nested_rows = resolver
-            .ensure_directory_path(
-                "/docs/nested/",
-                FilesystemRowContext::active_branch("branch-a"),
-                false,
-                &mut test_id_generator(&["dir-generated-nested"]),
-            )
-            .expect("nested directory should plan");
-
-        assert_eq!(nested_rows.len(), 1);
-        let snapshot: JsonValue = nested_rows[0].snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["id"], "dir-generated-nested");
-        assert_eq!(snapshot["parent_id"], "dir-generated-docs");
-        assert_eq!(snapshot["name"], "nested");
-    }
-
-    #[test]
-    fn directory_path_resolver_uses_explicit_leaf_id() {
-        let mut resolver =
-            DirectoryPathResolver::from_existing([]).expect("empty resolver should build");
-
-        let rows = resolver
-            .ensure_directory_path_with_leaf_id(
-                "/docs/nested/",
-                Some("dir-nested".to_string()),
-                FilesystemRowContext::active_branch("branch-a"),
-                false,
-                &mut test_id_generator(&["dir-generated-docs"]),
-            )
-            .expect("directory path should plan");
-
-        assert_eq!(rows.len(), 2);
-        assert_eq!(
-            resolver.directory_id("/docs/").unwrap(),
-            Some("dir-generated-docs")
-        );
-        assert_eq!(
-            resolver.directory_id("/docs/nested/").unwrap(),
-            Some("dir-nested")
-        );
-
-        let snapshot: JsonValue = rows[1].snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["id"], "dir-nested");
-        assert_eq!(snapshot["parent_id"], "dir-generated-docs");
-        assert_eq!(snapshot["name"], "nested");
-    }
-
-    #[test]
-    fn directory_path_resolver_does_not_restage_same_path() {
-        let mut resolver =
-            DirectoryPathResolver::from_existing([]).expect("empty resolver should build");
-
-        let rows = resolver
-            .ensure_directory_path(
-                "/docs/nested/",
-                FilesystemRowContext::active_branch("branch-a"),
-                false,
-                &mut test_id_generator(&["dir-generated-docs", "dir-generated-nested"]),
-            )
-            .expect("directory path should plan");
-        assert_eq!(rows.len(), 2);
-
-        let rows = resolver
-            .ensure_directory_path(
-                "/docs/nested/",
-                FilesystemRowContext::active_branch("branch-a"),
-                false,
-                &mut test_id_generator(&["should-not-be-used"]),
-            )
-            .expect("directory path should plan");
-        assert!(rows.is_empty());
-    }
-
-    #[test]
-    fn file_path_write_stages_missing_directories_file_blob_and_payload() {
-        let mut resolver =
-            DirectoryPathResolver::from_existing([]).expect("empty resolver should build");
-
-        let plan = plan_file_path_write(
-            &mut resolver,
-            FilePathWriteInput {
-                id: Some("file-readme".to_string()),
-                path: "/docs/guides/readme.md".to_string(),
-                data: Some(b"hello".to_vec()),
-                hidden: Some(false),
-                context: FilesystemRowContext::active_branch("branch-a"),
-            },
-            &mut test_id_generator(&["dir-generated-docs", "dir-generated-guides"]),
-        )
-        .expect("file path write should plan");
-
-        assert_eq!(plan.count, 1);
-        assert_eq!(plan.file_data.len(), 1);
-        assert_eq!(plan.file_data[0].file_id, "file-readme");
-        assert_eq!(plan.file_data[0].branch_id, "branch-a");
-        assert_eq!(plan.file_data[0].data, b"hello");
-        assert_eq!(plan.rows.len(), 4);
-        assert_eq!(
-            plan.rows
-                .iter()
-                .filter(|row| row.schema_key == "lix_directory_descriptor")
-                .count(),
-            2
-        );
-        assert!(plan
-            .rows
-            .iter()
-            .any(|row| row.schema_key == "lix_binary_blob_ref"));
-
-        let file_row = plan
-            .rows
-            .iter()
-            .find(|row| row.schema_key == "lix_file_descriptor")
-            .expect("file descriptor row should be planned");
-        let snapshot: JsonValue = file_row.snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["id"], "file-readme");
-        assert_eq!(snapshot["directory_id"], "dir-generated-guides");
-        assert_eq!(snapshot["name"], "readme.md");
-    }
-
-    #[test]
-    fn file_path_write_reuses_existing_parent_directory() {
-        let mut resolver = DirectoryPathResolver::from_existing([
-            ("/docs/".to_string(), "dir-docs".to_string()),
-            ("/docs/guides/".to_string(), "dir-guides".to_string()),
-        ])
-        .expect("existing directories should seed");
-
-        let plan = plan_file_path_write(
-            &mut resolver,
-            FilePathWriteInput {
-                id: Some("file-readme".to_string()),
-                path: "/docs/guides/readme.md".to_string(),
-                data: Some(b"hello".to_vec()),
-                hidden: Some(false),
-                context: FilesystemRowContext::active_branch("branch-a"),
-            },
-            &mut test_id_generator(&["should-not-be-used"]),
-        )
-        .expect("file path write should plan");
-
-        assert_eq!(plan.rows.len(), 2);
-        assert_eq!(
-            plan.rows
-                .iter()
-                .filter(|row| row.schema_key == "lix_directory_descriptor")
-                .count(),
-            0
-        );
-        let file_row = plan
-            .rows
-            .iter()
-            .find(|row| row.schema_key == "lix_file_descriptor")
-            .expect("file descriptor row should be planned");
-        let snapshot: JsonValue = file_row.snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["directory_id"], "dir-guides");
-    }
-
-    #[test]
-    fn file_path_update_reuses_existing_parent_and_preserves_data() {
-        let mut resolver =
-            DirectoryPathResolver::from_existing([("/docs/".to_string(), "dir-docs".to_string())])
-                .expect("existing directories should seed");
-
-        let plan = plan_file_path_update(
-            &mut resolver,
-            "file-readme".to_string(),
-            "/docs/renamed.md".to_string(),
-            false,
-            Some(b"hello".to_vec()),
-            FilesystemRowContext::active_branch("branch-a"),
-            &mut test_id_generator(&["should-not-be-used"]),
-        )
-        .expect("file path update should plan");
-
-        assert_eq!(plan.count, 1);
-        assert!(plan.file_data.is_empty());
-        assert_eq!(plan.rows.len(), 1);
-        assert!(plan
-            .rows
-            .iter()
-            .all(|row| row.schema_key != "lix_binary_blob_ref"));
-
-        let snapshot: JsonValue = plan.rows[0].snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["id"], "file-readme");
-        assert_eq!(snapshot["directory_id"], "dir-docs");
-        assert_eq!(snapshot["name"], "renamed.md");
-        assert_eq!(snapshot["hidden"], false);
-    }
-
-    #[test]
-    fn file_path_update_stages_missing_parent_directories() {
-        let mut resolver =
-            DirectoryPathResolver::from_existing([]).expect("empty resolver should build");
-
-        let plan = plan_file_path_update(
-            &mut resolver,
-            "file-readme".to_string(),
-            "/docs/guides/readme.md".to_string(),
-            true,
-            Some(b"hello".to_vec()),
-            FilesystemRowContext::active_branch("branch-a"),
-            &mut test_id_generator(&["dir-generated-docs", "dir-generated-guides"]),
-        )
-        .expect("file path update should plan");
-
-        assert_eq!(plan.count, 1);
-        assert!(plan.file_data.is_empty());
-        assert_eq!(plan.rows.len(), 3);
-        assert_eq!(
-            plan.rows
-                .iter()
-                .filter(|row| row.schema_key == "lix_directory_descriptor")
-                .count(),
-            2
-        );
-        assert!(plan
-            .rows
-            .iter()
-            .all(|row| row.schema_key != "lix_binary_blob_ref"));
-
-        let file_row = plan
-            .rows
-            .iter()
-            .find(|row| row.schema_key == "lix_file_descriptor")
-            .expect("file descriptor row should be planned");
-        let snapshot: JsonValue = file_row.snapshot.as_ref().unwrap().value().clone();
-        assert_eq!(snapshot["directory_id"], "dir-generated-guides");
-        assert_eq!(snapshot["name"], "readme.md");
-        assert_eq!(snapshot["hidden"], true);
-    }
-
-    #[test]
-    fn directory_path_resolvers_from_state_rows_derives_nested_paths() {
-        let resolvers = super::directory_path_resolvers_from_state_rows(vec![
-            live_directory_row(
-                "dir-docs",
-                "branch-a",
-                "{\"id\":\"dir-docs\",\"parent_id\":null,\"name\":\"docs\"}",
-            ),
-            live_directory_row(
-                "dir-guides",
-                "branch-a",
-                "{\"id\":\"dir-guides\",\"parent_id\":\"dir-docs\",\"name\":\"guides\"}",
-            ),
-        ])
-        .expect("state rows should seed directory resolvers");
-
-        let resolver = resolvers
-            .get(&super::filesystem_storage_scope_key(
-                "branch-a", false, false, None,
-            ))
-            .expect("storage-scope resolver should exist");
-        assert_eq!(resolver.directory_id("/docs/").unwrap(), Some("dir-docs"));
-        assert_eq!(
-            resolver.directory_id("/docs/guides/").unwrap(),
-            Some("dir-guides")
-        );
-    }
-
-    #[test]
-    fn file_delete_plans_descriptor_and_blob_ref_tombstones() {
-        let plan = super::plan_file_delete(FileDeleteInput {
-            file_id: "file-readme".to_string(),
-            has_blob_ref: true,
-            context: FilesystemRowContext::active_branch("branch-a"),
-        });
-
-        assert_eq!(plan.count, 1);
-        assert_eq!(plan.rows.len(), 2);
-        let descriptor = plan
-            .rows
-            .iter()
-            .find(|row| row.schema_key == "lix_file_descriptor")
-            .expect("file descriptor tombstone should be planned");
-        assert_eq!(
-            descriptor.entity_pk.as_ref(),
-            Some(&crate::entity_pk::EntityPk::single("file-readme"))
-        );
-        assert_eq!(descriptor.file_id, None);
-        assert_eq!(descriptor.snapshot, None);
-
-        let blob_ref = plan
-            .rows
-            .iter()
-            .find(|row| row.schema_key == "lix_binary_blob_ref")
-            .expect("blob ref tombstone should be planned");
-        assert_eq!(
-            blob_ref.entity_pk.as_ref(),
-            Some(&crate::entity_pk::EntityPk::single("file-readme"))
-        );
-        assert_eq!(blob_ref.file_id.as_deref(), Some("file-readme"));
-        assert_eq!(blob_ref.snapshot, None);
-    }
-
-    #[test]
-    fn file_delete_without_blob_ref_plans_only_descriptor_tombstone() {
-        let plan = super::plan_file_delete(FileDeleteInput {
-            file_id: "file-readme".to_string(),
-            has_blob_ref: false,
-            context: FilesystemRowContext::active_branch("branch-a"),
-        });
-
-        assert_eq!(plan.count, 1);
-        assert_eq!(plan.rows.len(), 1);
-        assert_eq!(plan.rows[0].schema_key, "lix_file_descriptor");
-        assert_eq!(plan.rows[0].snapshot, None);
-    }
-
-    #[test]
-    fn directory_delete_plans_descriptor_tombstone() {
-        let plan = super::plan_directory_delete(DirectoryDeleteInput {
-            directory_id: "dir-docs".to_string(),
-            context: FilesystemRowContext::active_branch("branch-a"),
-        });
-
-        assert_eq!(plan.count, 1);
-        assert_eq!(plan.rows.len(), 1);
-        assert_eq!(
-            plan.rows[0].entity_pk.as_ref(),
-            Some(&crate::entity_pk::EntityPk::single("dir-docs"))
-        );
-        assert_eq!(plan.rows[0].schema_key, "lix_directory_descriptor");
-        assert_eq!(plan.rows[0].file_id, None);
-        assert_eq!(plan.rows[0].snapshot, None);
-    }
-
-    #[test]
-    fn recursive_directory_delete_plans_files_blobs_and_deepest_directories_first() {
-        let context = FilesystemRowContext::active_branch("branch-a");
-        let mut directories_by_id = BTreeMap::new();
-        directories_by_id.insert(
-            "dir-docs".to_string(),
-            visible_directory("dir-docs", None, "docs", context.clone()),
-        );
-        directories_by_id.insert(
-            "dir-guides".to_string(),
-            visible_directory("dir-guides", Some("dir-docs"), "guides", context.clone()),
-        );
-
-        let mut directory_children_by_parent_id = BTreeMap::new();
-        directory_children_by_parent_id.insert(
-            Some("dir-docs".to_string()),
-            BTreeSet::from(["dir-guides".to_string()]),
-        );
-
-        let mut files_by_directory_id = BTreeMap::new();
-        files_by_directory_id.insert(
-            Some("dir-guides".to_string()),
-            BTreeMap::from([(
-                "file-readme".to_string(),
-                visible_file("file-readme", Some("dir-guides"), "readme", context.clone()),
-            )]),
-        );
-        files_by_directory_id.insert(
-            Some("dir-docs".to_string()),
-            BTreeMap::from([(
-                "file-index".to_string(),
-                visible_file("file-index", Some("dir-docs"), "index", context.clone()),
-            )]),
-        );
-
-        let visible_filesystem = VisibleFilesystem {
-            directories_by_id,
-            directory_children_by_parent_id,
-            files_by_directory_id,
-            blob_refs_by_file_id: BTreeMap::from([(
-                "file-readme".to_string(),
-                visible_blob_ref("file-readme", context.clone()),
-            )]),
-        };
-
-        let plan = super::plan_recursive_directory_delete("dir-docs", &visible_filesystem, context);
-
-        assert_eq!(plan.count, 4);
-        assert_eq!(
-            plan.rows
-                .iter()
-                .map(|row| {
-                    (
-                        row.schema_key.as_str(),
-                        row.entity_pk
-                            .as_ref()
-                            .expect("planned recursive delete row should carry entity_pk")
-                            .as_single_string_owned()
-                            .expect("planned recursive delete row should project entity_pk"),
-                    )
-                })
-                .collect::<Vec<_>>(),
-            vec![
-                ("lix_file_descriptor", "file-readme".to_string()),
-                ("lix_binary_blob_ref", "file-readme".to_string()),
-                ("lix_directory_descriptor", "dir-guides".to_string()),
-                ("lix_file_descriptor", "file-index".to_string()),
-                ("lix_directory_descriptor", "dir-docs".to_string()),
-            ]
-        );
-        assert!(plan.rows.iter().all(|row| row.snapshot.is_none()));
-    }
-
-    fn visible_directory(
-        id: &str,
-        parent_id: Option<&str>,
-        name: &str,
-        context: FilesystemRowContext,
-    ) -> VisibleDirectory {
-        VisibleDirectory {
-            id: id.to_string(),
-            parent_id: parent_id.map(ToOwned::to_owned),
-            name: name.to_string(),
-            hidden: false,
-            context,
-        }
-    }
-
-    fn visible_file(
-        id: &str,
-        directory_id: Option<&str>,
-        name: &str,
-        context: FilesystemRowContext,
-    ) -> VisibleFile {
-        VisibleFile {
-            id: id.to_string(),
-            directory_id: directory_id.map(ToOwned::to_owned),
-            name: name.to_string(),
-            hidden: false,
-            context,
-        }
-    }
-
-    fn visible_blob_ref(file_id: &str, context: FilesystemRowContext) -> VisibleBlobRef {
-        VisibleBlobRef {
-            file_id: file_id.to_string(),
-            blob_hash: format!("hash-{file_id}"),
-            size_bytes: Some(1),
-            context,
-        }
-    }
-
-    fn live_directory_row(
-        entity_pk: &str,
-        branch_id: &str,
-        snapshot_content: &str,
-    ) -> MaterializedLiveStateRow {
-        MaterializedLiveStateRow {
-            entity_pk: EntityPk::single(entity_pk),
-            schema_key: "lix_directory_descriptor".to_string(),
-            file_id: None,
-            snapshot_content: Some(snapshot_content.to_string()),
-            metadata: None,
-            deleted: false,
-            branch_id: branch_id.to_string(),
-            change_id: Some(format!("change-{entity_pk}")),
-            commit_id: Some(format!("commit-{entity_pk}")),
-            global: false,
-            untracked: false,
-            created_at: "2026-04-23T00:00:00Z".to_string(),
-            updated_at: "2026-04-23T01:00:00Z".to_string(),
-        }
-    }
-}