definitions

type ActiveDocuments struct {
	Runtime             Document
	Schema              Document
	EpochImplementation Document
	Retention           Document
	Interpreter         Document
}

type ByteBounds struct {
	Min int `json:"min"`
	Max int `json:"max"`
}

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

type EpochPhase struct {
	ID          string            `json:"id"`
	Number      int               `json:"number"`
	OwnerRoles  []string          `json:"owner_roles"`
	Transitions []EpochTransition `json:"transitions"`
}

type EpochQueue struct {
	Name        string `json:"name"`
	Concurrency string `json:"concurrency"`
}

type EpochRole struct {
	ID string `json:"id"`
}

type EpochSpecification struct {
	// Cohort is the DBOS recovery cohort marker. Recovery filters in-flight
	// epochs by executor and cohort, so a rebuilt binary with this marker
	// still recovers epochs an earlier build left in flight.
	Cohort string `json:"cohort"`
	// ProtocolTransitions are the canonical protocol reachability table:
	// every phase with the phases directly reachable from it.
	ProtocolTransitions map[string][]string `json:"protocol_transitions"`
	// ConsensusGated are the protocol transitions requiring all-ACCEPT
	// consensus, as from/to pairs.
	ConsensusGated [][2]string `json:"consensus_gated"`
	// BlockerGated are the protocol transitions blocked while blockers stand.
	BlockerGated [][2]string `json:"blocker_gated"`
	// ReviseDrivesBack are the review phases where a REVISE vote forces only
	// the backward transition.
	ReviseDrivesBack []string `json:"revise_drives_back"`
	// Phases are the codegen phase inventory with owner roles and gated
	// transitions, sorted by phase number.
	Phases []EpochPhase `json:"phases"`
	// Roles are the codegen role inventory by wire identity, sorted.
	Roles []EpochRole `json:"roles"`
	// Workflows are the codegen workflow inventory with execution stages,
	// sorted by workflow identity.
	Workflows []EpochWorkflow `json:"workflows"`
	// WriteClasses are the closed lifecycle write classes the gate admits,
	// in class order.
	WriteClasses []string `json:"write_classes"`
	// SignalTopics are the durable epoch signal topics, sorted.
	SignalTopics []string `json:"signal_topics"`
	// QueryNames are the read-only epoch state queries, sorted.
	QueryNames []string `json:"query_names"`
	// Queues are the durable work queues with their concurrency discipline.
	Queues []EpochQueue `json:"queues"`
	// Sources is the engine execution source manifest: every production epoch
	// execution source with its generation-time content hash, sorted by path.
	Sources []SourceEntry `json:"sources"`
}

type EpochStage struct {
	ID        string `json:"id"`
	Order     int    `json:"order"`
	Execution string `json:"execution"`
	Phase     string `json:"phase,omitempty"`
}

type EpochTransition struct {
	To        string `json:"to"`
	Condition string `json:"condition"`
	Action    string `json:"action,omitempty"`
}

type EpochWorkflow struct {
	ID     string       `json:"id"`
	Role   string       `json:"role"`
	Stages []EpochStage `json:"stages"`
}

type IdentityDescriptor struct {
	Kind     pastureruntime.NativeIdentityKind `json:"kind"`
	Name     string                            `json:"name"`
	Required bool                              `json:"required"`
}

type InterpreterSpecification struct {
	// Pipeline is the ordered interpretation contract from verified event to
	// durable record.
	Pipeline []InterpreterStage `json:"pipeline"`
	// Semantics are the closed event meanings the transform discriminates.
	Semantics []string `json:"semantics"`
	// Terminals maps each non-observation semantic to the legalization
	// terminal the transform produces. Observation needs no terminal.
	Terminals map[string]string `json:"terminals"`
	// UnresolvedReasons are the closed correlation-gap reasons.
	UnresolvedReasons []string `json:"unresolved_reasons"`
	// IdentityKinds are the native correlation kinds interpretation may
	// carry, in canonical order.
	IdentityKinds []string `json:"identity_kinds"`
	// IdentityBounds bounds interpretation identity values.
	IdentityBounds ByteBounds `json:"identity_bounds"`
	// DecisionKinds are the consultation decision vocabulary shared by the
	// evaluator, the durable consultation, and the backend.
	DecisionKinds []string `json:"decision_kinds"`
	// RecordKinds are the durable interpreted evidence kinds: v1 is read-only
	// legacy without a coordinate, v2 carries the producing manifest, and v3
	// carries the complete five-reference semantic envelope.
	RecordKinds []string `json:"record_kinds"`
	// VocabularyRule states how the interpretation vocabulary travels: every
	// produced record stamps the manifest coordinate it was interpreted
	// against; readers resolve meaning to the journaled vocabulary, never to
	// the current binary's belief.
	VocabularyRule string `json:"vocabulary_rule"`
	// Sources is the compiled interpretation source manifest: every
	// production interpretation source with its generation-time content hash,
	// sorted by path.
	Sources []SourceEntry `json:"sources"`
}

