backend

type Arg struct {
	Name    string
	Value   Expr
	Missing bool
}

type AssignStmt struct {
	Name, Op string
	Value    Expr
}

type BackendSpec struct {
	ID           string
	Aliases      []string
	Capabilities []string
	Dialects     []string
}

type BinaryExpr struct {
	Op   string
	L, R Expr
}

type BlockStmt struct{ List []Stmt }

type BreakStmt struct{}

type CallExpr struct {
	Fun        Expr
	Args       []Arg
	Eager      bool // explicit call boundary, including decoded R force wrappers
	Resolution *SemanticCallResolution
}

type CapabilityMatrix struct {
	Features    []string              `json:"features"`
	Targets     []string              `json:"targets"`
	Native      matrixir.SparseMatrix `json:"native"`
	Lowering    matrixir.SparseMatrix `json:"lowering"`
	Emulated    matrixir.SparseMatrix `json:"emulated"`
	Unsupported matrixir.SparseMatrix `json:"unsupported"`
}

type CapabilityResult struct {
	Feature string           `json:"feature"`
	Backend string           `json:"backend"`
	Status  CapabilityStatus `json:"status"`
	Reason  string           `json:"reason,omitempty"`
}

type CapabilityStatus string

type DirectLoweringAnalysis struct {
	Schema              string                      `json:"schema"`
	Rows                []DirectLoweringRequirement `json:"rows"`
	AtomicObligations   []string                    `json:"atomic_obligations"`
	MissingVectors      map[string][]string         `json:"missing_vectors"`
	Classes             map[string][]string         `json:"classes"`
	Primitives          []string                    `json:"primitives"`
	ConnectedComponents int                         `json:"connected_components"`
	DataOnlyPrimitives  int                         `json:"data_only_primitives"`
	NewHandlerClasses   int                         `json:"new_handler_classes"`
}

type DirectLoweringContract struct {
	Target          string
	ProjectionClass string
	Primitive       string
	Handler         string
	RecipeIDs       []string
	TemplateID      string
	ProofStatus     string
}

type DirectLoweringRequirement struct {
	CandidateID, Target, ProjectionClass string
	UASF                                 []string
	Required, Existing, Missing          []string
	Classification                       string
}

type Doc interface {
	// contains filtered or unexported methods
}

type DocConcat struct{ Parts []Doc }

type DocHardLine struct{}

type DocIndent struct {
	By   string
	Body Doc
}

type DocText struct{ Text string }

type EmissionContractAnalysis struct {
	Contracts   []string
	Operations  []string
	Combinators []ProjectionObligationPrimitive
}

type EmissionHandlerClass string

type EmissionRecipe struct {
	ID         string
	Archetypes []string
	Operations []EmissionRecipeOperation
}

type EmissionRecipeChild struct {
	Role    string
	Ordinal int
	Doc     Doc
}

type EmissionRecipeInput struct {
	NodeID   int
	Children []EmissionRecipeChild
}

type EmissionRecipeOperation struct {
	Atomic  string
	Handler EmissionHandlerClass
	Slot    string
}

type EmissionRecipeRegistry struct {
	Recipes        map[string]EmissionRecipe
	HandlerClasses []EmissionHandlerClass
}

type ExecutionPrimitiveMatrixAnalysis struct {
	Schema                                                                                         string `json:"schema"`
	Targets, ProjectionClasses, Primitives                                                         []string
	E                                                                                              matrixir.SparseMatrix `json:"e"`
	R, S, SDirect, SClosed, M                                                                      matrixir.SparseMatrix
	Direct                                                                                         map[string]map[string]bool `json:"direct"`
	NativeSupportCells, DerivedSupportCells, ClosedSupportCells                                    int
	MissingCells, SemanticMissingCells, DirectCells, ExistingDirectCells, ReconstructedDirectCells int
	Contradictions                                                                                 []string `json:"contradictions"`
	UnknownSupportCells                                                                            int      `json:"unknown_support_cells"`
	ResidualClasses                                                                                int      `json:"residual_classes"`
	SolveObligations                                                                               int      `json:"solve_obligations"`
	NativeProven                                                                                   int      `json:"native_proven"`
	NativeImpossible                                                                               int      `json:"native_impossible"`
	Conflicts                                                                                      int      `json:"conflicts"`
	InsufficientProof                                                                              int      `json:"insufficient_proof"`
	ExecutableWitnessBefore                                                                        int      `json:"executable_witness_before"`
	RuntimeFallbackOnly                                                                            int      `json:"runtime_fallback_only"`
	MissingRegistryEdges                                                                           int      `json:"missing_registry_edges"`
	MissingDispatchEdges                                                                           int      `json:"missing_dispatch_edges"`
	MissingRecipeBindings                                                                          int      `json:"missing_recipe_bindings"`
	MissingRendererBindings                                                                        int      `json:"missing_renderer_bindings"`
	MissingHandlerBehaviors                                                                        int      `json:"missing_handler_behaviors"`
}

type Expr interface {
	// contains filtered or unexported methods
}

type ExprStmt struct{ X Expr }

type ForStmt struct {
	Name string
	Seq  Expr
	Body Stmt
}

type FrontendFactSink interface {
	AddNode(UniversalASTNode)
	AddField(FrontendFieldFact)
	AddSource(FrontendSourceFact)
	AddRole(FrontendRelationFact)
	AddOperand(FrontendRelationFact)
	AddSymbol(FrontendSymbolFact)
	AddBinding(FrontendRelationFact)
	AddRelation(FrontendRelationFact)
}

type FrontendFactsBuilder struct{ Facts FrontendSemanticFacts }

type FrontendFieldFact struct {
	NodeID int
	Name   string
	Value  json.RawMessage
}

type FrontendRelationFact struct {
	Kind        string
	From        int
	To          UniversalASTReference
	Role        string
	Ordinal     int
	EvidenceRef int
	Attributes  map[string]json.RawMessage
}

type FrontendReturnFact struct {
	ReturnNodeID   int
	FunctionNodeID int
	ValueNodeID    int
	Type           SemanticType
}

type FrontendSemanticFacts struct {
	SchemaVersion          int
	BasisSHA256            string
	SemanticDocumentSHA256 string
	LanguageProfile        string
	LanguageFacet          []float64
	Projection             string
	Evaluation             string
	ValueModel             string
	IndexBase              int
	Types                  SemanticTypeContract
	Origin                 SemanticOrigin
	Metadata               map[string]string
	Extensions             map[string]any
	Contracts              SemanticContracts
	Dialects               []SemanticDialect
	SemanticFeatures       *SemanticFeatureModel
	TypeTable              []SemanticTypeDefinition
	TypeGraph              matrixir.SparseMatrix
	TypeRelations          *SemanticTypeRelations

	Nodes     []UniversalASTNode
	Fields    []FrontendFieldFact
	Sources   []FrontendSourceFact
	TypesFact []FrontendTypeFact
	Symbols   []FrontendSymbolFact
	Bindings  []FrontendRelationFact
	Relations []FrontendRelationFact
	Returns   []FrontendReturnFact
	Evidence  SemanticEvidence

	// LanguageFacts is reserved for frontend-local, proved data. It is never
	// emitted unless it is represented by a permitted UAST field, facet or
	// relation above.
	LanguageFacts map[string]json.RawMessage
}

type FrontendSourceFact struct {
	NodeID int
	Span   SemanticSourceSpan
}

type FrontendSpec struct {
	ID           string
	Aliases      []string
	Extensions   []string
	Capabilities []string
	Dialects     []string
}

