panorama

type AccessResolver func(r *http.Request, applicationID string) (ApplicationAccess, error)

type Application struct {
	ID      string
	Name    string
	CanView bool
}

type ApplicationAccess struct {
	Exists    bool
	CanView   bool
	CanEdit   bool
	Protected bool
}

type ArchiMateExport struct {
	// Instance names the Atlas the landscape was read from — a host, as the reader
	// knows it. Never a credential and never a peer's address: this is the server the
	// reader is already looking at.
	Instance string
	// GeneratedAt is when, in Unix seconds. Zero says so rather than inventing one.
	GeneratedAt int64
}

type Binding struct {
	ElementID   string `json:"elementId"`
	ElementType string `json:"elementType"`
	// ElementName is what the architect called it. The mesh overlay shows it, and
	// for an element Atlas has no resource for it is the only name there is.
	ElementName string   `json:"elementName,omitempty"`
	Key         string   `json:"key"`
	Values      []string `json:"values"`
}

type BindingCandidate struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

type BindingCandidates struct {
	Key string `json:"key"`
	// Supported is false when this server cannot resolve the kind at all. Without
	// it an empty list would read as "there are none", which is a different and
	// wrong answer.
	Supported  bool               `json:"supported"`
	Candidates []BindingCandidate `json:"candidates"`
}

type BindingSet struct {
	ContractVersion int       `json:"contractVersion"`
	Bindings        []Binding `json:"bindings"`
	Problems        []Problem `json:"problems"`
}

type Bucket struct {
	At    int64   `json:"at"`
	Value float64 `json:"value"`
}

type C4Element struct {
	ID          string `json:"id"`
	Type        string `json:"type"`
	Name        string `json:"name,omitempty"`
	Description string `json:"description,omitempty"`
	// Parent is the enclosing element, from a composition or aggregation.
	Parent     string `json:"parent,omitempty"`
	SourceType string `json:"sourceType"`
}

type C4Loss struct {
	ID         string `json:"id"`
	SourceType string `json:"sourceType"`
	Name       string `json:"name,omitempty"`
	Reason     string `json:"reason"`
}

type C4Projection struct {
	Notation       string `json:"notation"`
	SourceNotation string `json:"sourceNotation"`
	SourceModelID  string `json:"sourceModelId"`
	SourceRevision int64  `json:"sourceRevision"`
	MappingVersion int    `json:"mappingVersion"`
	// ReadOnly is always true and is in the payload on purpose: a consumer must not
	// be able to mistake a projection for a source document.
	ReadOnly      bool             `json:"readOnly"`
	Elements      []C4Element      `json:"elements"`
	Relationships []C4Relationship `json:"relationships"`
	Dropped       []C4Loss         `json:"dropped"`
}

type C4Relationship struct {
	ID         string `json:"id"`
	Source     string `json:"source"`
	Target     string `json:"target"`
	Name       string `json:"name,omitempty"`
	SourceType string `json:"sourceType"`
}

type Call struct {
	ElementID       string
	CalledProcessID string
	TargetKey       uint64
}

type Catalog struct {
	Applications map[string]ResourceRef
	Processes    map[string]ResourceRef
	Connectors   map[string]ResourceRef
	JobTypes     map[string]ResourceRef
	Runtimes     map[string]ResourceRef
	Targets      map[string]ResourceRef
	Releases     map[string]ResourceRef
}

type CatalogResolver func(r *http.Request) (Catalog, error)

type Clock func() time.Time

type ContextDocument struct {
	ContractVersion int             `json:"contractVersion"`
	ElementID       string          `json:"elementId"`
	ObservedAt      int64           `json:"observedAt"`
	Window          ContextWindow   `json:"window"`
	Results         []ContextResult `json:"results"`
	// Truncated reports that results were dropped to stay inside the bound, so a
	// short answer is not read as a complete one.
	Truncated bool           `json:"truncated"`
	Limits    []ContextLimit `json:"limits"`
}

type ContextLimit struct {
	Limit  string `json:"limit"`
	Reason string `json:"reason"`
}

type ContextQuery struct {
	Key    string
	Value  string
	Window ContextWindow
}

type ContextResolver func(r *http.Request, queries []ContextQuery) ([]ContextResult, error)

