runtime

type ActionablePanicOptions struct {
	Source         string
	Subject        string
	Message        string
	Path           string
	ComponentStack []string
	Consequence    string
}

type AgentDeleteAtomResult struct {
	Deleted     bool
	Subscribers []string
}

type AgentDetachedRoot struct {
	// Selector is the container the tree was rendered into.
	Selector string `json:"selector"`
	// Root is the budgeted, redacted fiber tree for the detached runtime. Refs
	// within it are relative to this detached root, scoped to Selector.
	Root *AgentNodeSnapshot `json:"root,omitempty"`
}

type AgentHookPreview struct {
	// Slot is the hook slot index.
	Slot int `json:"slot"`
	// Kind is the hook kind string (state, memo, ref, effect, …).
	Kind string `json:"kind"`
	// Value is the preview string; "[redacted]" when a redaction policy is active.
	Value string `json:"value"`
}

type AgentNodeSnapshot struct {
	// Name is the component or element name from describeFiber.
	Name string `json:"name"`
	// Kind is "component", "host", "text", "root", etc. from describeFiber.
	Kind string `json:"kind"`
	// Text is the full rendered text content for text nodes (empty otherwise),
	// redacted to "[redacted]" when a redaction policy is active. This lets a
	// reader recover the actual rendered copy, not just the node structure.
	Text string `json:"text,omitempty"`
	// AgentRef is the stable agent ref for this node; empty on the root fiber.
	AgentRef string `json:"agentRef,omitempty"`
	// HookCount is the number of hook slots on this fiber.
	HookCount int `json:"hookCount"`
	// Dirty reports whether this fiber has pending updates.
	Dirty bool `json:"dirty,omitempty"`
	// NeedsUpdate reports whether an ancestor queued an update for this fiber.
	NeedsUpdate bool `json:"needsUpdate,omitempty"`
	// Hooks carries hook value previews; values are redacted when a panic-report
	// redaction policy is active (fail-closed: any configured policy silences
	// hook values).
	Hooks []AgentHookPreview `json:"hooks,omitempty"`
	// Children is the (possibly truncated) list of child nodes in tree order.
	Children []AgentNodeSnapshot `json:"children,omitempty"`
}

type AgentQueryMatch struct {
	// AgentRef is the stable agent ref for the matched node.
	AgentRef string `json:"agentRef"`
	// Name is the component or element name.
	Name string `json:"name"`
	// Kind is "component", "host", "text", "root", etc.
	Kind string `json:"kind"`
	// Tag is the host element tag; empty for non-host nodes.
	Tag string `json:"tag,omitempty"`
}

type AgentQuerySelector struct {
	// Role matches the computed ARIA role derived from the element tag or the
	// "role" / "aria-role" prop (case-insensitive, same mapping as testkit
	// ByRole).
	Role string
	// Label matches the accessible label from "aria-label" prop (substring,
	// case-insensitive). When Role is also set, only nodes that have both the
	// correct role AND a matching label are returned.
	Label string
	// Text matches the concatenated text content of the fiber subtree
	// (substring, case-insensitive), the same text that testkit ByText uses.
	Text string
	// ID matches the "id" prop exactly (case-sensitive, same rule as testkit
	// ByID).
	ID string
	// Tag matches the host element tag (case-insensitive), same rule as testkit
	// AllByTag.
	Tag string
}

type AgentSnapshot struct {
	// Root is the budgeted, redacted fiber tree starting from the runtime root.
	Root *AgentNodeSnapshot `json:"root,omitempty"`
	// TruncatedNodes is the count of nodes omitted to satisfy the depth or node
	// budget; zero when the full tree fit within the budget.
	TruncatedNodes int `json:"truncatedNodes,omitempty"`
	// BudgetApplied is true whenever either budget (maxDepth or maxNodes) was
	// reached and at least one node was omitted. Callers must check this field
	// rather than inferring truncation from the shape of Root.
	BudgetApplied bool `json:"budgetApplied,omitempty"`
	// Detached carries the trees rendered into separate containers via
	// RenderDetached (agent-injected/mounted content), keyed by their selector.
	// These live in their own isolated runtimes, so they are NOT part of Root;
	// including them here lets an agent read injected content it cannot
	// otherwise see in the global tree.
	Detached []AgentDetachedRoot `json:"detached,omitempty"`
}

type AsyncBoundaryElementType struct{}

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

type Attrs map[string]any

type Blurrer interface {
	Blur()
}