type InterpreterStage struct {
	Stage  string `json:"stage"`
	Owner  string `json:"owner"`
	Entry  string `json:"entry"`
	Input  string `json:"input"`
	Output string `json:"output"`
}

type LifecycleDescriptor struct {
	Name                 string                              `json:"name"`
	Semantic             pastureruntime.EventSemantic        `json:"semantic"`
	Surface              pastureruntime.HookSurface          `json:"surface"`
	Blocking             pastureruntime.BlockingMode         `json:"blocking"`
	Mutation             pastureruntime.MutationMode         `json:"mutation"`
	Order                pastureruntime.HandlerOrder         `json:"order"`
	Reconciliation       pastureruntime.ReconciliationMode   `json:"reconciliation"`
	Failure              pastureruntime.FailureMode          `json:"failure"`
	DeclaredFailure      pastureruntime.FailureMode          `json:"declared_failure"`
	Evidence             pastureruntime.FailureEvidence      `json:"evidence"`
	AskEvidence          pastureruntime.FailureEvidence      `json:"ask_evidence"`
	PreAction            bool                                `json:"pre_action"`
	Response             pastureruntime.ResponseCapability   `json:"response"`
	StopLoop             pastureruntime.StopLoopPolicy       `json:"stop_loop"`
	IdentityPolicy       pastureruntime.IdentityPolicy       `json:"identity_policy"`
	Identities           []IdentityDescriptor                `json:"identities"`
	UnresolvedIdentities []pastureruntime.NativeIdentityKind `json:"unresolved_identities"`
}

type RetentionSpecification struct {
	// Policy names the single retention mode. Committed named bodies are
	// retained; there is no age- or size-bounded dropping of journal rows.
	Policy string `json:"policy"`
	// CommittedNamedBodies states the fate of payload blobs a recorded
	// occurrence names: retained, never reclaimed.
	CommittedNamedBodies string `json:"committed_named_bodies"`
	// OrphanEligibility states when an unnamed payload blob may be reclaimed:
	// unreferenced by any recorded occurrence, strictly older than the snapshot
	// instant minus the writer window, and of known age.
	OrphanEligibility string `json:"orphan_eligibility"`
	// UnknownAge states the fate of a blob with an unknown written-at stamp:
	// never eligible, whatever the snapshot instant.
	UnknownAge string `json:"unknown_age"`
	// ReadCap bounds how many orphan blobs one projection rebuild reclaims. It
	// sizes a read command's added latency, not a host budget.
	ReadCap int `json:"read_cap"`
	// PruneBatchCap bounds how many orphan blobs one operator prune batch
	// deletes. Each batch is its own short write transaction.
	PruneBatchCap int `json:"prune_batch_cap"`
	// WindowRule names the writer window the reclaim ages against: the
	// WorkflowResult tier of the injected timeout profile, or the operator's
	// retention age when larger. The window is a floor and never a ceiling.
	WindowRule string `json:"window_rule"`
	// WriteOrder states the deliberate blob/journal order: the payload blob is
	// written before the journal row that names it, so an orphan blob is
	// reclaimable while a journal row naming an absent blob is corruption.
	WriteOrder string `json:"write_order"`
	// Digest names the content-address algorithm for payload blobs.
	Digest string `json:"digest"`
	// NewestRow states the operator prune's one exclusion: the row at the
	// greatest written-at is never deleted.
	NewestRow string `json:"newest_row"`
}