type FrontendSymbolFact struct {
	NodeID int
	Name   string
	Kind   string
}

type FrontendTypeFact struct {
	NodeID int
	Type   SemanticType
}

type FunctionExpr struct {
	Binding           string
	DefaultEvaluation string
	Params            []Param
	Body              *BlockStmt
}

type FunctionFlowEvidence struct {
	Name         string              `json:"name"`
	Entry        int                 `json:"entry"`
	Nodes        []string            `json:"nodes"`
	Always       matrixir.Matrix     `json:"always"`
	WhenTrue     matrixir.Matrix     `json:"when_true"`
	WhenFalse    matrixir.Matrix     `json:"when_false"`
	Reachable    matrixir.Vector     `json:"reachable"`
	Error        string              `json:"error,omitempty"`
	Cycles       matrixir.Vector     `json:"cycles"`
	StateMachine bool                `json:"state_machine"`
	Slots        []string            `json:"slots"`
	Reads        matrixir.Matrix     `json:"reads"`
	Writes       matrixir.Matrix     `json:"writes"`
	Defined      matrixir.Matrix     `json:"defined"`
	Initial      matrixir.Vector     `json:"initial"`
	Iterations   []IterationEvidence `json:"iterations,omitempty"`
}

type GoNativeFrontend struct{}

type HelperRequirement struct{ ID string }

type HelperSpec struct {
	ID, Target, RequiredCapability, Source string
	Dependencies                           []string
}

type IdentExpr struct{ Name string }

type IfStmt struct {
	Cond Expr
	Then Stmt
	Else Stmt
}

type ImplementationMatrix struct {
	Operations  []string              `json:"operations"`
	Stages      []string              `json:"stages"`
	Implemented matrixir.SparseMatrix `json:"implemented"`
	Unsupported matrixir.SparseMatrix `json:"unsupported"`
	Arity       matrixir.Vector       `json:"operand_count"`
	Results     []string              `json:"result_kinds"`
	Evidence    string                `json:"evidence_policy"`
	Languages   []string              `json:"languages"`
	Routes      matrixir.SparseMatrix `json:"declared_complete_operation_routes"`
}

type IndexExpr struct {
	X      Expr
	Args   []Arg
	Double bool
}

type IterationEvidence struct {
	Sequence        string          `json:"sequence_slot"`
	Position        string          `json:"position_slot"`
	Length          string          `json:"length_slot"`
	Element         string          `json:"element_slot"`
	Advance         matrixir.Matrix `json:"advance"`
	InitialPosition float64         `json:"initial_position"`
}

type IterationExpr struct {
	Kind  string
	Value Expr
}

type Language struct {
	ID        string
	Name      string
	Extension string
	Comment   string
}

type LiteralExpr struct{ Kind, Text string }

type NativeAnalysis struct {
	Schema                string                   `json:"schema"`
	Language              string                   `json:"language"`
	Executable            bool                     `json:"executable"`
	Events                []NativeEvent            `json:"events"`
	Syntax                matrixir.SparseMatrix    `json:"syntax"`
	Binding               matrixir.SparseMatrix    `json:"binding"`
	SameBinding           matrixir.SparseMatrix    `json:"same_binding"`
	Requirements          []string                 `json:"requirements"`
	Scopes                []SemanticScope          `json:"scopes"`
	ScopeMembership       matrixir.SparseMatrix    `json:"scope_membership"`
	TypeCheckArchitecture string                   `json:"type_check_architecture"`
	TypeTable             []SemanticTypeDefinition `json:"type_table"`
	TypeGraph             matrixir.SparseMatrix    `json:"type_graph"`
	TypeRelations         *SemanticTypeRelations   `json:"type_relations"`
}

type NativeEmissionInput struct {
	NodeID   int
	Children []EmissionRecipeChild
}

type NativeEvent struct {
	ID           int                `json:"id"`
	Kind         string             `json:"kind"`
	Name         string             `json:"name,omitempty"`
	Literal      string             `json:"literal,omitempty"`
	Type         SemanticType       `json:"type"`
	Source       SemanticSourceSpan `json:"source"`
	Binding      *int               `json:"binding,omitempty"`
	Declaration  bool               `json:"declaration,omitempty"`
	Operation    string             `json:"operation,omitempty"`
	ShortCircuit bool               `json:"short_circuit,omitempty"`
	Confidence   string             `json:"confidence"`
	Scope        int                `json:"scope"`
}

type NativeFrontend interface {
	Analyze(filename, source string) (*NativeAnalysis, error)
}

type NativeGoEvidenceFact struct {
	NodeID       int
	Kind, Detail string
}

type NativeGoNodeFact struct {
	ID, Parent                                           int
	Kind, Name, Operator, LiteralKind, LiteralValue      string
	SourceID, TypeID, SymbolID                           int
	Children                                             []int
	Fields                                               map[string]string
	ParameterRefs, ArgumentRefs, OperandRefs, ReturnRefs []int
	CallTargetRef, FunctionRef, ScopeRef                 int
}

type NativeGoRelationFact struct {
	Kind        string
	From, To    int
	Role        string
	Ordinal     int
	EvidenceRef int
}

type NativeGoSemanticFacts struct {
	FrontendSemanticFacts
	Root                                                                       *SemanticStatement
	Structure, Fields, Sources, Types, Symbols, Calls, Control, Data, Evidence int
	SourceFacts                                                                []NativeGoSourceFact
	TypeFacts                                                                  []NativeGoTypeFact
	SymbolFacts                                                                []NativeGoSymbolFact
	BindingFacts                                                               []NativeGoRelationFact
	RelationFacts                                                              []NativeGoRelationFact
	EvidenceFacts                                                              []NativeGoEvidenceFact
	Nodes                                                                      []NativeGoNodeFact
	RawUAST                                                                    *UniversalASTDocument
}

type NativeGoSourceFact struct {
	ID   int
	Span SemanticSourceSpan
}

type NativeGoSymbolFact struct {
	ID         int
	Name, Kind string
}

type NativeGoTypeFact struct {
	ID   int
	Type SemanticType
}

type NextStmt struct{}

type OperationExpr struct {
	Operation SemanticOperation
	Operands  []Expr
}

type Param struct {
	Mode    string
	Name    string
	Default Expr
	Type    *SemanticType // exact executable parameter type; nil is legacy dynamic
}

type ParsedNode struct {
	ID     int
	Kind   string
	Source *SemanticSourceSpan
}

type PreservationMode string

type PreservationRegistry struct{ Rules []PreservationRule }

type PreservationRule struct {
	Capability, Target          string
	Mode                        PreservationMode
	Preconditions, Requirements []string
	Handler, Test               string
}

type PrimitiveSpec struct {
	TableIndex string
	Name       string
	Kernel     string
	Arity      string
}

type ProductPathWitness struct{ Target, Primitive, Status, MissingFactor string }

type ProjectionDerivationRule struct {
	ID        string
	Input     string
	Output    string
	Transform string
}

type ProjectionGapInformation struct {
	GapID                 string
	ProjectionPrimitive   string
	RequiredInformation   string
	Class                 ProjectionGapInformationClass
	ExistingUASTElement   string
	DerivationRule        string
	TargetSyntaxParameter string
	SemanticGapID         string
	EvidenceSource        string
	Conflict              bool
}

type ProjectionGapInformationAnalysis struct {
	Rows   []ProjectionGapInformation
	Counts map[ProjectionGapInformationClass]int
}