type BrowserState interface {
	// History
	PushState(state any, title, url string)
	ReplaceState(state any, title, url string)
	GetCurrentPath() string
	OnPopState(callback func(path string))

	// Storage
	SetItem(key, value string) error
	GetItem(key string) (string, bool)
	RemoveItem(key string)

	// Location
	GetHash() string
	SetHash(hash string)
	Reload()
}

type BudgetBehavior uint8

type BudgetSignal struct {
	// Name identifies the cliff. Stable across versions; devtools and tests key
	// on it.
	Name string
	// Limit is the configured capacity, zero meaning unbounded.
	Limit int
	// Observed is the current occupancy, for a "how close are we" reading rather
	// than only a "did it blow" one. The distinction matters: a workload sitting
	// at 95% is a warning, and one that never trips is not a bug.
	Observed int
	// Behavior is what happens at the limit.
	Behavior BudgetBehavior
	// Triggered counts how many times this cliff has been reached in the
	// runtime's lifetime.
	Triggered int
	// Active reports whether the cliff is currently in its degraded state.
	Active bool
}

type Clicker interface {
	Click()
}

type ComponentRenderTraceSnapshot struct {
	Name                    string
	Path                    string
	RenderCount             int
	RerenderCount           int
	LastTrigger             string
	LastRenderDurationNs    int64
	TotalRenderDurationNs   int64
	AverageRenderDurationNs int64
	LastRenderedAt          string
	TriggerCounts           map[string]int
}

type ComponentSignature struct {
	Kind          string
	Name          string
	QualifiedName string
	Key           string
	HookKinds     []string
}

type ComponentType struct {
	ID            string
	Name          string
	QualifiedName string
	// contains filtered or unexported fields
}

type Config struct {
	DOMAdapter   DOMAdapter
	EventAdapter EventAdapter
	Scheduler    Scheduler
	BrowserState BrowserState
	Reset        bool
	// HideRawPanicOutput is deprecated: crash containment (structured report,
	// no raw rethrow) is now the default. Use ShowRawPanicOutput to opt back
	// into re-panicking with the raw Go panic output.
	HideRawPanicOutput bool
	// ShowRawPanicOutput re-throws contained panics with their raw output
	// after the structured report. In wasm this kills the page; only enable
	// it for debugging native test runs.
	ShowRawPanicOutput     bool
	OnUnhandledPanicReport func(PanicReport)
	StrictMode             StrictModeOptions
	Limits                 RuntimeLimits
	// PassiveEffectsAfterPaint enables the v5 P1.1 commit split: layout effects
	// run synchronously in the commit task (so they observe committed DOM before
	// paint), passive effects run after the browser has painted.
	//
	// Off by default. Enabling it changes effect ORDERING, not just timing:
	// every layout effect in the tree now precedes every passive effect, where
	// previously each fiber ran both tiers before the next fiber ran either.
	// See internal/runtime/effect_ordering_contract_test.go.
	PassiveEffectsAfterPaint bool
	// FrameBudgetMs enables the v5 P1.2 wall-clock slice budget: the work loop
	// yields when a slice has consumed this many milliseconds, instead of only
	// after a fixed fiber count.
	//
	// ON by default: zero takes the 5ms default, a positive value sets an
	// explicit budget, and NEGATIVE opts out to count-only slicing.
	//
	// This flag was flipped on, reverted, and flipped back, and the middle step
	// is the useful one. Turning it on froze the Example 201 core-* and
	// enterprise-* scenarios: the tree never rendered and the harness timed out
	// with zero items, in both builds. Slicing did not cause that defect, it
	// EXPOSED one — an update arriving while a pass was already walking the tree
	// was folded into pendingLane and never run, because the coalescing path
	// acted only when the new work was MORE urgent than the running pass. A pass
	// completes inside one task without a budget, so the window was nearly
	// closed; a budget opens it at every yield.
	//
	// With that fixed (scheduleFollowUpForInFlightUpdate) the browser benchmark
	// is green with the budget on, which is now the gate. The first flip was
	// validated against `go test ./...` alone, where only this flag's own
	// "off by default" test failed — a clean-looking result that could not have
	// caught it, because nothing native drives those scenarios.
	//
	// Requires the interrupt-safe restart path (P2.5); without it the runtime
	// falls back to count-only slicing and emits a diagnostic rather than
	// degrading silently.
	FrameBudgetMs float64
	// LaneQueues enables per-lane deferral with expiration (v5 P2.2): work
	// marked at a lower priority than the running pass is deferred to a
	// follow-up pass rather than rendered inside this one.
	//
	// ON by default; set DisableLaneQueues to opt out. Each deferrable lane
	// carries a deadline (transition 500ms, background 2s) after which it is
	// admitted regardless of priority,
	// so deferral cannot become starvation under sustained input.
	LaneQueues bool
	// DisableLaneQueues turns per-lane deferral back off.
	//
	// A separate field rather than inverting LaneQueues, so existing callers
	// that set LaneQueues:true keep compiling and keep meaning what they said.
	DisableLaneQueues bool

	// AsyncIngress routes state updates made outside the frame loop through the
	// async inbox (v5 P2.1).
	//
	// Without it, a gRPC callback, a worker reply, or any goroutine mutates hook
	// state at whatever moment it happens to run — which is the race the inbox
	// was built to remove, and which no amount of care at the call site can fix
	// because the call site does not know whether a render is in flight. With
	// it, such a write is queued and applied at one defined point per frame, so
	// the in-flight tree is isolated by construction and N async writes in a
	// frame produce one render rather than N.
	//
	// Off by default: it changes WHEN an async write lands (one task later, at
	// the drain), and that is a semantic change existing apps should opt into.
	//
	// Measured 2026-07-25 rather than assumed: forcing it on for the whole suite
	// fails nine tests, all of the same shape — a test calls a setter directly
	// from its own goroutine and asserts the new value on the next line. That is
	// precisely the write this defers, so the failures are the feature working,
	// not a defect in it. They are also proof the change is observable to code
	// that already exists, which is why it stays opt-in until an app has been
	// migrated deliberately rather than by a default flip.
	AsyncIngress bool
}

