backend

type Arg struct {
	Name    string
	Value   Expr
	Missing bool
}

type ArtifactKind string

type AssignStmt struct {
	Name, Op string
	Value    Expr
}

type AuditBackendFactDemand struct {
	Consumer           string `json:"consumer"`
	Node               int    `json:"node"`
	Operation          string `json:"operation"`
	RequestedFact      string `json:"requested_fact"`
	SourceOfFact       string `json:"source_of_fact"`
	Resolved           bool   `json:"resolved"`
	Reachable          bool   `json:"reachable"`
	RequiredForCodegen bool   `json:"required_for_codegen"`
}

type AuditFactProvenance struct {
	Node      int    `json:"node"`
	Operation string `json:"operation"`
	Fact      string `json:"fact"`
	Source    string `json:"source_of_fact"`
	Resolved  bool   `json:"resolved"`
	Reachable bool   `json:"reachable"`
	Evidence  string `json:"evidence,omitempty"`
}

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 CSharpProjectionPrimitive struct {
	ID             string
	InputFamily    string
	RequiredFacts  []string
	EmittedSurface []string
	FailureIfUnset string
}

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

type CanonicalPrimitiveWitness struct {
	Primitive string
	Kernel    string
	Program   *SemanticProgram
}

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 CompilationRegion struct {
	ID       int   `json:"id"`
	Entry    int   `json:"entry"`
	Exits    []int `json:"exits,omitempty"`
	LiveIns  []int `json:"live_ins,omitempty"`
	LiveOuts []int `json:"live_outs,omitempty"`
}

type CompilationUnit struct {
	ID                 int                 `json:"id"`
	FunctionIDs        []int               `json:"function_ids"`
	RequiredPrimitives []string            `json:"required_primitives,omitempty"`
	EstimatedOps       int                 `json:"estimated_ops"`
	Regions            []CompilationRegion `json:"regions,omitempty"`
}

type CompileInputKind string

type CompileOptions struct {
	InputKind       CompileInputKind
	SourceLanguage  string
	SourceArch      string
	SourceOS        string
	SourceABI       string
	SourceAsmSyntax string
	TargetArch      string
	TargetOS        string
	ABI             string
	OutputKind      CompileOutputKind
	TargetLanguage  string
	EntryPoint      string
	ViaAssembly     bool
	BaseAddress     uint64
	// ModuleBaseDir resolves relative Semantic module references. An explicit
	// link-root plan remains the default; EmbedAllModules is the opt-in for a
	// complete declared-module bundle.
	ModuleBaseDir   string
	ModuleStoreRoot string
	EmbedAllModules bool
	// ModuleEmbeddingMode is "needed" (default), "references", or "all".
	// EmbedAllModules is retained for source/API compatibility and implies "all".
	ModuleEmbeddingMode SemanticModuleEmbeddingMode
	// CacheDir enables the content-addressed native lowering cache. Empty keeps
	// the API hermetic and disables disk caching.
	CacheDir string
	// ExecutableClosureReportPath optionally overrides the deterministic
	// executable-closure.json diagnostic emitted before project code generation.
	ExecutableClosureReportPath string
	ProjectInitializers         []ExecutableFunctionRef
	// MaxWorkers optionally caps project pipeline concurrency. A zero value
	// uses the CPU policy. MemoryBudgetBytes and UnitPeakBytes enable the
	// conservative RAM-aware cap; when unset only the CPU cap is applied.
	MaxWorkers        int
	MemoryBudgetBytes int64
	UnitPeakBytes     int64
	GlobalMemoryBytes int64
	QueueMemoryBytes  int64
	LinkMemoryBytes   int64
	// ProjectMode keeps unresolved named calls as linker relocations. It is set
	// by CompileSemanticProject; standalone compilation remains fail-closed.
	ProjectMode   bool
	ProjectIndex  *SemanticProjectIndex
	ProjectUnitID string
	// contains filtered or unexported fields
}

type CompileOutputKind string

