types

type CompiledDataset struct {
	// Name is the dataset's collection name — the module's canonical
	// collection for a shared dataset, `<typeId>_<key>` otherwise.
	Name string
	// Key is the dataset's slug inside its type; for a shared dataset
	// it equals the canonical collection name.
	Key string
	// Module is the module serving the dataset (`records` for the
	// generic schema-enforced kind).
	Module string
	// Shared marks a dataset that participates in the module's
	// canonical collection instead of a namespaced one.
	Shared bool
	// PartId is the owning part record's id.
	PartId string
	// DefId is the head record's id — the definition's stable identity.
	DefId string
	// TypeId is the declaring type object.
	TypeId string
	// Schema is the compiled declaration the generic schema handler
	// enforces. Empty for a module-served dataset — the module owns the
	// schema.
	Schema schema.Dataset
	// SkipHistory mirrors the head's skipHistory flag.
	SkipHistory bool
	// Search mirrors the head's search annotation (also inside Schema).
	Search *schema.SearchFields
	// DisplayName / Description are the head's mutable display fields.
	DisplayName string
	Description string
	// SchemaRev fingerprints the compiled declaration. A controller
	// registered with an older rev (a field added/removed since it was
	// built) is stale and gets lazily evicted; identical declarations
	// on every peer produce the identical rev.
	SchemaRev string
	// Invalid marks a definition whose folded declaration fails
	// validation (e.g. author rules without a creator stamp — a
	// cross-record fact no record-local handler check can see — or an
	// unknown module). Invalid definitions never register or accept
	// data, but they stay VISIBLE so the management API can repair or
	// remove them — otherwise their key would wedge unreachably.
	Invalid       bool
	InvalidReason string
	// FieldDefIds are the field records' ids, aligned with
	// Schema.Fields — the identities RemoveDatasetField targets.
	FieldDefIds []string
}

type CompiledPart struct {
	Id     string // the part record's id
	Key    string
	TypeId string
	Name   string
	Icon   string
	Pos    string
	Hidden bool
	UI     map[string]any
	Uses   []string
	// Datasets are the part's datasets in key order, invalid ones
	// included (flagged).
	Datasets []CompiledDataset
}

type CompiledType struct {
	Parts    []CompiledPart
	Datasets []CompiledDataset
}

type DataVersionPair struct {
	TypeId  string
	ShortId string
}

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

type ModuleInfo struct {
	Name       string
	Canonical  string
	SharedOnly bool
	Reserved   bool
}

type Modules map[string]ModuleInfo

type PropInfo struct {
	Id    string
	Name  string
	Kind  schema.Kind
	Scope schema.Scope
}

type Registry interface {
	// LookupKind returns the declared kind of the property with the
	// given (typeId, propId). Returns (KindUnknown, false) if either
	// the type or the property is unknown to this registry.
	LookupKind(typeId, propId string) (schema.Kind, bool)

	// TypeKnown reports whether a schema for typeId is resolvable —
	// a built-in (any / spaceIndex), a registered external type, or a
	// user type whose property defs have synced. Distinguishes
	// "type not implemented / not here yet" from "type known, property
	// unknown" so the writer-side validator can produce a precise
	// rejection.
	TypeKnown(typeId string) bool

	// PropsOf returns the declared properties of typeId for validation
	// and for building agent-readable error messages (valid-property
	// lists). ok is false when the type is unresolvable.
	PropsOf(typeId string) (props []PropInfo, ok bool)
}

type StubRegistry struct {
	// Kinds[typeId][propId] = declared kind.
	Kinds map[string]map[string]schema.Kind
	// Scopes[typeId][propId] = declared scope. Optional — absent
	// entries read as the zero value (ScopeSynced via
	// PropInfo.EffectiveScope), matching pre-scope definitions.
	Scopes map[string]map[string]schema.Scope
}