type ContextDescriptor struct {
	ID           int64
	DefaultValue any
}

type ContextProviderType struct {
	Descriptor *ContextDescriptor
}

type DOMAdapter interface {
	// Element creation and manipulation
	CreateElement(tag string) DOMNode
	CreateTextNode(text string) DOMNode
	SetAttribute(node DOMNode, name, value string)
	RemoveAttribute(node DOMNode, name string)
	SetProperty(node DOMNode, name string, value any)
	GetProperty(node DOMNode, name string) any

	// Tree manipulation
	AppendChild(parent, child DOMNode)
	RemoveChild(parent, child DOMNode)
	InsertBefore(parent, newNode, referenceNode DOMNode)
	ReplaceChild(parent, newNode, oldNode DOMNode)

	// Queries
	GetParent(node DOMNode) DOMNode
	GetChildren(node DOMNode) []DOMNode
	GetFirstChild(node DOMNode) DOMNode
	GetNextSibling(node DOMNode) DOMNode

	// Text nodes
	SetTextContent(node DOMNode, text string)

	// Styling
	SetStyle(node DOMNode, property, value string)
	SetStyles(node DOMNode, styles map[string]string)

	// Function wrapping
	WrapFunction(fn any) any
}

type DOMNode interface {
	IsNull() bool
	Equals(other DOMNode) bool
}

type DOMRefSink interface {
	SetDOMNode(node DOMNode)
}

type Deadline interface {
	TimeRemaining() float64
	DidTimeout() bool
}

type Diagnostic struct {
	Source         string
	Severity       DiagnosticSeverity
	Classification DiagnosticClassification
	Code           string
	Docs           string
	Remediation    string
	Recoverable    bool
	TopFrame       string
	Consequence    string
	Message        string
	Count          int
	Path           string
	ComponentStack []string
	Fields         map[string]string
}

type DiagnosticClassification string

type DiagnosticSeverity string

type Effect struct {
	Fn           func() func()
	CleanupIndex int
	// Layout marks an effect that must run synchronously after DOM mutation but
	// before the browser paints, and before this fiber's passive effects (G36 /
	// UseLayoutEffect). Passive effects (UseEffect) leave it false.
	Layout bool
}

type Element struct {
	Type     any
	Props    map[string]any
	Children []any
	// Key carries the reconciliation key for elements built through the typed
	// fast lane (html.Props). Map-built elements keep their key in Props; the
	// key helpers consult this field first.
	Key         string
	TextContent string // Optimization for TEXT_ELEMENT to avoid map allocation
	// contains filtered or unexported fields
}

type ErrorBoundaryType struct{}

type Event interface {
	PreventDefault()
	StopPropagation()
	GetValue() string
	GetTarget() DOMNode
	GetKeyCode() int
	GetKey() string
	IsChecked() bool
}