type ProjectionGapInformationClass string

type ProjectionInformationIntegration struct {
	DirectBindings               []ProjectionGapInformation
	Derivations                  []ProjectionDerivationRule
	Syntax                       []ProjectionGapInformation
	PrimitiveInformationComplete map[string]bool
	PrimitiveEmissionComplete    map[string]bool
	DerivationClasses            []string
	TargetSyntaxCapabilities     []string
}

type ProjectionObligationAnalysis struct {
	Archetypes   []string
	Obligations  []string
	Primitives   []ProjectionObligationPrimitive
	Requirements map[string]map[string]bool // M_AO
}

type ProjectionObligationPrimitive struct {
	ID          string
	Archetypes  []string
	Obligations []string
}

type ProjectionPrimitiveReduction struct {
	Before            int
	Primitives        []ProjectionObligationPrimitive
	DuplicatesRemoved int
	Compositions      map[string][]string
	ExistingRenderers map[string][]string
	TargetSpecOnly    map[string]bool
	Rewrite           map[string][]string
	Helpers           map[string][]string
	Runtime           map[string][]string
	Irreducible       []string
}

type ProjectionPrimitiveTargetSupport struct {
	Target     string
	Primitive  string
	Available  bool
	Mode       PreservationMode
	Parameters map[string]string
}

type ProjectionRendererArchetype struct {
	ID                string   `json:"id"`
	ProjectionClasses []string `json:"projection_classes"`
	Signature         string   `json:"signature"`
	ExistingRenderers []string `json:"existing_renderers"`
	Implemented       bool     `json:"implemented"`
}

type ProjectionRendererBinding struct {
	Form       string
	RendererID string
	SourceFile string
	Function   string
	Reusable   bool
}

type ProjectionRendererCatalogEntry struct {
	RendererID         string   `json:"renderer_id"`
	SourceFile         string   `json:"source_file"`
	SourceFunction     string   `json:"source_function"`
	SyntacticCategory  string   `json:"syntactic_category"`
	RequiredChildren   []string `json:"required_children"`
	RequiredFields     []string `json:"required_fields"`
	RequiredRelations  []string `json:"required_relations"`
	TargetScope        string   `json:"target_scope"`
	ReturnsDocOrSource string   `json:"returns_doc_or_source"`
	Reusable           bool     `json:"reusable"`
}

type ProjectionRendererComposition struct {
	ArchetypeID string
	Primitives  []string
}

type ProjectionRendererHarvest struct {
	Catalog     []ProjectionRendererCatalogEntry `json:"catalog"`
	Archetypes  []ProjectionRendererArchetype    `json:"archetypes"`
	Assignments map[string]string                `json:"class_to_archetype"`
	Matches     []ProjectionRendererMatch        `json:"matches"`
}

type ProjectionRendererMatch struct {
	ArchetypeID string `json:"archetype_id"`
	RendererID  string `json:"renderer_id"`
	Compatible  bool   `json:"compatible"`
}

type ProjectionResidualAnalysis struct {
	Targets         []string
	Archetypes      []string
	Primitives      []string
	Rows            []ProjectionResidualCell
	Classes         []ProjectionResidualClass
	ColumnGapCounts map[string]int
	PrimitiveImpact map[string]int
	SetCounts       map[string]int
}

type ProjectionResidualCell struct {
	Target             string
	Archetype          string
	RequiredPrimitives []string
	Supported          []string
	Missing            []string
	AffectedUASFCells  int
}

type ProjectionResidualClass struct {
	ID                string
	MemberCount       int
	Targets           []string
	Archetypes        []string
	MissingPrimitives []string
	AffectedUASFCells int
}

type RepeatStmt struct{ Body Stmt }

type RequiredSemantics struct{ Structures, Relations, Facets, Fields []string }

type Requirement struct {
	ID                   string
	Kind                 RequirementKind
	Target               string
	Dependencies         []string
	Preconditions, Tests []string
	Emit                 string
}

type RequirementKind string

type RequirementRegistry struct{ Rules map[string]Requirement }

type ReturnStmt struct{ X Expr }

type RuntimeModule struct {
	ID, Target                                                        string
	ProvidedCapabilities, RequiredCapabilities, Dependencies, Imports []string
	Emit                                                              Doc
	Tests                                                             []string
}

type RuntimeModuleRegistry struct{ Modules map[string]RuntimeModule }

type RuntimePromotionAnalysis struct {
	Schema                 string                         `json:"schema"`
	Targets                []string                       `json:"targets"`
	ProjectionClasses      []string                       `json:"projection_classes"`
	RuntimeUASF            [][]string                     `json:"runtime_uasf"`
	RuntimeProjectionClass map[string]map[string]bool     `json:"runtime_projection_classes"`
	DirectProjectionClass  map[string]map[string]bool     `json:"direct_projection_classes"`
	Residual               map[string]map[string][]string `json:"direct_residual"`
	Promotable             map[string]map[string]bool     `json:"promotable"`
}

type RuntimePromotionEvidence struct {
	Source, Target, ProjectionClass, UASF, SourceID, Package, SourceHash string
}

type RuntimePromotionEvidenceSummary struct {
	Schema                   string `json:"schema"`
	SourceRecordsRead        int    `json:"source_records_read"`
	RelevantRuntimeMatches   int    `json:"relevant_runtime_matches"`
	DirectCandidates         int    `json:"direct_candidates"`
	NoDirectCandidate        int    `json:"no_direct_candidate"`
	NewProvenDirectContracts int    `json:"new_proven_direct_contracts"`
	RuntimeCellsPromoted     int    `json:"runtime_cells_promoted"`
	MLCPDRows                int    `json:"mlcpd_rows"`
	EcosystemPackages        int    `json:"ecosystem_packages"`
	CrossSourceConfirmed     int    `json:"cross_source_confirmed"`
	EmpiricalSemanticProven  int    `json:"empirical_semantic_proven"`
	Rejected                 int    `json:"rejected"`
	Conflicts                int    `json:"conflicts"`
	DirectBefore             int    `json:"direct_before"`
	RuntimeBefore            int    `json:"runtime_before"`
	DirectAfter              int    `json:"direct_after"`
	RuntimeAfter             int    `json:"runtime_after"`
	MLCPDInputState          string `json:"mlcpd_input_state"`
}

type RuntimeTaintCell struct {
	Target, Fixture, Primitive, NativeError, RuntimeError, SyntaxFailure   string
	NativeReached, PureNative, RuntimeFallback, SyntaxChecked, SyntaxValid bool
	TaintArtifacts                                                         []string
}

type RuntimeTaintFixture struct {
	ID, Source string
	Primitives []string
}

type RuntimeTaintReport struct {
	Artifacts []string `json:"artifacts"`
}

type SemanticArgument struct {
	Name    string              `json:"name,omitempty"`
	Missing bool                `json:"missing,omitempty"`
	Value   *SemanticExpression `json:"value,omitempty"`
}

type SemanticBinding struct {
	ID         int    `json:"id"`
	Name       string `json:"name"`
	Scope      int    `json:"scope"`
	Mutable    bool   `json:"mutable"`
	Definition int    `json:"definition"`
	TypeOrigin string `json:"type_origin"`
}

type SemanticCallCandidate struct {
	Name        string       `json:"name"`
	Declaration string       `json:"declaration"`
	Type        SemanticType `json:"type,omitempty"`
}