type ContextResult struct {
	Source string `json:"source"`
	Key    string `json:"key"`
	Value  string `json:"value"`
	State  string `json:"state"`
	// Reason is why the state is what it is, in the source's own words. It is
	// required for every state except available: a source that could not answer owes
	// the reader a sentence, and one that could does not need to explain itself.
	Reason   string            `json:"reason,omitempty"`
	Measures []Measure         `json:"measures,omitempty"`
	Detail   map[string]string `json:"detail,omitempty"`
}

type ContextWindow struct {
	Window string `json:"window"`
	From   int64  `json:"from"`
	To     int64  `json:"to"`
}

type Decision struct {
	ID      string
	Name    string
	CanView bool
}

type Draft struct {
	ProcessID     string
	Name          string
	ApplicationID string
	CanView       bool
}

type DriftDocument struct {
	ContractVersion int          `json:"contractVersion"`
	Entries         []DriftEntry `json:"entries"`
	// Since is the moment from which this document can speak, or zero when this
	// model has never been read. It is the honest bound on every question asked of
	// it: nothing before it can be answered, whether or not anything happened.
	//
	// While nothing has been dropped that is when the journal *started watching*,
	// not the oldest entry it holds — a quiet hour is a real answer, and dating the
	// document from its first entry would throw that hour away. Once entries have
	// been dropped it is the oldest retained entry instead, because everything
	// before that one genuinely is gone.
	Since int64 `json:"since"`
	// Truncated reports that entries were dropped to stay inside the bound, so an
	// empty stretch is not read as a quiet one.
	Truncated bool         `json:"truncated"`
	Limits    []DriftLimit `json:"limits"`
}

type DriftEntry struct {
	ElementID string `json:"elementId"`
	Key       string `json:"key"`
	Value     string `json:"value"`
	// From is the state this value was last seen in, and To the state it is in
	// now. Both travel because the direction is the finding: healthy → degraded and
	// degraded → healthy are the same transition seen from opposite sides, and one
	// of them is somebody's incident and the other is somebody's fix.
	From string `json:"from"`
	To   string `json:"to"`
	// Reason is the new state's own sentence, kept so an entry read a week later
	// still says what happened rather than only that something did.
	Reason string `json:"reason,omitempty"`
	At     int64  `json:"at"`
}

type DriftLimit struct {
	Limit  string `json:"limit"`
	Reason string `json:"reason"`
}

type Edge struct {
	From string `json:"from"`
	To   string `json:"to"`
	Kind string `json:"kind"`
}

type ElementKind struct {
	// Type is the xsi:type written into the document — the standard's own name,
	// because the document is an interchange format and not Atlas's private store.
	Type string `json:"type"`
	// Label is what a person reads in the palette; Layer groups it there.
	Label string `json:"label"`
	Layer string `json:"layer"`
	// Aspect is the element's role in the standard's structure/behaviour split, and
	// it is what most of the relationship rules below are actually about. Carrying
	// it makes those rules readable as the sentences the specification states,
	// rather than as a list of type pairs somebody has to trust.
	Aspect string `json:"aspect"`
}

type Fact struct {
	Source string
	State  string
	Reason string
	// Detail is a small, flat set of specifics — a version, a count — for a reader
	// who wants the number behind the sentence. It is bounded on the way out
	// (see boundDetail): this document is fetched per model view, and an unbounded
	// detail object is how one becomes too big to render.
	Detail map[string]string
}

type Facts struct {
	Applications map[string]Fact
	Processes    map[string]Fact
	Connectors   map[string]Fact
	JobTypes     map[string]Fact
	Runtimes     map[string]Fact
	Targets      map[string]Fact
	Releases     map[string]Fact
}

type FactsResolver func(r *http.Request) (Facts, error)

type Graph struct {
	Nodes []Node `json:"nodes"`
	Edges []Edge `json:"edges"`
	// Restricted is how many placeholder nodes stand in for resources this caller
	// may not see. The legend states it, so a filtered picture says that it is
	// filtered instead of looking complete.
	Restricted int `json:"restricted"`
	// Clustered reports that the graph exceeded its size budget and collapsed to
	// applications.
	Clustered bool `json:"clustered"`
	// The desired-versus-observed comparison, when a model was overlaid.
	// Modeled counts what a model declares and Atlas does not have; Unmodeled counts
	// what Atlas has and no model mentions.
	Modeled   int `json:"modeled"`
	Unmodeled int `json:"unmodeled"`
	// OutOfScope counts bindings to kinds this picture does not draw — releases,
	// deployment targets, runtimes. They are neither matched nor absent, and the
	// count keeps that visible instead of silently dropping them.
	OutOfScope int `json:"outOfScope"`
	// Status is the severity summary and, as importantly, the declaration of which
	// observation states this build cannot produce at all (ADR-0211 §4).
	Status Status `json:"status"`
	// ObservedAt is when this picture was derived, in Unix seconds, and zero when
	// the caller supplied no clock.
	//
	// It is on the payload rather than left to the reader's own clock because the
	// picture outlives the tab it was drawn in: ADR-0211 §10 requires an exported
	// landscape to carry its observation time *into* the artifact, and a time the
	// browser invented would date the export rather than the facts in it. The two
	// differ by however long the file sat unsaved, and by all of history once
	// somebody re-exports a stale tab.
	ObservedAt int64 `json:"observedAt,omitempty"`
}

