schema

type Arg struct {
	Name  string
	Match *ir.Node
}

type Context struct {
	// OutIn maps URI to short names (which short names belong to this URI)
	OutIn map[string]map[string]bool

	// InOut maps short name to URI
	InOut map[string]string

	// URI is the primary/long name for this context (e.g., "tony-format/context/match")
	// If not set, will be inferred from OutIn
	URI string

	// ShortName is the short name for this context (e.g., "match")
	ShortName string

	// Tags defines which tags are available in this context
	// Map of tag name -> TagDefinition
	Tags map[string]*TagDefinition

	// Extends lists URIs of parent contexts (for inheritance/composition)
	Extends []string
}

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

type FromReference struct {
	// SchemaName is the name of the schema containing the definition
	SchemaName string

	// DefName is the name of the definition within that schema
	DefName string

	// SchemaArgs are schema arguments (for parameterized schemas)
	SchemaArgs []*ir.Node
}

type Schema struct {
	// The context in which this schema lives (handles @context and with)
	Context *Context

	// Signature defines how the schema can be referenced
	Signature *Signature `tony:"signature"`

	// Tags defines tags that this schema introduces
	// Map of tag name -> TagDefinition
	//
	// When reading: If signature.name exists, a tag with that name is automatically
	// added to Tags (if not already present) for programmatic access. Writers don't
	// need to duplicate signature.name in the tags field.
	//
	// When encoding: Tags matching signature.name with no additional fields
	// (only Name set, no Contexts/SchemaRef/Description) are elided to avoid duplication.
	Tags map[string]*TagDefinition `tony:"tags"`

	// Define provides a place for value definitions, like json-schema $defs
	Define map[string]*ir.Node `tony:"define"`

	// Accept defines what documents this schema accepts
	Accept *ir.Node `tony:"accept"`
}

type SchemaReference struct {
	// Name is the schema name (from signature.name)
	Name string

	// URI is the fully qualified schema URI (optional, for cross-context refs)
	URI string

	// Args are schema arguments (for parameterized schemas)
	Args []*ir.Node
}

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

type Signature struct {
	// Name is the schema name, so we can use '!name' to refer to this
	Name string `tony:"name"`

	// Args are the schema arguments (for parameterized schemas)
	Args []Arg `tony:"args"`
}

type TagDefinition struct {
	// Name is the tag name (e.g., "or", "and")
	Name string

	// Contexts lists which contexts this tag belongs to (URIs)
	Contexts []string

	// SchemaRef optionally references a schema that defines this tag's behavior
	// Empty if no schema defines it (built-in tag)
	SchemaRef string

	// Description of what this tag does
	Description string
}