typetype

const (
	DefKindPart    = "part"    // part record: one per part of the type
	DefKindDataset = "dataset" // head record: one per dataset of a part
	DefKindField   = "field"   // field record: one per field of a records dataset
)

Discriminator values of the pinned `def` field.

const (
	DefFieldDef         = "def"         // discriminator, pinned
	DefFieldModule      = "module"      // module slug (head), pinned
	DefFieldShared      = "shared"      // bool (head), pinned — the module's canonical collection
	DefFieldPart        = "part"        // owning part record id (head), pinned
	DefFieldDynamic     = "dynamic"     // bool (head), pinned
	DefFieldIdRule      = "idRule"      // "auto"/"user" (head), pinned ("id" is a reserved head)
	DefFieldIdPattern   = "idPattern"   // RE2 (head), pinned
	DefFieldIdMaxLen    = "idMaxLen"    // number (head), pinned
	DefFieldDeleteBy    = "deleteBy"    // "anyone"/"author" (head), pinned
	DefFieldSkipHistory = "skipHistory" // bool (head), pinned
	DefFieldSearch      = "search"      // {title,text,scope} (head); leaves mutable, text string-or-array
	DefFieldDisplayName = "displayName" // human label (head), mutable
	DefFieldDataset     = "dataset"     // owning head record id (field), pinned
	DefFieldStamp       = "stamp"       // "creator"/"createTime"/"modifyTime" (field), pinned
	DefFieldRequired    = "required"    // bool (field), pinned
	DefFieldMutableBy   = "mutableBy"   // "never"/"author"/"any" (field), pinned
)

Dataset-def record field names. Part records use the Part* set plus FieldKey / FieldName; head records the Def* set plus FieldKey; field records reuse FieldKey/FieldKind/FieldName/FieldDescription/FieldItems/ FieldProperties from the property-record vocabulary plus the Field* behavioral set below.

const (
	PartFieldIcon   = "icon"   // string
	PartFieldPos    = "pos"    // string, clients sort parts by it
	PartFieldHidden = "hidden" // bool, not shown by default
	PartFieldUI     = "ui"     // object {type, config}, written whole
	PartFieldUses   = "uses"   // array of dataset keys of this type
)

Part record fields — the display slice a client renders. All mutable; `key` (FieldKey) is the only pinned one.

const (
	SearchKeyTitle = "title"
	SearchKeyText  = "text"
	SearchKeyScope = "scope"
)

Sub-keys of the head `search` object — mutable leaves (broad `search` replaces are pinned, the leaves mutate freely). `title` and `scope` are scalar strings; `text` is a bare field key or a non-empty array of field keys.

const (
	ShortIdFieldChangeId = "changeId" // the changeId the shortId was derived from
	ShortIdFieldPropId   = "propId"   // the property record this shortId stamps (added or removed)
	ShortIdFieldKind     = "kind"     // on-wire kind label, present on add rows
	ShortIdFieldRemoved  = "removed"  // bool, true on removal rows
	ShortIdFieldDefId    = "defId"    // the dataset-def record this shortId stamps
	ShortIdFieldSrc      = "src"      // discriminator: absent = properties, "datasets" = dataset defs
)

ShortId row field names.

const (
	MetaTypeMarker = "__type__"
	TypeId         = "type"
)

MetaTypeMarker is the reserved value every type object carries in `any.type` — what distinguishes a type object from a regular one (see spaceobjects.LiveTypeRowsFilter). A definition object has no type of its own: the slot holds the marker.

TypeId is the meta-type's id: the namespace its type-only property values live under (`record.type.xkey`) and the id surfaced through Space.Types(). The two differ because a `_`-prefixed top-level field is protocol-owned (crdt.validatePath), so the marker cannot double as a storage namespace.

Both are reserved — user-derived type ids are content-addressable and never produce either string.

const (
	Name        = "Type"
	Description = "A type — defines the properties, parts and layout of the objects that have it"
)

Display metadata for the `type` meta-type object.

const (
	FieldHiddenProp = "hidden"
	FieldMetaProp   = "meta"
)