type IDGenerator func() (string, error)

type IncidentSite struct {
	// ElementID is the BPMN element id, which is what an operator searches the
	// diagram for.
	ElementID string `json:"elementId"`
	// ElementType is the BPMN type ("ServiceTask", "CallActivity", …), so the id
	// reads as a thing rather than as a string.
	ElementType string `json:"elementType,omitempty"`
	// Count is how many incidents are parked on this element.
	Count int `json:"count"`
	// Message is the first one seen here, not a summary of all of them: several
	// incidents on one element usually share a cause, and inventing a combined
	// sentence would be writing a message nobody produced. Operations has the rest.
	Message string `json:"message,omitempty"`
}

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

type Landscape struct {
	Applications []Application
	Processes    []Process
	// Drafts are the saved diagrams nobody has deployed, and are empty unless the
	// caller asked for them — see [Draft].
	Drafts    []Draft
	Workers   []Worker
	Decisions []Decision
	// Targets are the peers this server can promote to, and what asking them
	// produced. Filled in two halves: the collector names them on the run loop, and
	// [ReachOut] supplies each one's state off it.
	Targets []Target
	// PartialStatus reports that the server stopped counting parked work before it
	// had seen all of it. It travels with the landscape because only the collector
	// knows it, and it must reach the payload: without it a process the scan never
	// reached would be published as healthy on no evidence at all.
	PartialStatus bool
}

type LandscapeCollector func(r *http.Request) (Landscape, ReachOut, error)

type LayoutChange struct {
	// NodeID is the view node's `identifier`, not the element it references. A view
	// may place the same element more than once, and each placement moves on its own.
	NodeID string `json:"nodeId"`
	X      int    `json:"x"`
	Y      int    `json:"y"`
	W      int    `json:"w"`
	H      int    `json:"h"`
}

type Measure struct {
	// Name is the stable identifier a client may key on; Label is what a person
	// reads. Both travel because one of them is a contract and the other is prose,
	// and using either for both jobs makes it impossible to change the prose.
	Name  string `json:"name"`
	Label string `json:"label"`
	// Total is the measure across the whole window. It is carried rather than left
	// to be summed from the buckets, because for a gauge the sum of the buckets is
	// not the total and a client cannot tell which kind it has.
	Total   float64  `json:"total"`
	Buckets []Bucket `json:"buckets"`
}

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

type Model struct {
	ID            string `json:"id"`
	ApplicationID string `json:"applicationId"`
	Name          string `json:"name"`
	Notation      string `json:"notation"`
	Revision      int64  `json:"revision"`
	XML           string `json:"xml"`
	CreatedAt     int64  `json:"createdAt"`
	CreatedBy     string `json:"createdBy,omitempty"`
	UpdatedAt     int64  `json:"updatedAt"`
	UpdatedBy     string `json:"updatedBy,omitempty"`
}

type ModelElement struct {
	ElementID   string
	ElementType string
	Name        string
	Key         string
	Values      []string
}

type NewElement struct {
	// Type is an ArchiMate element type from the authoring subset. Anything else is
	// refused: this writer will not create what the canvas cannot draw rules for.
	Type string `json:"type"`
	Name string `json:"name"`
	// ViewID is the view the new shape is placed on, and the geometry is where.
	ViewID string `json:"viewId"`
	X      int    `json:"x"`
	Y      int    `json:"y"`
	W      int    `json:"w"`
	H      int    `json:"h"`
}

type NewRelationship struct {
	Type   string `json:"type"`
	Source string `json:"source"`
	Target string `json:"target"`
	ViewID string `json:"viewId"`
}