type CompileResult struct {
	Bytes []byte
	// ObjectBytes is the COFF representation of the exact selected instruction
	// stream. It lets callers retain a real linker intermediate without running
	// selection and register allocation a second time.
	ObjectBytes []byte
	// FunctionObjects contains per-function COFF staging artifacts. Their text
	// is cut from the same encoded program and is retained for incremental build
	// inspection; final image linking still uses the complete encoded stream so
	// cross-function fixups remain authoritative.
	FunctionObjects map[string][]byte
	// Fragments are derived target-output units corresponding to the retained
	// COFF objects. They carry no semantic state and are safe to discard after
	// the deterministic linker has completed.
	Fragments map[string]MachineFragment
	Imports   []pe64ImportSpec `json:"imports,omitempty"`
	// Plan exposes the derived summary/partition metrics for profiling and
	// build journals without exposing semantic internals to callers.
	Plan     StreamingPlan
	Metrics  StreamingMetrics
	CacheHit bool
	Regions  []EncodedRegion

	NativeUnitCount                    int `json:"native_unit_count,omitempty"`
	NativeFragmentCount                int `json:"native_fragment_count,omitempty"`
	NativeRelocationCount              int `json:"native_relocation_count,omitempty"`
	UnresolvedProjectSymbolsBeforeLink int `json:"unresolved_project_symbols_before_link,omitempty"`
	UnresolvedProjectSymbolsAfterLink  int `json:"unresolved_project_symbols_after_link,omitempty"`
	Text                               string
	OutputKind                         CompileOutputKind
	InstructionCount                   int
	AppliedRecipes                     []string
	AllocatedLiveRanges                int
	// contains filtered or unexported fields
}

type CompilerCallEdge struct {
	From     string                   `json:"from"`
	To       string                   `json:"to"`
	Location CompilerEvidenceLocation `json:"location"`
}

type CompilerEvidence struct {
	ID                   string                     `json:"id"`
	Compiler             string                     `json:"compiler"`
	Version              string                     `json:"version"`
	Stage                CompilerStage              `json:"stage"`
	TargetArchitecture   string                     `json:"target_architecture,omitempty"`
	SemanticIdentity     string                     `json:"semantic_identity,omitempty"`
	InputPattern         string                     `json:"input_pattern"`
	Conditions           []string                   `json:"conditions,omitempty"`
	OutputPattern        []string                   `json:"output_pattern,omitempty"`
	ReferencedOperations []string                   `json:"referenced_operations,omitempty"`
	Relation             string                     `json:"relation"`
	Confidence           EvidenceConfidence         `json:"confidence"`
	Locations            []CompilerEvidenceLocation `json:"locations"`
}

type CompilerEvidenceGap struct {
	ID               string                   `json:"id"`
	Compiler         string                   `json:"compiler"`
	SemanticIdentity string                   `json:"semantic_identity,omitempty"`
	Gap              string                   `json:"gap"`
	Detail           string                   `json:"detail"`
	Location         CompilerEvidenceLocation `json:"location"`
}

type CompilerEvidenceLocation struct {
	Repository string `json:"repository"`
	Commit     string `json:"commit,omitempty"`
	File       string `json:"file"`
	SHA256     string `json:"sha256"`
	Symbol     string `json:"symbol"`
	StartLine  int    `json:"start_line"`
	EndLine    int    `json:"end_line"`
}

type CompilerEvidenceMatrix struct {
	SchemaVersion       string                       `json:"schema_version"`
	EvidenceAuthority   string                       `json:"evidence_authority"`
	Nodes               []CompilerMatrixNode         `json:"nodes"`
	Edges               []CompilerMatrixEdge         `json:"edges"`
	Rules               []CompilerEvidence           `json:"rules"`
	Equivalences        []SemanticEquivalence        `json:"semantic_equivalences"`
	PrimitiveCandidates []CompilerPrimitiveCandidate `json:"primitive_candidates"`
	Gaps                []CompilerEvidenceGap        `json:"gaps"`
	CompilerSummaries   []map[string]any             `json:"compiler_summaries"`
}

type CompilerFrontendEvidence struct {
	ID, Language, Compiler, Stage, SourceArea, Representation string
	Features, Relations                                       []string
	Phase, EvidenceClass, Guidance, SourceURL                 string
}

type CompilerMatrixEdge struct {
	From       string                     `json:"from"`
	Relation   string                     `json:"relation"`
	To         string                     `json:"to"`
	Confidence EvidenceConfidence         `json:"confidence"`
	Conditions []string                   `json:"conditions,omitempty"`
	Locations  []CompilerEvidenceLocation `json:"locations"`
}

type CompilerMatrixNode struct {
	ID         string                     `json:"id"`
	Compiler   string                     `json:"compiler"`
	Kind       string                     `json:"kind"`
	Identity   string                     `json:"identity"`
	Stage      CompilerStage              `json:"stage,omitempty"`
	Attributes map[string]string          `json:"attributes,omitempty"`
	Locations  []CompilerEvidenceLocation `json:"locations"`
}

