gotreesitter

type ASCIIEquivalenceExternalScanner interface {
	ExternalScanner
	ExternalScannerASCIIEquivalenceClass(byte) uint8
}

type AmbiguityKey struct {
	State                          StateID
	Lookahead                      Symbol
	ActionCount                    uint8
	ShiftCount                     uint8
	ReduceCount                    uint8
	ReduceSymbol                   Symbol
	ChildCount                     uint8
	ProductionID                   uint16
	ReduceChainTerminalState       StateID
	ReduceChainTerminalActionClass uint8
}

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

type AmbiguityStat struct {
	State                          StateID
	Lookahead                      Symbol
	ActionCount                    uint8
	ShiftCount                     uint8
	ReduceCount                    uint8
	ReduceSymbol                   Symbol
	ChildCount                     uint8
	ProductionID                   uint16
	Actions                        []ParseAction
	Hits                           uint64
	Forks                          uint64
	MultiStackHits                 uint64
	StackInTotal                   uint64
	StackInMax                     int
	ReduceChainHits                uint64
	ReduceChainSteps               uint64
	ReduceChainMaxLen              int
	ReduceChainNanos               int64
	ReduceChainRuns                uint64
	ReduceChainClassHits           uint64
	ReduceChainStopNoAction        uint64
	ReduceChainStopMulti           uint64
	ReduceChainStopShift           uint64
	ReduceChainStopAccept          uint64
	ReduceChainStopDead            uint64
	ReduceChainStopCycle           uint64
	ReduceChainStopLimit           uint64
	ReduceChainTerminalState       StateID
	ReduceChainTerminalActionClass uint8
	ActionNanos                    int64
	ExtraShiftNanos                int64
	NoActionNanos                  int64
	ConflictChoiceNanos            int64
	ConflictForkNanos              int64
	SingleShiftNanos               int64
	SingleReduceNanos              int64
	SingleAcceptNanos              int64
	SingleRecoverNanos             int64
	SingleOtherNanos               int64
	MergeCalls                     uint64
	MergeStacksIn                  uint64
	MergeStacksOut                 uint64
	MergeStacksInMax               int
	MergeStacksOutMax              int
}

type ArenaBreakdown struct {
	CompactReuseDependencyBytesAllocated int64

	NodeStructBytesAllocated            int64
	NodeFieldMetadataBytesAllocated     int64
	NoTreeNodeBytesAllocated            int64
	CompactFullLeafBytesAllocated       int64
	PendingParentBytesAllocated         int64
	PendingChildEntryBytesAllocated     int64
	RawShapeBytesAllocated              int64
	RawShapeChildBytesAllocated         int64
	RawShapeHashCacheBytesAllocated     int64
	FinalChildSidecarBytesAllocated     int64
	MissingNodeDependencyBytesAllocated int64
	CompactCheckpointLeafBytesAllocated int64
	MissingNodeDependencyCount          uint64
	PendingChildEntriesAllocated        uint64
	PendingChildEntryCapacity           uint64
	PendingChildEntryWaste              uint64
	ChildSliceBytesAllocated            int64
	FieldIDBytesAllocated               int64
	FieldSourceBytesAllocated           int64
	MergeScratchBytesAllocated          int64

	ArenaNodesConstructed uint64
	// NodeLiveCount is arena allocation-slot usage, not root-reachable tree
	// liveness. It includes parser alternatives and recovery nodes allocated
	// during the parse.
	NodeLiveCount                     uint64
	NodeCapacityCount                 uint64
	NodeCapacityWaste                 uint64
	PrimaryNodeCapacity               uint64
	PrimaryNodeUsed                   uint64
	OverflowNodeCapacity              uint64
	OverflowNodeUsed                  uint64
	OverflowNodeSlabs                 uint64
	LargestNodeSlabUsedFraction       float64
	LeafNodesConstructed              uint64
	ParentNodesConstructed            uint64
	FieldedParentNodesConstructed     uint64
	UnfieldedParentNodesConstructed   uint64
	ParentConstructedChildLen0        uint64
	ParentConstructedChildLen1        uint64
	ParentConstructedChildLen2        uint64
	ParentConstructedChildLen3        uint64
	ParentConstructedChildLen4Plus    uint64
	ParentConstructedNoLinks          uint64
	ParentConstructedWithLinks        uint64
	ParentConstructedTrackErrors      uint64
	ParentConstructedFieldSources     uint64
	ParentReductionVisible            uint64
	ParentReductionInvisible          uint64
	ParentReductionVisibleFielded     uint64
	ParentReductionVisibleUnfielded   uint64
	ParentReductionInvisibleFielded   uint64
	ParentReductionInvisibleUnfielded uint64
	ParentReductionVisibleChildPtrs   uint64
	ParentReductionInvisibleChildPtrs uint64
	ParentReductionVisibleLen0        uint64
	ParentReductionVisibleLen1        uint64
	ParentReductionVisibleLen2        uint64
	ParentReductionVisibleLen3        uint64
	ParentReductionVisibleLen4Plus    uint64
	ParentReductionInvisibleLen0      uint64
	ParentReductionInvisibleLen1      uint64
	ParentReductionInvisibleLen2      uint64
	ParentReductionInvisibleLen3      uint64
	ParentReductionInvisibleLen4Plus  uint64
	ReduceChildSlicesFastGSS          uint64
	ReduceChildPointersFastGSS        uint64
	ReduceChildSlicesAllVisible       uint64
	ReduceChildPointersAllVisible     uint64
	ReduceChildSlicesScratchGeneral   uint64
	ReduceChildPointersScratchGeneral uint64
	ReduceChildSlicesScratchNoAlias   uint64
	ReduceChildPointersScratchNoAlias uint64
	CollapseRawUnaryAttempts          uint64
	CollapseRawUnarySuccesses         uint64
	CollapseRawUnaryMissShape         uint64
	CollapseRawUnaryMissGrammar       uint64
	CollapseRawUnaryMissChild         uint64
	CollapseRawUnaryMissRule          uint64
	CollapseUnaryAttempts             uint64
	CollapseUnarySuccesses            uint64
	CollapseUnaryMissShape            uint64
	CollapseUnaryMissGrammar          uint64
	CollapseUnaryMissFielded          uint64
	CollapseUnaryMissChild            uint64
	CollapseUnaryMissRule             uint64
	CollapseRuleSameSymbol            uint64
	CollapseRuleInvisibleWrapper      uint64
	CollapseRuleNamedLeafAlias        uint64
	NoTreeReduceNodesConstructed      uint64
	NoTreeLeafNodesConstructed        uint64
	NoTreePlaceholderNodesConstructed uint64
	OtherNodesConstructed             uint64
	ExtraNodesConstructed             uint64
	ErrorSymbolNodesConstructed       uint64
	HasErrorNodesConstructed          uint64
	ChildSlicesConstructed            uint64
	ChildPointersConstructed          uint64
	ChildSlicesLen1                   uint64
	ChildSlicesLen2                   uint64
	ChildSlicesLen3                   uint64
	ChildSlicesLen4Plus               uint64
	ParentChildPointersConstructed    uint64
	ParentChildrenLen0                uint64
	ParentChildrenLen1                uint64
	ParentChildrenLen2                uint64
	ParentChildrenLen3                uint64
	ParentChildrenLen4Plus            uint64
	FieldIDElementsConstructed        uint64
	FieldSourceElementsConstructed    uint64
}

type ArenaProfile struct {
	IncrementalAcquire uint64
	IncrementalNew     uint64
	FullAcquire        uint64
	FullNew            uint64
}

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

type ByteSkippableTokenSource interface {
	TokenSource
	SkipToByte(offset uint32) Token
}

type CRecoveryGateDiagnostics struct {
	Supported bool
	Reason    string

	StateCount       int
	SymbolCount      int
	TokenCount       int
	LexModeCount     int
	LexStateCount    int
	ParseActionCount int

	HasExternalScanner     bool
	ExternalSymbolCount    int
	ExternalTokenCount     int
	ExternalLexStateRows   int
	ExternalLexStateMinLen int
}

type CallRef struct {
	Lang          string
	Kind          string
	Name          string
	Receiver      string
	NodeType      string
	StartByte     uint32
	EndByte       uint32
	NameStartByte uint32
	NameEndByte   uint32
}

type CheckpointedExternalScanner interface {
	ExternalScanner
	UsesExternalScannerCheckpoints() bool
}

type CheckpointlessExternalScannerReuse interface {
	ExternalScanner
	AllowsIncrementalReuseWithoutCheckpoint() bool
}