type EventAdapter interface {
	AddEventListener(node DOMNode, eventType string, handler EventHandler)
	RemoveEventListener(node DOMNode, eventType string, handler EventHandler)
	CreateEventHandler(fn func(Event)) EventHandler
	ReleaseEventHandler(handler EventHandler)
}

type EventHandler interface {
	Release()
}

type FetchState struct {
	Data    any    // The fetched data
	Error   string // Error message if fetch failed
	Loading bool   // Whether currently fetching
}

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

type FiberSnapshot struct {
	Name string
	Path string
	// AgentRef is the stable key/index-disambiguated ref the agent bridge
	// resolves back to this node (empty on the root, which is not addressable).
	AgentRef string
	// Text is the full text content for text fibers (empty otherwise). Name
	// only carries a short preview; Text lets a reader recover the rendered copy.
	Text              string
	Kind              string
	Dirty             bool
	NeedsUpdate       bool
	FineGrained       bool
	ReactiveSource    string
	UpdateOrigin      string
	EffectCount       int
	HookCount         int
	Signature         *ComponentSignature
	RenderDurationNs  int64
	DiffDurationNs    int64
	CommitDurationNs  int64
	EffectDurationNs  int64
	CleanupDurationNs int64
	SelfDurationNs    int64
	SubtreeDurationNs int64
	Hooks             []HookSnapshot
	Children          []FiberSnapshot
}

type FlamegraphFrameSnapshot struct {
	Name              string
	Kind              string
	Path              string
	Depth             int
	StartNs           int64
	DurationNs        int64
	SelfDurationNs    int64
	RenderDurationNs  int64
	DiffDurationNs    int64
	CommitDurationNs  int64
	EffectDurationNs  int64
	CleanupDurationNs int64
}

type Focuser interface {
	Focus()
}

type HookSnapshot struct {
	Slot         int
	Kind         string
	Value        string
	Dependencies string
	Status       string
}

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

type HostAttr struct {
	Name  string
	Value string
}

type HostMountSpec struct {
	Tag   string
	Attrs []HostAttr
	Text  string
}

type HotBranchSnapshot struct {
	Name              string
	Kind              string
	Path              string
	RenderDurationNs  int64
	DiffDurationNs    int64
	CommitDurationNs  int64
	EffectDurationNs  int64
	CleanupDurationNs int64
	SelfDurationNs    int64
	SubtreeDurationNs int64
}

type HotReloadComponentSnapshot struct {
	Signature     ComponentSignature       `json:"signature"`
	Path          string                   `json:"path,omitempty"`
	IdentityTrail []string                 `json:"identityTrail,omitempty"`
	States        []any                    `json:"states,omitempty"`
	Memos         []HotReloadMemoSnapshot  `json:"memos,omitempty"`
	Refs          []any                    `json:"refs,omitempty"`
	IDs           []string                 `json:"ids,omitempty"`
	Fetches       []HotReloadFetchSnapshot `json:"fetches,omitempty"`
}

type HotReloadFetchSnapshot struct {
	URL   string     `json:"url"`
	State FetchState `json:"state"`
}

type HotReloadMemoSnapshot struct {
	Value any   `json:"value"`
	Deps  []any `json:"deps,omitempty"`
}

type HotReloadRestoreDecision struct {
	Strategy     string
	UnsafeReason string
}

type HotReloadRestorePlan struct {
	Selective         bool
	ChangedIdentities []string
}

type HotReloadSnapshot struct {
	Components []HotReloadComponentSnapshot `json:"components,omitempty"`
}

type HydrationDebugSnapshot struct {
	CorrelationID        string
	StartedAt            string
	FinishedAt           string
	DurationNs           int64
	ExistingDOMNodeCount int
	FallbackCount        int
	MismatchCount        int
	DiscardedNodeCount   int
	Strict               bool
	Failed               bool
	Failure              string
	RecentMessages       []string
}

type HydrationMetrics struct {
	CorrelationID        string
	StartedAt            time.Time
	FinishedAt           time.Time
	Duration             time.Duration
	DurationNs           int64
	ExistingDOMNodeCount int
	FallbackCount        int
	MismatchCount        int
	DiscardedNodeCount   int
	Strict               bool
	Failed               bool
	Failure              string
}

type InspectionSnapshot struct {
	Root        *FiberSnapshot
	Stats       InspectionStats
	Profiling   ProfilingSnapshot
	Hydration   HydrationDebugSnapshot
	Diagnostics []Diagnostic
	Logs        []LogEntry
}

