# Changelog

## v0.7.0 - 2026-10-26

### Removed

- The `:decoder_sources` option. Generated helpers are typed against the
  reference `Decoder`, whose method signatures a crate's own keeps.
- The `:sparse_messages` option. Sparse message decoders always use one table
  of their fields, shared with skip decoders when both are generated, which is
  what `:descriptor` did; `:match` generated the same Rust another way.
- Unknown options raise instead of being ignored.

### Changed

- The generator's helper Rust comes from ordinary RustQ modules, included whole
  per feature, instead of modules built at generation time and lists of the
  functions to take from them. Full and sparse decoders share their primitive
  readers, enum decoding, and field reading, and `KiwiDecodeFn` replaces
  `KiwiSparseDecodeFn` and `KiwiFullDecodeFn`. The skip helpers are one module,
  `KiwiCodec.RustlerGenerator.Skip.Helpers`, which RustQ code calling them names
  instead of `Skip.ValueHelpers`. This needs RustQ 1.0.0-rc.19.

- The record feature writes each definition once, as a row of one
  `kiwi_records!` call: its fields and enum values one per line. The macro,
  in the record runtime, expands to the definition table and the
  `kiwi_record_definitions` and `kiwi_records` constants as before, which
  the generator used to write out separately, one table field per line.
  Figma's schema generates about 630 KB less Rust.

## v0.6.0 - 2026-10-25

### Changed

- The constants naming each definition's fields and enum values are associated
  constants of a type per definition, `kiwi_records::NodeChange::FILL_PAINTS`,
  instead of a module per definition, `kiwi_records::node_change::FILL_PAINTS`.
  Rust code naming them changes accordingly.
- RustQ code reaches them through `KiwiCodec.RustlerGenerator.Records`:
  `Records.NodeChange.FILL_PAINTS` and `Records.Definitions.NODE_CHANGE`, in a
  module that aliases it, with no `defrustmod` of its own. This needs RustQ
  1.0.0-rc.17.

## v0.5.1 - 2026-10-25

### Changed

- `KiwiCodec.RustlerGenerator.Records` provides the record runtime to RustQ.
  RustQ code that works with records names the module through `alias` and
  writes `Records.kiwi_record()` in its specs, instead of reading the runtime's
  Rust file from the dependency's directory. The runtime is `templates/records.rs`. This needs RustQ 1.0.0-rc.16.

## v0.5.0 - 2026-10-24

### Added

- `KiwiCodec.RustlerGenerator.Decoder` documents the `Decoder` generated
  decoders read with, and ships `decoder.rs`, a complete one. The generator
  reads its method signatures unless `:decoder_sources` names another
  `Decoder`, so every feature knows which reads return a `NifResult`.
- Projects that depend on KiwiCodec can use `KiwiCodec.RustlerGenerator`.
  RustQ is an optional dependency, and the generator compiles wherever it is
  available, such as a project's development and test builds; it used to
  compile only in KiwiCodec's own, so projects loaded its sources themselves.
- `KiwiCodec.Schema.Token` has a `kind`: `:identifier`, `:integer`,
  `:symbol`, or `:eof`.

### Changed

- The docs have a Native decoders guide covering each generator feature,
  entrypoints, and the `Decoder`. The generator architecture guide is now
  Internals, for people changing KiwiCodec, and the module groups separate the
  public API from internals.
- The schema tokenizer reads with binary patterns rather than a regular
  expression, and is about 14 times faster on Figma's schema. Tokens,
  positions, and errors are unchanged.
- Skip and sparse helpers are always built from `Decoder` metadata. Without
  `:decoder_sources`, they used to come from a separate set of helpers that
  did not know which reads could fail.
- Item macro rows in generated Rust separate their values with commas, as
  RustQ 1.0.0-rc.14 writes them.
- Records name a definition whose name is a Rust keyword with a raw
  identifier, such as `kiwi_records::r#type`, rather than appending `_` from a
  list of keywords that missed `gen`, `try`, and others.
- Generated Rust builds on rustler 0.37 to 0.39. It used to call
  `rustler::wrapper`, which rustler 0.39 removed.
- Require RustQ 1.0.0-rc.14 for code generation.

### Removed