type CompactRecoverEOFArtifactReceipt struct {
	BlobSHA256        [32]byte
	TerminalSymbol    Symbol
	EOFState          StateID
	EOFByteOffset     uint32
	Passes            uint64
	Elections         uint64
	ActionLookups     uint64
	Dispatches        uint64
	OrdinaryShifts    uint64
	OrdinaryCohorts   uint64
	ExtraShifts       uint64
	ExtraCohorts      uint64
	Reductions        uint64
	Conflicts         uint64
	ConflictActions   uint64
	Forks             uint64
	RepetitionFolds   uint64
	RecoveryWork      uint64
	NoActionDrops     uint64
	ReductionPauses   uint64
	Accepts           uint64
	Canonicalizations uint64
	PeakHeaders       uint64
}

type CompactRecoveryTerminalAliasRule struct {
	ResumeState  StateID
	ResumeSymbol Symbol
	AliasSymbol  Symbol
}

type ConflictPolicy struct {
	State     StateID
	Lookahead Symbol
	Kind      ConflictPolicyKind
	// CompactOnly prevents the production GLR parser from applying this
	// policy. The compact scheduler can still use it after its safety gates.
	CompactOnly bool
	// CompactMinFrontierHeaders limits this policy to a compact scheduler
	// frontier with at least this many live headers. Production ignores this
	// gate when CompactOnly is false.
	CompactMinFrontierHeaders uint16

	// ReduceSymbols, when non-empty, requires every reduce in the conflict to
	// reduce one of these symbols. The generic action-shape validator still
	// requires at least one reduce.
	ReduceSymbols []Symbol
}

type ConflictPolicyKind uint8

type DefinitionSpan struct {
	Lang          string
	Kind          string
	Name          string
	NodeType      string
	StartByte     uint32
	EndByte       uint32
	NameStartByte uint32
	NameEndByte   uint32
}

type DiagnosticParserCoreBoundaryKind string

type DiagnosticParserCoreClass1Candidate struct {
	Detail string
}

type DiagnosticParserCoreDispatchRound struct {
	Index   int
	Before  []DiagnosticParserCoreHeaderReceipt
	Actions []DiagnosticParserCoreRoundAction
	After   []DiagnosticParserCoreHeaderReceipt
}

type DiagnosticParserCoreElection struct {
	States                 []StateID
	Token                  Token
	ScannerBefore          DiagnosticParserCoreScannerCheckpoint
	ScannerAfter           DiagnosticParserCoreScannerCheckpoint
	CurrentCheckpointValid bool
	CurrentCheckpointStart DiagnosticParserCoreScannerCheckpoint
	CurrentCheckpointEnd   DiagnosticParserCoreScannerCheckpoint
	CurrentCheckpointBytes [2]uint32
}

type DiagnosticParserCoreGenericAcceptance struct {
	ElectionIndex  int
	Token          Token
	Header         DiagnosticParserCoreHeaderPathReceipt
	Payloads       []uint32
	Score          int64
	BranchOrder    uint64
	HasBranchOrder bool
	// MaterialityCertified records the bounded public-tree comparison that
	// makes a multi-derivation selection safe without a certified primary.
	MaterialityCertified bool
	// RecoveredElectionCertified records an authenticated C recovered-root fold.
	RecoveredElectionCertified bool
	// StructuralElectionCertified records an exact artifact's C-order proof.
	// It makes a clean multi-derivation selection safe without a primary proof.
	StructuralElectionCertified bool
	CoreWork                    core.Work
	Accepts                     uint64
	SelectedNodes               uint64
	SelectedParents             uint64
	SelectedLeaves              uint64
	Stats                       core.Stats
	Work                        DiagnosticParserCoreGenericWork
}

type DiagnosticParserCoreGenericCompletion struct {
	TargetByte    uint32
	ElectionIndex int
	LastToken     Token
	State         StateID
	Headers       []DiagnosticParserCoreHeaderPathReceipt
	Stats         core.Stats
	Work          DiagnosticParserCoreGenericWork
}

type DiagnosticParserCoreGenericConflict struct {
	ElectionIndex            int
	Token                    Token
	HeaderIndex              int
	BranchOrderBefore        uint64
	BranchOrderAfter         uint64
	NextCreationSeqBefore    uint64
	NextCreationSeqAfter     uint64
	Round                    DiagnosticParserCoreDispatchRound
	Prefix                   []DiagnosticParserCoreHeaderReceipt
	PrimaryOutput            DiagnosticParserCoreHeaderReceipt
	PrimaryPaused            bool
	PrimaryAdopted           bool
	OriginalSuffix           []DiagnosticParserCoreHeaderReceipt
	SecondaryArms            []DiagnosticParserCoreGenericConflictArm
	AdditionalPrimaryOutputs []DiagnosticParserCoreHeaderReceipt
	After                    []DiagnosticParserCoreHeaderReceipt
}

type DiagnosticParserCoreGenericConflictArm struct {
	Ordinal     int
	BranchOrder uint64
	Outputs     []DiagnosticParserCoreHeaderReceipt
	Paused      bool
	Adopted     bool
}

type DiagnosticParserCoreGenericExternalShift struct {
	ElectionIndex int
	Token         Token
	ScannerBefore DiagnosticParserCoreScannerCheckpoint
	ScannerAfter  DiagnosticParserCoreScannerCheckpoint
	RoundIndex    int
	Payloads      []DiagnosticParserCoreTerminalPayloadView
}

type DiagnosticParserCoreGenericNoActionDrop struct {
	ElectionIndex int
	Token         Token
	Header        DiagnosticParserCoreHeaderPathReceipt
}

type DiagnosticParserCoreGenericScheduler struct {
	ReceiptMode          DiagnosticParserCoreReceiptMode
	StartCheckpoint      DiagnosticParserCoreScannerCheckpoint
	StartHeaders         []DiagnosticParserCoreHeaderPathReceipt
	Rounds               []DiagnosticParserCoreDispatchRound
	Conflicts            []DiagnosticParserCoreGenericConflict
	ExternalShifts       []DiagnosticParserCoreGenericExternalShift
	Elections            []DiagnosticParserCoreElection
	VersionLexerRequests []DiagnosticParserCoreVersionLexerRequest
	NoActionDrops        []DiagnosticParserCoreGenericNoActionDrop
	Completion           *DiagnosticParserCoreGenericCompletion
	Acceptance           *DiagnosticParserCoreGenericAcceptance

	Stop                             DiagnosticParserCoreGenericStop
	Tokens                           uint64
	Dispatches                       uint64
	GlobalBranchOrder                uint64
	NextCreationSeq                  uint64
	PerVersionLexRequests            uint64
	PerVersionLexRestores            uint64
	PerVersionLexPublications        uint64
	PerVersionLexAcceptedRaggedSpans uint64
	PerVersionLexViabilityDrops      uint64
	PeakLiveVersions                 uint64
	PotentialReductionActions        uint64
	PotentialReductionOutputs        uint64
	ReductionPromotions              uint64
	MissingTokenTrials               uint64
	MissingTokenCommits              uint64
	RecoveryDiscontinuityMerges      uint64
	RecoveryCeilingDeclines          uint64
	// contains filtered or unexported fields
}

type DiagnosticParserCoreGenericStop struct {
	Boundary      DiagnosticParserCoreBoundaryKind
	Detail        string
	ElectionIndex int
	HeaderIndex   int
	State         StateID
	ByteOffset    uint32
	Token         Token
	Headers       []DiagnosticParserCoreHeaderPathReceipt
	Stats         core.Stats
	Work          DiagnosticParserCoreGenericWork
}

