hookwire

type Ack = AckRow

type AckBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

type AckCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

type AckRow struct {
	Id [65]byte // string(64): buffer, used length beside it

	IdLength int32
	Stage    Stage
	Push     PushState
	Reason   [153]byte // string(152): buffer, used length beside it

	ReasonLength int32
	// contains filtered or unexported fields
}

type Beat = BeatRow

type BeatBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

type BeatCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

type BeatRow struct {
	FriendName [65]byte // string(64): buffer, used length beside it

	FriendNameLength int32
	SentMs           int64
	SentMsPresent    bool // ?: one byte, in Go's model as in C++

	ActiveMs        int64
	ActiveMsPresent bool // ?: one byte, in Go's model as in C++

	UntilMs        int64
	UntilMsPresent bool      // ?: one byte, in Go's model as in C++
	Reason         [201]byte // string(200): buffer, used length beside it

	ReasonLength       int32
	StopReturns        uint32
	StopReturnsPresent bool // ?: one byte, in Go's model as in C++
	// contains filtered or unexported fields
}

type PushState uint8

type Stage uint8

type Stamp = StampRow

type StampBuilder struct {
	Arena TableArena
	Main  TableWorker
	// contains filtered or unexported fields
}

type StampCook struct {
	Region       unsafe.Pointer // the DATA part's base: the root sits at offset zero
	RegionLength int64          // data_length, as the header framed it
}

type StampRow struct {
	Epoch        int64
	EpochPresent bool // ?: one byte, in Go's model as in C++

	AtMs        int64
	AtMsPresent bool      // ?: one byte, in Go's model as in C++
	By          [129]byte // string(128): buffer, used length beside it

	ByLength int32
	// contains filtered or unexported fields
}

type TableAllocator struct {
	Alloc func(int64) []byte
	Free  func([]byte)
}

type TableArena struct {
	Allocator TableAllocator
	Locked    bool
	// contains filtered or unexported fields
}

type TableBitReader struct {
	Buffer []byte
	Offset int64
}

type TableBitWriter struct {
	Buffer              []byte
	Bits                int64
	Measuring, Overflow bool
}

type TableBlob struct {
	Length uint32
	Zero   uint32
}

type TableBuildVersionMismatch struct{ Peer, Own uint64 }

type TableByteOrder uint8

type TableBytesView struct {
	Data   []byte
	Length int64
}

type TableCookFieldInfo struct {
	Name          string
	Offset        int32 // the field's offset in the record this descriptor describes
	Size          int32 // its whole storage there, companions included
	ElemSize      int32 // one element's size, for an array; the field's own otherwise
	IsArray       bool
	ArrayBound    int32 // the DECLARED bound: a counted array's N, a string's or bytes' length
	IsPointer     bool  // an eight-byte SIGNED SELF-RELATIVE delta slot (§6.3)
	CountOffset   int32 // the count companion's offset, or -1 when the field has none
	PresentOffset int32 // an optional's presence bool, or -1
	Storage       TableCookStorage
	// Record is the record this field NAMES, behind a function so the table
	// stays constructible in any order — Go refuses an initialisation cycle
	// among package-level variables, and the DESCRIPTOR graph is cyclic by
	// design: a record's field column can name its own record. A cooked REGION
	// is never cyclic; schema cook refuses one by name (§3.1).
	// nil when the field is a scalar. Following it is how a walker DESCENDS: a
	// pointer's target, a by-value nesting, and an array's element are all
	// reached through this one column.
	Record func() *TableCookInfo
}

type TableCookInfo struct {
	Name      string
	Size      int32
	Align     int32
	NumFields int32
	Fields    []TableCookFieldInfo
}

type TableCookStorage uint8