type CompilerPrimitiveCandidate struct {
	ID                string                     `json:"id"`
	Compiler          string                     `json:"compiler"`
	SourceIdentity    string                     `json:"source_identity"`
	CanonicalIdentity string                     `json:"canonical_identity,omitempty"`
	Status            string                     `json:"status"`
	Reason            string                     `json:"reason"`
	EvidenceIDs       []string                   `json:"evidence_ids"`
	Locations         []CompilerEvidenceLocation `json:"locations"`
}

type CompilerRepositoryEdge struct {
	From       string                   `json:"from"`
	Relation   string                   `json:"relation"`
	To         string                   `json:"to"`
	Confidence EvidenceConfidence       `json:"confidence"`
	Location   CompilerEvidenceLocation `json:"location"`
}

type CompilerRepositoryNode struct {
	ID         string                   `json:"id"`
	Compiler   string                   `json:"compiler"`
	Kind       string                   `json:"kind"`
	Identity   string                   `json:"identity"`
	Stage      CompilerStage            `json:"stage"`
	Location   CompilerEvidenceLocation `json:"location"`
	Attributes map[string]string        `json:"attributes,omitempty"`
}

type CompilerRepositoryReport struct {
	SchemaVersion      string                   `json:"schema_version"`
	Compiler           string                   `json:"compiler"`
	Repository         string                   `json:"repository"`
	Ref                string                   `json:"branch_or_tag,omitempty"`
	Commit             string                   `json:"commit,omitempty"`
	Version            string                   `json:"version,omitempty"`
	ExtractedAt        string                   `json:"extracted_at_utc"`
	License            string                   `json:"license,omitempty"`
	SourceRoot         string                   `json:"source_root"`
	TargetArchitecture string                   `json:"target_architecture,omitempty"`
	Units              []CompilerRepositoryUnit `json:"source_units"`
	Nodes              []CompilerRepositoryNode `json:"nodes"`
	Edges              []CompilerRepositoryEdge `json:"edges"`
	Rules              []CompilerEvidence       `json:"rules"`
	Equivalences       []SemanticEquivalence    `json:"semantic_equivalences"`
	Gaps               []CompilerEvidenceGap    `json:"gaps"`
	Summary            map[string]int           `json:"summary"`
}

type CompilerRepositorySpec struct {
	Compiler           string   `json:"compiler"`
	Repository         string   `json:"repository"`
	Ref                string   `json:"branch_or_tag,omitempty"`
	Root               string   `json:"root"`
	Commit             string   `json:"commit,omitempty"`
	Version            string   `json:"version,omitempty"`
	License            string   `json:"license,omitempty"`
	TargetArchitecture string   `json:"target_architecture,omitempty"`
	Include            []string `json:"include"`
	Extensions         []string `json:"extensions"`
}

type CompilerRepositoryUnit struct {
	File     string `json:"file"`
	SHA256   string `json:"sha256"`
	Bytes    int    `json:"bytes"`
	Language string `json:"language"`
}

type CompilerSemanticCrosswalk struct {
	CanonicalIdentity   string              `json:"canonical_identity"`
	CanonicalContractID string              `json:"canonical_contract_id,omitempty"`
	Relation            string              `json:"relation"`
	EvidenceIDs         []string            `json:"evidence_ids"`
	EvidenceContracts   map[string][]string `json:"evidence_contracts"`
	Conditions          []string            `json:"conditions,omitempty"`
	Confidence          EvidenceConfidence  `json:"confidence"`
}

type CompilerSourceEvidence struct{ Language, Compiler, Repository, Area, URL, LicensePolicy string }

type CompilerSourceTruth struct {
	ID             string
	Layer          string
	SemanticAxes   []string
	RequiredFacts  []string
	BackendDemand  []string
	FailureIfUnset string
}

type CompilerSourceUnit struct {
	File   string `json:"file"`
	SHA256 string `json:"sha256"`
}

type CompilerStage string