type SemanticCallResolution struct {
	Candidates     []SemanticCallCandidate `json:"candidates"`
	Obligations    []string                `json:"obligations"`
	Required       matrixir.Matrix         `json:"required"`
	Satisfied      matrixir.Matrix         `json:"satisfied"`
	ConversionCost matrixir.Matrix         `json:"conversion_cost"`
	Priority       []float64               `json:"priority"`
	Selected       *int                    `json:"selected"`
}

type SemanticContracts struct {
	Requires   []string `json:"requires,omitempty"`
	Ensures    []string `json:"ensures,omitempty"`
	Invariants []string `json:"invariants,omitempty"`
}

type SemanticDialect struct {
	Name         string                     `json:"name"`
	Capabilities []string                   `json:"capabilities"`
	Operations   []SemanticDialectOperation `json:"operations"`
}

type SemanticDialectOperation struct {
	ID         string         `json:"id"`
	Kind       string         `json:"kind"`
	Attributes map[string]any `json:"attributes,omitempty"`
}

type SemanticDocument struct {
	SchemaVersion    int                      `json:"schema_version"`
	Schema           string                   `json:"schema"`
	Evaluation       string                   `json:"evaluation"`
	ValueModel       string                   `json:"value_model"`
	IndexBase        int                      `json:"index_base"`
	Types            SemanticTypeContract     `json:"type_contract"`
	Origin           SemanticOrigin           `json:"origin"`
	Metadata         map[string]string        `json:"metadata,omitempty"`
	Extensions       map[string]any           `json:"extensions,omitempty"`
	Contracts        SemanticContracts        `json:"contracts,omitempty"`
	Dialects         []SemanticDialect        `json:"dialects,omitempty"`
	SemanticFeatures *SemanticFeatureModel    `json:"semantic_features,omitempty"`
	UniversalAST     *UniversalASTDocument    `json:"universal_ast,omitempty"`
	TypeTable        []SemanticTypeDefinition `json:"type_table,omitempty"`
	TypeGraph        matrixir.SparseMatrix    `json:"type_graph,omitempty"`
	TypeRelations    *SemanticTypeRelations   `json:"type_relations,omitempty"`
	Root             SemanticStatement        `json:"root"`
	Evidence         SemanticEvidence         `json:"evidence"`
}

type SemanticEffectSummary struct {
	Counts           map[string]int `json:"counts"`
	ConservativePure bool           `json:"conservative_pure"`
	Unknown          bool           `json:"unknown"`
}

type SemanticEvidence struct {
	Nodes        []SemanticNode        `json:"nodes"`
	TypeAxes     []string              `json:"type_axes"`
	EffectAxes   []string              `json:"effect_axes"`
	Types        matrixir.SparseMatrix `json:"types"`
	Effects      matrixir.SparseMatrix `json:"effects"`
	Syntax       matrixir.SparseMatrix `json:"syntax"`
	Control      matrixir.SparseMatrix `json:"control"`
	Data         matrixir.SparseMatrix `json:"data"`
	Binding      matrixir.SparseMatrix `json:"binding"`
	Order        matrixir.SparseMatrix `json:"evaluation_order"`
	CallModes    matrixir.SparseMatrix `json:"call_modes"`
	CallModeAxes []string              `json:"call_mode_axes"`
	Scope        matrixir.SparseMatrix `json:"scope_membership"`
	Scopes       []SemanticScope       `json:"scopes"`
	Bindings     []SemanticBinding     `json:"bindings"`
	Contract     matrixir.Vector       `json:"contract"`
	ContractAxes []string              `json:"contract_axes"`
}

type SemanticExpression struct {
	Operation   *SemanticOperation      `json:"typed_operation,omitempty"`
	ID          int                     `json:"id"`
	Kind        string                  `json:"kind"`
	Scope       int                     `json:"scope"`
	Type        SemanticType            `json:"type,omitempty"`
	TypeOrigin  string                  `json:"type_origin,omitempty"`
	Semantics   SemanticSemantics       `json:"semantics,omitempty"`
	Effects     []string                `json:"effects,omitempty"`
	Binding     *int                    `json:"binding,omitempty"`
	Source      *SemanticSourceSpan     `json:"source,omitempty"`
	Attributes  map[string]any          `json:"attributes,omitempty"`
	Extensions  map[string]any          `json:"extensions,omitempty"`
	Name        string                  `json:"name,omitempty"`
	Operator    string                  `json:"operator,omitempty"`
	LiteralKind string                  `json:"literal_kind,omitempty"`
	Text        string                  `json:"text,omitempty"`
	Left        *SemanticExpression     `json:"left,omitempty"`
	Right       *SemanticExpression     `json:"right,omitempty"`
	Value       *SemanticExpression     `json:"value,omitempty"`
	Function    *SemanticFunction       `json:"function,omitempty"`
	Arguments   []SemanticArgument      `json:"arguments,omitempty"`
	Resolution  *SemanticCallResolution `json:"call_resolution,omitempty"`
	DoubleIndex bool                    `json:"double_index,omitempty"`
}

type SemanticFeatureBasis struct {
	Schema                 string            `json:"schema"`
	Languages              []string          `json:"languages"`
	Features               []string          `json:"features"`
	LanguageFeature        matrixir.Matrix   `json:"language_feature"`
	DialectFeatures        []string          `json:"dialect_features"`
	LanguageDialectFeature matrixir.Matrix   `json:"language_dialect_feature"`
	DialectObserved        matrixir.Vector   `json:"dialect_observed"`
	NodeKinds              []string          `json:"node_kinds"`
	FeatureNode            matrixir.Matrix   `json:"feature_node"`
	RelationKinds          []string          `json:"relation_kinds"`
	FeatureRelation        matrixir.Matrix   `json:"feature_relation"`
	Provenance             map[string]string `json:"provenance"`
}

type SemanticFeatureModel struct {
	BasisSHA256       string               `json:"basis_sha256"`
	Basis             SemanticFeatureBasis `json:"basis"`
	ProfileLanguage   string               `json:"profile_language"`
	LanguageSelection matrixir.Vector      `json:"language_selection"`
	FeatureDemand     matrixir.Vector      `json:"feature_demand"`
	DialectDemand     matrixir.Vector      `json:"dialect_demand"`
	NodeDemand        matrixir.Vector      `json:"node_demand"`
	RelationDemand    matrixir.Vector      `json:"relation_demand"`
}

type SemanticField struct {
	Name string       `json:"name"`
	Type SemanticType `json:"type"`
}

type SemanticFunction struct {
	Binding           string              `json:"binding,omitempty"`
	DefaultEvaluation string              `json:"default_evaluation,omitempty"`
	Parameters        []SemanticParameter `json:"parameters"`
	Body              SemanticStatement   `json:"body"`
}

type SemanticNode struct {
	ID     int    `json:"id"`
	Kind   string `json:"kind"`
	Symbol string `json:"symbol,omitempty"`
	Scope  int    `json:"scope"`
}

type SemanticNominalRelations struct {
	Identities  []string              `json:"identities"`
	Definitions matrixir.SparseMatrix `json:"definitions"`
	References  matrixir.SparseMatrix `json:"references"`
	Resolution  matrixir.SparseMatrix `json:"resolution"`
	Unresolved  []int                 `json:"unresolved"`
}

type SemanticObservation struct {
	Stdout  string                `json:"stdout"`
	Error   string                `json:"error,omitempty"`
	Effects SemanticEffectSummary `json:"effects"`
}

type SemanticOperation struct {
	Name string       `json:"name"`
	Type SemanticType `json:"type"`
	Text string       `json:"text,omitempty"`
}