type Node struct {
	ID         string `json:"id"`
	Kind       string `json:"kind"`
	Name       string `json:"name,omitempty"`
	Provenance string `json:"provenance"`
	// Application is the owning application's node id, for grouping. Empty on
	// application, restricted, and unresolved nodes.
	Application string `json:"application,omitempty"`
	// ProcessID and Version identify a process node well enough to navigate to the
	// Operations view (L2) without a second lookup.
	ProcessID string `json:"processId,omitempty"`
	Version   int32  `json:"version,omitempty"`
	// WorkerType is a worker node's Worker Type ("rest", "mail", …). Never its
	// endpoint and never its credential reference — see [Worker].
	WorkerType string `json:"workerType,omitempty"`
	// The ArchiMate element bound to this node, when a model binds one. ModelName is
	// carried beside Name rather than replacing it: the architect's name and the
	// Atlas name are allowed to differ, and the difference is informative.
	ModelElementID   string `json:"modelElementId,omitempty"`
	ModelElementType string `json:"modelElementType,omitempty"`
	ModelName        string `json:"modelName,omitempty"`
	// State is the observation state behind Severity (ADR-0189 §6), kept beside it
	// because the three classes are a reading aid and never a replacement: an
	// operator acting on a finding needs the state, not the color.
	State    string `json:"state"`
	Severity string `json:"severity"`
	// Reason is the sentence behind this node's severity, in the words of whatever
	// observed it. Empty on a node with nothing to report.
	Reason string `json:"reason,omitempty"`
	// SeverityFrom names the descendant a node inherited its severity from, and is
	// empty when the severity is the node's own. ADR-0211 §4 requires it: a red
	// parent that cannot say which child is red is not actionable.
	SeverityFrom string `json:"severityFrom,omitempty"`
	// Incidents is how many unresolved incidents the engine holds against this node.
	// Only a process node can carry one — an incident belongs to a token, and only a
	// process has tokens — so it is absent everywhere else rather than zero, because
	// "no incidents" and "cannot have incidents" are different facts.
	//
	// It is a count, not a severity: the state above already says what class this
	// node is in, and this says how much of it there is. A node with a count is
	// always in a state that reports one, so the two can never disagree.
	Incidents int `json:"incidents,omitempty"`
	// Sites are where in the process that work is parked (see [IncidentSite]).
	//
	// Only a process node carries them, and a collapsed application deliberately
	// does not: an element id without the process it belongs to is not something
	// anybody can act on, and a list of them from six different processes would read
	// as one broken diagram. The collapsed node keeps the summed count, which is the
	// part that survives losing the context.
	Sites []IncidentSite `json:"sites,omitempty"`
	// Children is how many nodes a collapsed application stands for. Set only when
	// the graph is clustered.
	Children int `json:"children,omitempty"`
	// Runtime is the engine's instance tally for this node (see [Runtime]).
	//
	// A process node carries its own. A *collapsed* application carries the sum of
	// the processes it stands for, for the same reason it carries their summed
	// incident count: it is standing in for them, and reporting one child's number
	// against the whole would understate it. An uncollapsed application carries
	// none — its processes are on screen with their own — and no other kind can have
	// instances at all, which is why this is absent rather than zero.
	Runtime *Runtime `json:"runtime,omitempty"`
}

type Notation struct {
	ID             string                  `json:"id"`
	Label          string                  `json:"label"`
	Short          string                  `json:"short"`
	Projection     bool                    `json:"projection"`
	MappingVersion int                     `json:"mappingVersion"`
	Types          map[string]NotationType `json:"types"`
	Loss           []string                `json:"loss"`
}

type NotationType struct {
	Name string `json:"name"`
	Type string `json:"type,omitempty"`
}

type Observation struct {
	ElementID   string `json:"elementId"`
	ElementType string `json:"elementType"`
	Key         string `json:"key"`
	Value       string `json:"value"`

	Source string `json:"source"`
	// State is one of ADR-0189 §6's seven; Severity is ADR-0211 §4's three-class
	// reading of it. Both travel: the class is what makes a hundred elements
	// legible at a glance, and the state is what somebody acts on.
	State    string `json:"state"`
	Severity string `json:"severity"`
	Reason   string `json:"reason,omitempty"`
	// ObservedAt is when this was read, in Unix seconds. It is on every observation
	// rather than only on the document, because the next slice resolves some of
	// them from remote nodes and those will not share one instant.
	ObservedAt int64             `json:"observedAt"`
	Detail     map[string]string `json:"detail,omitempty"`
	// ChangedAt and PreviousState are what the drift journal knows about this
	// value's last transition (ADR-0189 P5). They are on the observation rather
	// than only in the journal because "degraded" and "degraded since nine this
	// morning" are different findings, and the second is the one somebody acts on.
	// Both are absent when nothing has been seen to change — which is not the same
	// as nothing having changed, and is why the journal publishes its limits.
	ChangedAt     int64  `json:"changedAt,omitempty"`
	PreviousState string `json:"previousState,omitempty"`
}

