runtime

type APIRoute struct {
	Route   router.Route
	Methods map[string]gb.Handler
}

type Action struct {
	ID      string
	MaxBody int64
	// contains filtered or unexported fields
}

type Config struct {
	BuildID             string
	PublicOrigin        string
	ResolvePublicOrigin PublicOriginResolver
	AllowedHosts        []string
	BrowserAssets       *browserassets.Manifest
	Pages               []PageRoute
	Actions             []Action
	APIs                []APIRoute
	// Middleware is the one authored Go request hook discovered from the
	// application's root middleware.go. It is applied to documents, APIs,
	// actions, and runtime payloads, but not health, static, or image routes.
	Middleware gb.Middleware
	// ProxyPolicy is the validated build artifact shared by the origin and the
	// platform edge. It runs before route classification, including static and
	// image dispatch, while reserved GoBeyond paths remain outside it.
	ProxyPolicy *gb.ProxyPolicy
	// FetchOrigin is the trusted platform-origin fallback used by gb.Fetch
	// when the current build has no matching local route. It is intentionally
	// injected by hosted adapters; application code never selects the fallback
	// transport.
	FetchOrigin   gb.Fetcher
	CSRF          *security.CSRF
	Logger        *slog.Logger
	Deadlines     gb.DeadlinePolicy
	MaxHeaderSize int
	ImageLoader   imageopt.Loader
	// Cache installs the request-time cache (cache.Load, cache.Revalidate*).
	// Leave it nil to run without one: loaders then compute every value. The
	// server owns Cache.BuildID - it must be empty or equal to Config.BuildID,
	// so one build can never read another build's cached shapes - and defaults
	// Cache.Store to a bounded in-process L1, which is the degraded mode of a
	// deployment with no shared cache endpoint configured.
	Cache *cache.RuntimeConfig
	// Contracts is the build's value-contract document. Route caching needs
	// it: cached props cross JSON, and only the contract says which strings
	// were renderplan.SafeHTML before they did, so decoding without it would
	// either lose the trust marker or restore it blindly. A server with a
	// cache and a route that sets Revalidate must supply it. When nil and
	// Static is set, it defaults to Static.Contracts().
	Contracts *codegen.Document
	// PlanStore supplies render plans on demand for pages that omit an
	// inline Plan. New verifies membership per page and that the
	// store's build ID equals BuildID exactly; the decode itself is deferred
	// to the first request that must render the route. An inline
	// PageRoute.Plan always wins over the store.
	PlanStore PlanStore
	// Static supplies packaged static page data on demand for pages that
	// ship neither inline Static data nor a loader. Its build ID must be
	// empty (build-agnostic adapters such as the eager StaticStore) or equal
	// BuildID.
	Static StaticEntries
}

type LoadedPage struct {
	Kind            gb.ResultKind  `json:"kind"`
	Props           any            `json:"props,omitempty"`
	Metadata        gb.Metadata    `json:"metadata,omitempty"`
	Status          int            `json:"status,omitempty"`
	Headers         http.Header    `json:"headers,omitempty"`
	Cache           gb.CachePolicy `json:"cache"`
	RedirectTo      string         `json:"redirectTo,omitempty"`
	ErrorCode       string         `json:"errorCode,omitempty"`
	Message         string         `json:"message,omitempty"`
	CacheGeneration string         `json:"cacheGeneration,omitempty"`
}

type LoadedPageEntry struct {
	Params map[string]any
	Page   LoadedPage
}

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

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

type PageLoader func(*gb.PageContext) (LoadedPage, error)

type PageRoute struct {
	Route  router.Route
	Plan   *renderplan.Plan
	Load   PageLoader
	Static *LoadedPage
	// Revalidate is how long the origin may reuse this route's loaded props,
	// metadata, status, and kind for one URL, from definePage({ revalidate }).
	// Zero leaves the route uncached. It is route metadata, deliberately not
	// part of gb.CachePolicy: CachePolicy is the HTTP edge header the loader
	// returns, this is how often the Go origin re-runs the loader. A route
	// that sets both should derive the edge policy from this window
	// (gb.PublicRevalidate) rather than letting the two drift apart.
	Revalidate time.Duration
	// Tags are the route's invalidation handles, from definePage({ tags }).
	// cache.RevalidateTag on any of them drops this route's cached entries;
	// cache.RevalidatePath drops one URL's entry without them.
	Tags         []string
	Indexable    bool
	ClientScript string
	Styles       []string
}

type PlanStore interface {
	BuildID() string
	Has(routeID string) bool
	Plan(ctx context.Context, routeID string) (*renderplan.Plan, error)
}

type PublicOriginResolver func(*http.Request) (string, error)

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

type StaticEntries interface {
	BuildID() string
	Has(routeID string) bool
	Entry(ctx context.Context, routeID string, params map[string]string) (LoadedPage, bool, error)
	Contracts() *codegen.Document
}

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

type StoreOption func(*residency.Options)