type DiagnosticParserCoreGenericWork struct {
	Passes uint64
	// PotentialReductionActions counts C-style any-terminal reduction actions
	// examined by the staged S5 frontier.
	PotentialReductionActions uint64
	// PotentialReductionOutputs counts physical outputs returned by staged S5
	// reduction actions.
	PotentialReductionOutputs uint64
	// ReductionPromotions counts outputs promoted into an earlier local source
	// slot after a positive-child reduction.
	ReductionPromotions uint64
	// MissingTokenTrials counts viable missing-terminal trial candidates.
	MissingTokenTrials uint64
	// MissingTokenCommits counts committed missing-terminal versions.
	MissingTokenCommits uint64
	// RecoveryDiscontinuityMerges counts committed recovery-head merges.
	RecoveryDiscontinuityMerges uint64
	// RecoveryCeilingDeclines counts staged recovery searches that hit a
	// configured ceiling and then declined.
	RecoveryCeilingDeclines uint64
	// StackSummaryRecoveryForks counts S4 forks that retain both the
	// ancestor-recovered lineage and the error-absorb lineage.
	StackSummaryRecoveryForks uint64
	// RecoveryLineageSelections counts accepting frontiers resolved by pricing
	// competing recovery lineages instead of declining. Every other
	// head-removal site in this scheduler accounts for itself; without this
	// counter a parse that arbitrated three competitors is indistinguishable
	// in the receipt from one that never competed, and no differential harness
	// could confirm the port picks what C picks.
	// RecoveryRootSelections counts completed recovered-path elections.
	RecoveryRootSelections    uint64
	RecoveryLineageSelections uint64
	// RecoveryLineageRetirements counts C-condense-tail transitions that remove
	// one trailing no-action recovery version after an earlier version shifts.
	RecoveryLineageRetirements uint64
	// RecoveryAmbiguityForks counts ordinary grammar forks whose source already
	// belongs to a recovery competition. The outputs retain recovery cost.
	RecoveryAmbiguityForks uint64
	// RecoveryCondensePasses counts completed C-style recovery condensations.
	RecoveryCondensePasses uint64
	// RecoveryVersionCapDrops counts histories removed because their distinct
	// C merge key ranked after the six-version recovery limit.
	RecoveryVersionCapDrops uint64
	// SingleHeaderPasses counts dispatch passes executed against a
	// single-header frontier (spec.c4-bytecode-isa.v1 section 5, obligation
	// R6). It is count-only and published on the gts_workcount board so
	// corridor coverage is a committed board row rather than a
	// profile-derived figure. It is a strict subset of Passes.
	SingleHeaderPasses uint64
	// CorridorPasses counts the subset of SingleHeaderPasses the C4 bytecode
	// corridor executed. It is zero on every build and every parse with the
	// corridor lane off, so it never perturbs the pinned board.
	CorridorPasses             uint64
	ActionLookups              uint64
	Dispatches                 uint64
	Conflicts                  uint64
	ConflictActions            uint64
	Forks                      uint64
	ConflictActionArmsAdmitted uint64
	CausalConflictForks        uint64
	ConflictHeads              uint64
	// ConvergedReductionSplitDrops counts no-action drops descended from a
	// reduction that split multiple compact predecessor paths into live heads.
	ConvergedReductionSplitDrops uint64
	// ConvergedCoverageDrops counts converged split drops whose dropped
	// header's recorded alternative set was contained in one surviving,
	// non-blended header's recorded set (spec.b4b-alternative-set.v2 section
	// 5, the revised theorem). Renamed from SelectedLineageDrops at stage
	// 2b, when the v2 containment predicate replaced the scalar (rank,
	// lineage) proof as the deciding proof.
	ConvergedCoverageDrops uint64
	RepetitionFolds        uint64
	Reductions             uint64
	OrdinaryShifts         uint64
	OrdinaryCohorts        uint64
	ExtraShifts            uint64
	ExtraCohorts           uint64
	Accepts                uint64
	// RecoverEOFAccepts counts one certified live publication of C's
	// recover_eof ERROR root. It is distinct from ordinary ActionAccept work.
	RecoverEOFAccepts uint64
	ReductionPauses   uint64
	NoActionDrops     uint64
	Elections         uint64
	// PerVersionLexRequests counts lexer calls issued for an owned parser
	// version. The shared lexer election does not contribute to this counter.
	PerVersionLexRequests uint64
	// PerVersionLexRestores counts exact DFA and scanner snapshot restores
	// before an owned request or a state-dependent re-request.
	PerVersionLexRestores uint64
	// PerVersionLexPublications counts immutable snapshots published to a
	// parser header or its scheduler sidecar.
	PerVersionLexPublications uint64
	// PerVersionLexAcceptedRaggedSpans counts different-width token views that
	// the owned scheduler accepted instead of declining at a shared cursor.
	PerVersionLexAcceptedRaggedSpans uint64
	// PerVersionLexViabilityDrops counts owned versions removed only after
	// their own tokens exhausted reductions without an action and a sibling's
	// token shifted from the same byte. These are not grammar-ambiguity drops.
	PerVersionLexViabilityDrops uint64
	// PeakLiveVersions records the largest live owned-header frontier.
	PeakLiveVersions  uint64
	Canonicalizations uint64
	PeakHeaders       uint64
	// ZeroWidthCatchUpMissedMerge counts an ownedZeroWidthCatchUp call whose
	// own header (identified by creationSeq) could not be found: the
	// committed zero-width shift's own canonicalizeOwned call (inside
	// applyGenericShifts/applyGenericExtraShifts, run before
	// ownedZeroWidthCatchUp) already folded that header into a different
	// surviving one before the reopen mark could be set. Not a correctness
	// failure -- the merge target still closes its own barrier normally --
	// but the ragged-drop rescue this election's shift was meant to unlock
	// never activates for it, so a differential harness needs this counter,
	// not a silent no-op, to notice the mechanism did not fire.
	ZeroWidthCatchUpMissedMerge uint64
	Overflow                    bool
}

type DiagnosticParserCoreHeaderPathReceipt struct {
	Header               DiagnosticParserCoreHeaderReceipt
	Derivations          []DiagnosticParserCorePackedDerivation
	DerivationsTruncated bool
}

type DiagnosticParserCoreHeaderReceipt struct {
	CreationSeq uint64
	State       StateID
	ByteOffset  uint32
	Shifted     bool
	Accepted    bool
	Paused      bool
	ExactPaths  uint64
	Checkpoint  [32]byte
}

type DiagnosticParserCorePackedDerivation struct {
	Score          int64
	BranchOrder    uint64
	HasBranchOrder bool
}

type DiagnosticParserCorePrefixOptions struct {
	Recovery       bool
	Retry          bool
	Incremental    bool
	IncludedRanges bool
	// GenericStopAtClosedByte publishes a successful closed-frontier receipt
	// when every authenticated scheduler head closes at this byte. Nil is
	// unbounded. The boundary is checked before another scanner election.
	GenericStopAtClosedByte *uint32
	ReceiptMode             DiagnosticParserCoreReceiptMode

	// DisablePerHeaderSpanUnlockedRelex restores relexTokenForState's
	// pre-D2-1 span-locked probe (only an exact-span relex is eligible; a
	// relex whose EndByte differs from the shared election is declined the
	// same way a scan failure is, never routed through owned lexer
	// activation). The zero value keeps the span-unlocked probe on. This is a
	// test-and-diagnostic lever only: no production caller sets it, and it
	// has no operator-facing surface (config flag, CLI flag, or similar).
	DisablePerHeaderSpanUnlockedRelex bool

	MaxDispatches uint64
	MaxTokens     uint64
	Limits        core.Limits
	// contains filtered or unexported fields
}

type DiagnosticParserCorePrefixResult struct {
	Boundary          DiagnosticParserCoreBoundaryKind
	Detail            string
	Dispatches        uint64
	Tokens            uint64
	State             StateID
	Lookahead         Token
	LastBranchOrder   uint64
	GenericScheduler  *DiagnosticParserCoreGenericScheduler
	Completed         bool
	Elections         []DiagnosticParserCoreElection
	SourceSHA256      [32]byte
	GrammarBlobSHA256 [32]byte
	Grammar           string
	ExactRootDFA      bool
	Materialized      bool
	// MaterializedTree is a structural diagnostic owned by the caller and must
	// be released. It is set only after authenticated EOF acceptance and
	// one-shot compact-tree materialization succeed. The diagnostic runner does
	// not force parser-state replay, so its default tree retains the hard
	// incremental-reuse bar. The production admission runner separately forces
	// replay and may clear that bar only when materialization proves the required
	// states and scanner quiescence per tree.
	MaterializedTree *Tree
}

type DiagnosticParserCoreReceiptMode uint8

type DiagnosticParserCoreRoundAction struct {
	HeaderIndex int
	State       StateID
	ByteOffset  uint32
	Ordinal     int
	Action      ParseAction
	BranchOrder uint64
}

type DiagnosticParserCoreScannerCheckpoint struct {
	Length int
	SHA256 [32]byte
}

type DiagnosticParserCoreShadowCensusFalsifier struct {
	Detail string
}

type DiagnosticParserCoreShadowCensusTotals struct {
	// Agree: both proofs reached the same verdict (both proved or both
	// declined).
	Agree uint64
	// OldProvedNewUnproved is a design falsifier candidate (spec.b4b-
	// alternative-set.v2 section 7): the scalar proof proved a drop v2 could
	// not. Under the theorem this is expected and safe (v2 is strictly more
	// conservative, never less), so it is not itself a stop rule; class 2
	// below is its typed name.
	OldProvedNewUnproved uint64
	// NewProvedOldUnproved is the expected, desired direction: the v2 proof
	// is strictly more capable than the scalar proof on this drop.
	NewProvedOldUnproved uint64
	// NeitherProved: both proofs declined.
	NeitherProved uint64
}