`type.hidden` keeps a type out of default listings and pickers (self-typed bundle roots carry it); `type.meta` is the open bag of consumer flags — one scalar per key, written per key so writers touching different keys merge (`meta.index`, a client's own tags).

const (
	FieldKey         = "key"         // user-facing stable identifier (e.g. "actors")
	FieldKind        = "kind"        // "string"/"number"/"boolean"/"null"/"array"/"object"/"datetime"
	FieldScope       = "scope"       // "synced"/"account"/"local" — write/sync class, pinned
	FieldName        = "name"        // human label, mutable
	FieldDescription = "description" // mutable
	FieldXKey        = "x-key"       // caller-side handle, mutable
	FieldItems       = "items"       // recursive sub-shape for arrays
	FieldProperties  = "properties"  // recursive sub-shape for objects
	FieldRequired    = "required"    // []string, mutable per docs/data-structure.md
	FieldMeta        = "meta"        // opaque consumer flag map (string→string), mutable
	FieldXFormat     = "x-format"    // opaque descriptor object, mutable — see below
)

Property-record field names. The shape is hardcoded in Go (no JSON Schema applies on this dataset — see docs/types-properties-proposal.md § "Schema format — decision").

const DatasetDefs = "datasets"

DatasetDefs is the dataset on a type object holding its dataset definition records. On disk the collection is `<typeId>_datasets`.

const DatasetDefsHandlerVersion = "typeDatasetHandler-v1"

DatasetDefsHandlerVersion is the DataVersion stamped on changes to the DatasetDefs dataset itself (hardcoded, like HandlerVersion — definition writes are never gated on their own schema state).

Known mixed-fleet limitation: this string is deliberately NOT parseable by the spaceobjects DataVersion gate (legacy handler-version strings pass through unconstrained — see gateFor), so bumping it CANNOT park new wire forms on old replicas. A peer that predates the array text form sheds an array-form `search.text` $set (its handler admits only scalar strings) and never replays it, diverging the head record until re-written. Accepted pre-release; a real fix needs a version pair the gate parses (and old drainers can satisfy), which is a protocol change.

const DatasetDefsLocalVersion = 4

DatasetDefsLocalVersion is this handler's LOCAL logic version (HandlerReg.Version): bumped when a validation change means an already-materialized set of dataset definitions would come out different, so the SDK replays the type object's tree. Like the property handler's, it is also the recovery path for definitions an older build dropped because it could not validate them.

v2: `datetime` is a kind, so a stamped time field validates. v3: field records carry an opaque `x-format` (an object, created whole, mutable); head records carry none. v4: parts. A head is keyed (`key`, pinned) and bound to a part and a module (`part`, `module`, `shared`, pinned); the `collection` field is gone — the collection is computed at compile.

const DatasetPropertyDefs = "properties"

DatasetPropertyDefs is the dataset on a type object that holds its property-*definition* records (id, name, kind, ...). On disk the collection is named "properties"; the Go identifier was chosen to disambiguate from property *values*, which live in a separate dataset called "objects" (properties.Dataset, handled by properties.SystemPropertiesHandler). Every object registers both handlers — only type objects actually write to this one.

const FieldLayoutProp = "layout"

Rendering metadata a type object carries in its own namespace: `type.layout` is the type's layout descriptor ({type, config}, written whole, opaque to the SDK).

const FieldXKeyProp = "xkey"

FieldXKeyProp is the property id of the meta-type's `xkey` — the caller-side programmatic handle for the type itself, stored at `record.type.xkey`. Distinct from FieldXKey (`x-key`), which is the same idea one level down, on a property DEFINITION record.

const HandlerVersion = "typePropertyHandler-v1"

HandlerVersion is the DataVersion string stamped onto every change this handler emits against the `properties` dataset of a type object. Per docs/types-properties-proposal.md § "Change-level DataVersion", this dataset uses a hardcoded handler-chosen identifier (not a shortId) — bump the suffix if the validation rules ever change in a way that must reject stale writers.

const PropertyHandlerLocalVersion = 3

PropertyHandlerLocalVersion is this handler's LOCAL logic version (HandlerReg.Version) — bumped when a validation change means an already-materialized set of definitions would come out different, so the SDK replays the type object's tree (docs/versioning.md).

It is also how a peer recovers definitions its previous build dropped: the wire DataVersion deliberately stays put (bumping it would park every property change on peers that don't know the new version — see the Properties note above), so an older build rejects a definition it cannot validate, and the replay after the upgrade applies it.

v2: `datetime` is a kind, and the date formats accept it. v3: the typed `format` object is gone (no format→kind coupling, no pinned `format.type`); `x-format` must be an object, created whole.

const ShortIdSrcDatasets = "datasets"

ShortIdSrcDatasets marks rows projected by DatasetDefsHandler. Property rows carry no `src` — the absent value is the legacy discriminant, so old readers keep working. The gate never inspects fields (KnownShortId is a FindId), so mixing both streams in one collection is free; LatestShortId then gates data changes against the type's WHOLE schema state (properties + dataset defs), which is strictly safer.

const ShortIdsDataset = "shortIds"

ShortIdsDataset is the name of the sibling collection registered on every type object's Controller alongside DatasetPropertyDefs. One row per important change to the type's properties dataset.

docs/types-properties-proposal.md § "Known-shortIds set":

{ shortId, versionId, changeId }

Append-only in v1; no GC. The shortId record id is base58(xxh3-64(changeId)) — the same derivation as crdt.DeriveRecordId, since a content-addressable changeId is the only thing we hash.

const WellKnownDeriveSeed = "builtin:type"

WellKnownDeriveSeed mints the same `type` type object id on every peer.