type ContractGapClosureReport struct {
	InitialGaps                   int            `json:"initial_contract_gaps"`
	RecoveredExactContracts       []string       `json:"recovered_exact_contracts"`
	NewDerivedPrimitives          []string       `json:"new_derived_primitives"`
	NewGeneratedRecipes           []string       `json:"new_generated_recipes"`
	NewRecoveredExactRules        []string       `json:"new_recovered_exact_rules"`
	NewParameterizedAtomic        []string       `json:"new_parameterized_atomic_primitives"`
	TrueAtomicResidual            []string       `json:"true_atomic_residual_primitives"`
	RuntimeOnly                   []string       `json:"runtime_only_reclassifications"`
	TargetTerminal                []string       `json:"target_terminal_reclassifications"`
	ValidationOnly                []string       `json:"validation_only_reclassifications"`
	Aliases                       []string       `json:"aliases"`
	RemainingInsufficientEvidence []string       `json:"remaining_insufficient_evidence"`
	FinalContractGaps             []string       `json:"final_contract_gaps"`
	TotalGeneratedRecipes         int            `json:"total_generated_recipes"`
	TotalClosureReachableRules    int            `json:"total_closure_reachable_rules"`
	TotalExecutorReachableRules   int            `json:"total_executor_reachable_rules"`
	GenericAtomicKernelClasses    []string       `json:"generic_atomic_kernel_classes"`
	MinimalMissingAtomicBasis     []string       `json:"minimal_missing_atomic_basis"`
	BasisHash                     string         `json:"basis_hash"`
	ImplementationGraphRows       int            `json:"implementation_graph_rows"`
	RecoveredEquivalenceRules     int            `json:"recovered_equivalence_rules"`
	AtomicResidualCount           int            `json:"atomic_residual_count"`
	ProductiveFamilyContracts     int            `json:"productive_family_contracts"`
	ValidationOnlyFamilyContracts int            `json:"validation_only_family_contracts"`
	UnresolvedFamilyContracts     int            `json:"unresolved_family_contracts"`
	FamilyCounts                  map[string]int `json:"family_counts,omitempty"`
}

type DetectionResult struct {
	Kind       ArtifactKind   `json:"kind"`
	Language   string         `json:"language,omitempty"`
	Confidence string         `json:"confidence"`
	Scores     map[string]int `json:"scores"`
	Languages  []string       `json:"languages,omitempty"`
	Mixed      bool           `json:"mixed,omitempty"`
}

type DiagnosticContext struct {
	Mode     DiagnosticMode
	Failures []SemanticFailure
	// Holes are transient placeholders used only while saturating a
	// diagnostic walk. They must never be handed to a canonical builder.
	Holes         []DiagnosticHole
	RewriteProofs []RewriteProofRecord
}

type DiagnosticHole struct {
	FailureID     string `json:"failure_id"`
	Stage         string `json:"stage"`
	NodeKind      string `json:"node_kind,omitempty"`
	SemanticRole  string `json:"semantic_role,omitempty"`
	SourceStart   int    `json:"source_start,omitempty"`
	SourceEnd     int    `json:"source_end,omitempty"`
	RecoveryClass string `json:"recovery_class"`
}

type DiagnosticMode 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 DirectLoweringStatus 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 EmpiricalLoweringContract struct {
	Target       string
	ASTNode      string
	Primitive    string
	UASTContract string
}

type EncodedRegion struct {
	Function    string `json:"function"`
	Start       int    `json:"start"`
	End         int    `json:"end"`
	SingleEntry bool   `json:"single_entry"`
}

type EvidenceConfidence string

type ExecutableClosure struct {
	EntryRoots                []string                      `json:"entry_roots"`
	ReachableFunctions        []ExecutableFunctionRef       `json:"reachable_functions"`
	ReachableFunctionCount    int                           `json:"reachable_functions_count"`
	ReachableUnits            []string                      `json:"reachable_units"`
	ReachableUnitCount        int                           `json:"reachable_units_count"`
	RequiredInitializers      []string                      `json:"required_initializers"`
	InitializerFunctions      []ExecutableFunctionRef       `json:"initializer_functions"`
	InitializerOrderBasis     string                        `json:"initializer_order_basis,omitempty"`
	RequiredRuntimePrimitives []string                      `json:"runtime_primitives"`
	RequiredExternalImports   []ProjectExternalImport       `json:"external_imports"`
	Unresolved                []ExecutableClosureUnresolved `json:"unresolved"`
	Edges                     []ExecutableClosureEdge       `json:"edges,omitempty"`
}

type ExecutableClosureEdge struct {
	CallerID       string                 `json:"caller_id"`
	CallerUnit     string                 `json:"caller_unit"`
	Callee         string                 `json:"callee"`
	NodeID         int                    `json:"node_id"`
	Resolution     string                 `json:"resolution"`
	TargetID       string                 `json:"target_id,omitempty"`
	ExternalImport *ProjectExternalImport `json:"external_import,omitempty"`
}

type ExecutableClosureUnresolved struct {
	Caller             string   `json:"caller,omitempty"`
	UnitID             string   `json:"unit_id,omitempty"`
	NodeID             int      `json:"node_id,omitempty"`
	Callee             string   `json:"callee,omitempty"`
	SemanticIdentity   string   `json:"semantic_identity,omitempty"`
	ExpectedSignature  string   `json:"expected_signature,omitempty"`
	Reason             string   `json:"reason"`
	ResolutionAttempts []string `json:"resolution_attempts"`
}

