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

package/dist-engine-src/src/session/merge/analysis.rs

@@ -1,108 +0,0 @@
-use crate::storage::StorageRead;
-use crate::tracked_state::{
-    plan_merge, TrackedStateDiff, TrackedStateDiffRequest, TrackedStateMergePlan,
-    TrackedStateStoreReader,
-};
-use crate::LixError;
-
-use super::conflicts::{conflicts_from_plan, MergeConflict};
-use super::stats::{stats_from_diff, stats_from_plan, MergeStats};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum MergeOutcome {
-    AlreadyUpToDate,
-    FastForward,
-    MergeCommitted,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct MergeCommits {
-    pub(crate) base_commit_id: String,
-    pub(crate) target_commit_id: String,
-    pub(crate) source_commit_id: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct MergeAnalysis {
-    pub(crate) outcome: MergeOutcome,
-    pub(crate) commits: MergeCommits,
-    pub(crate) source_diff: TrackedStateDiff,
-    pub(crate) target_diff: TrackedStateDiff,
-    pub(crate) stats: MergeStats,
-    pub(crate) conflicts: Vec<MergeConflict>,
-    pub(crate) merge_plan: Option<TrackedStateMergePlan>,
-}
-
-impl MergeAnalysis {
-    pub(crate) fn merge_plan(&self) -> Option<&TrackedStateMergePlan> {
-        self.merge_plan.as_ref()
-    }
-}
-
-pub(crate) async fn analyze<S>(
-    reader: &mut TrackedStateStoreReader<S>,
-    commits: MergeCommits,
-) -> Result<MergeAnalysis, LixError>
-where
-    S: StorageRead + Send + Sync,
-{
-    let request = TrackedStateDiffRequest::default();
-    let source_diff = reader
-        .diff_commits(&commits.base_commit_id, &commits.source_commit_id, &request)
-        .await?;
-    let target_diff = if commits.base_commit_id == commits.source_commit_id
-        || commits.base_commit_id == commits.target_commit_id
-    {
-        TrackedStateDiff::default()
-    } else {
-        reader
-            .diff_commits_with_validation(
-                &commits.base_commit_id,
-                &commits.target_commit_id,
-                &request,
-                false,
-                true,
-            )
-            .await?
-    };
-
-    let outcome = if commits.base_commit_id == commits.source_commit_id {
-        MergeOutcome::AlreadyUpToDate
-    } else if commits.base_commit_id == commits.target_commit_id {
-        MergeOutcome::FastForward
-    } else {
-        MergeOutcome::MergeCommitted
-    };
-
-    let merge_plan = if outcome == MergeOutcome::MergeCommitted {
-        Some(plan_merge(&target_diff, &source_diff)?)
-    } else {
-        None
-    };
-
-    let stats = match outcome {
-        MergeOutcome::AlreadyUpToDate => MergeStats::default(),
-        MergeOutcome::FastForward => stats_from_diff(&source_diff),
-        MergeOutcome::MergeCommitted => merge_plan
-            .as_ref()
-            .map(|plan| stats_from_plan(plan, &source_diff))
-            .transpose()?
-            .unwrap_or_default(),
-    };
-
-    let conflicts = merge_plan
-        .as_ref()
-        .map(conflicts_from_plan)
-        .transpose()?
-        .unwrap_or_default();
-
-    Ok(MergeAnalysis {
-        outcome,
-        commits,
-        source_diff,
-        target_diff,
-        stats,
-        conflicts,
-        merge_plan,
-    })
-}

package/dist-engine-src/src/session/merge/branch.rs

@@ -1,417 +0,0 @@
-use serde_json::{json, Value as JsonValue};
-
-use crate::branch::{BranchLifecycle, BranchOperation, BranchReferenceRole};
-use crate::storage::StorageBackend;
-use crate::LixError;
-
-use super::analysis::{analyze, MergeCommits, MergeOutcome};
-use super::conflicts::{
-    MergeConflict as AnalysisMergeConflict,
-    MergeConflictChangeKind as AnalysisMergeConflictChangeKind,
-    MergeConflictKind as AnalysisMergeConflictKind, MergeConflictSide as AnalysisMergeConflictSide,
-};
-use super::stats::MergeStats;
-use crate::session::context::SessionContext;
-use crate::tracked_state::TrackedStateMergePick;
-use crate::transaction::types::StagedCommitChangeRef;
-
-/// Options for merging another branch into this session's active branch.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MergeBranchOptions {
-    /// Branch whose changes should be merged into the active session branch.
-    pub source_branch_id: String,
-}
-
-/// Options for previewing a merge from another branch into this session's
-/// active branch.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MergeBranchPreviewOptions {
-    /// Branch whose changes would be merged into the active session branch.
-    pub source_branch_id: String,
-}
-
-/// Receipt returned after merging a branch.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MergeBranchReceipt {
-    pub outcome: MergeBranchOutcome,
-    pub target_branch_id: String,
-    pub source_branch_id: String,
-    pub base_commit_id: String,
-    pub target_head_before_commit_id: String,
-    pub source_head_before_commit_id: String,
-    pub target_head_after_commit_id: String,
-    pub created_merge_commit_id: Option<String>,
-    pub change_stats: MergeChangeStats,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct MergeChangeStats {
-    pub total: usize,
-    pub added: usize,
-    pub modified: usize,
-    pub removed: usize,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MergeBranchPreview {
-    pub outcome: MergeBranchOutcome,
-    pub target_branch_id: String,
-    pub source_branch_id: String,
-    pub base_commit_id: String,
-    pub target_head_commit_id: String,
-    pub source_head_commit_id: String,
-    pub change_stats: MergeChangeStats,
-    pub conflicts: Vec<MergeConflict>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MergeConflict {
-    pub kind: MergeConflictKind,
-    pub schema_key: String,
-    pub entity_pk: JsonValue,
-    pub file_id: Option<String>,
-    pub target: MergeConflictSide,
-    pub source: MergeConflictSide,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MergeConflictKind {
-    SameEntityChanged,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct MergeConflictSide {
-    pub kind: MergeConflictChangeKind,
-    pub before_change_id: Option<String>,
-    pub after_change_id: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MergeConflictChangeKind {
-    Added,
-    Modified,
-    Removed,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MergeBranchOutcome {
-    AlreadyUpToDate,
-    FastForward,
-    MergeCommitted,
-}
-
-impl<B> SessionContext<B>
-where
-    B: StorageBackend + Clone + Send + Sync + 'static,
-    for<'backend> B::Read<'backend>: Clone + Send + Sync + 'static,
-    for<'backend> B::Write<'backend>: Send,
-{
-    /// Previews merging `source_branch_id` into this session's active branch
-    /// without advancing refs, staging changes, or creating commits.
-    pub async fn merge_branch_preview(
-        &self,
-        options: MergeBranchPreviewOptions,
-    ) -> Result<MergeBranchPreview, LixError> {
-        let source_branch_id = options.source_branch_id;
-
-        self.with_write_transaction(|transaction| {
-            Box::pin(async move {
-                let active_branch_id = transaction.active_branch_id().to_string();
-                if source_branch_id == active_branch_id {
-                    return Err(LixError::invalid_self_merge(active_branch_id));
-                }
-
-                let (target_head, source_head) = {
-                    let reader = transaction.branch_ref_reader();
-                    let lifecycle = BranchLifecycle::new(&reader);
-                    let target_head = lifecycle
-                        .require_existing_commit_id(
-                            &active_branch_id,
-                            BranchOperation::MergeBranchPreview,
-                            BranchReferenceRole::Target,
-                        )
-                        .await?;
-                    let source_head = lifecycle
-                        .require_existing_commit_id(
-                            &source_branch_id,
-                            BranchOperation::MergeBranchPreview,
-                            BranchReferenceRole::Source,
-                        )
-                        .await?;
-                    (target_head, source_head)
-                };
-
-                let merge_base = {
-                    let mut reader = transaction.commit_graph_reader();
-                    reader.merge_base(&target_head, &source_head).await?
-                };
-
-                let analysis = {
-                    let mut reader = transaction.tracked_state_reader();
-                    analyze(
-                        &mut reader,
-                        MergeCommits {
-                            base_commit_id: merge_base.commit_id,
-                            target_commit_id: target_head,
-                            source_commit_id: source_head,
-                        },
-                    )
-                    .await?
-                };
-
-                Ok(preview_from_analysis(
-                    &active_branch_id,
-                    &source_branch_id,
-                    &analysis,
-                ))
-            })
-        })
-        .await
-    }
-
-    /// Merges `source_branch_id` into this session's active branch.
-    ///
-    /// The generated target commit keeps the previous target head as its first
-    /// parent and records the source head as an additional parent, so the
-    /// commit graph preserves branch ancestry while tracked-state storage
-    /// selects the planned source changes into the new target root.
-    pub async fn merge_branch(
-        &self,
-        options: MergeBranchOptions,
-    ) -> Result<MergeBranchReceipt, LixError> {
-        let source_branch_id = options.source_branch_id;
-
-        self.with_write_transaction(|transaction| {
-            Box::pin(async move {
-                let active_branch_id = transaction.active_branch_id().to_string();
-                if source_branch_id == active_branch_id {
-                    return Err(LixError::invalid_self_merge(active_branch_id));
-                }
-
-                let (target_head, source_head) = {
-                    let reader = transaction.branch_ref_reader();
-                    let lifecycle = BranchLifecycle::new(&reader);
-                    let target_head = lifecycle
-                        .require_existing_commit_id(
-                            &active_branch_id,
-                            BranchOperation::MergeBranch,
-                            BranchReferenceRole::Target,
-                        )
-                        .await?;
-                    let source_head = lifecycle
-                        .require_existing_commit_id(
-                            &source_branch_id,
-                            BranchOperation::MergeBranch,
-                            BranchReferenceRole::Source,
-                        )
-                        .await?;
-                    (target_head, source_head)
-                };
-
-                let merge_base = {
-                    let mut reader = transaction.commit_graph_reader();
-                    reader.merge_base(&target_head, &source_head).await?
-                };
-                let base_commit_id = merge_base.commit_id;
-
-                let analysis = {
-                    let mut reader = transaction.tracked_state_reader();
-                    analyze(
-                        &mut reader,
-                        MergeCommits {
-                            base_commit_id,
-                            target_commit_id: target_head,
-                            source_commit_id: source_head,
-                        },
-                    )
-                    .await?
-                };
-
-                if analysis.outcome == MergeOutcome::AlreadyUpToDate {
-                    return Ok(MergeBranchReceipt {
-                        outcome: MergeBranchOutcome::AlreadyUpToDate,
-                        target_branch_id: active_branch_id,
-                        source_branch_id,
-                        base_commit_id: analysis.commits.base_commit_id,
-                        target_head_after_commit_id: analysis.commits.target_commit_id.clone(),
-                        target_head_before_commit_id: analysis.commits.target_commit_id,
-                        source_head_before_commit_id: analysis.commits.source_commit_id,
-                        created_merge_commit_id: None,
-                        change_stats: merge_change_stats_from_analysis(&analysis.stats),
-                    });
-                }
-
-                if analysis.outcome == MergeOutcome::FastForward {
-                    transaction
-                        .advance_branch_ref(&active_branch_id, &analysis.commits.source_commit_id)
-                        .await?;
-
-                    return Ok(MergeBranchReceipt {
-                        outcome: MergeBranchOutcome::FastForward,
-                        target_branch_id: active_branch_id,
-                        source_branch_id,
-                        base_commit_id: analysis.commits.base_commit_id,
-                        target_head_before_commit_id: analysis.commits.target_commit_id,
-                        source_head_before_commit_id: analysis.commits.source_commit_id.clone(),
-                        target_head_after_commit_id: analysis.commits.source_commit_id,
-                        created_merge_commit_id: None,
-                        change_stats: merge_change_stats_from_analysis(&analysis.stats),
-                    });
-                }
-
-                let merge_plan = analysis
-                    .merge_plan()
-                    .expect("merge analysis should include a plan for mergeCommitted");
-
-                if !analysis.conflicts.is_empty() {
-                    return Err(merge_conflict_error(
-                        &analysis
-                            .conflicts
-                            .iter()
-                            .map(merge_conflict_from_analysis)
-                            .collect::<Vec<_>>(),
-                    )?);
-                }
-
-                let selected_changes = merge_plan
-                    .picks
-                    .iter()
-                    .map(selected_change_from_merge_pick)
-                    .collect::<Vec<_>>();
-                let created_merge_commit_id = transaction.stage_merge_commit(
-                    active_branch_id.clone(),
-                    analysis.commits.source_commit_id.clone(),
-                    selected_changes,
-                )?;
-                return Ok(MergeBranchReceipt {
-                    outcome: MergeBranchOutcome::MergeCommitted,
-                    target_branch_id: active_branch_id,
-                    source_branch_id,
-                    base_commit_id: analysis.commits.base_commit_id,
-                    target_head_after_commit_id: created_merge_commit_id.clone(),
-                    target_head_before_commit_id: analysis.commits.target_commit_id,
-                    source_head_before_commit_id: analysis.commits.source_commit_id,
-                    created_merge_commit_id: Some(created_merge_commit_id),
-                    change_stats: merge_change_stats_from_analysis(&analysis.stats),
-                });
-            })
-        })
-        .await
-    }
-}
-
-fn selected_change_from_merge_pick(pick: &TrackedStateMergePick) -> StagedCommitChangeRef {
-    StagedCommitChangeRef {
-        schema_key: pick.selected_row.schema_key.clone(),
-        file_id: pick.selected_row.file_id.clone(),
-        entity_pk: pick.selected_row.entity_pk.clone(),
-        change_id: pick.change_id.clone(),
-        snapshot_ref: pick.selected_row.snapshot_ref,
-        metadata_ref: pick.selected_row.metadata_ref,
-        deleted: pick.selected_row.deleted,
-        created_at: pick.selected_row.created_at.clone(),
-        updated_at: pick.selected_row.updated_at.clone(),
-    }
-}
-
-fn preview_from_analysis(
-    target_branch_id: &str,
-    source_branch_id: &str,
-    analysis: &super::analysis::MergeAnalysis,
-) -> MergeBranchPreview {
-    MergeBranchPreview {
-        outcome: merge_branch_outcome_from_analysis(analysis.outcome),
-        target_branch_id: target_branch_id.to_string(),
-        source_branch_id: source_branch_id.to_string(),
-        base_commit_id: analysis.commits.base_commit_id.clone(),
-        target_head_commit_id: analysis.commits.target_commit_id.clone(),
-        source_head_commit_id: analysis.commits.source_commit_id.clone(),
-        change_stats: merge_change_stats_from_analysis(&analysis.stats),
-        conflicts: analysis
-            .conflicts
-            .iter()
-            .map(merge_conflict_from_analysis)
-            .collect(),
-    }
-}
-
-fn merge_branch_outcome_from_analysis(outcome: MergeOutcome) -> MergeBranchOutcome {
-    match outcome {
-        MergeOutcome::AlreadyUpToDate => MergeBranchOutcome::AlreadyUpToDate,
-        MergeOutcome::FastForward => MergeBranchOutcome::FastForward,
-        MergeOutcome::MergeCommitted => MergeBranchOutcome::MergeCommitted,
-    }
-}
-
-fn merge_change_stats_from_analysis(stats: &MergeStats) -> MergeChangeStats {
-    MergeChangeStats {
-        total: stats.total,
-        added: stats.added,
-        modified: stats.modified,
-        removed: stats.removed,
-    }
-}
-
-fn merge_conflict_from_analysis(conflict: &AnalysisMergeConflict) -> MergeConflict {
-    MergeConflict {
-        kind: match conflict.kind {
-            AnalysisMergeConflictKind::SameEntityChanged => MergeConflictKind::SameEntityChanged,
-        },
-        schema_key: conflict.schema_key.clone(),
-        entity_pk: conflict.entity_pk.clone(),
-        file_id: conflict.file_id.clone(),
-        target: merge_conflict_side_from_analysis(&conflict.target),
-        source: merge_conflict_side_from_analysis(&conflict.source),
-    }
-}
-
-fn merge_conflict_side_from_analysis(side: &AnalysisMergeConflictSide) -> MergeConflictSide {
-    MergeConflictSide {
-        kind: match side.kind {
-            AnalysisMergeConflictChangeKind::Added => MergeConflictChangeKind::Added,
-            AnalysisMergeConflictChangeKind::Modified => MergeConflictChangeKind::Modified,
-            AnalysisMergeConflictChangeKind::Removed => MergeConflictChangeKind::Removed,
-        },
-        before_change_id: side.before_change_id.clone(),
-        after_change_id: side.after_change_id.clone(),
-    }
-}
-
-fn merge_conflict_error(conflicts: &[MergeConflict]) -> Result<LixError, LixError> {
-    let conflict_count = conflicts.len();
-    Ok(LixError::new(
-        LixError::CODE_MERGE_CONFLICT,
-        format!("merge_branch found {conflict_count} tracked-state conflict(s)"),
-    )
-    .with_hint("Resolve the conflicting entities in the target branch, then retry the merge.")
-    .with_details(json!({
-        "conflicts": conflicts.iter()
-            .map(merge_conflict_details)
-            .collect::<Vec<_>>(),
-    })))
-}
-
-fn merge_conflict_details(conflict: &MergeConflict) -> serde_json::Value {
-    json!({
-        "kind": match conflict.kind {
-            MergeConflictKind::SameEntityChanged => "sameEntityChanged",
-        },
-        "schemaKey": conflict.schema_key,
-        "entityPk": conflict.entity_pk,
-        "fileId": conflict.file_id,
-        "target": merge_conflict_side_details(&conflict.target),
-        "source": merge_conflict_side_details(&conflict.source),
-    })
-}
-
-fn merge_conflict_side_details(side: &MergeConflictSide) -> serde_json::Value {
-    json!({
-        "kind": match side.kind {
-            MergeConflictChangeKind::Added => "added",
-            MergeConflictChangeKind::Modified => "modified",
-            MergeConflictChangeKind::Removed => "removed",
-        },
-        "beforeChangeId": side.before_change_id,
-        "afterChangeId": side.after_change_id,
-    })
-}

package/dist-engine-src/src/session/merge/conflicts.rs

@@ -1,63 +0,0 @@
-use crate::tracked_state::{
-    TrackedStateDiffEntry, TrackedStateDiffKind, TrackedStateMergeConflict, TrackedStateMergePlan,
-};
-use crate::LixError;
-use serde_json::Value as JsonValue;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct MergeConflict {
-    pub(crate) kind: MergeConflictKind,
-    pub(crate) schema_key: String,
-    pub(crate) entity_pk: JsonValue,
-    pub(crate) file_id: Option<String>,
-    pub(crate) target: MergeConflictSide,
-    pub(crate) source: MergeConflictSide,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum MergeConflictKind {
-    SameEntityChanged,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct MergeConflictSide {
-    pub(crate) kind: MergeConflictChangeKind,
-    pub(crate) before_change_id: Option<String>,
-    pub(crate) after_change_id: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum MergeConflictChangeKind {
-    Added,
-    Modified,
-    Removed,
-}
-
-pub(crate) fn conflicts_from_plan(
-    plan: &TrackedStateMergePlan,
-) -> Result<Vec<MergeConflict>, LixError> {
-    plan.conflicts.iter().map(conflict_from_tracked).collect()
-}
-
-fn conflict_from_tracked(conflict: &TrackedStateMergeConflict) -> Result<MergeConflict, LixError> {
-    Ok(MergeConflict {
-        kind: MergeConflictKind::SameEntityChanged,
-        schema_key: conflict.identity.schema_key.clone(),
-        entity_pk: conflict.identity.entity_pk.as_json_array_value()?,
-        file_id: conflict.identity.file_id.clone(),
-        target: conflict_side_from_diff_entry(&conflict.target),
-        source: conflict_side_from_diff_entry(&conflict.source),
-    })
-}
-
-fn conflict_side_from_diff_entry(entry: &TrackedStateDiffEntry) -> MergeConflictSide {
-    MergeConflictSide {
-        kind: match entry.kind {
-            TrackedStateDiffKind::Added => MergeConflictChangeKind::Added,
-            TrackedStateDiffKind::Modified => MergeConflictChangeKind::Modified,
-            TrackedStateDiffKind::Removed => MergeConflictChangeKind::Removed,
-        },
-        before_change_id: entry.before.as_ref().map(|row| row.change_id.clone()),
-        after_change_id: entry.after.as_ref().map(|row| row.change_id.clone()),
-    }
-}

package/dist-engine-src/src/session/merge/mod.rs

@@ -1,10 +0,0 @@
-mod analysis;
-mod branch;
-mod conflicts;
-mod stats;
-
-pub use branch::{
-    MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchPreviewOptions,
-    MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictChangeKind,
-    MergeConflictKind, MergeConflictSide,
-};

package/dist-engine-src/src/session/merge/stats.rs

@@ -1,61 +0,0 @@
-use crate::tracked_state::{
-    TrackedStateDiff, TrackedStateDiffKind, TrackedStateMergePick, TrackedStateMergePlan,
-};
-use crate::LixError;
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub(crate) struct MergeStats {
-    pub(crate) total: usize,
-    pub(crate) added: usize,
-    pub(crate) modified: usize,
-    pub(crate) removed: usize,
-}
-
-pub(crate) fn stats_from_diff(diff: &TrackedStateDiff) -> MergeStats {
-    let mut stats = MergeStats::default();
-    for entry in &diff.entries {
-        stats.add(entry.kind);
-    }
-    stats
-}
-
-pub(crate) fn stats_from_plan(
-    plan: &TrackedStateMergePlan,
-    source_diff: &TrackedStateDiff,
-) -> Result<MergeStats, LixError> {
-    let mut stats = MergeStats::default();
-    for pick in &plan.picks {
-        let identity = pick_identity(pick);
-        let Some(entry) = source_diff
-            .entries
-            .iter()
-            .find(|entry| &entry.identity == identity)
-        else {
-            return Err(LixError::new(
-                "LIX_ERROR_UNKNOWN",
-                format!(
-                    "merge analysis could not find source diff entry for source schema '{}' entity '{}'",
-                    identity.schema_key,
-                    identity.entity_pk.as_json_array_text()?
-                ),
-            ));
-        };
-        stats.add(entry.kind);
-    }
-    Ok(stats)
-}
-
-impl MergeStats {
-    fn add(&mut self, kind: TrackedStateDiffKind) {
-        self.total += 1;
-        match kind {
-            TrackedStateDiffKind::Added => self.added += 1,
-            TrackedStateDiffKind::Modified => self.modified += 1,
-            TrackedStateDiffKind::Removed => self.removed += 1,
-        }
-    }
-}
-
-fn pick_identity(pick: &TrackedStateMergePick) -> &crate::tracked_state::TrackedStateDiffIdentity {
-    &pick.identity
-}

package/dist-engine-src/src/session/mod.rs

@@ -1,30 +0,0 @@
-//! Engine session boundary.
-//!
-//! Transaction invariant: a session has one execution lease. Parent-handle
-//! calls use it for implicit single-statement execution; explicit transactions
-//! hold it until commit or rollback. Session feature submodules should enter
-//! write flows through the centralized session helpers rather than opening
-//! `Transaction` directly or using session-level read helpers inside writes.
-//!
-//! MVP boundary: session close can cancel queued or pre-boundary writes until
-//! the durable commit point-of-no-return. After that point, close waits for
-//! commit completion. Durability itself is the backend's responsibility.
-
-mod context;
-mod create_branch;
-mod execute;
-mod merge;
-mod switch_branch;
-mod transaction;
-
-pub use context::SessionContext;
-pub(crate) use context::{SessionMode, WORKSPACE_BRANCH_KEY};
-pub use create_branch::{CreateBranchOptions, CreateBranchReceipt};
-pub use execute::{ExecuteResult, Row, RowRef, TryFromValue};
-pub use merge::{
-    MergeBranchOptions, MergeBranchOutcome, MergeBranchPreview, MergeBranchPreviewOptions,
-    MergeBranchReceipt, MergeChangeStats, MergeConflict, MergeConflictChangeKind,
-    MergeConflictKind, MergeConflictSide,
-};
-pub use switch_branch::{SwitchBranchOptions, SwitchBranchReceipt};
-pub use transaction::SessionTransaction;