type SemanticOrigin struct {
	SourceLanguage string   `json:"source_language"`
	SourceVersion  string   `json:"source_version,omitempty"`
	EntryPoint     string   `json:"entry_point"`
	Modules        []string `json:"modules"`
}

type SemanticParameter struct {
	Mode    string              `json:"mode,omitempty"`
	ID      int                 `json:"id"`
	Name    string              `json:"name"`
	Type    SemanticType        `json:"type,omitempty"`
	Passing string              `json:"passing,omitempty"`
	Default *SemanticExpression `json:"default,omitempty"`
}

type SemanticParameterVisitor interface {
	EnterParameter(*SemanticParameter) error
}

type SemanticProgram struct {
	Body             *BlockStmt            `json:"-"`
	Evaluation       string                `json:"evaluation"`
	ValueModel       string                `json:"value_model"`
	IndexBase        int                   `json:"index_base"`
	Types            SemanticTypeContract  `json:"type_contract"`
	Origin           SemanticOrigin        `json:"origin"`
	Metadata         map[string]string     `json:"metadata,omitempty"`
	Extensions       map[string]any        `json:"extensions,omitempty"`
	Contracts        SemanticContracts     `json:"contracts,omitempty"`
	Dialects         []SemanticDialect     `json:"dialects,omitempty"`
	SemanticFeatures *SemanticFeatureModel `json:"semantic_features,omitempty"`
	UniversalAST     *UniversalASTDocument `json:"universal_ast,omitempty"`
	Evidence         SemanticEvidence      `json:"evidence"`
	// contains filtered or unexported fields
}

type SemanticScope struct {
	ID     int    `json:"id"`
	Kind   string `json:"kind"`
	Parent int    `json:"parent"`
}

type SemanticSemantics struct {
	Operation       string `json:"operation,omitempty"`
	Dispatch        string `json:"dispatch,omitempty"`
	Overflow        string `json:"overflow,omitempty"`
	EvaluationOrder string `json:"evaluation_order,omitempty"`
	ShortCircuit    bool   `json:"short_circuit,omitempty"`
	IndexBase       int    `json:"index_base,omitempty"`
	NegativeIndex   string `json:"negative_index,omitempty"`
	OutOfBounds     string `json:"out_of_bounds,omitempty"`
	Slicing         string `json:"slicing,omitempty"`
	ErrorModel      string `json:"error_model,omitempty"`
	Confidence      string `json:"confidence,omitempty"`
}

type SemanticSourceSpan struct {
	File        string `json:"file,omitempty"`
	StartOffset int    `json:"start_offset,omitempty"`
	EndOffset   int    `json:"end_offset,omitempty"`
	StartLine   int    `json:"start_line,omitempty"`
	StartColumn int    `json:"start_column,omitempty"`
	EndLine     int    `json:"end_line,omitempty"`
	EndColumn   int    `json:"end_column,omitempty"`
}

type SemanticStatement struct {
	ID         int                 `json:"id"`
	Kind       string              `json:"kind"`
	Scope      int                 `json:"scope"`
	Type       SemanticType        `json:"type,omitempty"`
	TypeOrigin string              `json:"type_origin,omitempty"`
	Semantics  SemanticSemantics   `json:"semantics,omitempty"`
	Effects    []string            `json:"effects,omitempty"`
	Source     *SemanticSourceSpan `json:"source,omitempty"`
	Attributes map[string]any      `json:"attributes,omitempty"`
	Extensions map[string]any      `json:"extensions,omitempty"`
	Name       string              `json:"name,omitempty"`
	AssignOp   string              `json:"assign_op,omitempty"`
	Expression *SemanticExpression `json:"expression,omitempty"`
	Condition  *SemanticExpression `json:"condition,omitempty"`
	Sequence   *SemanticExpression `json:"sequence,omitempty"`
	Then       *SemanticStatement  `json:"then,omitempty"`
	Else       *SemanticStatement  `json:"else,omitempty"`
	Body       *SemanticStatement  `json:"body,omitempty"`
	Statements []SemanticStatement `json:"statements,omitempty"`
}

type SemanticType struct {
	Identity       string             `json:"identity,omitempty"`
	Reference      bool               `json:"reference,omitempty"`
	Kind           string             `json:"kind,omitempty"`
	Name           string             `json:"name,omitempty"`
	Bits           int                `json:"bits,omitempty"`
	Signed         *bool              `json:"signed,omitempty"`
	IEEE754        bool               `json:"ieee754,omitempty"`
	Element        *SemanticType      `json:"element,omitempty"`
	Key            *SemanticType      `json:"key,omitempty"`
	Value          *SemanticType      `json:"value,omitempty"`
	Parameters     []SemanticType     `json:"parameters,omitempty"`
	Result         *SemanticType      `json:"result,omitempty"`
	Fields         []SemanticField    `json:"fields,omitempty"`
	Length         int                `json:"length,omitempty"`
	Rows           int                `json:"rows,omitempty"`
	Columns        int                `json:"columns,omitempty"`
	Constraints    []string           `json:"constraints,omitempty"`
	Nullable       string             `json:"nullable,omitempty"`
	Ownership      string             `json:"ownership,omitempty"`
	Lifetime       string             `json:"lifetime,omitempty"`
	TypeOrigin     string             `json:"type_origin,omitempty"`
	TypeParameters []SemanticType     `json:"type_parameters,omitempty"`
	TypeArguments  []SemanticType     `json:"type_arguments,omitempty"`
	Constraint     *SemanticType      `json:"constraint,omitempty"`
	Embedded       []SemanticType     `json:"embedded,omitempty"`
	Methods        []SemanticField    `json:"methods,omitempty"`
	Terms          []SemanticTypeTerm `json:"terms,omitempty"`
}

type SemanticTypeContract struct {
	SchemaVersion int    `json:"schema_version"`
	Numeric       string `json:"numeric"`
	IntegerWidth  string `json:"integer_width"`
	Text          string `json:"text"`
	Truth         string `json:"truth"`
	Null          string `json:"null"`
	Collection    string `json:"collection"`
	Pointer       string `json:"pointer"`
	Ownership     string `json:"ownership"`
	ABI           string `json:"abi"`
}

type SemanticTypeDefinition struct {
	ID   int          `json:"id"`
	Type SemanticType `json:"type"`
}

type SemanticTypeEdge struct {
	Role       string `json:"role"`
	Index      int    `json:"index"`
	Name       string `json:"name,omitempty"`
	Underlying bool   `json:"underlying,omitempty"`
}

type SemanticTypeEquivalence struct {
	Equivalent matrixir.SparseMatrix `json:"equivalent"`
	Unknown    []int                 `json:"unknown"`
	Rounds     int                   `json:"refinement_rounds"`
}

type SemanticTypeRelations struct {
	Occurrences []string                  `json:"occurrences"`
	Uses        matrixir.SparseMatrix     `json:"uses"`
	Edges       []SemanticTypeEdge        `json:"edges"`
	Parents     matrixir.SparseMatrix     `json:"parents"`
	Children    matrixir.SparseMatrix     `json:"children"`
	UsageCounts []int                     `json:"usage_counts"`
	Nominal     *SemanticNominalRelations `json:"nominal,omitempty"`
	Equivalence *SemanticTypeEquivalence  `json:"equivalence,omitempty"`
}

type SemanticTypeTerm struct {
	Type       SemanticType `json:"type"`
	Underlying bool         `json:"underlying,omitempty"`
}