type ExecutableFunctionRef struct {
	ID     string `json:"id"`
	Name   string `json:"name,omitempty"`
	UnitID string `json:"unit_id"`
	NodeID int    `json:"node_id,omitempty"`
}

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 ExternalCCompileOptions struct {
	Family         ExternalCompilerFamily
	TargetLanguage string
	OutputKind     CompileOutputKind
	CompilerPath   string
	MSVCSetupPath  string
	Optimization   int
	Timeout        time.Duration
}

type ExternalCCompileResult struct {
	Bytes          []byte                 `json:"-"`
	Source         string                 `json:"source"`
	SourceSHA256   string                 `json:"source_sha256"`
	ArtifactSHA256 string                 `json:"artifact_sha256,omitempty"`
	OutputKind     CompileOutputKind      `json:"output_kind"`
	Family         ExternalCompilerFamily `json:"family"`
	CompilerPath   string                 `json:"compiler_path"`
	Command        []string               `json:"command"`
	ProjectionMode string                 `json:"projection_mode"`
	Stdout         string                 `json:"stdout,omitempty"`
	Stderr         string                 `json:"stderr,omitempty"`
}

type ExternalCompilerAvailability struct {
	Family        ExternalCompilerFamily `json:"family"`
	Available     bool                   `json:"available"`
	CompilerPath  string                 `json:"compiler_path,omitempty"`
	MSVCSetupPath string                 `json:"msvc_setup_path,omitempty"`
	Diagnostic    string                 `json:"diagnostic,omitempty"`
}

type ExternalCompilerFamily string

type ExternalPrimitiveCrosswalkReport struct {
	InitialInsufficientEvidence int      `json:"initial_insufficient_evidence"`
	ExternalEvidenceRows        int      `json:"external_evidence_rows"`
	ExactCodeEvidenceRows       int      `json:"exact_code_evidence_rows"`
	CodeEvidenceRows            int      `json:"code_evidence_rows"`
	DocCandidateRows            int      `json:"doc_candidate_rows"`
	GapRowsWithExternalMatch    int      `json:"gap_rows_with_external_match"`
	GapRowsPromotedExact        int      `json:"gap_rows_promoted_exact"`
	NewDerivedPrimitives        int      `json:"new_derived_primitives"`
	NewGeneratedRecipes         int      `json:"new_generated_recipes"`
	NewParameterizedMappings    int      `json:"new_parameterized_kernel_mappings"`
	NewTargetTerminalProofs     int      `json:"new_target_terminal_proofs"`
	TransitivelyClosedGaps      int      `json:"transitively_closed_gaps"`
	RemainingInsufficient       int      `json:"remaining_insufficient_evidence"`
	TotalGeneratedRecipes       int      `json:"total_generated_recipes"`
	TotalClosureRules           int      `json:"total_closure_reachable_rules"`
	TotalExecutorRules          int      `json:"total_executor_reachable_rules"`
	ExternalGapClosureRate      float64  `json:"external_gap_closure_rate"`
	Promoted                    []string `json:"promoted_exact_contracts"`
	Remaining                   []string `json:"remaining_contracts"`
	EvidenceSHA256              string   `json:"evidence_sha256"`
}

type FailureClass string

type ForStmt struct {
	Name string
	Seq  Expr
	Body Stmt
}

type FragmentRelocation struct {
	Offset uint32 `json:"offset"`
	Target string `json:"target"`
	Kind   string `json:"kind"`
	Addend int64  `json:"addend,omitempty"`
}

