!!id:"https://tson.io/2026/38/m/core-resolved.tn"
!!schema:"https://tson.io/2026/38/m/meta.tn"
@doc:"""
  Resolver-output fixture for core.tn (2026 Revision 38 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 (`schema`, `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 at entries' tags
  (`integer_type`, `decimal_type`, `float_type`, `complex_type`, ...)
  likewise name meta- and kernel-level entries.

  The open entries (`extern_of`, `extern_type`, `set`, `kind`, `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 (Part 2 Section 5.10's shadowing rule). A
  processor comparing these compares wire form, not bound values.
  """
!schema {
  void => !void_type {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  set => !template { parameters: [{ name: T  type: type_kind }]  template: "!set_type { element_type: T }" }

  kind => !template { parameters: [{ name: T  type: type_name }]  template: "!kind_type { of: T }" }

  tuple1 => !template { parameters: [{ name: T  type: type_kind }]  template: "!tuple { elements: [{ element_type: T }] }" }

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

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