0.10.0 Vatrushka

• The macros accept swift-syntax from 602 to 604, where they accepted 602
  alone, so an app that pins swift-syntax to its compiler's release, 603
  for Swift 6.3 or 604 for 6.4, resolves Baton, and gets swift-syntax's
  prebuilt macro support with it. The range spans the floor's toolchain to
  the newest release and CI builds both ends; recorded in
  docs/decisions/swift-syntax-spans-the-floor-to-the-newest.md.
• A list of scalars follows its element type in what it accepts, as the
  contract says and the Kotlin readers do: a list of strings reads a
  number's or a boolean's text, a list of floats reads an int, a list of
  ints reads a whole float, as the single-value readers always did. Before,
  a list element of another kind was dropped or read as nil where the
  scalar reader converted it.
• The Kotlin runtime has its store and its ingest: a response's bytes
  become a change set by the plan, with no JSON tree between, and the
  commit writes it into records whose cells are Compose snapshot state, so
  a read in composition registers the field and a write tells its readers
  alone. Connections merge, edge directives edit, errors land on their
  fields and deferred parts on their records, and every case of
  spec/manifest.json leaves its dump byte for byte on the JVM. The
  lenses, layers, retention and the image follow.
• batonc writes Kotlin: generate --language kotlin, or a .kt host,
  writes each operation as a class of its variables, equal by them, whose
  companion holds its document and plan, and the shared Baton.baton.kt
  with Types, Slots, the schema's enums and its input objects, in the
  package baton.json names under "kotlin": {"package": …} or the host's
  own. The .kt scanner reads every Kotlin string form, and a document with
  a variable is written in a $$ string. A mapped scalar names its Kotlin
  type and converter under kotlin. Lenses follow with the Kotlin readers.
• The Kotlin runtime reads: the anchor's readers behind every accessor
  generated code prints, the owner that settles a lens's keys, conditions
  and @arguments once, and the placeholder behind a non-null link with no
  record. A read registers the one cell it reads; a missing or wrong-kind
  value is reported to the store's log once and reads as null or a zero
  value; @required, @catch, @throwOnFieldError and @defer read by
  Relay's rules, @catch as a kotlin.Result. Lenses written by hand
  after the Swift goldens read the reads rows of ten operations' cases
  as the cases say. Pagination and refetch come with the environment.
• URLSessionTransport reads a request error answered with a 4xx or 5xx
  status as application/graphql-response+json, as GraphQL Yoga, Hive
  Gateway and Apollo Router do for a document that fails to parse or
  validate or an unknown persisted document: it throws the server's
  GraphQLErrors, the request kind of failure, where it threw a
  TransportError with the body as text. A query fails with the server's
  errors and their extensions, and a subscription refused so ends rather
  than reconnecting by backoff. Another body outside 2xx, and any
  application/json one, is still a TransportError.
• The common-first record is amended: the JVM, through Compose for
  Desktop, is the first actual and the development target of the Kotlin
  runtime; Android is the first shipped target and the ingest budget's
  home. It names the two primitives a target supplies beside the image,
  the transports and the activity signal: a thread's identity and a
  double's shortest text.
• The authors' documents are under spec/sources/, one .graphql file
  each, with the configuration they compile with in spec/tests/baton.json,
  so a second runtime's harness compiles its lenses from the specification
  alone. The compiler's tests check them against the Swift test target's
  markers and prove they plan what the markers plan. The manifest is format
  3: sources names the directory and the configuration.
• The spec's scripts compare the requests a step sends: a sent
  expectation lists each request's operation and the exact body the
  standard encoding writes. Script transport holds the body's member
  order, the text without client fields and client directives, an enum and
  a mapped scalar sent as their text, and an input object's unset fields
  left out.
• A nullable variable left unset is left out of the request, and one the
  operation declares with a default is sent as that default, where both
  were sent as null; GraphQL applies an argument's default only to an
  absent variable, so the server and the store's keys now see one value.