kernel

type AdminExtensionManifest ¶

type AdminExtensionManifest struct {
	MenuEntries      []AdminMenuEntry
	SettingsSections []string
	EditorExtensions []string
}

AdminExtensionManifest is the declarative UI a feature module contributes to the admin shell: navigation, settings sections, and editor extensions. One shell renders everything; modules never ship their own mini-SPA.

func (m AdminExtensionManifest) Validate() error

type AdminExtensionProvider ¶

type AdminExtensionProvider interface {
	Module
	AdminManifest() AdminExtensionManifest
}

AdminExtensionProvider contributes UI to the admin shell via manifest.

type AdminMenuEntry ¶

type AdminMenuEntry struct {
	Label string
	Path  string
	Icon  string
}

AdminMenuEntry is one navigation item contributed to the admin shell.

type CapabilityResolver ¶

type CapabilityResolver func(principal Principal, capability string) bool

CapabilityResolver maps a principal plus a capability name (for example "content.publish") to an allow/deny decision.

Implemented by the users module. The kernel never resolves roles itself.

type ContentTypeProvider ¶

type ContentTypeProvider interface {
	Module
	PostTypes() []PostTypeDef
}

ContentTypeProvider registers content types (post, page, product, ...).

type DroppedModule ¶

type DroppedModule struct {
	// Name is the dropped module's registry key.
	Name string
	// Direct is true when the module itself was named in disabled, false
	// when it cascaded from a disabled requirement.
	Direct bool
	// Cause names the disabled module that forced the drop: the module
	// itself when Direct, otherwise the unavailable requirement.
	Cause string
}

DroppedModule names one module Prune removed from the candidate list.

type Host ¶

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

Host is the default Kernel implementation handed to Module.Init.

func NewHost(logger Logger) *Host

func (h *Host) Logger() Logger

func (h *Host) Registry() *Registry

type Kernel ¶

type Kernel interface {
	Logger() Logger
	Registry() *Registry
}

Kernel is the minimal host surface a module receives at Init.

type Logger ¶

type Logger interface {
	Info(format string, args ...any)
	Error(format string, args ...any)
}

Logger is the printf-style logging contract modules use.

Core adapts *util.Logger to it; tests and fixtures may supply any sink. Messages use fmt-style verbs, matching the util.Logger convention.

type Migrator ¶

type Migrator interface {
	Module
	Migrations() fs.FS
}

Migrator ships namespaced migrations as an embedded filesystem.

Layout convention: {sqlite,postgresql,mysql}/NNN_name.{up,down}.sql. The core migration runner selects the subdir via Driver.MigrationDir.

type Module ¶

type Module interface {
	Name() string
	Version() string
	Requires() []string
	Optional() []string
	Init(kernel Kernel) error
	Shutdown() error
}

Module is the only interface every Lesstruct module must implement.

Name is the stable registry key ("users", "comments", "site-ssr"). Requires lists hard dependencies resolved topologically at startup; Optional lists soft dependencies the module degrades without. Init wires the module (routes, subscriptions, services); Shutdown releases it.

type PostTypeDef ¶

type PostTypeDef struct {
	Slug      string
	Name      string
	Protected bool
}

PostTypeDef is the minimal post-type registration the kernel understands. Richer definitions (fields, templates) live in the posttypes module. Protected marks slugs reserved by built-in modules (post, page, media, comment): the kernel index records them so later phases can refuse overrides, and config entries may not hide them.

type Principal ¶

type Principal struct {
	ID       string
	Username string
	Roles    []string
}

Principal is the minimal identity every auth module injects into requests.

The kernel owns this shape — never a concrete user type — so identity stays a module concern (users/auth) while route protection stays declarative.

func PrincipalFromContext(ctx context.Context) (principal Principal, ok bool)

func (p Principal) HasRole(role string) bool

func (p Principal) IsAnonymous() bool

type PruneResult ¶

type PruneResult struct {
	Kept    []Module
	Dropped []DroppedModule
}

PruneResult is the outcome of Prune: the modules to register plus every dropped module with its reason.

func Prune(candidates []Module, disabled []string) PruneResult

type PublicRouteProvider ¶

type PublicRouteProvider interface {
	Module
	RegisterPublicRoutes(router chi.Router)
}

PublicRouteProvider mounts HTTP routes onto the shared Chi router. Core passes the public router (no auth chain), so everything mounted here is anonymous. Prefer RouteProvider unless the endpoint is genuinely public.

The method is deliberately named differently from RouteProvider's so one module can serve both surfaces and core can discover each independently: a single RegisterRoutes method would satisfy both interfaces at once and mount the same routes twice.

type Registry ¶

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

Registry is the module graph: it stores modules, resolves their Requires edges into a deterministic init order, and runs lifecycle transitions. Register order never matters; InitAll always topologically sorts.

func NewRegistry() *Registry

func (r *Registry) Get(name string) (Module, bool)

func (r *Registry) InitAll(kernel Kernel) error

func (r *Registry) InitOrder() []string

func (r *Registry) Initialized() bool

func (r *Registry) Names() []string

func (r *Registry) Register(module Module) error

func (r *Registry) ShutdownAll() error

type RoleProvider ¶

type RoleProvider interface {
	Module
	Capabilities() []string
}

RoleProvider contributes capability strings to the permission registry.

type RouteProvider ¶

type RouteProvider interface {
	Module
	RegisterRoutes(router chi.Router)
}

RouteProvider mounts HTTP routes onto the shared Chi router. Core passes the protected router (auth middleware pre-chained), so everything mounted here requires authentication. For anonymous surfaces, implement PublicRouteProvider instead.

type ThemeProvider ¶

type ThemeProvider interface {
	Module
	ThemeFiles() fs.FS
	ThemeFuncs() template.FuncMap
}

ThemeProvider registers a base theme consumed by the site-ssr engine: embedded layouts and CSS, template funcs, and site-root files.