type FrontendClosureReport struct {
	Languages []string
	Forms     []string
	Features  []string
	Patterns  []string
	// ParserAccept is the independently inventoried source-parser axis.
	// Accept is retained as a compatibility alias for callers that consumed
	// the older closure report.
	ParserAccept                  matrixir.SparseMatrix
	ParserEvidence                []FrontendParserFormEvidence
	SourceToMatrixIR              matrixir.SparseMatrix `json:"source_to_matrixir"`
	MatrixIRForms                 []string              `json:"matrixir_forms"`
	PerLanguage                   []FrontendLanguageClosure
	OldAxisForms                  []string
	OldGenericMatrixIRAxis        int  `json:"old_generic_matrixir_form_axis"`
	SourceParserFormUnion         int  `json:"true_source_parser_form_union"`
	SourceParserLanguageFormCells int  `json:"true_source_parser_language_form_cells"`
	SourceParserGapInitial        int  `json:"source_parser_gap_initial"`
	SourceParserGapFinal          int  `json:"source_parser_gap_final"`
	SilentSourceParserDrop        int  `json:"silent_source_parser_drop"`
	InvalidParserEvidenceRows     int  `json:"invalid_parser_evidence_rows"`
	IdenticalLanguageAxisWarning  bool `json:"identical_language_axis_warning"`

	Accept           matrixir.SparseMatrix // Language x Form
	Accounted        matrixir.SparseMatrix // Language x Form
	Required         matrixir.SparseMatrix // Form x Feature
	Have             matrixir.SparseMatrix // Form x Feature
	RelationRequired matrixir.SparseMatrix // Form x Pattern
	RelationHave     matrixir.SparseMatrix // Form x Pattern
	Phase            matrixir.SparseMatrix // Language x phase
	Dependency       matrixir.SparseMatrix // Language x dependency class

	NodeGap, SemanticGap, RelationGap, PhaseGap, DependencyGap  int
	Families                                                    []string
	NodeGapInitial, NodeGapFinal                                int
	LanguageSpecificPreserved, UnknownSemanticForms             int
	UnownedSurface                                              int
	StructuralComplete, SemanticComplete, CrossLanguageEmitSafe bool
	OldAxisComplete                                             bool
}

type FrontendConstructMatrixEntry struct {
	Construct           string   `json:"construct"`
	UASTStructure       string   `json:"uast_structure"`
	UASTKind            string   `json:"uast_kind"`
	ExecutionPrimitives []string `json:"execution_primitives"`
}

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 FrontendFeatureEvidence struct {
	Language, Feature, State, Proof, IDs string
	Count                                int
}

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

type FrontendInputKind string

type FrontendLanguageClosure struct {
	Language                  string   `json:"language"`
	ParserForms               []string `json:"parser_forms"`
	AccountedForms            []string `json:"accounted_forms"`
	DirectCanonical           []string `json:"direct_canonical"`
	DesugaredCanonical        []string `json:"desugared_canonical"`
	CompiletimeMetadata       []string `json:"compiletime_metadata"`
	LanguageSpecificPreserved []string `json:"language_specific_preserved"`
	RecoveredError            []string `json:"recovered_error"`
	NodeGaps                  []string `json:"node_gaps"`
	UnownedSurface            []string `json:"unowned_surface"`
}

type FrontendParserFormEvidence struct {
	Language      string   `json:"language"`
	Form          string   `json:"form"`
	ParserSource  string   `json:"parser_source"`
	ParserSymbol  string   `json:"parser_symbol"`
	Origin        string   `json:"origin"`
	Productive    bool     `json:"productive"`
	Coverage      string   `json:"coverage"`
	NodeNamed     bool     `json:"node_named"`
	HasFields     bool     `json:"has_fields"`
	HasChildren   bool     `json:"has_children"`
	MatrixForms   []string `json:"matrix_forms"`
	MappingStatus string   `json:"mapping_status"`
	CanonicalForm string   `json:"canonical_form"`
}

type FrontendParserInventory struct {
	Languages   []string
	Forms       []string
	Accept      matrixir.SparseMatrix
	Evidence    []FrontendParserFormEvidence
	PerLanguage map[string][]string
	ByLanguage  map[string]map[string]FrontendParserFormEvidence
}

type FrontendPhaseEvidence struct{ Language, Compiler, Area, Phase, Features, ID string }

type FrontendRelationEvidence struct{ ID, Left, Relation, Right, Language, Proof, EvidenceID string }

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
	Surface                *UniversalASTSurface

	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 FullSemanticSource struct{ Program *SemanticProgram }

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 GeneratedLoweringRecipe struct {
	ID           string               `json:"id"`
	Primitive    string               `json:"primitive"`
	Class        string               `json:"class"`
	Dependencies []string             `json:"dependencies,omitempty"`
	Guards       []string             `json:"guards,omitempty"`
	Steps        []LoweringRecipeStep `json:"steps"`
	BasisHash    string               `json:"basis_hash"`
	ProofState   string               `json:"proof_state"`
}

type GeneratedPrimitiveRegistry struct {
	RecipesByPrimitive map[string]GeneratedLoweringRecipe
	AtomicKernels      map[string]string
}

type GlobalSemanticIndex struct {
	Functions []StreamingFunctionSummary `json:"functions"`
	Order     []int                      `json:"order"`
}

type GoIRNodeContract struct {
	Opcode          string
	StructuralKind  string
	SemanticKind    string
	RequiresWitness bool
}

