graph

const (
	EdgeContains EdgeKind = "contains"
	EdgeDeclares EdgeKind = "declares"
	EdgeImports  EdgeKind = "imports"
	EdgeExports  EdgeKind = "exports"
	EdgeCalls    EdgeKind = "calls"
	// EdgeTests is direct, uniquely resolved structural test evidence. Helper
	// expansion stays query-time and never persists synthetic transitive edges.
	EdgeTests       EdgeKind = "tests"
	EdgeEmbeds      EdgeKind = "embeds"
	EdgeExtends     EdgeKind = "extends"
	EdgeImplements  EdgeKind = "implements"
	EdgeReadsConfig EdgeKind = "reads_config"
	EdgeDefines     EdgeKind = "defines"
	EdgeExposes     EdgeKind = "exposes"
	EdgeHandledBy   EdgeKind = "handled_by"
	// uses_middleware connects an endpoint to one callable in its effective
	// outer-to-inner middleware chain. Order and framework form are edge
	// evidence, keeping the relation language-neutral.
	EdgeUsesMiddleware EdgeKind = "uses_middleware"
	EdgePublishes      EdgeKind = "publishes"
	EdgeSubscribes     EdgeKind = "subscribes"
	EdgeReferences     EdgeKind = "references"
	EdgeReads          EdgeKind = "reads"
	EdgeWrites         EdgeKind = "writes"
	// encodes and decodes connect application code to a language-neutral
	// protocol declaration. Field-level protocol access continues to use the
	// shared reads and writes relations, distinguished by edge properties.
	EdgeEncodes EdgeKind = "encodes"
	EdgeDecodes EdgeKind = "decodes"
	// sends and receives connect application code to a stable transport
	// operation callsite. carries connects that operation to a canonical
	// protocol message only when payload provenance proves the relationship.
	EdgeSends     EdgeKind = "sends"
	EdgeReceives  EdgeKind = "receives"
	EdgeCarries   EdgeKind = "carries"
	EdgeHasField  EdgeKind = "has_field"
	EdgeAssigns   EdgeKind = "assigns"
	EdgeReturns   EdgeKind = "returns"
	EdgePasses    EdgeKind = "passes"
	EdgeRequests  EdgeKind = "requests"
	EdgeDependsOn EdgeKind = "depends_on"
	EdgeDocuments EdgeKind = "documents"
	// generated_from connects a language binding projection to the canonical
	// declaration that defines its wire/schema identity. Generated source is
	// evidence for a projection, never a second schema authority.
	EdgeGeneratedFrom EdgeKind = "generated_from"

	// Failure-flow relations are language-neutral even though Go is currently
	// their only producer. returns_error describes a callable's typed result
	// contract; propagates_error and wraps_error describe actual exits;
	// handles_error records a consuming conditional action. panics, recovers,
	// and defers keep abrupt exits and cleanup separate from ordinary calls.
	// Recognition details such as return, join, comparison, switch, or recovery
	// live in the edge's "form" property.
	EdgeReturnsError    EdgeKind = "returns_error"
	EdgePropagatesError EdgeKind = "propagates_error"
	EdgeHandlesError    EdgeKind = "handles_error"
	EdgeWrapsError      EdgeKind = "wraps_error"
	EdgePanics          EdgeKind = "panics"
	EdgeRecovers        EdgeKind = "recovers"
	EdgeDefers          EdgeKind = "defers"

	// Godot composition relations. instantiates records a scene instance
	// (nested or inherited) and is deliberately distinct from extends so
	// scene composition is never mislabeled as language class inheritance.
	// attaches_script records a script bound to a scene node, scene, or
	// resource. autoloads records the target a project.godot autoload
	// declaration exposes globally.
	EdgeInstantiates   EdgeKind = "instantiates"
	EdgeAttachesScript EdgeKind = "attaches_script"
	EdgeAutoloads      EdgeKind = "autoloads"

	// Godot gameplay-interaction relations. uses_input_action records a read of
	// a declared input action; in_group records that a node belongs to (or
	// leaves) a node group; uses_group records a lookup of, or a dispatch to,
	// the members of a group without asserting membership.
	//
	// The operation that produced each edge lives in its "form" property rather
	// than in a separate edge kind, because direction and meaning are shared
	// within each relation: a group lookup and a group call both read the
	// group's members, and add_to_group and remove_from_group both name a
	// membership between the same two nodes. A membership test (is_in_group) is
	// deliberately a uses_group lookup and never an in_group edge: asking
	// whether a node is in a group is not evidence that it is.
	EdgeUsesInputAction EdgeKind = "uses_input_action"
	EdgeInGroup         EdgeKind = "in_group"
	EdgeUsesGroup       EdgeKind = "uses_group"
)