type DiagnosticParserCoreTerminalPayloadView struct {
	ID                uint32
	Symbol            Symbol
	ProductionID      uint16
	DynamicPrecedence int16
	StartByte         uint32
	EndByte           uint32
	Children          []uint32
	Fields            []FieldMapEntry
	Aliases           []Symbol
	Extra             bool
	External          bool
	Terminal          bool
}

type DiagnosticParserCoreThreeProofCensusTotals struct {
	// Elections is the number of converged-split no-action drop elections
	// observed (one call to dropGenericNoActionHeads with a non-empty
	// indices batch).
	Elections uint64
	// ScalarProved / V1Proved / V2Proved count how many elections each
	// proof, evaluated independently, proved.
	ScalarProved uint64
	V1Proved     uint64
	V2Proved     uint64
	// Class1V2AdmitsScalarDeclines: v2 proves where the retired scalar proof
	// declines -- the class the stage 1 census structurally could not see,
	// and the Kotlin class detector (spec section 7 class 1). The stage 2b
	// gate required this class to carry zero differing-tree cases
	// (adjudicated against the C oracle, not raw production equality;
	// campaign amendment 2026-08-02) across the corpora in scope; it stays a
	// live regression watch now that v2 is the decider.
	Class1V2AdmitsScalarDeclines uint64
	// Class2ScalarProvesV2Declines: the retired scalar proof proves where v2
	// (the live decider) declines -- expected non-zero (rank-preference
	// drops, the coincidental-premise class v1's own design indicted; spec
	// section 7 class 2). No gate; these are the newly-declined drops v2
	// falls back on.
	Class2ScalarProvesV2Declines uint64
	// Class3V1ProvesV2Declines: v1 (event-only) proves where v2 declines --
	// the branch-discrimination accepted capability cost (spec section 7
	// class 3). No gate; the Kotlin witness is the canonical member.
	Class3V1ProvesV2Declines uint64
	// BlendedVetoFirings: elections where v2 found an exact-member-
	// containing candidate witness but rejected it solely because that
	// witness was blended (spec section 7 class 4 rate; open question 2).
	BlendedVetoFirings uint64
	// OverflowDeclines: elections where v1 or v2 declined because the
	// dropped header's own recorded set had overflowed the hard cap (spec
	// section 7 class 4 rate).
	OverflowDeclines uint64
	// SpillElections / SpillObserved: elections examined, and how many of
	// them touched at least one spilled (beyond-inline) recorded set --
	// re-checks the 1-percent spill-rate gate at uint32 member width (v1
	// open question 5; spec section 7 class 4 rate).
	SpillElections uint64
	SpillObserved  uint64
	// MaxBranchOrdinalObserved: the largest branch ordinal recorded on any
	// member examined by the census (spec section 7 class 4 rate).
	MaxBranchOrdinalObserved uint16
}

type DiagnosticParserCoreVersionLexerRequest struct {
	ElectionIndex     int
	HeaderCreationSeq uint64
	State             StateID
	Token             Token
	InternalDFAToken  bool
	ScannerBefore     DiagnosticParserCoreScannerCheckpoint
	ScannerAfter      DiagnosticParserCoreScannerCheckpoint
}

type ErrorTreeIncrementalReuseExternalScanner interface {
	ExternalScanner
	SupportsIncrementalReuseFromErrorTree() bool
}

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

type ExternalScanner interface {
	Create() any
	Destroy(payload any)
	Serialize(payload any, buf []byte) int
	Deserialize(payload any, buf []byte)
	Scan(payload any, lexer *ExternalLexer, validSymbols []bool) bool
}

type ExternalScannerCheckpointIdentity struct {
	Scanner []byte
	Grammar []byte
}

type ExternalScannerCheckpointIdentityProvider interface {
	CheckpointedExternalScanner
	CheckpointIdentity() (ExternalScannerCheckpointIdentity, bool)
}

type ExternalScannerFullParseRetryPolicy uint8

type ExternalScannerState struct {
	Data []byte
}

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

type ExternalVMInstr struct {
	Op  ExternalVMOp
	A   int32
	B   int32
	Alt int32
}

type ExternalVMOp uint8

type ExternalVMProgram struct {
	Code     []ExternalVMInstr
	MaxSteps int // <=0 uses a safe default based on program size
}

type ExternalVMRuneClass uint8

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

type FactKind uint8

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

type FactSet struct {
	Definitions []DefinitionSpan
	Calls       []CallRef
	Heritage    []HeritageRef
	Imports     []ImportRef
}

type FailurePreservingExternalScanner interface {
	ExternalScanner
	PreservesStateOnScanFailure() bool
}

type FailureStateRetainingExternalScanner interface {
	ExternalScanner
	RetainsStateOnScanFailure() bool
}

type FieldID uint16

type FieldMapEntry struct {
	FieldID    FieldID
	ChildIndex uint8
	Inherited  bool
}

type ForestCapTieReceipt struct {
	Symbol             Symbol
	CandidateStart     uint32
	CandidateEnd       uint32
	CandidatePrevState StateID
	CandidatePrevByte  uint32
	IncumbentStart     uint32
	IncumbentEnd       uint32
	IncumbentPrevState StateID
	IncumbentPrevByte  uint32
	SameSpan           bool
	CandidateKept      bool
}

type ForestCapTieStats struct {
	HiddenTieDecisions int
	CandidatesPinned   int
	SameSpanTies       int
	Receipts           []ForestCapTieReceipt
}

type FullParseAcceptedErrorRetryProfile struct {
	MinSourceBytes                 uint32
	InitialStackCeiling            uint16
	SkipCompleteAcceptedErrorRetry bool
	FreshErrorNoStacksMaxPasses    uint8
	// SkipCompleteMaxEntryScratchPeak limits complete-tree and fresh-result skips
	// to a certified peak number of live GLR scratch entries. Zero is unbounded.
	SkipCompleteMaxEntryScratchPeak uint32
	// FreshErrorNoStacksRetryMaxStacks replaces the generic widened-stack
	// target for a fresh error-bearing no-stacks parse. Zero keeps the generic
	// target. Incremental fallbacks and explicit environment overrides ignore it.
	FreshErrorNoStacksRetryMaxStacks uint16
	// SkipInitialCompleteAcceptedErrorMergeRetry skips only the first
	// same-stack merge retry for a fresh, complete accepted-error parse. Later
	// widened-stack and merge retries remain available. Incremental fallbacks
	// and explicit stack/merge environment overrides ignore it.
	SkipInitialCompleteAcceptedErrorMergeRetry bool
	// SkipCompleteMinSourceBytes limits complete-tree and fresh-result skips to
	// sources at least this large. Zero preserves the unbounded behavior.
	SkipCompleteMinSourceBytes uint32
	// ReuseCleanWideForWideRetry certifies that the complete accepted-error tree
	// from the non-recovery widened-stack pass is identical to the following
	// recovery-enabled widened-stack pass. The parser may retain that tree and
	// substitute it at the recovery-wide slot while preserving retry accounting.
	ReuseCleanWideForWideRetry bool
	// ReuseCleanWideMinSourceBytes limits clean-wide reuse to the certified
	// large-source class. Zero disables the policy even when the boolean is set.
	ReuseCleanWideMinSourceBytes uint32
	// GSSConvergenceAcceptedErrorMergePerKey sets the exact merge width for an
	// accepted-error retry after a certified cap-one full parse. Zero keeps the
	// other retry policies. Explicit environment settings disable this policy.
	GSSConvergenceAcceptedErrorMergePerKey uint16
	// SkipFreshCompleteAcceptedErrorRetry keeps the initial fresh full-parse
	// result when it is a complete accepted-error tree. It does not suppress a
	// later merge retry after a no-stacks or node-limit result.
	SkipFreshCompleteAcceptedErrorRetry bool
}

type HeritageRef struct {
	Lang            string
	Kind            string
	Name            string
	Parent          string
	NodeType        string
	StartByte       uint32
	EndByte         uint32
	ParentStartByte uint32
	ParentEndByte   uint32
}

type HighlightRange struct {
	StartByte    uint32
	EndByte      uint32
	Capture      string // "keyword", "string", "function", etc.
	PatternIndex int    // query pattern index; later patterns override earlier for identical ranges
}

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

type HighlighterInjectionResolver func(languageHint string) (lang *Language, highlightQuery string, tokenSourceFactory func(source []byte) TokenSource, ok bool)