type GoIROperationContract struct {
	Opcode          string
	SemanticName    string
	Arity           int
	SemanticFamily  string
	RequiresWitness bool
}

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 LLVMCompileOptions struct {
	OutputKind   LLVMOutputKind
	TargetTriple string
	Optimization int
	EntryPoint   string
	// ModuleBaseDir resolves relative semantic module references. When set,
	// ModuleStoreRoot overrides the default user Semantic module store.
	ModuleBaseDir   string
	ModuleStoreRoot string
	// EmbedAllModules is an explicit opt-in. The default follows the semantic
	// module link-root plan and embeds only reachable required modules.
	EmbedAllModules bool
	// ModuleEmbeddingMode preserves the explicit module policy for the LLVM
	// ingress as well as the direct native ingress.
	ModuleEmbeddingMode SemanticModuleEmbeddingMode
	LLVMPath            string
	ClangPath           string
	LLCPath             string
	LLVMAsPath          string
	LLDLinkPath         string
	EmitIR              bool
	// ProjectIndex and UnitID are read-only project context for the optional
	// per-unit route. They never cause another SemanticProgram to be assembled.
	ProjectIndex    *SemanticProjectIndex
	UnitID          string
	ProjectBindings map[string]string
	CacheDir        string
	// ExecutableClosureReportPath optionally overrides the project-level
	// executable-closure.json diagnostic path.
	ExecutableClosureReportPath string
	ProjectInitializers         []ExecutableFunctionRef
	// EmitEntryWrapper is true for the legacy single-program API. Project
	// units set it only on the owning entry unit so library objects never
	// manufacture competing process entry points.
	EmitEntryWrapper bool
}

type LLVMCompileResult struct {
	IR                 string
	Bytes              []byte
	Text               string
	OutputKind         LLVMOutputKind
	TargetTriple       string
	InstructionCount   int
	Functions          int
	ProjectionSchema   string
	ProjectionBasis    string
	ProjectionFamilies map[string]int
	ProjectionModes    map[string]int
	ProjectionGaps     []string
	ProjectionPlan     *LLVMProjectionPlan
}

type LLVMObjectFragment struct {
	UnitID       string
	SemanticRoot string
	Object       []byte
	IR           string
	SymbolNames  []string
}

type LLVMOutputKind string

type LLVMProjectResult struct {
	Fragments   []LLVMObjectFragment
	Failures    []LLVMProjectUnitFailure
	ObjectCount int
	CacheHits   int
	CacheMisses int
	Executable  []byte
	LinkMicros  int64
}

type LLVMProjectUnitFailure struct {
	UnitID string `json:"unit_id"`
	Phase  string `json:"phase"`
	Error  string `json:"error"`
}

type LLVMProjectionCell struct {
	NodeID              int      `json:"node_id"`
	StructuralKind      string   `json:"structural_kind"`
	SemanticKind        string   `json:"semantic_kind"`
	Family              string   `json:"family"`
	Mode                string   `json:"mode"`
	ProjectionForm      string   `json:"projection_form"`
	ExecutionPrimitives []string `json:"execution_primitives,omitempty"`
	RequiredFields      []string `json:"required_fields,omitempty"`
	RequiredRelations   []string `json:"required_relations,omitempty"`
}

type LLVMProjectionGapFamily struct {
	Family    string `json:"family"`
	Primitive string `json:"primitive"`
	Contract  string `json:"contract"`
	Count     int    `json:"count"`
	NodeIDs   []int  `json:"node_ids"`
}

type LLVMProjectionPlan struct {
	Schema          string                       `json:"schema"`
	BasisSHA256     string                       `json:"basis_sha256"`
	Evidence        LLVMTechnicalEvidenceProfile `json:"evidence"`
	Cells           []LLVMProjectionCell         `json:"cells"`
	Families        map[string]int               `json:"families"`
	ModeCounts      map[string]int               `json:"mode_counts"`
	StructuralCount int                          `json:"structural_count"`
	Gaps            []string                     `json:"gaps,omitempty"`
	// GapFamilies and GapPrimitives are the quotient of node-level failures.
	// They make the next implementation batch explicit without discarding the
	// original node diagnostics in Gaps.
	GapFamilies   map[string]int                  `json:"gap_families,omitempty"`
	GapPrimitives map[string]int                  `json:"gap_primitives,omitempty"`
	GapQuotient   []LLVMProjectionGapFamily       `json:"gap_quotient,omitempty"`
	Contracts     UASTStructureProjectionRegistry `json:"-"`
	// contains filtered or unexported fields
}

type LLVMTechnicalEvidenceProfile struct {
	Pack                     string   `json:"pack"`
	Records                  int      `json:"records"`
	StructuredOperations     int      `json:"structured_operations"`
	ExactPrimitiveCount      int      `json:"exact_primitive_count"`
	ParameterizedFamilyCount int      `json:"parameterized_family_count"`
	DerivedFamilyCount       int      `json:"derived_family_count"`
	EvidenceHashesValid      bool     `json:"evidence_hashes_valid"`
	ExactPrimitiveIDs        []string `json:"exact_primitive_ids"`
}

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