type SemanticVisitor interface {
	EnterStatement(*SemanticStatement) error
	LeaveStatement(*SemanticStatement) error
	EnterExpression(*SemanticExpression) error
	LeaveExpression(*SemanticExpression) error
}

type SignatureArgument struct {
	Name   string `json:"name,omitempty"`
	Spread bool   `json:"spread,omitempty"`
}

type SignatureBinding struct {
	ParameterArguments matrixir.SparseMatrix `json:"parameter_arguments"`
	UseDefaults        []int                 `json:"use_defaults"`
	ArgumentCounts     []int                 `json:"argument_counts"`
}

type SignatureParameter struct {
	Name       string `json:"name"`
	Passing    string `json:"passing"`
	HasDefault bool   `json:"has_default"`
}

type Stmt interface {
	// contains filtered or unexported methods
}

type StructureProjectionContract struct {
	StructureKind       string   `json:"structure_kind"`
	ProjectionClass     string   `json:"projection_class"`
	ProjectionForm      string   `json:"projection_form"`
	SyntacticCategory   string   `json:"syntactic_category"`
	ChildRelations      []string `json:"child_relations"`
	RequiredFields      []string `json:"required_fields"`
	ExecutionPrimitives []string `json:"execution_primitives"`
	PrecedenceRole      string   `json:"precedence_role"`
	BlockPolicy         string   `json:"block_policy"`
	TerminatorPolicy    string   `json:"terminator_policy"`
	EmissionPolicy      string   `json:"emission_policy"`
	Implemented         bool     `json:"implemented"`
}

type StructuredConstructInput struct {
	Family       string
	NodeKind     string
	Roles        []matrixir.CanonicalRoleFact
	Operands     []matrixir.CanonicalOperandFact
	Bindings     []matrixir.CanonicalBindingFact
	Types        []matrixir.CanonicalSymbolFact
	Fields       map[string]string
	SourceOffset int
}

type TargetCapabilityDecision struct {
	Direct, Rewrite, Helper, Emulate, Runtime, Unsupported []string
}

type TargetImportSpec struct {
	RuntimeRequirement string `json:"runtime_requirement"`
	Ordering           string `json:"ordering"`
	Prelude            string `json:"-"`
}

type TargetLiteralSpec struct {
	True        string `json:"true"`
	False       string `json:"false"`
	Null        string `json:"null"`
	StringQuote string `json:"string_quote"`
	StringWrap  string `json:"string_wrap"`
	NumberWrap  string `json:"number_wrap"`
	NumberRule  string `json:"number_rule"`
}

type TargetNamingSpec struct {
	CaseSensitive    bool   `json:"case_sensitive"`
	StyleInsensitive bool   `json:"style_insensitive"`
	GeneratedPrefix  string `json:"generated_prefix"`
}

type TargetOperatorSpec struct {
	Spelling      string `json:"spelling"`
	Precedence    int    `json:"precedence"`
	Associativity string `json:"associativity"`
	Fixity        string `json:"fixity"`
}

type TargetProjectionSpec struct {
	Mode         PreservationMode `json:"mode"`
	Requirements []string         `json:"requirements,omitempty"`
}

type TargetSpec struct {
	ID                  string                          `json:"id"`
	Aliases             []string                        `json:"aliases"`
	Capabilities        []string                        `json:"capabilities"`
	StatementTerminator string                          `json:"statement_terminator"`
	ChildSeparator      string                          `json:"child_separator"`
	Indent              string                          `json:"indent"`
	BlockOpen           string                          `json:"block_open"`
	BlockClose          string                          `json:"block_close"`
	Hooks               []string                        `json:"hooks"`
	Operators           map[string]TargetOperatorSpec   `json:"operators"`
	Types               map[string]string               `json:"types"`
	Literals            TargetLiteralSpec               `json:"literals"`
	Naming              TargetNamingSpec                `json:"naming"`
	Imports             TargetImportSpec                `json:"imports"`
	TypedOperations     TargetTypedOperationSpec        `json:"typed_operations"`
	ProjectionForms     map[string]TargetProjectionSpec `json:"projection_forms"`
	SyntaxTokens        map[string]string               `json:"syntax_tokens"`
}

type TargetStructureSyntaxCell struct {
	Target          string
	StructureKind   string
	ProjectionClass string
	TemplateID      string
	ProjectionForm  string
	Complete        bool
	MissingReason   string
}

type TargetSyntaxCheck struct {
	Checked bool   `json:"checked"`
	Valid   bool   `json:"valid"`
	Tool    string `json:"tool,omitempty"`
	Failure string `json:"failure,omitempty"`
}

type TargetSyntaxTemplate struct {
	ID              string
	Signature       string
	ProjectionForms []string
	RecipeIDs       []string
	Available       bool
}

type TargetSyntaxTemplateAnalysis struct {
	Templates        []TargetSyntaxTemplate
	Cells            []TargetSyntaxTemplateCell
	StructureCells   []TargetStructureSyntaxCell
	ExistingMatches  int
	MissingTemplate  int
	MissingParameter int
}

type TargetSyntaxTemplateCell struct {
	Target          string
	ProjectionClass string
	TemplateID      string
	SyntaxSignature string
	ProjectionForm  string
	RecipeIDs       []string
	Complete        bool
	MissingReason   string
	Parameters      map[string]string
}

type TargetSyntaxTemplateForm struct {
	ProjectionForm string
	RendererID     string
}

type TargetTypedOperationSpec struct{ Form, Runtime, ArgumentsOpen, ArgumentsClose, SignedTrue, SignedFalse string }

type UASTBackendAuditReport struct {
	CanonicalInput                 string                        `json:"canonical_input"`
	UniversalCoreUASTOnly          bool                          `json:"universal_core_uast_only"`
	ProductiveLegacyASTDependency  bool                          `json:"productive_legacy_ast_dependency"`
	SourceLanguageSemanticBranches int                           `json:"source_language_semantic_branches"`
	FrontendSemanticBoundaries     int                           `json:"frontend_semantic_conversion_boundaries"`
	BackendSemanticBoundaries      int                           `json:"backend_semantic_conversion_boundaries"`
	Targets                        []UASTTargetBackendAudit      `json:"targets"`
	Compatibility                  UASTSourceTargetCompatibility `json:"source_target_compatibility"`
}

type UASTBackendPath struct {
	Name     string `json:"name"`
	Mode     string `json:"mode"`
	Function string `json:"function"`
}

type UASTCapabilityPlane struct {
	Rows             []string              `json:"rows"`
	Targets          []string              `json:"targets"`
	Direct           matrixir.SparseMatrix `json:"direct"`
	LoweringRequired matrixir.SparseMatrix `json:"lowering_required"`
	RuntimeRequired  matrixir.SparseMatrix `json:"runtime_required"`
	Unsupported      matrixir.SparseMatrix `json:"unsupported"`
	Unknown          matrixir.SparseMatrix `json:"unknown"`
}

type UASTConsumerKind string

type UASTDirectExecutionItem struct {
	Category                   string   `json:"category"`
	Name                       string   `json:"name"`
	Projected                  bool     `json:"projected"`
	CurrentlyDirect            bool     `json:"currently_direct"`
	CurrentlyViaLegacyAdapter  bool     `json:"currently_via_legacy_adapter"`
	RepresentableNotExecutable bool     `json:"representable_not_executable"`
	StoredOnly                 bool     `json:"stored_only,omitempty"`
	DirectTargets              []string `json:"direct_targets,omitempty"`
	LowerableTargets           []string `json:"lowerable_targets,omitempty"`
	RuntimeRequiredTargets     []string `json:"runtime_required_targets,omitempty"`
	UnsupportedTargets         []string `json:"unsupported_targets,omitempty"`
	UnknownTargets             []string `json:"unknown_targets,omitempty"`
}