type HighlighterInjectionSpec struct {
	Query           string
	ResolveLanguage HighlighterInjectionResolver
}

type HighlighterOption func(*Highlighter)

type ImportExtractResult struct {
	Imports             []ImportRef
	Status              ImportExtractStatus
	Reason              string
	FallbackRecommended bool
}

type ImportExtractStatus string

type ImportRef struct {
	Lang      string
	Kind      string
	Path      string
	From      string
	Name      string
	Alias     string
	Static    bool
	Wildcard  bool
	Relative  int
	StartByte uint32
	EndByte   uint32
}

type IncrementalParseProfile struct {
	ReuseCursorNanos int64
	ReparseNanos     int64
	ReusedSubtrees   uint64
	ReusedBytes      uint64
	// TokenInvariantDependencyChecks counts bounded lexical comparisons.
	// A comparison can reject reuse when an earlier token changes.
	TokenInvariantDependencyChecks     uint64
	NewNodesAllocated                  uint64
	ReuseUnsupported                   bool
	ReuseUnsupportedReason             string
	AcceptedErrorRetryAttempts         uint8
	AcceptedErrorRetryAdopted          bool
	AcceptedErrorRetryMergePerKey      int
	AcceptedErrorRetryCause            IncrementalRetryCause
	OldTreeReuseRoute                  bool
	ReuseRejectDirty                   uint64
	ReuseRejectAncestorDirtyBeforeEdit uint64
	ReuseRejectHasError                uint64
	ReuseRejectInvalidSpan             uint64
	ReuseRejectOutOfBounds             uint64
	ReuseRejectRootNonLeafChanged      uint64
	// ReuseObservedPreGotoStateMismatch counts top-level block-splice candidates
	// observed at a live parser state different from the node's recorded
	// PreGotoState. This is diagnostic only: the established admission contract
	// remains goto-target compatibility plus fragility until #432 replaces it
	// with a complete ownership proof.
	ReuseObservedPreGotoStateMismatch uint64
	ReuseRejectLargeNonLeaf           uint64
	ReuseRejectStaleNonLeafBoundary   uint64
	// ReuseRejectFragileNonLeaf counts interior (non-leaf) reuse candidates
	// rejected because Node.isFragile() reported the candidate was built
	// under an ambiguous parse decision (LR-table conflict, GSS multi-pop, or
	// concurrent GLR stack versions) or is itself an ERROR/MISSING node -- see
	// markReduceFragility (parser_reduce.go) and reuseNonLeafTargetStateOnStack
	// (incremental.go). A nonzero count on a conflict-heavy grammar (e.g. js)
	// is expected and correct: it is exactly the unsound reuse this gate is
	// designed to prevent.
	ReuseRejectFragileNonLeaf uint64
	// BlockSpliceSteps is the number of top-level sibling reuses taken inside
	// the W1 block-splice composition loop (spec.campaign.oedit): one per
	// sibling spliced without a full main-loop round trip. It is O(edit) and
	// deterministic for a fixed (source, edit, language).
	BlockSpliceSteps uint64
	// ReuseRejectScannerUnquiescent counts reuse candidates the external
	// scanner checkpoint/quiescence gate rejected -- a checkpoint state
	// mismatch on a checkpoint language, or a refuted quiescence proof on an
	// opt-out scanner (campaign O(edit) workstream W4, spec.campaign.oedit).
	// It is 0 for stateless-scanner languages such as Go, whose ASI scanner
	// carries no cross-token state and is proven quiescent at every boundary
	// (external_scanner_quiescence.go). A nonzero count marks boundaries where
	// scanner state, not fragility or byte drift, is the binding constraint.
	ReuseRejectScannerUnquiescent uint64
	// ReuseRejectFrontierProofUnavailable counts compact-materialized non-leaf
	// candidates rejected because exact scanner bytes do not prove the parser
	// frontier that owned the original reduction.
	ReuseRejectFrontierProofUnavailable uint64
	RecoverSearches                     uint64
	RecoverStateChecks                  uint64
	RecoverStateSkips                   uint64
	RecoverSymbolSkips                  uint64
	RecoverLookups                      uint64
	RecoverHits                         uint64
	MaxStacksSeen                       int
	EntryScratchPeak                    uint64
	StopReason                          ParseStopReason
	TokensConsumed                      uint64
	LastTokenEndByte                    uint32
	ExpectedEOFByte                     uint32
	ArenaBytesAllocated                 int64
	// ArenaBaselineBytes sums retained arena capacity before each attempt.
	// Subtract it from ArenaBytesAllocated to measure total operation growth.
	ArenaBaselineBytes    int64
	ScratchBytesAllocated int64
	// ScratchBaselineBytes sums retained scratch capacity before each attempt.
	// Subtract it from ScratchBytesAllocated to measure total operation growth.
	ScratchBaselineBytes                int64
	EntryScratchBytesAllocated          int64
	GSSBytesAllocated                   int64
	SingleStackIterations               int
	MultiStackIterations                int
	SingleStackTokens                   uint64
	MultiStackTokens                    uint64
	SingleStackGSSNodes                 uint64
	MultiStackGSSNodes                  uint64
	GSSNodesAllocated                   uint64
	GSSNodesRetained                    uint64
	GSSNodesDroppedSameToken            uint64
	ParentNodesAllocated                uint64
	ParentNodesRetained                 uint64
	ParentNodesDroppedSameToken         uint64
	LeafNodesAllocated                  uint64
	LeafNodesRetained                   uint64
	LeafNodesDroppedSameToken           uint64
	MergeStacksIn                       uint64
	MergeStacksOut                      uint64
	MergeSlotsUsed                      uint64
	GlobalCullStacksIn                  uint64
	GlobalCullStacksOut                 uint64
	ParserLoopNanos                     int64
	TokenNextNanos                      int64
	ActionDispatchNanos                 int64
	ActionLookupNanos                   int64
	GLRMergeNanos                       int64
	GLRCullNanos                        int64
	ResultSelectionNanos                int64
	TransientParentMaterializationNanos int64
	ResultTreeBuildNanos                int64
	TransientChildMaterializationNanos  int64
	ResultPythonKeywordRepairNanos      int64
	ResultPythonRootRepairNanos         int64
	ResultFinalizeRootNanos             int64
	ResultExtendTrailingNanos           int64
	ResultNormalizeRootStartNanos       int64
	ResultCompatibilityNanos            int64
	ResultParentLinkNanos               int64
	ReduceRangeNanos                    int64
	ReducePendingParentNanos            int64
	ReduceChildBuildNanos               int64
	ReduceParentBuildNanos              int64
	ReduceSpanNanos                     int64
	ReduceStackPushNanos                int64
	ReduceNoTreeBuildNanos              int64
	ActionExtraShiftNanos               int64
	ActionNoActionNanos                 int64
	ActionNoActionRelexNanos            int64
	ActionNoActionMissingNanos          int64
	ActionNoActionRecoverNanos          int64
	ActionNoActionErrorNanos            int64
	ActionConflictChoiceNanos           int64
	ActionConflictForkNanos             int64
	ActionSingleShiftNanos              int64
	ActionSingleReduceNanos             int64
	ActionSingleAcceptNanos             int64
	ActionSingleRecoverNanos            int64
	ActionSingleOtherNanos              int64
	NormalizationNanos                  int64
}

type IncrementalPrefixFrontierExternalScanner interface {
	ExternalScanner
	RequiresIncrementalPrefixFrontierProof() bool
}

type IncrementalRetryCause uint8

type IncrementalReuseExternalScanner interface {
	ExternalScanner
	SupportsIncrementalReuse() bool
}

type IncrementalReuseTokenSource interface {
	TokenSource
	SupportsIncrementalReuse() bool
}

type Injection struct {
	// Language is the detected language name (e.g., "javascript").
	Language string
	// Tree is the parse tree for this region, or nil if the language
	// was not registered.
	Tree *Tree
	// Ranges are the source ranges this tree covers.
	Ranges []Range
	// Node is the parent tree node that triggered the injection.
	Node *Node
}

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

type InjectionResult struct {
	// Tree is the parent language's parse tree.
	Tree *Tree
	// Injections contains child language parse results, ordered by position.
	Injections []Injection
}

type InputEdit struct {
	StartByte   uint32
	OldEndByte  uint32
	NewEndByte  uint32
	StartPoint  Point
	OldEndPoint Point
	NewEndPoint Point
}

type InputEncoding uint8

