!!id:"https://tson.io/2026/37/m/core-resolved.tn"
!!schema:"https://tson.io/2026/37/m/meta.tn"
@doc:"""
  Resolver-output fixture for core.tn (2026 Revision 37 draft).
  Parse the source schema, run the resolver, canonicalise, compare.
  Conventions as in meta-kernel-resolved.tn.

  This document is governed by the meta-schema: the structural
  vocabulary (`type_definition`, `record`, `enum`, ...) reaches it
  through meta's kernel import. As a data document, this header
  cannot carry `!!import`: the namespace in which this map's
  type-name tokens resolve (core.tn's locals; core imports nothing)
  is declared by the source schema's header and supplied at ingest
  ([TSON-SCHEMA] Section 8.1), never by this document. The
  annotation types used here
  (`doc` from the kernel via that import; `ordering`, `bounded`,
  `exact`, `numeric` from meta itself) resolve one hop against meta's
  namespace. Constructor names in `source` fields and bodies
  (`integer_type`, `decimal_type`, `float_type`, `complex_type`, ...)
  likewise name meta- and kernel-level entries.

  The open entries (`extern_of`, `extern_type`, `set`, `tuple1`,
  `voidable_tuple1`) hold their bodies — the application as written,
  unread until materialisation substitutes the parameters away — so a
  token in one is a parameter reference rather than a value of the
  slot's declared type (Section 8.1's shadowing rule). A processor comparing these compares wire
  form, not bound values.
  """
!schema {
  void => !type_definition {
    source: void_type
    body: !void_type {}
  }

  boolean => !type_definition {
    source: enum
    body: !enum { members: [true false] }
  }

  @ordering:TOTAL @bounded:false @exact:true @numeric
  integer => !type_definition {
    source: integer_type
    subtypes: [int128 int16 int256 int32 int64 int8 uint128 uint16 uint256 uint32 uint64 uint8]
    body: !integer_type {}
  }

  @ordering:TOTAL @bounded:false @exact:true @numeric
  number => !type_definition {
    source: decimal_type
    body: !decimal_type {}
  }

  @ordering:TOTAL @bounded:false @exact:true @numeric
  rational => !type_definition {
    source: rational_type
    body: !rational_type {}
  }

  @ordering:NONE @bounded:false @numeric
  complex => !type_definition {
    source: complex_type
    body: !complex_type {}
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  int8 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 8  signed: true } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  int16 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 16  signed: true } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  int32 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 32  signed: true } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  int64 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 64  signed: true } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  int128 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 128  signed: true } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  int256 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 256  signed: true } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  uint8 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 8  signed: false } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  uint16 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 16  signed: false } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  uint32 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 32  signed: false } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  uint64 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 64  signed: false } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  uint128 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 128  signed: false } }
  }

  @ordering:TOTAL @bounded:true @exact:true @numeric
  uint256 => !type_definition {
    source: integer_type
    supertypes: [integer]
    body: !integer_type { size: { bits: 256  signed: false } }
  }

  @ordering:PARTIAL @bounded:false @exact:false @numeric
  float32 => !type_definition {
    source: float_type
    body: !float_type { format: BINARY32 }
  }

  @ordering:PARTIAL @bounded:false @exact:false @numeric
  float64 => !type_definition {
    source: float_type
    body: !float_type { format: BINARY64 }
  }

  @ordering:NONE @bounded:false
  text => !type_definition {
    source: text_type
    body: !text_type {}
  }

  @ordering:NONE @bounded:false
  regex => !type_definition {
    source: regex_type
    body: !regex_type {}
  }

  @ordering:NONE @bounded:false
  uri_reference => !type_definition {
    source: uri_type
    subtypes: [uri]
    body: !uri_type {}
  }

  @ordering:NONE @bounded:false
  uri => !type_definition {
    source: uri_type
    supertypes: [uri_reference]
    body: !uri_type { allow_relative: false }
  }

  @ordering:NONE @bounded:false
  iri_reference => !type_definition {
    source: iri_type
    subtypes: [iri]
    body: !iri_type {}
  }

  @ordering:NONE @bounded:false
  iri => !type_definition {
    source: iri_type
    supertypes: [iri_reference]
    body: !iri_type { allow_relative: false }
  }

  @ordering:NONE @bounded:false
  bytes => !type_definition {
    source: bytes_type
    body: !bytes_type {}
  }

  @ordering:TOTAL @bounded:true
  date => !type_definition {
    source: date_type
    body: !date_type {}
  }

  @ordering:TOTAL @bounded:true
  time => !type_definition {
    source: time_type
    body: !time_type {}
  }

  @ordering:TOTAL @bounded:true
  datetime => !type_definition {
    source: datetime_type
    body: !datetime_type {}
  }

  @ordering:TOTAL @bounded:true
  duration => !type_definition {
    source: duration_type
    body: !duration_type {}
  }

  @ordering:TOTAL @bounded:false
  period => !type_definition {
    source: period_type
    body: !period_type {}
  }

  @ordering:NONE @bounded:false
  uuid => !type_definition {
    source: uuid_type
    body: !uuid_type {}
  }

  @ordering:NONE @bounded:false
  email => !type_definition {
    source: email_type
    body: !email_type {}
  }

  @ordering:TOTAL @bounded:true
  ipv4 => !type_definition {
    source: ipv4_type
    body: !ipv4_type {}
  }

  @ordering:TOTAL @bounded:true
  ipv6 => !type_definition {
    source: ipv6_type
    body: !ipv6_type {}
  }

  @ordering:PARTIAL @bounded:false
  cidr4 => !type_definition {
    source: cidr4_type
    body: !cidr4_type {}
  }

  @ordering:PARTIAL @bounded:false
  cidr6 => !type_definition {
    source: cidr6_type
    body: !cidr6_type {}
  }

  @ordering:NONE @bounded:false
  mac => !type_definition {
    source: mac_type
    body: !mac_type {}
  }

  @ordering:NONE @bounded:false
  declared => !type_definition {
    source: scoped
    body: !scoped { scope: [LOCAL] }
  }

  @ordering:NONE @bounded:false
  extern => !type_definition {
    source: scoped
    body: !scoped { scope: [EXTERN] }
  }

  @ordering:NONE @bounded:false
  dynamic => !type_definition {
    source: scoped
    body: !scoped { scope: [LOCAL EXTERN] }
  }

  extern_of => !type_definition {
    source: scoped
    body: !template { parameters: [{ name: S  type: schema_identity }]  template: "!scoped { scope: [EXTERN]  schemas: { S => _ } }" }
  }

  extern_type => !type_definition {
    source: scoped
    body: !template { parameters: [{ name: S  type: schema_identity } { name: T  type: type_name }]  template: "!scoped { scope: [EXTERN]  schemas: { S => [T] } }" }
  }

  set => !type_definition {
    source: set_type
    body: !template { parameters: [{ name: T  type: type_ref }]  template: "!set_type { element_type: T }" }
  }

  tuple1 => !type_definition {
    source: tuple
    body: !template { parameters: [{ name: T  type: type_ref }]  template: "!tuple { elements: [{ element_type: T }] }" }
  }

  voidable_tuple1 => !type_definition {
    source: tuple
    body: !template {
      parameters: [{ name: T  type: type_ref }]
      template: "!tuple { elements: [{ element_type: T  voidable: true }] }"
    }
  }

  doc => @annotation !type_definition {
    source: text
    body: !reference { target: text }
  }
}