type TableFieldInfo struct {
	CookOffset, CookElemSize, CookCountOffset, CookPresentOffset uint32
	List, Map                                                    bool // unbounded by-value containers
	ElemAlign                                                    uint32
	Name                                                         string // schema field name, e.g. "health"
	Json                                                         string // the TEXT form's key: the json = "key" attribute, else Name (§16.3)
	TypeName                                                     string // schema element type, e.g. "float32", "Grade"
	DeclaredTypeName                                             string // complete schema spelling including arrays, bounds and pointers
	Id                                                           uint64 // table-wire field id (name hash; the was alias's hash after a rename)
	Pointer                                                      bool
	TargetId                                                     uint64
	Kind                                                         uint8 // table-wire kind; for arrays/strings/bytes, the ELEMENT kind
	IsArray                                                      bool  // fixed or counted array (bytes included)
	Counted                                                      bool  // a <Name>Count/<Name>Length int32 companion exists
	Optional                                                     bool  // a ?T field: a <Name>Present bool decides whether it rides

	ArrayBound    int32  // array capacity / string max length; 0 for plain scalars
	Offset        uint32 // unsafe.Offsetof the storage member
	ElemSize      uint32 // unsafe.Sizeof the member (element size for arrays)
	CountOffset   uint32 // unsafe.Offsetof the count/length companion, or 0xffffffff
	PresentOffset uint32 // unsafe.Offsetof the Present companion, or 0xffffffff

	FracBits         uint8 // fixed-point binary scale
	WideRange        bool
	WideMin, WideMax [2]uint64 // exact two-complement raw bounds, low lane first
	HasRange         bool      // a declared [min, max] (int or float)
	RangeMin         float64   // NOTE: int64 ranges beyond 2^53 lose precision here
	RangeMax         float64

	// EnumMax bounds the vocabulary: enums, the highest valid value (None = 0
	// is always valid); unions, the arm count (tag range [0, EnumMax]); a
	// FLAGS field, the highest declared BIT INDEX; else -1.
	EnumMax int64
	// EnumName is the vocabulary's names, indexed the way EnumMax bounds: an
	// enum's value -> name, a union's tag -> arm name, a FLAGS field's bit
	// index -> variant name. nil for every other kind.
	EnumName func(value uint64) string
	// VariantId is the TABLE-WIRE id of one variant (mas-bandwidth/schema docs/SPEC-TABLES.md §5): for
	// an enum, the hash of the variant's name; for a union, the hash of the
	// arm's name. Hash zero is an ordinary id; ordinal zero is None. nil
	// for every other kind — a FLAGS field's variants have no per-variant wire
	// id (§4), so a nil here beside a non-nil EnumName is what says "flags".
	VariantId func(value uint64) uint64

	// an ENUM-KEYED array (mas-bandwidth/schema docs/SPEC-TABLES.md §2.4, §8): the array has one slot
	// per variant of KeyTypeName, indexed by the variant's value, and its
	// slots ride under variant ids rather than positions. KeyName and KeyId
	// are the key's vocabulary — walk [0, ArrayBound) to print slots by name.
	// All three are nil/"" on every other field.
	KeyTypeName string
	KeyName     func(value uint64) string
	KeyId       func(value uint64) uint64

	// Arms is a union field's shape: the tag and the arms indexed by it, behind
	// a function so a descriptor graph needs no initialization order. nil for
	// every other kind.
	Arms func() *TableUnionInfo

	Guard string // branch guard, e.g. "at_rest" or "!at_rest"; "" if unguarded

	// Table is the nested table's descriptor, or nil. Held as a factory rather
	// than a value so a descriptor graph needs no initialization order: Go
	// refuses an initialization cycle across package-level variables, and a
	// table may name one declared later.
	Table func() *TableTypeInfo

	// what a PERSON wrote about the field (mas-bandwidth/schema docs/SPEC-TABLES.md §8.1): the ///
	// block above it, verbatim (SPEC §4.1). It is TableDocNone when there is
	// none, never nil. Its tags (SPEC §4.2) follow in declared order, and an
	// untagged field is 0 beside a nil list. Static package data, allocating
	// nothing.
	Doc     string
	NumTags int32
	Tags    []string
}

type TableFixedDst struct {
	Dst, Stride, Aux   uint32
	Counted, Arg, Meta uint8
}