type InternObservationStats struct {
	// Phase 2 counters (parseState-blind observation across ALL leaves).
	LeafLookups uint64
	LeafHits    uint64
	LeafMisses  uint64
	LeafStores  uint64
	LeafGrowths uint64
	// Phase 3 attribution. Shift-path leaves get parseState set per-fork
	// so they can't be canonically substituted via the parseState-blind
	// measurement; non-shift leaves can. "Safe to substitute" via blind
	// measurement = (LeafMisses+LeafHits) - ShiftLeafObserved.
	ShiftLeafObserved uint64
	// Phase 3 parseState-aware measurement. Same hook as LeafLookups
	// but with parseState/preGotoState included in the key. A hit here
	// means a truly dedup-safe duplicate; the difference between this
	// and the blind hit rate quantifies how much of the blind
	// observation was an artifact of ignoring state.
	FullLookups uint64
	FullHits    uint64
	FullMisses  uint64
}

type Language struct {
	Name string
	// GeneratedByGrammargen is true for languages assembled by grammargen at
	// runtime rather than decoded from a checked-in ts2go blob.
	GeneratedByGrammargen bool

	// CRecoveryCostCompetitionCapable records parser.c/table evidence that the
	// grammar exposes the C recovery surface: RECOVER actions plus an
	// ERROR_STATE lex mode. It is capability metadata only, not a default-on
	// parity certification.
	CRecoveryCostCompetitionCapable bool

	// CRecoveryCostCompetitionEnabledByDefault explicitly certifies that the
	// faithful C recovery-cost competition gate is parity-safe as default
	// behavior for this language. Runtime gating also requires capability
	// metadata and conservative table validation.
	CRecoveryCostCompetitionEnabledByDefault bool

	// WantsForest opts this language into the GSS-forest GLR fast path.
	// Consumers generating a Language via grammargen set this (directly or via
	// grammargen.Grammar.WantsForest) to enable forest for their own grammar. This
	// bypasses the byte-range parity certification built-ins undergo — the
	// decline->production fallback still prevents hard failures on declined inputs,
	// but a clean-but-different tree is the consumer's responsibility.
	WantsForest bool

	// LanguageVersion is the tree-sitter language ABI version.
	// A value of 0 means "unknown/unspecified" and is treated as compatible.
	LanguageVersion uint32

	// Counts
	SymbolCount        uint32
	TokenCount         uint32
	ExternalTokenCount uint32
	StateCount         uint32
	LargeStateCount    uint32
	FieldCount         uint32
	ProductionIDCount  uint32

	// Symbol metadata
	SymbolNames    []string
	SymbolMetadata []SymbolMetadata
	FieldNames     []string // index 0 is ""

	// Parse tables
	ParseTable         [][]uint16 // dense: [state][symbol] -> action index
	SmallParseTable    []uint16   // compressed sparse table
	SmallParseTableMap []uint32   // state -> offset into SmallParseTable
	ParseActions       []ParseActionEntry
	// LargeStateGotos stores nonterminal GOTO targets that do not fit in the
	// uint16 parse-table cells used by tree-sitter C tables. Keys are
	// uint64(state)<<32 | uint64(symbol). Terminal actions must never live here.
	//
	// This is the only exported map field on Language, which matters for blob
	// serialization: gob's map codec iterates via reflect's randomized
	// MapRange, so blob encoders never gob-encode this field directly when
	// it's non-empty (today, only c_sharp populates it). See
	// large_state_gotos_trailer.go for the deterministic encode/decode path.
	LargeStateGotos map[uint64]StateID

	// ReduceChainHints are optional generated hot-path hints for deterministic
	// reduce runs. They are only consumed when reduce-chain hints are enabled.
	ReduceChainHints []ReduceChainHint

	// ConflictPolicies are optional deterministic conflict policies derived
	// from grammar tables.
	ConflictPolicies []ConflictPolicy

	// Lex tables
	LexModes            []LexMode
	LexStates           []LexState // main lexer DFA
	KeywordLexStates    []LexState // keyword lexer DFA (optional)
	KeywordCaptureToken Symbol
	// LayoutFallbackLexState is an optional broad DFA start state used only in
	// layout-entry parser states. It lets the runtime avoid skipping over
	// zero-width external layout markers before the layout scanner fires.
	LayoutFallbackLexState    uint16
	HasLayoutFallbackLexState bool

	// Field mapping
	FieldMapSlices  [][2]uint16 // [production_id] -> (index, length)
	FieldMapEntries []FieldMapEntry

	// Alias sequences
	AliasSequences [][]Symbol // [production_id][child_index] -> alias symbol

	// ProductionSignatures records LHS/RHS shape for grammargen productions.
	// It is separate from ProductionID because ProductionID is deliberately
	// compacted by field/alias pattern and is not a unique RHS identity.
	ProductionSignatures []ProductionSignature

	// Primary state IDs (for table dedup)
	PrimaryStateIDs []StateID

	// ABI 15: Reserved words — flat array indexed by
	// (reserved_word_set_id * MaxReservedWordSetSize + i), terminated by 0.
	ReservedWords          []Symbol
	MaxReservedWordSetSize uint16

	// ABI 15: Supertype hierarchy
	SupertypeSymbols    []Symbol
	SupertypeMapSlices  [][2]uint16 // [supertype_symbol] -> (index, length)
	SupertypeMapEntries []Symbol

	// HiddenChoicePassthroughSymbols marks generated hidden nonterminals whose
	// productions are only neutral single-symbol pass-throughs. These wrappers
	// are structural parser routes, not tree nodes; checked-in blobs leave this
	// nil to preserve legacy behavior.
	HiddenChoicePassthroughSymbols []bool

	// ABI 15: Grammar semantic version
	Metadata LanguageMetadata

	// External scanner (nil if not needed)
	ExternalScanner ExternalScanner
	ExternalSymbols []Symbol // external token index -> symbol

	// ImmediateTokens is a bitmask of symbol IDs that are token.immediate() tokens.
	// When the lexer matches one of these after consuming whitespace, the match
	// should be rejected — immediate tokens must match at the original position.
	// nil means no immediate tokens (common for ts2go grammars).
	ImmediateTokens []bool
	// ZeroWidthTokens is a bitmask of symbol IDs whose DFA terminal pattern can
	// intentionally match empty input. nil means this information is unavailable,
	// which preserves historical lexer behavior for ts2go blobs.
	ZeroWidthTokens []bool

	// ExternalLexStates maps external lex state IDs (from LexMode.ExternalLexState)
	// to a boolean slice indicating which external tokens are valid. Row 0 is
	// always all-false (no external tokens valid). When non-nil, this table is
	// used instead of parse-action-table probing to compute validSymbols for the
	// external scanner, matching C tree-sitter's ts_external_scanner_states.
	ExternalLexStates [][]bool

	// InitialState is the parser's start state. In tree-sitter grammars
	// this is always 1 (state 0 is reserved for error recovery). For
	// hand-built grammars it defaults to 0.
	InitialState StateID

	// NonTerminalAliasMap mirrors tree-sitter C's ts_non_terminal_alias_map.
	// Rows are indexed by nonterminal symbol and contain aliases that require
	// preserving the wrapper during alias-bearing reductions. This is cold
	// metadata and intentionally lives in the struct's cold tail so parser hot
	// field offsets stay stable.
	NonTerminalAliasMap [][]Symbol

	// ExternalScannerFullParseRetryPolicy is a certified language-level policy
	// for scheduling the extra external-scanner full-parse retry. Zero preserves
	// the generic behavior for legacy blobs and caller-constructed languages.
	ExternalScannerFullParseRetryPolicy ExternalScannerFullParseRetryPolicy

	// FullParseAcceptedErrorRetryProfile is certified against an exact language
	// blob. Zero preserves widened-stack and no-stacks retries for legacy blobs,
	// caller-constructed languages, and language overrides.
	FullParseAcceptedErrorRetryProfile FullParseAcceptedErrorRetryProfile

	// AutomaticForestMemoryAllowanceBytes bounds only the speculative forest
	// phase used by automatic dispatch. Zero preserves the full parse budget for
	// legacy blobs, caller-constructed languages, language overrides, and
	// explicit ParseForestExperimental calls. Built-in values are certified and
	// attached only after exact blob-identity verification.
	AutomaticForestMemoryAllowanceBytes int64

	// AutomaticForestEnabledByDefault certifies the speculative forest route for
	// this exact language artifact. Checked-in built-ins receive this bit only
	// from an exact-blob runtime profile; legacy blobs, same-name custom grammars,
	// adapted grammars, and overrides retain the conservative false default.
	AutomaticForestEnabledByDefault bool

	// FullParseArenaDensityCapEnabled explicitly opts this language into the ASCII
	// structural-density arena cap. Checked-in built-ins are enabled automatically
	// only through an exact-blob runtime profile. Callers may explicitly opt in
	// custom or adapted languages; false preserves the baseline arena policy.
	FullParseArenaDensityCapEnabled bool

	// FullParseGSSConvergenceEnabled certifies faithful convergence for this
	// language artifact. The parser keeps clean alternatives in the graph when
	// one stack survives each merge group. Checked-in languages receive this
	// setting only through an exact blob profile. Callers can enable it for
	// custom languages after equivalent tree tests. An explicit merge limit of
	// one also enables this behavior for a fresh full parse.
	FullParseGSSConvergenceEnabled bool

	// NativeResultCompatibility identifies result-tree shapes produced natively
	// by this exact language artifact. Zero keeps conservative post-parse
	// compatibility fallbacks for legacy blobs, generated grammars, caller-built
	// languages, and overrides whose native behavior has not been certified.
	NativeResultCompatibility ResultCompatibilityCapability

	// NativeUnaryWrapperFlattening identifies exact same-span unary wrappers
	// that C omits below a public parent in one parser state. Exact runtime
	// profiles populate the symbol and state identities. Custom and stale
	// artifacts keep the wrappers.
	NativeUnaryWrapperFlattening []UnaryWrapperFlatteningRule

	// CompactConvergedReductionSplitDropsCertified permits the compact
	// fresh-full route to accept after it drops a no-action head descended from
	// a converged-path reduction split. Exact built-in artifact profiles set
	// this only after C-oracle parity proves that production selects the same
	// surviving path. Custom and adapted languages fail closed by default.
	CompactConvergedReductionSplitDropsCertified bool

	// CompactEOFAcceptNoActionSiblingsCertified permits one authenticated EOF
	// accept head to discard siblings that have no action for that same EOF.
	// Exact built-in profiles set this only after C-oracle parity proves the
	// accepted head matches production. Custom and adapted languages fail closed.
	CompactEOFAcceptNoActionSiblingsCertified bool

	// CompactPrimaryAcceptanceDerivationCertified permits the compact fresh-full
	// route to select one primary derivation over secondary conflict derivations.
	// The primary score must be at least every secondary score. Exact built-in
	// profiles set this only after C-oracle parity proves production selects it.
	CompactPrimaryAcceptanceDerivationCertified bool

	// CompactAcceptanceStructuralElectionCertified permits the compact route
	// to apply C's raw subtree ordering to a clean, tied acceptance frontier.
	// Exact built-in profiles set this only after the locked C oracle proves
	// the compact derivation order and result for that grammar artifact.
	// Custom, adapted, and stale artifacts retain the false default.
	CompactAcceptanceStructuralElectionCertified bool

	// CompactMixedGSSMergeCertified permits one boundary merge to join flat
	// and graph-structured stack forms with C's physical receiver ownership.
	// Exact built-in profiles set this only after locked C parity proves the
	// mixed representation path for that grammar artifact. Custom, adapted,
	// and stale artifacts retain the false default.
	CompactMixedGSSMergeCertified bool

	// CompactLexerSkippedPrefixTilingCertified permits an internal compact
	// reduction gap when the next accepted terminal carries exact DFA evidence
	// for the complete skipped prefix. Exact built-in profiles set this only
	// after locked-C parity proves the result for that grammar artifact.
	// Custom, adapted, and stale artifacts retain the false default.
	CompactLexerSkippedPrefixTilingCertified bool

	// ExactStackNodeEquivalenceCertified preserves deep stack-node alternatives
	// until generic result selection. Exact built-in profiles set this only when
	// bounded equivalence can merge parity-relevant shapes. Custom, adapted, and
	// stale artifacts retain bounded equivalence unless callers opt in.
	ExactStackNodeEquivalenceCertified bool

	// CompactPackedGSSVersionOrderCertified permits the compact fresh-full route
	// to use C's physical stack-version transaction order for packed graph-
	// structured stack reductions. The transaction includes action-slot ownership,
	// same-round scheduling, bounded wave-order pop traversal, C-equivalent link
	// packing, boundary packing, and packed-child election. Exact built-in
	// profiles set this only after locked-C receipts and memory-budget tests
	// certify the complete bundle. Custom, adapted, and stale artifacts retain
	// the false default.
	CompactPackedGSSVersionOrderCertified bool

	// CompactStrategy2ErrorRegionCertified permits the compact fresh-full route
	// to attempt native strategy-2 recovery (error-region absorb and
	// condense-resume, campaign v7 tranche B3 stage S3) for a true no-table-
	// action point: close in-progress productions on a single deterministic
	// path, open an ERROR region, absorb tokens the table cannot place, and
	// resume once the pre-error state accepts the current token. Exact
	// built-in profiles set this only after C-oracle parity proves the
	// resulting tree matches the pinned C oracle exactly for the certified
	// witness class. Custom and adapted languages fail closed: an
	// uncertified grammar keeps declining to production at the same
	// no-action point exactly as before this stage landed.
	CompactStrategy2ErrorRegionCertified bool

	// CompactS3MixedShiftReduceClosureStates permits standalone strategy-2
	// recovery to stop its single-path closure at one certified state that has
	// both shift and reduce actions across terminals. Other mixed states decline.
	CompactS3MixedShiftReduceClosureStates []StateID

	// CompactRecoverEOFCertified permits one exact EOF no-action lineage to
	// publish tree-sitter's non-extra ERROR root from recover_eof. It is a
	// compatibility marker. The compact route also requires the explicit,
	// artifact-bound CompactRecoverEOFArtifactReceipt below.
	CompactRecoverEOFCertified bool

	// CompactRecoverEOFArtifactReceipt carries locked-C boundary and scheduler
	// facts for the one recover_eof route certified on this language artifact.
	// Its zero value disables the route, including when the compatibility marker
	// above is set by an older caller.
	CompactRecoverEOFArtifactReceipt CompactRecoverEOFArtifactReceipt

	// CompactStackSummaryRecoveryCertified permits the compact fresh-full
	// route to scan C's bounded stack summary at a no-action point. A
	// successful scan forks the head into an ancestor-recovered lineage and
	// an error-absorb lineage.
	//
	// The fork also requires CompactStrategy2ErrorRegionCertified. Both
	// lineages continue to acceptance, where C-compatible error pricing selects
	// the result. Exact built-in profiles must certify the complete competition.
	// Custom and adapted languages retain the false default.
	CompactStackSummaryRecoveryCertified bool

	// CompactMissingTokenInsertionCertified permits the compact fresh-full
	// route to scan for C's missing-token recovery candidate. A successful
	// scan forks the head into missing and error-absorb lineages.
	//
	// The fork also requires CompactStrategy2ErrorRegionCertified. Both
	// lineages continue to acceptance, where C-compatible error pricing selects
	// the result. Exact built-in profiles must certify the complete competition.
	// Custom and adapted languages retain the false default.
	CompactMissingTokenInsertionCertified bool

	// CompactS5EOFMissingInsertionCertified permits the compact fresh-full
	// route to run S5 reductions and missing-token insertion when the elected
	// token is EOF. This is distinct from CompactRecoverEOFCertified: S5
	// publishes a grammar root with a missing leaf, not a recover_eof ERROR
	// root. Exact built-in profiles set this only after locked-C parity proves
	// the complete EOF competition. Custom and adapted languages retain the
	// false default.
	CompactS5EOFMissingInsertionCertified bool

	// CompactFaithfulS5RecoveryCertified permits the complete S5 scan
	// to merge equivalent physical recovery heads. The legacy bounded S5 path
	// remains active without this exact artifact capability.
	CompactFaithfulS5RecoveryCertified bool

	// CompactOwnedEOFRecoveryCertified permits the bounded owned EOF route.
	// The admission runner binds its required mechanisms as one bundle.
	// Publication requires executed version-owned EOF recovery, without prior
	// shared recovery or sibling drops. Other recovery grants remain separate.
	// Custom, adapted, and stale artifacts retain the false default.
	CompactOwnedEOFRecoveryCertified bool

	// CompactRecoveryTrailingLineageRetirementCertified permits the compact
	// scheduler to retire one trailing no-action missing lineage after the
	// earlier error-absorb lineage consumed the same elected token. This is the
	// exact two-version shape that C removes in its recovery condense tail.
	// Exact built-in profiles must certify the complete transition. Custom,
	// adapted, and stale artifacts retain the false default.
	CompactRecoveryTrailingLineageRetirementCertified bool

	// CompactRecoveryErrorModeKeywordCaptureCertified permits the compact
	// scheduler to apply the grammar's keyword lexer after an error-mode lex
	// returns the keyword-capture token. C performs this second lex while the
	// recovery stack is in ERROR_STATE. Exact built-in profiles must certify
	// the complete recovery election. Custom, adapted, and stale artifacts
	// retain the false default.
	CompactRecoveryErrorModeKeywordCaptureCertified bool

	// CompactRecoveryTerminalAliasRules permits the accepted-root leaf audit to
	// authenticate a materialized terminal alias after one certified recovery
	// resume. The materializer must also prove the exact raw terminal and alias
	// node relationship. Exact built-in profiles bind each rule to one grammar
	// blob. Custom, adapted, and stale artifacts retain an empty rule set.
	CompactRecoveryTerminalAliasRules []CompactRecoveryTerminalAliasRule

	// CompactRecoveryPlainFirstCertified preserves the ordinary compact lexer
	// for the first attempt. After a fail-closed decline, the route retries with
	// C error-mode lexing and the certified S3/S5 recovery mechanisms.
	//
	// Exact built-in profiles set this only when C-oracle differentials prove
	// that the retry adds recovery routes without removing clean routes. Custom,
	// adapted, and stale artifacts keep the direct recovery attempt.
	CompactRecoveryPlainFirstCertified bool

	// LineContinuationEscapeByte declares the single byte this language's
	// scanner treats as a line-continuation escape when immediately followed
	// by a newline (LF, or CR+LF) — for example PowerShell's backtick. C
	// tree-sitter's scanner consumes an escape+newline pair as ordinary
	// skipped trivia, the same treatment bytesAreParserPadding (mid-parse gap
	// classification) and parserTailAllowsCleanAcceptance (accepted-stack and
	// accepted-tree tail classification) already give backslash+newline
	// unconditionally. Backslash needs no per-language gate because no
	// grammar this parser loads leaves a bare backslash+newline as an
	// uncovered gap that must not be crossed: languages whose grammar assigns
	// backslash+newline its own meaning (for example Python's line_continuation
	// node) tokenize it as a real, accounted-for node rather than leaving a
	// gap for these padding checks to ever see. An arbitrary escape byte
	// cannot get that same unconditional treatment because it can collide
	// with unrelated grammar meaning elsewhere (for example backtick opens a
	// Markdown fence and a shell command substitution), so acceptance
	// requires this explicit per-language declaration. Zero (the default)
	// declares no continuation escape and leaves padding classification
	// exactly as it was before this field existed. Exact built-in profiles
	// set this only after C-oracle parity confirms the escape+newline pair is
	// scanner-owned padding for the certified blob (see
	// grammars/runtime_profiles.go). Custom, adapted, and generated languages
	// default to zero and are unaffected.
	LineContinuationEscapeByte byte
	// contains filtered or unexported fields
}