type UASTDirectExecutionReport struct {
	Schema             string                       `json:"schema"`
	BasisSHA256        string                       `json:"basis_sha256"`
	Summary            map[string]map[string]int    `json:"summary"`
	Items              []UASTDirectExecutionItem    `json:"items"`
	BackendPaths       []UASTBackendPath            `json:"backend_paths"`
	TargetCapabilities UASTTargetCapabilityMatrix   `json:"target_capabilities"`
	TargetPreservation UASTTargetPreservationMatrix `json:"target_preservation"`
	Execution          UASTExecutionAnalysis        `json:"execution"`
	EndToEnd           UASTEndToEndCapabilityReport `json:"end_to_end"`
	BackendAudit       UASTBackendAuditReport       `json:"backend_audit"`
}

type UASTEndToEndCapabilityPlane struct {
	Rows               []string              `json:"rows"`
	Representable      matrixir.SparseMatrix `json:"representable"`
	Frontend           matrixir.SparseMatrix `json:"frontend"`
	Enrichment         matrixir.SparseMatrix `json:"enrichment"`
	Evidence           matrixir.SparseMatrix `json:"evidence"`
	Normalize          matrixir.SparseMatrix `json:"normalize"`
	Backend            matrixir.SparseMatrix `json:"backend"`
	Target             matrixir.SparseMatrix `json:"target"`
	Test               matrixir.SparseMatrix `json:"test"`
	Full               matrixir.SparseMatrix `json:"full"`
	RepresentationOnly matrixir.SparseMatrix `json:"representation_only"`
	FrontendGap        matrixir.SparseMatrix `json:"frontend_gap"`
	EnrichmentGap      matrixir.SparseMatrix `json:"enrichment_gap"`
	EvidenceGap        matrixir.SparseMatrix `json:"evidence_gap"`
	BackendGap         matrixir.SparseMatrix `json:"backend_gap"`
	TargetGap          matrixir.SparseMatrix `json:"target_gap"`
	TestGap            matrixir.SparseMatrix `json:"test_gap"`
}

type UASTEndToEndCapabilityReport struct {
	Structures UASTEndToEndCapabilityPlane `json:"structures"`
	Relations  UASTEndToEndCapabilityPlane `json:"relations"`
	Facets     UASTEndToEndCapabilityPlane `json:"facets"`
	Fields     UASTEndToEndCapabilityPlane `json:"fields"`
	Summary    map[string]map[string]int   `json:"summary"`
}

type UASTExecutionAnalysis struct {
	Schema                    string                        `json:"schema"`
	BasisSHA256               string                        `json:"basis_sha256"`
	Primitives                []UASTExecutionPrimitiveSpec  `json:"primitives"`
	Capabilities              []string                      `json:"capabilities"`
	Structures                []string                      `json:"structures"`
	Relations                 []string                      `json:"relations"`
	Fields                    []string                      `json:"fields"`
	MCE                       matrixir.SparseMatrix         `json:"m_ce"`
	MSE                       matrixir.SparseMatrix         `json:"m_se"`
	MRE                       matrixir.SparseMatrix         `json:"m_re"`
	MDE                       matrixir.SparseMatrix         `json:"m_de"`
	Implemented               matrixir.Vector               `json:"exec_primitive_implemented"`
	Executable                matrixir.Vector               `json:"executable_uasf"`
	ExecutableStructures      matrixir.Vector               `json:"executable_structures"`
	ExecutableRelations       matrixir.Vector               `json:"executable_relations"`
	ExecutableFields          matrixir.Vector               `json:"executable_fields"`
	ProductivelyConsumed      matrixir.Vector               `json:"productively_consumed_uasf"`
	ConsumerCoverage          map[string][]UASTConsumerKind `json:"consumer_coverage"`
	Missing                   matrixir.SparseMatrix         `json:"missing_primitives"`
	GlobalMissing             map[string]int                `json:"global_missing_primitives"`
	EquivalenceClasses        []UASTExecutionClass          `json:"execution_equivalence_classes"`
	ProductiveLegacyRelations int                           `json:"productive_legacy_semantic_dependencies"`
}

type UASTExecutionClass struct {
	ID                 string   `json:"id"`
	UASFMembers        []string `json:"uasf_members"`
	ExecutionSignature string   `json:"execution_signature"`
	RequiredPrimitives []string `json:"required_primitives"`
}

type UASTExecutionPrimitive string

type UASTExecutionPrimitiveSpec struct {
	ID          UASTExecutionPrimitive `json:"id"`
	Implemented bool                   `json:"implemented"`
	Handler     string                 `json:"handler,omitempty"`
	Consumers   []UASTConsumerKind     `json:"consumers,omitempty"`
}

type UASTExecutionRegistry struct {
	Primitives      []UASTExecutionPrimitiveSpec
	SemanticAxis    map[string][]UASTExecutionPrimitive
	RelationAxis    map[string][]UASTExecutionPrimitive
	StructuralLayer map[string][]UASTExecutionPrimitive
	Relation        map[string][]UASTExecutionPrimitive
	Field           map[string][]UASTExecutionPrimitive
}

type UASTExecutionStatus string

type UASTPreservationAnalysis struct {
	Schema               string                             `json:"schema"`
	BasisSHA256          string                             `json:"basis_sha256"`
	Capabilities         []string                           `json:"capabilities"`
	Targets              []string                           `json:"targets"`
	Primitives           []UASTPreservationPrimitive        `json:"primitives"`
	MCP                  matrixir.SparseMatrix              `json:"m_cp"`
	MTP                  matrixir.SparseMatrix              `json:"m_tp"`
	Contracts            []UASTPreservationContract         `json:"m_ctp"`
	EquivalenceClasses   []UASTPreservationEquivalenceClass `json:"preservation_equivalence_classes"`
	GlobalMissing        map[string]int                     `json:"global_missing_preservation_primitives"`
	ErrorReasons         map[string]int                     `json:"error_reasons"`
	Unclassified         int                                `json:"unclassified"`
	ProductiveLegacyDeps int                                `json:"productive_legacy_semantic_dependencies"`
}

type UASTPreservationContract struct {
	Target              string           `json:"target"`
	UASF                string           `json:"uasf"`
	CurrentMode         PreservationMode `json:"current_mode"`
	RequiredPrimitives  []string         `json:"required_primitives"`
	AvailablePrimitives []string         `json:"available_primitives"`
	MissingPrimitives   []string         `json:"missing_primitives"`
	ErrorReason         string           `json:"error_reason,omitempty"`
	FallbacksChecked    []string         `json:"fallbacks_checked"`
}

type UASTPreservationEquivalenceClass struct {
	ID                 string           `json:"class_id"`
	Targets            []string         `json:"targets"`
	UASFMembers        []string         `json:"uasf_members"`
	RequiredPrimitives []string         `json:"required_primitives"`
	CurrentMode        PreservationMode `json:"current_mode"`
	MissingPrimitives  []string         `json:"missing_primitives"`
	ErrorReason        string           `json:"error_reason,omitempty"`
}

type UASTPreservationPrimitive struct {
	ID        string                 `json:"id"`
	Execution UASTExecutionPrimitive `json:"execution_primitive"`
}