type ObservationDocument struct {
	ContractVersion int `json:"contractVersion"`
	// ObservedAt is when this document was computed. Every observation in it was
	// read while serving this request — nothing here is cached — which is what
	// makes one timestamp meaningful for the whole document today.
	ObservedAt   int64              `json:"observedAt"`
	Observations []Observation      `json:"observations"`
	Summary      ObservationSummary `json:"summary"`
	// Unavailable names the observation states this document cannot produce at all.
	// It is empty now that peers are asked: every one of ADR-0189 §6's states is
	// reachable here. The field stays, because an empty list is a claim somebody
	// can check — and because the landscape mesh, which draws no deployment
	// targets, still has two it cannot produce and publishes them in the same shape.
	Unavailable []UnavailableState `json:"unavailable"`
	// Problems are the extractor's, carried through exactly as binding resolution
	// carries them: a declaration that was refused is as much a finding as one that
	// resolved.
	Problems []Problem `json:"problems"`
}

type ObservationSummary struct {
	OK        int `json:"ok"`
	Attention int `json:"attention"`
	Critical  int `json:"critical"`
	Unknown   int `json:"unknown"`
}

type Options struct {
	// Overlays are the Panorama models compared against this landscape. Empty
	// leaves the mesh exactly as the derivation alone made it.
	Overlays []Overlay
	// MaxNodes is the size budget (ADR-0211 §7). Zero means unlimited. Over budget
	// the graph collapses to applications and says so, rather than returning a graph
	// the browser cannot lay out — or, worse, a truncated one that looks complete.
	MaxNodes int
	// ObservedAt is when the landscape this graph derives from was read, in Unix
	// seconds. Zero omits it, which is what a caller with no clock gets — and is
	// deliberately not "now": a derivation that invented a timestamp would be
	// claiming a freshness nobody measured.
	ObservedAt int64
}

type Overlay struct {
	ModelID   string
	ModelName string
	Elements  []ModelElement
}

type OverlayCollector func(r *http.Request) ([]Overlay, error)

type Problem struct {
	Severity string `json:"severity"`
	Message  string `json:"message"`
}

type Process struct {
	Key           uint64
	ProcessID     string
	Name          string
	Version       int32
	ApplicationID string
	CanView       bool
	Calls         []Call
	Workers       []WorkerUse
	Decisions     []string
	// State is the observation state (ADR-0189 §6) the server read for this
	// process, and Reason is the sentence behind it. Empty means unbound: no
	// observation applies, which is not a finding.
	State  string
	Reason string
	// Incidents is how many unresolved incidents the engine holds against this
	// definition. It is the count behind Reason rather than a second opinion about
	// it, carried as a number so a reader can sort by it and a picture can show
	// which of two degraded processes is the worse one.
	Incidents int
	// Sites are the places in this process where that work is parked.
	Sites []IncidentSite
	// Runtime is what the engine has recorded about this definition's instances:
	// how many are live, how many have finished, and when it last did anything. It
	// is nil where the collector could not read it, which is not the same fact as
	// zero — a process nothing has ever run and a counter that failed to read are
	// different things, and only one of them is worth saying out loud.
	Runtime *Runtime
}

type ReachOut func(ctx context.Context, land *Landscape)

type Refusal struct {
	Reason  string `json:"reason"`
	Message string `json:"message"`
}

type RelationshipKind struct {
	Type  string `json:"type"`
	Label string `json:"label"`
	// Rule is the sentence from the specification this implements, in plain words.
	// It travels to the browser so a refusal can say *why* rather than only that it
	// was refused: "you cannot draw that" teaches nobody the notation.
	Rule string `json:"rule"`
}

