snapshot

type AbsenceProof struct {
	// MissingHash is the edge hash being proved absent.
	MissingHash types.Hash `json:"missing_hash"`

	// LeftNeighbor is the largest leaf smaller than MissingHash (nil if MissingHash
	// would be the first leaf).
	LeftNeighbor *types.Hash `json:"left_neighbor,omitempty"`
	// RightNeighbor is the smallest leaf larger than MissingHash (nil if MissingHash
	// would be the last leaf).
	RightNeighbor *types.Hash `json:"right_neighbor,omitempty"`

	// LeftProof proves LeftNeighbor is in the tree (nil if no left neighbor).
	LeftProof *MerkleProof `json:"left_proof,omitempty"`
	// RightProof proves RightNeighbor is in the tree (nil if no right neighbor).
	RightProof *MerkleProof `json:"right_proof,omitempty"`

	// RepoRoot is the root the absence is proved against.
	RepoRoot types.Hash `json:"repo_root"`
}

type ChangeClass string

type ChangeClassification struct {
	// Class is the highest-severity change class detected.
	Class ChangeClass

	// BehavioralCount is the number of changed edge types classified as behavioral.
	BehavioralCount int
	// StructuralCount is the number of changed edge types classified as structural.
	StructuralCount int
	// RuntimeDriftCount is the number of changed edge types classified as runtime drift.
	RuntimeDriftCount int
	// MetadataCount is the number of changed edge types not in any other category.
	MetadataCount int

	// ChangedPackages from the underlying diff.
	ChangedPackages []string
	// ChangedEdgeTypes from the underlying diff (raw "package:edgeType" keys).
	ChangedEdgeTypes []string
}

type DiffOptions struct {
	// PackageFilter restricts the diff to the listed package paths. When
	// empty, all packages are compared (default behaviour).
	PackageFilter []string

	// MaxChanges caps the total number of changed/added/removed packages
	// reported. Once the cap is reached the diff is marked Truncated and no
	// further packages are added. 0 means no cap.
	MaxChanges int
}

type EdgeInput struct {
	EdgeHash    types.Hash
	PackagePath string // extracted from source node's qualified name
	EdgeType    string // calls, imports, implements, references, etc.
}

type GCStats struct {
	// SnapshotsRemoved is the number of old snapshots pruned from the chain.
	SnapshotsRemoved int

	// NodesRemoved is the number of orphaned nodes deleted from the graph.
	NodesRemoved int64

	// EdgesRemoved is the number of orphaned edges deleted from the graph.
	EdgesRemoved int64

	// Duration is the wall-clock time taken by the full GC run.
	Duration time.Duration
}

type HierarchicalDiff struct {
	// ChangedPackages lists packages whose root changed (content differs).
	ChangedPackages []string

	// AddedPackages lists packages present in new but not old.
	AddedPackages []string

	// RemovedPackages lists packages present in old but not new.
	RemovedPackages []string

	// ChangedEdgeTypes lists "package:edgeType" keys whose root changed.
	ChangedEdgeTypes []string

	// RootChanged is true if the overall repo root differs.
	RootChanged bool

	// Truncated is true when the diff was cut short by a MaxChanges cap.
	Truncated bool
}

type HierarchicalTree struct {
	Root types.Hash

	// PackageRoots maps package path to its Merkle root.
	// A package root is hash(sorted edge-type roots for that package).
	PackageRoots map[string]types.Hash

	// EdgeTypeRoots maps "package:edgeType" to its Merkle root.
	// An edge-type root is hash(sorted edge hashes of that type in that package).
	EdgeTypeRoots map[string]types.Hash

	// PackageEdgeCounts tracks edge count per package for quick stats.
	PackageEdgeCounts map[string]int

	// TotalEdges is the total number of edges across all packages.
	TotalEdges int
	// contains filtered or unexported fields
}

type MerkleProof struct {
	// The edge being proved.
	EdgeHash types.Hash `json:"edge_hash"`

	// Hierarchical context.
	PackagePath string `json:"package_path"`
	EdgeType    string `json:"edge_type"`

	// Level 1: edge hash -> edge-type root.
	// Binary proof within the sorted edge hashes of this (package, edgeType).
	EdgeToEdgeTypeRoot []ProofStep `json:"edge_to_edge_type_root"`
	EdgeTypeRoot       types.Hash  `json:"edge_type_root"`

	// Level 2: edge-type root -> package root.
	// Binary proof within the sorted edge-type roots of this package.
	EdgeTypeToPackageRoot []ProofStep `json:"edge_type_to_package_root"`
	PackageRoot           types.Hash  `json:"package_root"`

	// Level 3: package root -> repo root.
	// Binary proof within the sorted package roots.
	PackageToRepoRoot []ProofStep `json:"package_to_repo_root"`
	RepoRoot          types.Hash  `json:"repo_root"`
}

type MerkleTree struct {
	Root   types.Hash   // the Merkle root (top of the tree)
	Leaves []types.Hash // sorted leaf hashes (the input edge hashes)
}

type ProofStep struct {
	Sibling types.Hash `json:"sibling"`
	IsLeft  bool       `json:"is_left"` // true if sibling is on the left (target is right)
}

type SnapshotManager struct {
	// contains filtered or unexported fields
}

type VerifyError struct {
	Level          string     // "ERROR" or "WARN"
	Kind           string     // "dangling_edge", "hash_mismatch", "broken_chain", "missing_file"
	Hash           types.Hash // hash of the entity with the issue
	Message        string     // human-readable description
	Classification string     // for dangling_edge: "cross_repo", "stdlib", or "truly_dangling"
}