type LanguageBlobInfo struct {
	// HasHeader is true when LoadLanguage found and validated a version
	// header on this blob.
	HasHeader bool
	// SchemaVersion is the blob header's own format version. Zero when
	// HasHeader is false.
	SchemaVersion uint16
	// GeneratorVersion identifies the tool and version that produced the
	// blob, e.g. "ts2go" or "grammargen". Empty when HasHeader is false or
	// the header did not set it.
	GeneratorVersion string
	// MinRuntimeVersion is the minimum BlobRuntimeVersion this runtime must
	// implement to load the blob correctly. Zero when HasHeader is false.
	MinRuntimeVersion uint32
}

type LanguageMetadata struct {
	MajorVersion uint8
	MinorVersion uint8
	PatchVersion uint8
}

type LexMode struct {
	LexState                  uint16
	ExternalLexState          uint16
	ReservedWordSetID         uint16
	AfterWhitespaceLexState   uint16 // DFA start state to use after whitespace (0 = same as LexState)
	LexStateID                uint32 // widened DFA start state for grammargen tables with >64K lexer states
	AfterWhitespaceLexStateID uint32
}

type LexState struct {
	AcceptToken    Symbol // 0 unless this state accepts a non-end token
	AcceptPriority int16  // lower = higher priority (0 for ts2go blobs = longest-match)
	Skip           bool   // true if accepted chars are whitespace
	AcceptEOF      bool   // true if this state accepts the end token at end of input
	Default        int    // default next state (-1 if none)
	EOF            int    // state on EOF (-1 if none)
	Transitions    []LexTransition
}