- `RustlerGenerator.RustExpr.ident/1` and `indent/2`, and
  `RustlerGenerator.Skip.field_expr/2`. `RustExpr.primitive/1` returns RustQ
  AST rather than Rust source.

### Fixed

- The `:full` feature, the default, generates Rust that compiles and decodes
  as `KiwiCodec.decode/2` does. Its entrypoints moved the decoder they then
  finished, its message macro called an undefined function, its reads were
  not propagated with `?`, its strings were read without `env`, and a float
  that is infinite or NaN raised instead of decoding to an atom.
- Generating both sparse and skip decoders without `:decoder_sources` defined
  `kiwi_skip_descriptor_kind` twice, and skip decoders alone with
  `:decoder_sources` called it without defining it.
- A schema name that is not a Rust identifier fails where it is rendered,
  rather than having its other characters replaced with `_`, which could give
  two names the same Rust name.

## v0.4.0 - 2026-10-23

- Add the `:unknown_fields` Rustler generator option. `:runtime_schema` makes
  generated message decoders skip fields the compiled schema does not define,
  using a `KiwiRuntimeSchema` read from the schema that accompanies the data, so
  data written with a newer, compatible schema decodes instead of failing with
  `BadArg`. The default, `:error`, keeps rejecting such fields.
- Route every generated message decoder's unknown fields through one
  `kiwi_unknown_field` helper, and pass full message decoders their definition
  name.
- Accept a `:schema` option in `KiwiCodec.decode/3` to skip message fields the
  generated modules do not define, using the schema the data was written with.
- Add `KiwiCodec.SchemaInterpreter.skip_message_field/4`.
- Add the `:records` Rustler generator feature. It decodes Kiwi data into
  native records Rust code can read, change, and share without building Elixir
  terms, then encodes them as the sparse maps generated decoders return,
  optionally only some fields. Generated constants name each definition, field,
  and enum value; records have typed getters and helpers that update nested
  records and scalar, string, enum, and float-array fields. See
  `KiwiCodec.RustlerGenerator.Records`.
- Sparse decoders intern their module and field-name atoms once instead of for
  every map they build, which took two thirds of the time decoding large files.
- Require RustQ 1.0.0-rc.13 for code generation.
- Rename the Rustler generator's skip, sparse, and full decoder helpers by
  family: `RustlerGenerator.SkipHelpers`, `SkipValueHelpers`, and
  `SkipDescriptor` are `RustlerGenerator.Skip.Helpers`, `Skip.ValueHelpers`,
  and `Skip.Descriptor`; `SparseHelpers` is `Sparse.Helpers`; and
  `FullDecoderHelpers` is `Full.Helpers`.

## v0.3.1 - 2026-07-18

- Compile the RustQ-backed Rustler generator only in development and test
  environments, keeping production codec consumers free of RustQ and its
  development-tool dependency graph.
- Continue shipping the Rustler generator source for development-time native
  generation while keeping the production runtime package limited to the Kiwi
  codec and schema APIs.
- Remove the unused Jason dependency from the production package.

## v0.3.0 - 2026-07-17

- Restore the required slice borrow for match-backed sparse field tables when
  decoder source metadata is enabled.
- Hide internal Rust-only helper types from ExDoc type-reference rendering.
- Add reusable prepared runtime schemas with indexed definition, message-field,
  and enum lookup for repeated `SchemaInterpreter` calls.
- Replace the timer-loop codec benchmark with Benchee coverage for small and
  256-field sparse/dense static and interpreted codecs, including allocation
  measurements.
- Clarify Rustler generator architecture docs now that compact decoder macros
  are RustQ-authored rather than raw Rust heredoc escape boundaries.
- Deduplicate Rustler generator skip descriptor selection and remove exact clone
  findings from the generator helper modules.
- Add optional `decoder_sources` metadata for RustQ-authored skip helpers.
- Emit Rustler macro prelude helpers only for requested generator features.
- Add opt-in descriptor-backed sparse message generation with
  `sparse_messages: :descriptor`.
- Move sparse primitive value helpers, descriptor scanning, descriptor dispatch,
  and sparse descriptor declarations into RustQ-authored `defrust` / `@type`
  support.
- Author the sparse message descriptor macro with item-generating
  `defrustmacro` and compact `repeat` macro-template support.
- Share descriptor field inventories between sparse and skip message decoders
  when both descriptor sparse and skip features are generated.