type UASTSourceTargetCompatibility struct {
	Sources     []string              `json:"sources"`
	Targets     []string              `json:"targets"`
	Full        matrixir.SparseMatrix `json:"full"`
	Partial     matrixir.SparseMatrix `json:"partial"`
	Unsupported matrixir.SparseMatrix `json:"unsupported"`
}

type UASTStructureProjectionRegistry struct {
	Schema           string                        `json:"schema"`
	BasisSHA256      string                        `json:"basis_sha256"`
	Contracts        []StructureProjectionContract `json:"contracts"`
	Classes          map[string][]string           `json:"classes"`
	ClassProjectable map[string]bool               `json:"class_projectable"`
	FieldUse         map[string]string             `json:"field_use"`
	RelationUse      map[string]string             `json:"relation_use"`
}

type UASTTargetBackendAudit struct {
	Language                 string         `json:"language"`
	UASTDirect               bool           `json:"uast_direct"`
	LegacyDependency         bool           `json:"legacy_dependency"`
	SourceLanguageDependency bool           `json:"source_language_dependency"`
	StructureCapabilities    map[string]int `json:"structure_capabilities"`
	RelationCapabilities     map[string]int `json:"relation_capabilities"`
	FacetCapabilities        map[string]int `json:"facet_capabilities"`
	FieldCapabilities        map[string]int `json:"field_capabilities"`
}

type UASTTargetCapabilityMatrix struct {
	Structures   UASTCapabilityPlane                  `json:"structures"`
	Facets       UASTCapabilityPlane                  `json:"facets"`
	Relations    UASTCapabilityPlane                  `json:"relations"`
	Fields       UASTCapabilityPlane                  `json:"fields"`
	StatusCounts map[string]map[string]map[string]int `json:"status_counts"`
}

type UASTTargetPreservationMatrix struct {
	Schema       string                    `json:"schema"`
	BasisSHA256  string                    `json:"basis_sha256"`
	Capabilities []string                  `json:"capabilities"`
	Targets      []string                  `json:"targets"`
	Direct       matrixir.SparseMatrix     `json:"direct"`
	Rewrite      matrixir.SparseMatrix     `json:"rewrite"`
	Helper       matrixir.SparseMatrix     `json:"helper"`
	Emulate      matrixir.SparseMatrix     `json:"emulate"`
	Runtime      matrixir.SparseMatrix     `json:"runtime"`
	Error        matrixir.SparseMatrix     `json:"error"`
	StatusCounts map[string]map[string]int `json:"status_counts"`
}

type UnaryExpr struct {
	Op string
	X  Expr
}

type UniversalASTBasis struct {
	Schema                     string                `json:"schema"`
	Features                   []string              `json:"features"`
	Facets                     []string              `json:"facets"`
	SemanticAxes               []string              `json:"semantic_axes"`
	RelationAxes               []string              `json:"relation_axes"`
	Languages                  []string              `json:"languages"`
	StructuralKinds            []string              `json:"structural_kinds"`
	ConcreteRelations          []string              `json:"concrete_relations"`
	Fields                     []string              `json:"fields"`
	Layers                     []string              `json:"layers"`
	GlobalRelations            []string              `json:"global_relations"`
	CrosswalkFields            []string              `json:"crosswalk_fields"`
	FeatureFacet               matrixir.SparseMatrix `json:"feature_facet"`
	FeatureSignature           matrixir.SparseMatrix `json:"feature_signature"`
	FacetAxis                  matrixir.SparseMatrix `json:"facet_axis"`
	FacetRelationAxis          matrixir.SparseMatrix `json:"facet_relation_axis"`
	LanguageFacet              matrixir.SparseMatrix `json:"language_facet"`
	CoverageLower              matrixir.SparseMatrix `json:"coverage_lower"`
	CoverageUpper              matrixir.SparseMatrix `json:"coverage_upper"`
	StructuralFacetSeed        matrixir.SparseMatrix `json:"structural_facet_seed"`
	FacetLayer                 matrixir.SparseMatrix `json:"facet_layer"`
	StructuralLayer            matrixir.SparseMatrix `json:"structural_layer"`
	FacetConcreteRelation      matrixir.SparseMatrix `json:"facet_concrete_relation"`
	StructuralConcreteRelation matrixir.SparseMatrix `json:"structural_concrete_relation"`
	FacetField                 matrixir.SparseMatrix `json:"facet_field"`
	StructuralField            matrixir.SparseMatrix `json:"structural_field"`
}

type UniversalASTCanonicalCoverage struct {
	Structures int `json:"structures"`
	Relations  int `json:"relations"`
	Facets     int `json:"facets"`
	Fields     int `json:"fields"`
	UASFReady  int `json:"uast_ready"`
}

type UniversalASTDocument struct {
	SchemaVersion          int                      `json:"schema_version"`
	BasisSHA256            string                   `json:"basis_sha256"`
	LanguageProfile        string                   `json:"language_profile"`
	LanguageFacet          matrixir.Vector          `json:"language_facet"`
	Projection             string                   `json:"projection,omitempty"`
	SemanticDocumentSHA256 string                   `json:"semantic_document_sha256,omitempty"`
	Evaluation             string                   `json:"evaluation,omitempty"`
	ValueModel             string                   `json:"value_model,omitempty"`
	IndexBase              int                      `json:"index_base,omitempty"`
	Types                  SemanticTypeContract     `json:"type_contract,omitempty"`
	Origin                 SemanticOrigin           `json:"origin,omitempty"`
	Metadata               map[string]string        `json:"metadata,omitempty"`
	Extensions             map[string]any           `json:"extensions,omitempty"`
	Contracts              SemanticContracts        `json:"contracts,omitempty"`
	Dialects               []SemanticDialect        `json:"dialects,omitempty"`
	SemanticFeatures       *SemanticFeatureModel    `json:"semantic_features,omitempty"`
	TypeTable              []SemanticTypeDefinition `json:"type_table,omitempty"`
	TypeGraph              matrixir.SparseMatrix    `json:"type_graph,omitempty"`
	TypeRelations          *SemanticTypeRelations   `json:"type_relations,omitempty"`
	Evidence               SemanticEvidence         `json:"evidence,omitempty"`
	Nodes                  []UniversalASTNode       `json:"nodes"`
	Relations              []UniversalASTRelation   `json:"relations"`
}

type UniversalASTNode struct {
	ID             int                        `json:"id"`
	StructuralKind string                     `json:"structural_kind"`
	SemanticFacets []string                   `json:"semantic_facets,omitempty"`
	FieldMask      []string                   `json:"field_mask"`
	Fields         map[string]json.RawMessage `json:"fields,omitempty"`
	Source         *SemanticSourceSpan        `json:"source_span,omitempty"`
	Attributes     map[string]json.RawMessage `json:"attributes,omitempty"`
}

type UniversalASTReference struct {
	Domain string `json:"domain"`
	ID     string `json:"id"`
}

type UniversalASTRelation struct {
	Kind       string                     `json:"kind"`
	From       int                        `json:"from"`
	To         UniversalASTReference      `json:"to"`
	Attributes map[string]json.RawMessage `json:"attributes,omitempty"`
}

type UniversalFormatter struct {
	Indent  string
	Newline string
}

type UniversalHelperResolver struct{}

type UniversalTargetNameResolver struct{}

type UniversalTargetProjector struct{}

type WhileStmt struct {
	Cond Expr
	Body Stmt
}