0.20.0

Added

• Standalone TypeScript normalization from Plan::typescript(package) and
  normalize-generate --target typescript --package NAME. Generated ES2022 ESM
  packages execute formats 1–6 from exact JSON text, use bigint for exact integer
  representation, retain source pins and expose strict retained-base64 helpers.
  The fixed schema profile refuses unsupported constraints before generation;
  uniqueItems: true is explicitly outside that profile. Complete Rust/Go maps
  retain their bytes at the same generator version.
• Authored ess/2 adds finite Binary64 fields, distinct from integer and decimal
  values. Model projection retains compiler-owned numeric locations; old authored
  formats and Binary64 map keys refuse at every declared type position.
  ess-normalization/5 requires explicit input paths and adds token-preserving
  binary64_literal constants and finite binary64 conversion/steps. Reference
  and generated Rust/Go preserve signed zero, subnormals and nearest-even rounding.
  Two typed Binary64 operands use IEEE equality; authored model predicates retain
  their existing Number comparisons. Complete format 1–4 generated maps remain
  frozen. Whole-system synthesis and conformance refuse unsupported Binary64
  before publication; TypeScript structural output reports the finite codec obligation.
• Standalone model Rust/Go libraries now emit checked finite Binary64 wrappers.
  Original-token codecs preserve signed zero, subnormals and nearest-even rounding
  through supported aliases, recursive containers and unions. Rust requires
  source-backed Serde decoding; mixed declared-field/Binary64-extra records refuse
  before output. Existing non-Binary64 generated maps remain unchanged.
• ess-normalization/6 adds explicit fixed string array preparation and checked
  position reads in the reference, Rust and Go targets. Declared boundaries
  preserve absence, turn null values/elements into empty strings, pad short arrays
  and discard excess tokens after strict lexical checks. Active policies require
  original JSON text. Format 6 retains target report 3; complete format 1–5 maps
  remain byte-identical at the same generator version.
• Opt-in ess-conformance-report/2 separates passed, failed, error, unsupported
  and skipped counts, binding outcomes to the exact executed suite bytes.
  Rust/CLI also expose checked ess-conformance-run/2 detailed output; generated
  Go supports standalone report 2 and explicit strict execution. Suite versions
  1–4 retain unknown coverage, so these counts cannot establish complete
  conformance. Report 1 and diagnostic defaults retain their existing behavior.
• Checked ess-openapi-import/1 envelopes retain original source identity and
  semantic accounting. Reloading verifies the source digest, normalization and
  derived interface before projection; constraints that cannot be preserved
  produce located gaps or refusals. Legacy ess-service-interface/1 readers
  retain their existing representation.
• ess-normalization/4 explicitly captures selected JSON field, array-item or root
  tokens as canonical standard base64 before first-stage schema validation. Exact
  token spelling, duplicate members and huge numeric lexemes are retained inside
  captures; JSON grammar, Unicode and the 64-level depth bound remain enforced.
  Reference, generated Rust and Go expose strict base64-to-JSON entrypoints for
  separately checked retained-document composition. Decoded-value APIs refuse
  capture branches without original token bytes. Targets use report version 3;
  frozen legacy templates preserve formats 1–3 emitted bytes and file maps.
• ess-normalization/3 model-owned stage roots, pinned to complete compiler
  provenance and explicit type selections. Plan::check_with_models and CLI
  --model inputs reuse checked model wire projections without duplicate schemas
  or trusted imported annotations. Rust and Go retain model sources and version 2
  target reports. Unevaluated model invariants refuse planning; existing Go pattern
  limits still apply. Versions 1 and 2 retain their bundle recipe representation.
• Explicit ess-normalization/2 ordered string concatenation/joining, exact integer
  rendering, list concatenation, original collection indices, filtered mapping and
  first-match selection. The reference engine and generated Rust libraries preserve
  order, duplicate values and lazy selected-value evaluation. Version 1 refuses the
  new operations and retains its existing semantics and canonical representation.
• Version 2 branch-specific binary64_inputs declarations and ordered
  binary64_to_integer conversion with finite multiply/minimum/maximum steps,
  nearest-even decoding and explicit out-of-range refusal. Undeclared numbers
  keep the exact JSON policy; signed integer scaling remains separately governed
  by its reject/wrap policy. Reference, CLI and generated Rust share the semantics.
• Standalone Go normalization libraries from Plan::go(package, module), with
  typed operation bindings, offline pinned schema validation, exact integer and
  declared binary64 input policies, and complete source/file provenance. Native
  Go fixtures exercise old, ordered and numeric recipes against reference results
  and located refusals. The exact frozen base64 pattern used by model Bytes is
  qualified against the pinned reference through a shared ASCII, Unicode, padding
  and long-input corpus in generated Go and Rust. Every other selected pattern
  retains its source-located go_schema_pattern generation refusal.
• ess generate schema normalize-generate exposes Rust, Go and TypeScript normalization
  libraries with explicit package/module identity and complete source provenance.
  It checks every branch and target before destination preflight, protects source
  inputs, and offers read-only planned-file drift checking through --check.

Changed

• Composition documentation states the generated client's selected-operation and
  model-identity guarantees alongside its byte-buffer transport boundary. An
  executable downstream example shows compatible and incompatible payloads
  forwarded unchanged, with separate authority and endpoint/error controls.
• Document the frozen normalization equality limitation: formats 5/6 compare two
  floating representations numerically even in an admitted Integer expression.
  TypeScript preserves reference behavior; mixed integer/floating operands retain
  integer eligibility refusal. Static Binary64 admission and output provenance
  remain distinct. This release does not tighten the core equality contract.
• In this pre-1.0 minor release, ess_synth::{go,clap}::workspace return
  Result<Emission, TargetFailure>. Their new finite-codec failures use
  ess-target-failure/2; Rust/Web failure envelopes keep version 1 and old bytes.
  ess_conformance::{go,web}::emit, ConformanceSuite::to_canonical_json, and
  Runner::run now return Result with a located AdmissionError. Readers,
  model producers, direct typed suites and CLI routes reject Binary64 before
  artifact creation or target interaction, including sparse models with no
  generated scenarios. Existing admitted suite bytes remain unchanged.

Fixed

• Specification admission checks complete expression paths, both operands,
  membership values and lexical collection bindings across invariant, command
  and view owners. Conformance reuses the same type rules while retaining its
  separate projection and witness limits; authored operand errors are distinct
  from unreadable paths.
• Authored conformance commands refuse an explicitly selected directory with no
  immediate lowercase YAML inputs before writing artifacts or selecting a runner.
  Diagnostics explain shallow discovery. Omitted selections, direct files and
  committed suites retain their existing behavior.

Changed

• Define execution recovery boundaries for interrupted apply and removal, manual
  drift and fresh observation. Current absence does not establish who removed a
  release. Applied-state modeling and executable recovery remain follow-on work.