type InspectionStats struct {
	TotalFibers       int
	DirtyFibers       int
	ComponentFibers   int
	HostFibers        int
	TextFibers        int
	FineGrainedFibers int
	HookEntries       int
	Effects           int
}

type InternalStateSnapshot struct {
	FiberCount            int
	AtomCount             int
	AtomSubscriberCount   int
	PendingEffectFibers   int
	UIQueueSize           int
	DiagnosticCount       int
	LogCount              int
	ProfilingEventCount   int
	SchedulerBackpressure bool
}

type LogEntry struct {
	Domain         string
	Level          LogLevel
	Classification DiagnosticClassification
	Code           string
	Docs           string
	Remediation    string
	Recoverable    bool
	TopFrame       string
	Consequence    string
	Message        string
	Timestamp      string
	CorrelationID  string
	Fields         map[string]string
}

type LogLevel string

type MemoryHygieneOptions struct {
	MaxHeapAllocBytes  uint64
	MaxHeapObjects     uint64
	MaxFiberCount      int
	MaxAtomCount       int
	MaxSubscriberCount int
	// MaxGoroutines bounds live goroutines.
	//
	// Added because its absence was measurable: a suspended async boundary parked
	// a fresh watcher goroutine on every render (fixed in ee39ac99), and none of
	// the thresholds above could see it. Heap bytes barely moved, the fiber tree
	// was the same size, and no atom or subscriber count changed — the leak was
	// entirely in goroutines holding channels. A framework that spawns goroutines
	// for suspensions, fetches, and worker replies needs the one counter that
	// makes those visible.
	MaxGoroutines int
}

type MemoryHygieneSnapshot struct {
	HeapAllocBytes uint64
	HeapObjects    uint64
	Goroutines     int
	Internal       InternalStateSnapshot
	Diagnostics    []string
}

type PanicLoggingOptions struct {
	HideRawPanicOutput bool
	OnReport           func(PanicReport)
}

type PanicPhase string

type PanicReport struct {
	Source          string
	Phase           PanicPhase
	Subject         string
	Where           string
	Path            string
	ComponentStack  []string
	Summary         string
	Code            string
	Docs            string
	Remediation     string
	Consequence     string
	TopFrame        string
	AppFrames       []string
	FrameworkFrames []string
	PlatformFrames  []string
	Artifact        WASMArtifactMetadata
	Formatted       string
}

type PanicReportRedactionContext struct {
	Path  string
	Field string
	Value any
}

type PanicReportRedactionPolicy struct {
	Fields []string
	Redact func(PanicReportRedactionContext) (any, error)
}

type PassiveEventHandler struct {
	Handler any
}

type PortalElementType struct{}

type ProfilingEvent struct {
	Domain        string
	Name          string
	Phase         string
	Target        string
	CorrelationID string
	DurationNs    int64
	Timestamp     string
	Fields        map[string]string
	// contains filtered or unexported fields
}

type ProfilingPhaseTotalsSnapshot struct {
	RenderDurationNs  int64
	DiffDurationNs    int64
	CommitDurationNs  int64
	EffectDurationNs  int64
	CleanupDurationNs int64
}

type ProfilingSnapshot struct {
	RenderCalls                      int
	ScheduledRootUpdates             int
	ScheduledFiberMarks              int
	ScheduledGranularMarks           int
	WorkLoopPasses                   int
	ProcessedUnits                   int
	CommitCount                      int
	FineGrainedCommits               int
	FineGrainedDescendantHostCommits int
	FineGrainedDescendantTextCommits int
	EffectExecutions                 int
	CleanupExecutions                int
	LastRenderDurationNs             int64
	LastCommitDurationNs             int64
	LastEffectDurationNs             int64
	LastCleanupDurationNs            int64
	PhaseTotals                      ProfilingPhaseTotalsSnapshot
	ComponentRenders                 []ComponentRenderTraceSnapshot
	RecentEvents                     []ProfilingEvent
	FlamegraphFrames                 []FlamegraphFrameSnapshot
	Startup                          StartupProfilingSnapshot
	HotBranches                      []HotBranchSnapshot
}

type ReactiveRegionElementType struct{}

type ReactiveTextElementType struct{}

type RefValue struct {
	Current any
}

type ReplayEvent struct {
	Kind    string
	Path    []int
	Origin  string
	Lane    string
	Seq     int
	Dropped bool
}