const (
	KindRepository NodeKind = "repository"
	KindComponent  NodeKind = "component"
	KindFile       NodeKind = "file"
	KindPackage    NodeKind = "package"
	KindModule     NodeKind = "module"
	KindFunction   NodeKind = "function"
	KindMethod     NodeKind = "method"
	// KindTest is a statically recognized test declaration. Subtype and
	// framework details remain properties so one language-neutral kind covers
	// Go tests, benchmarks, fuzz tests, examples, and Godot test methods.
	KindTest       NodeKind = "test"
	KindType       NodeKind = "type"
	KindClass      NodeKind = "class"
	KindInterface  NodeKind = "interface"
	KindField      NodeKind = "field"
	KindVariable   NodeKind = "variable"
	KindParameter  NodeKind = "parameter"
	KindTable      NodeKind = "table"
	KindView       NodeKind = "view"
	KindColumn     NodeKind = "column"
	KindIndex      NodeKind = "index"
	KindConfigKey  NodeKind = "config_key"
	KindEndpoint   NodeKind = "endpoint"
	KindEvent      NodeKind = "event"
	KindDocSection NodeKind = "document_section"
	KindExternal   NodeKind = "external"

	// Godot runtime composition vocabulary. Scenes and resources are the
	// engine's two text-resource forms, scene nodes are the tree a scene
	// declares, and an autoload is a globally available singleton declared in
	// project.godot. They are distinct kinds rather than generic modules and
	// variables so composition questions are answerable by kind and edge
	// instead of property inspection.
	KindGodotScene     NodeKind = "godot_scene"
	KindGodotResource  NodeKind = "godot_resource"
	KindGodotSceneNode NodeKind = "godot_scene_node"
	KindGodotAutoload  NodeKind = "godot_autoload"

	// Godot gameplay-interaction vocabulary. An input action is a named action
	// declared in a project.godot [input] section and read back by Input and
	// InputMap calls; a node group is a named set of scene nodes declared in a
	// [global_group] section and joined, tested, and dispatched to by name.
	// Both are project-scoped declarations rather than generic config keys, so
	// "who uses this action" and "who is in this group" are answerable by kind
	// and edge instead of by matching a key-name prefix.
	KindGodotInputAction NodeKind = "godot_input_action"
	KindGodotNodeGroup   NodeKind = "godot_node_group"

	// A transport operation is one evidence-backed send or receive callsite.
	// It is deliberately not a channel or peer node: equal channel values do
	// not establish communication between two endpoints.
	KindTransportOperation NodeKind = "transport_operation"
)

const (
	// MatchNone is the zero level, reported when a selector matched nothing.
	MatchNone NodeMatchLevel = ""
	// MatchQualifiedName means qualified_name equals the selector.
	MatchQualifiedName NodeMatchLevel = "qualified_name"
	// MatchName means name equals the selector.
	MatchName NodeMatchLevel = "name"
	// MatchSubstring means name or qualified_name contains the selector.
	MatchSubstring NodeMatchLevel = "substring"
)

const (
	LocalNodes    NodeVisibility = "local"
	ExternalNodes NodeVisibility = "external"
	AllNodes      NodeVisibility = "all"
)

const (
	IncomingRelations RelationDirection = "incoming"
	OutgoingRelations RelationDirection = "outgoing"
)