type TableFixedEntry struct {
	Src, Dst, Size, Aux, Guard uint32
	// Arg IS THE GUARD'S ORDINAL AT FULL WIDTH (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md
	// §4.1: arg : u64, "no byte lane anywhere"): a union past 255 arms or an
	// enum past 65535 variants holds its ordinal whole in this lane, and the
	// compare is made against the 64-bit tag load, never a truncation of it.
	Arg uint64
	// Guard2 / Arg2 / ArgW2 ARE THE OUTER TAG AN ARM INSIDE AN ARM ALSO ANSWERS
	// TO (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md §4.1): the entry runs only when BOTH tags
	// hold their ordinal. ArgW2 of zero is "no outer tag", so a plan that never
	// nests a union leaves the lane unset and the read is unchanged.
	Guard2 uint32
	Arg2   uint64
	// GuardIndex / GuardCount ARE THE GUARD CHAIN (mas-bandwidth/schema docs/FIXED-FORM-ALGORITHM.md
	// §4.1): offset+count into a pool of (guard, arg, argw) links, OUTERMOST
	// FIRST. GuardIndex is a BYTE OFFSET from the plan's own base, where the pool
	// is laid behind the entries the way the ordinal remap tables are, so the
	// plan stays one slice and the read loop one signature. Every guarded entry
	// carries its whole chain; the two lanes above stay its innermost two, the
	// special case, so the loop walks the pool only for a chain past two. The
	// only bound on a chain is the layout's 64 (tableFixedMaxDepth).
	GuardIndex, GuardCount               uint32
	Op, ArgW, DstSize, Sign, Meta, ArgW2 uint8
}

type TableFixedGuardLink struct {
	Guard uint32
	Arg   uint64
	ArgW  uint8
}

type TableFixedKnownLayout struct {
	Hash        uint64
	Layout      []byte
	LayoutBytes int
	Record      int64
}

type TableIds struct {
	Numbering *TableNumbering
	Values    [tableIdCapacity]uint64

	Count    int
	Overflow bool
	// contains filtered or unexported fields
}

type TableMessageEntry struct {
	Id             uint64
	Shape, Element TableMessageShape
}

type TableMessageReader struct {
	Nodes      TableNodeMap
	Bits       TableBitReader
	Vocabulary *TableVocabulary
	Report     TableReport
	IndexBits  int64
}

type TableMessageShape struct {
	Kind, Packing uint8
	Bits          int64
	Base          [2]uint64
	Min, Max      int64
	QMin, QDelta  float32
	QCount        uint32
}

type TableMessageWriter struct {
	TableBitWriter
	IndexBits int64
	Clamped   int32
	Numbering *TableNumbering
	// contains filtered or unexported fields
}

type TableMissingRequired struct{ Fields string }

type TableNodeDirEntry struct{ Offset, TypeId uint64 }

type TableNodeMap struct {
	Base    unsafe.Pointer
	Entries []TableNodeDirEntry
	Good    bool
	Arena   bool
}

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

type TableOpenVerdict uint8

type TableReader struct {
	Nodes  TableNodeMap
	Buffer []byte
	Offset int64
	Report *TableReport
	Ids    []byte
	Nested bool
}

type TableRef = int64

type TableRefuseReason uint8

type TableReport struct {
	Retained, RetainLost int32
	Verdict              TableOpenVerdict // unsupported form is distinct from damage
	Reason               string           // why the form was refused; empty for a file read
	Widened              int32            // a compatible wider kind preserved the value
	Unknown              int32            // unknown field ids skipped (newer data)
	KindMismatch         int32            // known id, changed type — skipped, never misdecoded
	Clamped              int32            // out-of-range values clamped to declared bounds
	// Duplicate counts repeated text keys. Fixed-class wire fields do not raise it.
	// A body carrying an id twice is legal input
	// whose last occurrence wins, silently. A wire read always leaves it zero.
	Duplicate int32
	// MissingRequired counts required fields (mas-bandwidth/schema docs/SPEC-TABLES.md §2.3) the
	// record did not carry: a record an older writer produced before the field
	// became required. The refusal names the field in Reason.
	MissingRequired int32
	Malformed       bool // framing damage; decode stopped, partial result kept
	// BuildVersionPeer and BuildVersionOwn are the two build versions a strict
	// announcement refusal carries (mas-bandwidth/schema docs/SPEC-TABLES.md §3.3): the peer's
	// announcement and this unit's own. They are zero on every other read.
	BuildVersionPeer uint64
	BuildVersionOwn  uint64
	// LayoutHash is THE FILE'S hash, and it is set by ONE refusal:
	// layout_newer reports it "AND NOTHING ELSE" (§5.3). layout_unsupported
	// reports it too — the operator's other answer, a layout this build served
	// and has retired.
	LayoutHash uint64
}

type TableRetain struct {
	Bytes []byte
	Ids   []TableRetainId
	Used  int64
	Count int
	// contains filtered or unexported fields
}

type TableRetainId struct {
	Id   uint64
	Slot int
}

type TableRetainIds struct {
	Numbering      *TableNumbering
	Retain         *TableRetain
	Path           tableRetainPath
	Count          int
	Overflow, Lost bool
	// contains filtered or unexported fields
}