type LiteralExpr struct{ Kind, Text string }

type LoweringExactness string

type LoweringRecipeStep struct {
	Operation string   `json:"operation"`
	Inputs    []string `json:"inputs,omitempty"`
	Output    string   `json:"output,omitempty"`
	Order     int      `json:"order"`
}

type LoweringStatus string

type LoweringTrace struct {
	Target       string         `json:"target"`
	Attempted    bool           `json:"attempted"`
	Success      bool           `json:"success"`
	Iterations   int            `json:"iterations"`
	Rules        []string       `json:"rules,omitempty"`
	Residuals    []string       `json:"residuals,omitempty"`
	Status       LoweringStatus `json:"status"`
	ErrorClass   string         `json:"error_class,omitempty"`
	BeforeDigest string         `json:"before_digest,omitempty"`
	AfterDigest  string         `json:"after_digest,omitempty"`
}

type MachineFragment struct {
	UnitID       int                  `json:"unit_id"`
	SemanticHash string               `json:"semantic_hash"`
	Text         []byte               `json:"text"`
	Symbols      map[string]uint32    `json:"symbols,omitempty"`
	Relocations  []FragmentRelocation `json:"relocations,omitempty"`
	Alignment    int                  `json:"alignment,omitempty"`
}

type MachineIR struct {
	Architecture string                 `json:"architecture"`
	BaseAddress  uint64                 `json:"base_address"`
	Instructions []MachineIRInstruction `json:"instructions"`
	CFG          []MachineIREdge        `json:"cfg"`
}

type MachineIREdge struct {
	From int    `json:"from"`
	To   int    `json:"to"`
	Kind string `json:"kind"`
}

type MachineIRInstruction struct {
	Index          int                `json:"index"`
	Offset         int                `json:"offset"`
	Operation      string             `json:"operation"`
	Classification string             `json:"classification"`
	Primitive      string             `json:"primitive,omitempty"`
	Operands       []MachineIROperand `json:"operands,omitempty"`
}

type MachineIROperand struct {
	Kind         string `json:"kind"`
	Register     string `json:"register,omitempty"`
	Index        string `json:"index,omitempty"`
	Scale        byte   `json:"scale,omitempty"`
	Immediate    int64  `json:"immediate,omitempty"`
	Displacement int64  `json:"displacement,omitempty"`
	Label        string `json:"label,omitempty"`
	HasBase      bool   `json:"has_base,omitempty"`
	RIPRelative  bool   `json:"rip_relative,omitempty"`
	Absolute     bool   `json:"absolute,omitempty"`
}

type ModuleImportOptions struct {
	Language string
	// SkipPersist keeps an import entirely in memory. It is used by the
	// executable directory fast path; callers that need the module cache leave
	// this false.
	SkipPersist bool
	Progress    func(ModuleImportProgress)
}

type ModuleImportProgress struct {
	Stage string
	Path  string
	Index int
	Total int
}

type NativeABIContext 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 NativeCapabilityBasis struct {
	Target     string
	Operations map[string]bool
	Runtime    map[string]bool
}

type NativeClosure struct {
	Supported bool
	Ranks     map[string]int
	Witnesses map[string]NativeClosureWitness
	Missing   []string
}

type NativeClosureWitness struct {
	Operation string
	Rank      int
	RecipeID  string
}

type NativeCompilerEvidenceReport struct {
	SchemaVersion string                `json:"schema_version"`
	Compiler      string                `json:"compiler"`
	Version       string                `json:"version"`
	Repository    string                `json:"repository"`
	SourceRoot    string                `json:"source_root"`
	Units         int                   `json:"source_units_analyzed"`
	Functions     int                   `json:"functions_indexed"`
	SourceFiles   []CompilerSourceUnit  `json:"source_files"`
	CallEdges     []CompilerCallEdge    `json:"call_edges"`
	Rules         []CompilerEvidence    `json:"rules"`
	Equivalences  []SemanticEquivalence `json:"semantic_equivalences"`
	Gaps          []CompilerEvidenceGap `json:"gaps"`
	EncodableOps  []string              `json:"encodable_machine_operations"`
	Summary       map[string]int        `json:"summary"`
}

type NativeCoverageAudit struct {
	SchemaVersion string              `json:"schema_version"`
	Rows          []NativeCoverageRow `json:"rows"`
}