type LexTransition struct {
	Lo, Hi    rune // inclusive character range
	NextState int
	// Skip mirrors tree-sitter's SKIP(state): consume the matched rune
	// and continue lexing while resetting token start.
	Skip bool
}

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

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

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

type NormalizationPassRuntime struct {
	Name           string
	Checked        uint64
	Run            uint64
	NodesVisited   uint64
	NodesRewritten uint64
	Nanos          int64
}

type OutlineOwnerRule struct {
	// NodeType is the definition node type the rule applies to, for example
	// "method_declaration".
	NodeType string
	// OwnerField is the field name read through Node.ChildByFieldName, for
	// example "receiver".
	OwnerField string
	// Unwrap lists node types the rule descends through, for example
	// "parameter_list", "parameter_declaration", "pointer_type".
	Unwrap []string
	// NameTypes lists the accepted terminal node types, for example
	// "type_identifier".
	NameTypes []string
}

type OutlineReport struct {
	// Symbols counts every emitted symbol, nested symbols included.
	Symbols int
	// OmittedNoName counts definition captures whose name capture is absent
	// or whose name text trims to empty.
	OmittedNoName int
	// OmittedDuplicate counts candidates dropped because an earlier
	// candidate holds the same Range, the same Kind, the same Name, and the
	// same NameRange. These are true repeats: dropping one changes nothing.
	OmittedDuplicate int
	// OmittedNameConflict counts candidates dropped because two or more
	// candidates hold the same Range and the same Kind but disagree about
	// the name. Every member of such a group is dropped.
	//
	// This is the common shape when shared tags patterns bind "@name" twice
	// on one definition node. In C-family method syntax the two bindings are
	// the return type and the method name, and no language-neutral rule can
	// tell them apart. Choosing by capture order would publish the return
	// type as the method name, so the outline drops the group instead and
	// counts it here. The remedy is a data edit: constrain the pattern with
	// a "name:" field, the way the Go tags override already does.
	OmittedNameConflict int
	// OmittedConflict counts candidates dropped because two or more
	// candidates hold the same Range with different Kinds. Every member of
	// such a group is dropped; the outline does not guess which one is
	// right.
	OmittedConflict int
	// OmittedOverlap counts candidates dropped because they partially
	// overlap an accepted symbol.
	//
	// This rule is defensive. Two nodes of one tree are always nested or
	// disjoint, so a partial overlap cannot arise from a single tree today.
	// The rule keeps the forest well-defined if a future capture source
	// relaxes that, and the unit cases exercise it directly.
	OmittedOverlap int
	// OmittedInvalidNameRange counts candidates whose NameRange is not byte
	// contained in Range, or whose Range is itself inverted. Like
	// OmittedOverlap this is defensive: the captures of a match all sit
	// inside the matched subtree, so a single tree does not produce this
	// today.
	OmittedInvalidNameRange int
	// OmittedMultipleDefinitions counts matches dropped because they carry
	// more than one "@definition.X" capture. Such a match names two
	// definitions at once and the outline does not choose between them.
	// No inferred pattern does this today; the counter exists so that a data
	// edit that introduces the shape is visible instead of silent.
	OmittedMultipleDefinitions int
	// OwnerRuleMisses counts symbols where an owner rule matched the node
	// type but the field or the normalization did not resolve a single
	// name. It is zero whenever no attached rule names a symbol's NodeType,
	// including whenever WithOutlineOwnerRules was never called.
	OwnerRuleMisses int
	// DeclineReason names why the outliner produced nothing, or is empty
	// when it ran the query. See the OutlineDecline constants. An empty
	// reason with zero Symbols means the query ran and matched nothing,
	// which is a different fact from every declined case.
	DeclineReason string
	// Truncated reports that query execution hit the match limit or the
	// match work budget, so the symbol list is partial.
	Truncated bool
	// TreeHasError reports that the parsed tree holds an ERROR or MISSING
	// node, so the parser did not fully recover the source.
	//
	// Symbols are the query's projection of the RECOVERED tree. When
	// TreeHasError is true, definitions inside or after unrecovered regions
	// may be absent, over-long, or missing entirely, and no omission counter
	// fires for them: the query never produced a candidate to omit. Do not
	// read "every counter is zero" as "the outline is complete" on such a
	// tree. Do not assume the symbols before the first error are
	// trustworthy either; a truncated definition is itself a symbol, and its
	// Range can swallow everything that follows it.
	TreeHasError bool
}