- Author sparse enum and sparse struct descriptor decoding with RustQ-authored
  `defrust` helpers and item-generating `defrustmacro`.
- Avoid emitting raw match-backed sparse/skip message macros when decoder-source
  descriptor sparse generation does not use them.
- Author decoder-source skip struct decoders with RustQ-authored `defrust`
  helpers and item-generating `defrustmacro`.
- Replace active shared sparse/skip descriptor `kiwi_skip_kind!` token macro use
  with explicit descriptor metadata and RustQ-authored enum construction.
- Move descriptor-backed skip message scanning into RustQ-authored `defrust`
  helpers with sorted field lookup.
- Generate skip descriptor function, enum, and field declarations from RustQ
  type metadata when decoder sources are available.
- Collapse the separate sparse bytes descriptor mode into ordinary `one`
  descriptor mode.

## v0.2.2 - 2026-06-28

- Centralize primitive Rustler decoder metadata.
- Compact generated skip decoders.
- Deduplicate sparse enum decoders when full enum decoders are generated.
- Compact generated enum decoders.
- Remove the unused Rustler decoder macro path.
- Update RustQ dependency to `~> 0.8.2`.

## v0.2.1 - 2026-06-26

- Generate Rustler decoders through shared Rust macros to reduce repeated generated source.
- Add generic Rustler sparse and skip decoder families for projection-oriented native backends.

## v0.2.0 - 2026-06-26

- Delegate LEB128/ZigZag integer encoding to the `varint` package while keeping Kiwi-specific range and error handling.
- Replace vague `FieldProps`/`MessageProps` modules with `KiwiCodec.Metadata` and `KiwiCodec.Metadata.Field`.
- Rename the Kiwi variable-length float wire module to `KiwiCodec.Wire.VarFloat`.
- Rename generated module metadata API from `__kiwi_props__/0` to `__kiwi_metadata__/0`.
- Split Rustler generator naming, selection, helper splice, and decoder macro concerns into dedicated modules.
- Rename generated Elixir source rendering from `KiwiCodec.Generator` to `KiwiCodec.ModuleGenerator`.
- Clarify generated-codec and runtime helper names around definitions, wire fields, and wire types.
- Replace caller-owned Rustler templates with `KiwiCodec.RustlerGenerator.source/2` for complete generated Rust source.
- Centralize Kiwi primitive type metadata in `KiwiCodec.PrimitiveType`.
- Rename schema runtime interpretation to `KiwiCodec.SchemaInterpreter`.
- Split vague `KiwiCodec.Compiler` responsibilities into `KiwiCodec.ModuleCompiler` and `KiwiCodec.FileGenerator`.
- Split parsed schema members into `KiwiCodec.Schema.Field` with `id` and `KiwiCodec.Schema.EnumVariant` with `value`.
- Replace overloaded parsed schema definitions with `KiwiCodec.Schema.Enum`, `KiwiCodec.Schema.Struct`, and `KiwiCodec.Schema.Message`.
- Extract compact binary schema type-reference encoding into `KiwiCodec.Schema.Binary.TypeIndex`.
- Split Rustler generator definition emission, field expressions, and entrypoints into dedicated modules.
- Split generated-module metadata, shape, and typespec emission out of `KiwiCodec.DSL`.
- Split schema tokenization and validation out of `KiwiCodec.Schema.Parser`.
- Group published HexDocs modules without hiding source documentation.
- Refresh README installation instructions for the latest released version.
- Infer Rustler generator entrypoint names and selected definitions from requested schema definitions.
- Render Rustler generator source prelude with RustQ AST imports instead of raw Rust strings.
- Infer Rustler generator entrypoints from matching exported NIF stub modules.
- Infer Rustler generator entrypoints from explicit NIF stub metadata modules without loading Rustler modules.
- Document inferred Rustler entrypoints and NIF stub metadata usage.

## v0.1.1 - 2026-06-25

- Reject unexpected characters while parsing `.kiwi` schema text.
- Normalize malformed binary schema failures to `KiwiCodec.DecodeError`.
- Document internal modules and Rustler generator template requirements.
- Reuse RustQ Rustler helper splices for generated native struct term construction.

## v0.1.0 - 2026-06-25

- Initial Kiwi wire codec, schema parser, runtime interpreter, DSL, and code generator.