type TableRetainMessageReader struct {
	Retain *TableRetain
	Path   tableRetainPath
	// contains filtered or unexported fields
}

type TableRetainReader struct {
	Retain *TableRetain
	Path   tableRetainPath
	// contains filtered or unexported fields
}

type TableRetainWriter struct {
	Buffer    []byte
	Offset    int64
	Overflow  bool
	Measuring bool
	Ids       *TableRetainIds
}

type TableStringView struct {
	Data   []byte
	Length int64
}

type TableTimestampError struct {
	Field string
	Time  time.Time
}

type TableTypeInfo struct {
	SaveBodyRetain        func(*TableRetainWriter, unsafe.Pointer) bool
	LoadBodyRetain        func(TableRetainReader, unsafe.Pointer) bool
	LoadMessageBodyRetain func(TableRetainMessageReader, unsafe.Pointer) (TableRetainMessageReader, bool)
	CookSize, CookAlign   uint32
	Name                  string // schema type name
	Size                  uint32 // unsafe.Sizeof the storage struct
	Id                    uint64
	Variable              bool
	NodeType              func(uint64) *TableTypeInfo
	SaveBody              func(*TableWriter, unsafe.Pointer) bool
	LoadBody              func(TableReader, unsafe.Pointer) bool
	SaveMessageBody       func(*TableMessageWriter, unsafe.Pointer) bool
	LoadMessageBody       func(TableMessageReader, unsafe.Pointer) (TableMessageReader, bool)
	NumFields             int32
	Fields                []TableFieldInfo
	// Reset puts one instance back at its declared defaults, in place. A
	// generic walker that fills a value has to be able to establish the
	// defaults an absent field takes, and it holds no type to spell — this is
	// the one thing the descriptors could not express without it.
	Reset func(storage unsafe.Pointer)

	// the declaration's own doc and tags, on the same terms as a field's
	// (mas-bandwidth/schema docs/SPEC-TABLES.md §8.1, SPEC §4.1, §4.2)
	Doc     string
	NumTags int32
	Tags    []string
}

type TableUnionArmInfo struct {
	Field  TableFieldInfo               // arm shape; offsets are relative to union storage
	Void   bool                         // a selected payload-free arm
	Reset  func(storage unsafe.Pointer) // establish selected payload defaults
	Offset uint32                       // unsafe.Offsetof the arm's payload within the union storage
	Table  func() *TableTypeInfo        // the arm payload's descriptor
}

type TableUnionInfo struct {
	CookTagSize uint32
	TagOffset   uint32 // unsafe.Offsetof the tag within the union storage
	TagSize     uint32 // unsafe.Sizeof the tag
	Arms        []TableUnionArmInfo
}

type TableVocabulary struct {
	Entries            []TableMessageEntry
	Count, RefBits     int64
	BuildVersion       uint64
	Announced, Refused bool
	MaxBytes           int64
	Strict             bool
}

type TableWorker struct {
	Arena *TableArena
	// contains filtered or unexported fields
}

type TableWriteContext interface {
	// contains filtered or unexported methods
}

type TableWriter struct {
	Buffer    []byte
	Offset    int64
	Overflow  bool
	Measuring bool
	Ids       *TableIds
}

type UnitViewInfo struct {
	Package                                                          string
	ProtocolId                                                       uint64
	NumTypes, NumTables, NumEnums, NumFlags, NumUnions, NumConstants int32
	Types, Tables                                                    []ViewType
	Enums, Flags, Unions                                             []ViewVocabulary
	Constants                                                        []ViewConstant
}

type ViewConstant struct {
	Name, File, TypeName string
	IsFloat              bool
	IntValue             int64
	FloatValue           float64
	Doc                  string
	NumTags              int32
	Tags                 []string
}

type ViewType struct {
	Name, File string
	Table      bool
	Type       *TableTypeInfo
	Doc        string
	NumTags    int32
	Tags       []string
}

type ViewVariant struct {
	Value       uint64
	Name        string
	Id          uint64
	PayloadName string
	Payload     func() *TableTypeInfo
	Field       func() *TableFieldInfo
	Doc         string
	NumTags     int32
	Tags        []string
}

type ViewVocabulary struct {
	Name, File               string
	Max                      int64
	StorageBits, NumVariants int32
	PayloadOffset            uint32
	Variants                 []ViewVariant
	Doc                      string
	NumTags                  int32
	Tags                     []string
}