type RouteStartupBudgetSnapshot struct {
	RouteFamily                       string
	LastRoutePath                     string
	SampleCount                       int
	AverageBootstrapReadDurationNs    int64
	AverageWASMTransferBytes          int64
	AverageWASMDecodedBytes           int64
	AverageBootstrapDecodedBytes      int64
	AverageCacheWarmupDurationNs      int64
	AverageServiceWorkerOverheadNs    int64
	AverageInitialRouteDataBytes      int64
	AverageHydrationDurationNs        int64
	AverageStartupCommitDurationNs    int64
	AverageFirstInteractionDurationNs int64
}

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

type RuntimeLimits struct {
	MaxPendingEffectFibers int
	MaxQueuedUpdates       int
	MaxReplayEvents        int
	MaxDiagnostics         int
	MaxProfilingEvents     int
	MaxLogEntries          int
}

type SSRStreamChunk struct {
	Kind       string
	BoundaryID string
	HTML       string
	Err        error
}

type SSRStreamOptions struct {
	BoundaryIDPrefix      string
	DisableBoundaryScript bool
	ScriptNonce           string
	OnChunk               func(SSRStreamChunk)
	Flush                 func()
	// InitialAtoms seeds this stream's per-render atom scope before the shell walk
	// starts, so request state is an INPUT to the render rather than something a
	// previous request left in a shared registry. Seeded ids beat the component's
	// UseAtom initial (InitAtom is init-if-absent); ignored in the browser, where
	// SSR keeps using the live page's atoms. See ssr_atom_scope.go.
	InitialAtoms map[string]any
}

type Scheduler interface {
	RequestIdleCallback(callback func(deadline Deadline))
	SetTimeout(callback func(), delay int)
}

type SchedulerSnapshot struct {
	PendingLane      string
	CurrentLane      string
	EnqueuedUpdates  int
	CoalescedUpdates int
	// CoalescedAtLimit counts updates that arrived once the queue was full and
	// were merged into the pending render. NOT dropped — it was named
	// DroppedUpdates, and nothing is lost: re-render requests are idempotent.
	CoalescedAtLimit int
	InterruptedWork  int
	Backpressure     bool
}

type ScrollIntoViewer interface {
	ScrollIntoView(behavior string)
}

type StartupCostAttribution struct {
	WASMTransferBytes       int64
	WASMDecodedBytes        int64
	BootstrapDecodedBytes   int64
	CacheWarmupDurationNs   int64
	ServiceWorkerOverheadNs int64
	InitialRouteDataBytes   int64
}

type StartupProfilingSnapshot struct {
	Mode                       string
	StartedAt                  string
	BootstrapReadDurationNs    int64
	WASMTransferBytes          int64
	WASMDecodedBytes           int64
	BootstrapDecodedBytes      int64
	CacheWarmupDurationNs      int64
	ServiceWorkerOverheadNs    int64
	InitialRouteDataBytes      int64
	HydrationDurationNs        int64
	StartupCommitDurationNs    int64
	FirstInteractionDurationNs int64
	FirstInteractionCaptured   bool
	FirstInteractionEvent      string
	RouteBudgets               []RouteStartupBudgetSnapshot
}

type StrictDiagnosticsOptions struct {
	Enabled               bool
	Codes                 []string
	Sources               []string
	Classifications       []DiagnosticClassification
	RecoverableOnly       bool
	EscalationConsequence string
}

type StrictModeOptions struct {
	Enabled                   bool
	DoubleRender              bool
	WarnSetStateDuringRender  bool
	RequireEffectCleanup      bool
	PanicOnViolation          bool
	ViolationDiagnosticSource string
}

type Suspension struct {
	Reason string
	Done   <-chan struct{}
}

type UpdateLane uint8

type WASMArtifactMetadata struct {
	BuildID      string
	ArtifactPath string
	SHA256       string
	ManifestPath string
	SymbolSet    string
	Version      string
}

type WASMStackFrame struct {
	Function string
	File     string
	Line     int
}

type WASMStackFrameMapper func(WASMStackFrame) (WASMStackFrame, bool)

type WorkloadBudgets struct {
	PendingEffects BudgetSignal
	QueuedUpdates  BudgetSignal
	// AsyncInbox is the off-loop ingress queue. It was missing for as long as
	// this file existed, which left the runtime's most consequential cliff
	// readable only as a console line: past the hard bound the drain moves onto
	// the producing goroutine and the frame-isolation guarantee — the whole
	// point of P2.1 — is suspended for that batch.
	AsyncInbox BudgetSignal
}