type RuntimeSpecification struct {
	Contract            ir.RuntimeContractID                  `json:"contract"`
	Harness             ir.HarnessID                          `json:"harness"`
	Minimum             string                                `json:"minimum"`
	Maximum             string                                `json:"maximum"`
	HasUpperBound       bool                                  `json:"has_upper_bound"`
	IncludesPrereleases bool                                  `json:"includes_prereleases"`
	NativeTransport     string                                `json:"native_transport"`
	Operations          []pastureruntime.BindingDescriptor    `json:"operations"`
	Effects             []pastureruntime.BindingDescriptor    `json:"effects"`
	Capabilities        []pastureruntime.CapabilityDescriptor `json:"capabilities"`
	Registration        registration.Manifest                 `json:"registration"`
	Lifecycle           []LifecycleDescriptor                 `json:"lifecycle"`
}

type SchemaSpecification struct {
	// OccurrenceKinds are the durable occurrence evidence kinds the receipt
	// writer emits. v1 is read-only legacy without refs; v2 carries the
	// complete four-reference envelope and is the only kind new writes emit.
	OccurrenceKinds []string `json:"occurrence_kinds"`
	// InterpretedKinds are the durable interpreted evidence kinds. v1 is
	// read-only legacy without a metamodel coordinate; v2 carries one; v3
	// carries the complete five-reference semantic envelope.
	InterpretedKinds []string `json:"interpreted_kinds"`
	// DefinitionKinds are the durable definition snapshot evidence kinds for
	// the legacy metamodel writer (v1) and the five-kind writer (v2).
	DefinitionKinds []string `json:"definition_kinds"`
	// DefinitionStateKinds are the durable activation-state evidence kinds
	// paired with the snapshot kinds above.
	DefinitionStateKinds []string `json:"definition_state_kinds"`
	// DefinitionSlots are the ordered result slots every definition activation
	// commits, in commit order.
	DefinitionSlots []string `json:"definition_slots"`
	// OccurrenceEnvelope is the complete four-reference occurrence envelope:
	// definition kind per slot name.
	OccurrenceEnvelope map[string]model.DefinitionKind `json:"occurrence_envelope"`
	// SemanticEnvelope is the complete five-reference semantic envelope:
	// definition kind per slot name. The runtime, schema and implementation
	// slots are shared with the occurrence envelope and must be exactly equal
	// across the pair; no ref may be zero, dangling, or content-mismatched.
	SemanticEnvelope map[string]model.DefinitionKind `json:"semantic_envelope"`
	// SharedEnvelopeSlots names the slots the two envelopes share. A paired
	// occurrence/interpretation is admitted only when these refs are exactly
	// equal; refs that each resolve separately but differ fail the pair.
	SharedEnvelopeSlots []string `json:"shared_envelope_slots"`
	// BindingKinds are the native correlation binding kinds an occurrence may
	// carry, in canonical order.
	BindingKinds []string `json:"binding_kinds"`
	// BindingValueBytes bounds occurrence binding text: 1 through 512 bytes of
	// valid UTF-8 with no surrounding padding and no control characters.
	BindingValueBytes ByteBounds `json:"binding_value_bytes"`
	// IdentityValueBytes bounds interpretation identity values: at most 512
	// bytes with the same text discipline as bindings.
	IdentityValueBytes ByteBounds `json:"identity_value_bytes"`
	// PayloadDigest names the content-address algorithm for evidence payload
	// blobs. The blob write precedes the journal append, so an orphan blob is
	// reclaimable while a journal row naming an absent blob is corruption.
	PayloadDigest string `json:"payload_digest"`
	// CaptureDispositions are the numeric capture dispositions a receipt may
	// record: valid plus every non-valid path, all of which still journal a
	// complete occurrence envelope and never fabricate an interpretation.
	CaptureDispositions []uint8 `json:"capture_dispositions"`
	// CaptureOrigins are the provenance origins an envelope may record. Origin
	// is provenance-only; the write gate never observes it.
	CaptureOrigins []string `json:"capture_origins"`
	// HostVersionSources are the closed provenance sources for the observed
	// host version, which is provenance rather than an admission check.
	HostVersionSources []string `json:"host_version_sources"`
	// RuntimeContractRule states the contract pairing the codecs enforce: the
	// envelope runtime ref resolves to the runtime body whose contract equals
	// the delivery contract and the occurrence codec's contract.
	RuntimeContractRule string `json:"runtime_contract_rule"`
}

type SourceEntry struct {
	Path   string `json:"path"`
	SHA256 string `json:"sha256"`
}