type Resolution struct {
	ContractVersion int               `json:"contractVersion"`
	Bindings        []ResolvedBinding `json:"bindings"`
	// Unresolved counts values that are forbidden or missing. It is the number a
	// listing shows as a badge: a model whose bindings no longer resolve is drifting
	// from the instance it describes, and that is worth seeing without opening it.
	Unresolved int `json:"unresolved"`
	// Problems are the extractor's, carried through: a caller needs to hear about
	// declarations that were refused as much as about the ones that stood.
	Problems []Problem `json:"problems"`
}

type ResolvedBinding struct {
	ElementID   string          `json:"elementId"`
	ElementType string          `json:"elementType"`
	Key         string          `json:"key"`
	Values      []ResolvedValue `json:"values"`
}

type ResolvedValue struct {
	Value  string `json:"value"`
	Status string `json:"status"`
	Name   string `json:"name,omitempty"`
}

type ResourceRef struct {
	ID      string
	Name    string
	CanView bool
}

type Runtime struct {
	// Running is how many instances of this definition are live right now.
	Running int `json:"running"`
	// Finished is how many have completed or been terminated. It never decreases —
	// there is no un-finishing — so it is a lifetime total rather than a rate.
	Finished int `json:"finished"`
	// LastActivity is the Unix-nano timestamp of the most recent lifecycle event of
	// any of its instances, or zero for a definition nothing has ever run. Zero is
	// meaningful here in a way it is not for the counts: no activity ever is exactly
	// what a definition nobody has started reports.
	LastActivity int64 `json:"lastActivity,omitempty"`
}

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

type Status struct {
	OK        int `json:"ok"`
	Attention int `json:"attention"`
	Critical  int `json:"critical"`
	// Unknown counts the nodes with no applicable observation. It is stated rather
	// than folded into ok, because "nothing is wrong here" and "nothing here is
	// watched" are the two answers a status view must never merge.
	Unknown int `json:"unknown"`
	// Partial reports that the incident scan hit its bound before it finished, so
	// some parked work went uncounted and a node's ok is a floor rather than a
	// verdict.
	Partial bool `json:"partial,omitempty"`
	// Unavailable names the observation states this build cannot produce at all.
	Unavailable []UnavailableState `json:"unavailable"`
}

type Store struct {
	*sidecar.Store[Model]
}

type Subset struct {
	Version       int                `json:"version"`
	Elements      []ElementKind      `json:"elements"`
	Relationships []RelationshipKind `json:"relationships"`
	// Matrix is the permitted relationship types for every ordered pair of element
	// types in the subset, keyed "Source>Target". It is precomputed and sent whole
	// rather than asked for pair by pair: the canvas needs an answer during a drag,
	// and a network round trip per pointer move is not an answer.
	Matrix map[string][]string `json:"matrix"`
	// Limits says what this subset is not, in the same shape every other Panorama
	// answer publishes its limits.
	Limits []SubsetLimit `json:"limits"`
}

type SubsetLimit struct {
	Limit  string `json:"limit"`
	Reason string `json:"reason"`
}

type Summary struct {
	ID            string `json:"id"`
	ApplicationID string `json:"applicationId"`
	Name          string `json:"name"`
	Notation      string `json:"notation"`
	Revision      int64  `json:"revision"`
	CreatedAt     int64  `json:"createdAt"`
	CreatedBy     string `json:"createdBy,omitempty"`
	UpdatedAt     int64  `json:"updatedAt"`
	UpdatedBy     string `json:"updatedBy,omitempty"`
}

type Target struct {
	ID   string
	Name string
	// State is the observation state ReachOut resolved (ADR-0189 §6), and Reason the
	// sentence behind it. Empty means the peer was never asked — which is not the
	// same as unreachable, and is what a landscape derived while the loop was closing
	// would carry.
	State  string
	Reason string
}

type UnavailableState struct {
	State  string `json:"state"`
	Reason string `json:"reason"`
}

type ValidationResult struct {
	Valid           bool      `json:"valid"`
	Notation        string    `json:"notation"`
	Namespace       string    `json:"namespace,omitempty"`
	ModelIdentifier string    `json:"modelIdentifier,omitempty"`
	Name            string    `json:"name,omitempty"`
	Elements        int       `json:"elements"`
	Relationships   int       `json:"relationships"`
	Views           int       `json:"views"`
	Problems        []Problem `json:"problems"`
}

type Worker struct {
	ID             string
	Name           string
	Type           string
	CanView        bool
	Endpoint       string
	CredentialsRef string
	// State and Reason are this worker's observation, as on [Process].
	State  string
	Reason string
}

type WorkerUse struct {
	ElementID string
	Name      string
	TargetID  string
}