0.3.0 — 2026-09-06

Released: alder-cli 0.3.0, alder-ast 0.3.0, alder-bundle 0.3.0, alder-can 0.4.0, alder-codegen 0.4.0, alder-constrain 0.4.0, alder-driver 0.4.0, alder-fmt 0.2.1, alder-kernel 0.4.0, alder-parse 0.3.0, alder-runtime 0.2.2, alder-solve 0.4.0, alder-source 0.3.0

Minor changes

• alder-cli, alder-ast, alder-can, alder-codegen, alder-driver, alder-kernel, alder-solve — 556a21c Treat optional record-field shorthand as an ordinary Option type and materialize omitted Option fields as None during contextual record construction.

  Remove separate record-field optionality from serialized interfaces and invalidate the previous interface format.

  Read Fiber traversal concurrency options using ordinary Option semantics so omitted and explicit None fields both select the sequential default.

  Preserve known generic Result error rows during propagation, including explicit Option fallback branches.

  Provide conditional Option ordering and Unit ordering so derived record payloads use ordinary field dictionaries, including nested Options. — Thanks @rvcas!

• alder-cli, alder-ast, alder-bundle, alder-can, alder-codegen, alder-driver, alder-kernel, alder-runtime, alder-solve — f87e540 Add inferred lazy tasks, generator-based async lowering, Promise extern lifting,
  and a structured fiber runtime with interruption, scopes, finalizers, all, and
  race. — Thanks @rvcas!

• alder-cli, alder-codegen, alder-solve — 556a21c Provide structural Json codecs for closed error rows with Json-capable payloads,
  independent of group names and declaration order. — Thanks @rvcas!

• alder-cli, alder-bundle, alder-can — 83c2be3 Add lazy Ref cells with synchronous atomic reads, writes, updates, and modifications. — Thanks @rvcas!

• alder-cli, alder-codegen, alder-solve — 556a21c Provide structural Show for closed error rows when every payload supports Show,
  independent of named error groups and their declaration order. — Thanks @rvcas!

• alder-cli, alder-driver, alder-solve — 0ddfea3 Report invalid stored dependency trait indexes once at build level, preserving
  canonical module identities without attributing errors to unrelated source.
  Reject incoherent registries even when the build contains no source modules. — Thanks @rvcas!

• alder-cli, alder-bundle, alder-can — 556a21c Expose Fiber.map, forEach, tryMap, and tryForEach with optional MapOptions,
  execution-time concurrency validation, and sequential defaults. — Thanks @rvcas!

• alder-cli, alder-driver — 9c16136 Require explicit package and source-relative identity metadata for every source
  module. Remove URI-based identity guesses and metadata-free driver entry points;
  report missing metadata deterministically before publishing compiler artifacts. — Thanks @rvcas!

• alder-cli, alder-ast, alder-can, alder-codegen, alder-constrain, alder-driver, alder-parse, alder-solve, alder-source — 0db756d Represent explicit async function declarations and lazy async block syntax. — Thanks @rvcas!

• alder-cli, alder-can, alder-codegen, alder-kernel, alder-solve — 556a21c Resolve Hash structurally for closed error rows, honoring payload dictionaries
  and preserving hashes across equivalent groups and row widening. Share payload
  evidence with the equality superclass without duplicating nested generated code.
  Remove nominal error-group derives and their declaration-order-dependent behavior;
  error groups use conditional structural Eq, Show, Hash, and Json capabilities.
  Normalize derived enum payloads through the ordinary annotation converter so
  nominal wrappers of named error groups retain their checked structural evidence. — Thanks @rvcas!

• alder-cli, alder-bundle, alder-can — 83c2be3 Add fixed-capacity semaphores with FIFO weighted requests and scoped,
  cancellation-safe permit ownership. — Thanks @rvcas!

• alder-cli, alder-bundle, alder-can — 83c2be3 Add synchronized shared cells with serialized task-based state transformations. — Thanks @rvcas!

• alder-cli, alder-driver — 0ddfea3 Stop body compilation after source-package coherence failures, reporting errors
  at their defining modules and marking other modules blocked. Avoid phantom
  source labels for overlapping implementations declared in different modules. — Thanks @rvcas!

• alder-ast, alder-can, alder-codegen, alder-solve — ea6b284 Resolve embedded stdlib members through packaged Alder signatures, rejecting unknown members, wrong arguments, invalid callbacks, and arity mismatches. Remove untyped builtin references and correct expected-versus-actual call diagnostics. — Thanks @rvcas!

• alder-ast, alder-can, alder-driver, alder-solve — d87e721 Carry error-row inclusion relationships in canonical and serialized annotations,
  preserving them through arena copies and interface hydration. Bump the interface
  format for the new scheme layout.

  Retain inclusion dependencies during solver generalization and instantiation,
  and reject inferred inclusions between independent universal error-row tails.

  Resolve concrete error unions for inferred results, including exhaustive matches
  across module boundaries. Preserve explicitly open result contracts and apply
  directional Result return checking consistently to named functions and lambdas. — Thanks @rvcas!

• alder-ast, alder-can, alder-driver, alder-solve — 556a21c Add sparse exact-length tuple constraint metadata to annotations and stored interfaces, preserving arena copies and fingerprint identity with a new interface format. Carry imported constraints through inference and check concrete tuple lengths, constrained elements, and generic contracts.

  Finalize source tuple projections without allocating by the largest index, preserve fixed tuple lengths, and reject recursive tuple-element constraints. — Thanks @rvcas!

• alder-ast, alder-can, alder-driver, alder-parse, alder-source — f7fb26b Permit type-checked reassignment and field/index writes through ordinary let bindings and function or lambda parameters. Keep assignment-aware generalization restrictions on shared replaceable values.

  Remove obsolete mutability fields from canonical lets, parameters, and assignment places. Local pattern bindings are writable; non-storage references retain assignment-target checks with diagnostics that no longer suggest adding mut.

  Remove mut from the grammar, keyword list, and source AST. Parsing uses the current grammar without compatibility handling or migration diagnostics. — Thanks @rvcas!

• alder-can, alder-driver, alder-parse, alder-source — 470e3ef Parse named optional parameter annotations and canonicalize their shorthand to
  ordinary builtin Option types, including lambda and trait signatures. — Thanks @rvcas!

• alder-can, alder-driver — 749ba31 Publish public named and wildcard imports in module interfaces, preserving
  original identities and checked schemes including multiple aliases of one name.
  Interface construction APIs now require dependency interfaces; the driver threads
  them through header and final publication. — Thanks @rvcas!

• alder-codegen, alder-driver, alder-solve — 556a21c Apply contextual recursive Option lifting to fresh record field initializers,
  including direct record return contexts, without converting existing mutable
  record aliases. Emit field wrapping through the centralized Option helpers. — Thanks @rvcas!

• alder-codegen, alder-constrain, alder-driver, alder-solve — 556a21c Infer contextual outer Option wrapping jointly across call arguments and emit
  the resolved Some layers directly through the centralized kernel representation.
  Report incompatible inference preferences with a source-aware diagnostic. — Thanks @rvcas!

• alder-codegen, alder-solve — 556a21c Allow omission of trailing Option arguments and emit explicit None values at
  direct, higher-order, and piped call sites using solver-provided call metadata. — Thanks @rvcas!

• alder-codegen, alder-driver, alder-solve — 556a21c Support Option propagation with postfix ? in Option-returning contexts,
  including async bodies and pipe destinations, without implicit Result conversion.
  Wait for recursive peers to constrain unknown propagation carriers before
  generalization, preserving inferred Option contracts across module boundaries. — Thanks @rvcas!

• alder-driver, alder-solve — 556a21c Reject custom trait implementations directly targeting named error groups or
  their transparent aliases, with a source-aware structural-row diagnostic. — Thanks @rvcas!

• alder-kernel — 2cdb02a Add lazy fixed-capacity semaphores with FIFO weighted requests, cancellation-safe
  permit ownership, and scoped cleanup before handing permits to the next waiter. — Thanks @rvcas!

• alder-kernel — aca4bc3 Add bounded lazy traversal workers with ordered map results, unit-only forEach,
  explicit typed-error traversal, and structured cancellation. Stop active siblings
  as soon as an item defect or selected typed error is observed, before waiting for
  that item's cleanup, and join all cleanup before completing the traversal. — Thanks @rvcas!

• alder-kernel — 1e9bb8c Add lazy synchronized cells with serialized task-based updates, nonblocking
  reads, and cancellation-safe write ownership through scoped cleanup. — Thanks @rvcas!

• alder-kernel — 667d9be Add lazy reusable Ref operations with synchronous state transitions, preserved
  payload aliasing, and cancellation-safe commit boundaries. — Thanks @rvcas!

Patch changes

• alder-cli, alder-codegen — 556a21c Capture reached pattern payloads before later pins can mutate their source,
  preserving checked binding types, array-rest values, and alias identity. — Thanks @rvcas!
• alder-cli, alder-kernel — 36e654e Wait for owned child cleanup in scope, all, and race before delivering cancellation
  to the caller, including cancellation during winner/failure cleanup. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Preserve expected field types through if, match, and block-tail initializers.
  Keep implicit Option wrapping at call and field boundaries, reject conversions
  of existing mutable records, and preserve reachable fallthrough checks. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Reject contradictory field requirements on equivalent parenthesizations of
  record spreads, empty operands, and redundant earlier repeated inputs while preserving
  independent generic merge instantiations and rightmost overwrite priority. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Normalize direct named error-group annotations to structural rows, including
  nested aliases, arrays, records, and stored function signatures. — Thanks @rvcas!
• alder-cli, alder-codegen — 556a21c Share lazy child dictionaries between container Hash and its Eq superclass,
  preventing exponential emitted-code growth while preserving equality dispatch. — Thanks @rvcas!
• alder-cli, alder-codegen — a0b9a41 Check refutable patterns before binding payloads in lets, parameters, and loops.
  Failed bindings now report a source-located match failure instead of exposing
  values that violate their checked types, including inside lazy async tasks. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Propagate expected Option payload types through explicit Some and Option.some
  construction, allowing fresh record fields to receive their contextual Option
  types without converting existing mutable payload aliases. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Keep later pattern alternatives reachable after a failed guard. Check their pin
  exits against loop results, matching the existing per-alternative runtime guard
  retry semantics. — Thanks @rvcas!
• alder-cli, alder-kernel — 13e97ef Reject JSON Result envelopes with a missing payload before invoking a custom
  payload decoder, preserving the decoder's String argument contract. — Thanks @rvcas!
• alder-cli, alder-can — 743a09c Resolve pinned expressions against the enclosing scope before pattern bindings
  are introduced, preventing field-order-dependent lookup and uninitialized
  local references when patterns shadow an outer name. — Thanks @rvcas!
• alder-cli, alder-constrain, alder-driver, alder-solve — 556a21c Report out-of-range tuple reads and writes at the index with the tuple length
  and valid zero-based bounds instead of a misleading unit-type mismatch. — Thanks @rvcas!
• alder-cli, alder-bundle, alder-codegen, alder-driver — 54d1b63 Carry physical source origins alongside generated ASTs so local JavaScript extern modules resolve beside their Alder declarations. Preserve virtual module identities after AST transfer, order bundle inputs deterministically, and verify Promise fulfillment, foreign defects, and cancellation through local wrappers. — Thanks @rvcas!
• alder-cli, alder-driver — 9b47b90 Separate interface and instance-index cache paths by package identity kind so
  application modules, workspace members, named packages, and builtins cannot
  overwrite one another's artifacts. Remove the unused unqualified cache lookup. — Thanks @rvcas!
• alder-cli, alder-codegen — b8924f2 Make equality inherited through primitive Hash dictionaries agree with ordinary
  equality, including signed zero and NaN through nested containers and derives. — Thanks @rvcas!
• alder-cli, alder-kernel — 10379a9 Detect active cycles in derived value operations: Show emits <cycle>, while
  Hash, Ord, and JSON encoding raise explicit TypeError defects. Clear active
  tracking after success or exceptions and preserve shared acyclic values. — Thanks @rvcas!
• alder-cli, alder-codegen — 556a21c Resolve recursive derived dictionary references through nested container and
  structural evidence, preventing undefined self bindings in emitted equality,
  showing, and hashing functions. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Check returns and propagation inside match-pin expressions against their
  enclosing function contract, including pins nested inside destructuring patterns. — Thanks @rvcas!
• alder-cli, alder-driver — 2971f2a Preserve external application-member identities when a workspace and its sibling members are relocated together. — Thanks @rvcas!
• alder-cli, alder-kernel — 556a21c Delegate every declared record field to its ordinary equality, ordering,
  hashing, and JSON dictionary. Preserve nested Options and unit payloads, and
  decode missing Option fields as None. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Track pattern matching, rejection, and pin-expression exits in control-flow
  analysis. Keep pin break values in loop result checking and exclude guards,
  arm bodies, later alternatives, and sibling pattern operands that an earlier
  pin exits before reaching. — Thanks @rvcas!
• alder-cli, alder-codegen — 556a21c Avoid exponential generated-code growth for nested JSON codecs by sharing lazy
  payload descriptors between encoding and decoding, preserving recursive codecs. — Thanks @rvcas!
• alder-cli, alder-kernel — 13e97ef Reject unknown JSON variant names that coincide with inherited JavaScript
  properties using the normal path-qualified unknown-variant diagnostic. — Thanks @rvcas!
• alder-cli, alder-bundle, alder-codegen, alder-driver — 41f55b6 Retain Alder source and extern declaration regions through bundling, render unresolved externs as labeled shared diagnostics, and verify sibling JavaScript wrapper resolution across path-dependency packages. — Thanks @rvcas!
• alder-cli, alder-codegen, alder-solve — c9bb0b6 Fix Option coalescing to return its payload type, preserve unit and nested
  Options, and evaluate the default only for None. — Thanks @rvcas!
• alder-cli, alder-driver — 32f5ff4 Reject duplicate module identities before publishing interfaces or code, with diagnostics for both source files. Resolve CLI project imports and canonical module paths using package identity and actual source roots, and resolve package-root imports to mod.ald. — Thanks @rvcas!
• alder-cli, alder-driver — adb35ac Resolve nested workspace source files against their most specific containing source root, keeping package identity and local imports independent of member discovery order. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Require compatible payload types for alternative match bindings, preventing
  incompatible values escaping through another alternative. — Thanks @rvcas!
• alder-cli, alder-driver — 6b4af4c Reject interface-only dependency caches whose package instance index disagrees
  with the implementation headers in their module interfaces, even when each file
  has a valid fingerprint. — Thanks @rvcas!
• alder-cli, alder-can, alder-solve — d8c4983 Allow type variables in local let annotations and reuse the enclosing callable's
  generic variables consistently with lambda annotations. Preserve generic
  contract checking and monomorphic local bindings. — Thanks @rvcas!
• alder-cli, alder-driver — cb89192 Reject distinct workspace roots declaring the same package name before module
  discovery, with a deterministic diagnostic identifying both roots. Repeated
  paths to the same physical package remain one member. — Thanks @rvcas!
• alder-cli, alder-can, alder-driver — 743a09c Require alternative match patterns to bind identical names and share canonical
  binding identities, with source-aware diagnostics for missing or extra names. — Thanks @rvcas!
• alder-cli, alder-kernel — 6080822 Invoke array map, filter, flatMap, and applicative callbacks with only their
  declared value argument. Do not leak JavaScript array indexes or source arrays
  to unary extern-returned callbacks. — Thanks @rvcas!
• alder-cli, alder-solve — 8be2b83 Preserve all trait parameters in default-method annotation scopes, including
  parameters omitted from a method signature. Reject specialization through local
  annotations and retain the trait's superclass evidence in nested bodies. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Carry reachability across aggregate elements, record fields, tag payloads,
  template interpolations, indexing, and assignment operands so unreachable break
  payloads do not constrain an enclosing loop's result. Include contextually
  checked arrays and records. — Thanks @rvcas!
• alder-cli, alder-can, alder-codegen — a0b9a41 Register the documented Option constructors and lower Some/None construction
  and patterns through the existing nesting-preserving Option representation. — Thanks @rvcas!
• alder-cli, alder-driver, alder-parse — 14be079 Reject overflowing tuple indices with a source diagnostic instead of silently
  changing them to the largest representable index. — Thanks @rvcas!
• alder-cli, alder-ast, alder-can, alder-codegen, alder-driver, alder-solve — 556a21c Retain and emit inherited default methods when implementing an imported trait,
  including async defaults and constrained dictionary factories. Publish accurate
  default-helper symbols and implementation method metadata, and invalidate stale
  interface caches. — Thanks @rvcas!
• alder-cli, alder-bundle, alder-can, alder-kernel — 556a21c Expose Fiber.unbounded as a Number value for explicit unbounded traversal
  concurrency, including typed built-in value lookup and the bundled runtime export. — Thanks @rvcas!
• alder-cli, alder-can — 743a09c Keep match-only pin patterns and constructor lookup confined to actual match
  patterns instead of leaking permission into nested bindings. — Thanks @rvcas!
• alder-cli, alder-driver — 209141d Discover transitive source dependencies using each dependency project's own
  manifest and path base, without requiring prebuilt semantic caches.
  Reject distinct dependency roots claiming one package identity, while coalescing
  equivalent paths to the same canonical root.
  Resolve workspace imports against their owning member's dependency declarations,
  without activating unused sibling dependencies. — Thanks @rvcas!
• alder-cli, alder-codegen — 5932a9c Include runtime tag prefixes in structural error-row equality metadata so
  errors with the same tag but different payloads no longer compare equal. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Preserve contextual Option field initialization in records containing spreads.
  Resolve written-field wrapping through ordered field relationships so overwritten
  values retain their own types, later Option fields overwrite earlier values, and inherited
  mutable payloads are not converted. Support nested fresh constructors and arrays. — Thanks @rvcas!
• alder-cli, alder-driver — cc5d41e Build source-backed dependencies from current source without mixing in saved
  interfaces or instance indexes, so removed trait implementations cannot remain
  available to consumers through stale caches. — Thanks @rvcas!
• alder-cli, alder-bundle, alder-can, alder-codegen, alder-kernel, alder-solve — edbcd63 Add Array.iter and independent ArrayIterator cursors, replacing the non-advancing
  Iterator instance on arrays. Preserve shared source values, live iteration, and
  correct Option payloads through exhaustion. — Thanks @rvcas!
• alder-cli, alder-codegen — 556a21c Initialize trait dictionaries in superclass dependency order before top-level
  values, fixing references to later-declared or derived superclass dictionaries. — Thanks @rvcas!
• alder-cli, alder-driver, alder-solve — 556a21c Attribute Option lifting failures to a source argument in the failing constraint
  component, preserving its actual types instead of blaming an unrelated earlier
  argument. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Preserve fresh record and array initializer context on pipe inputs, including
  Option-valued fields and optional parameters. Check each input once without
  converting existing mutable aliases or changing runtime evaluation order. — Thanks @rvcas!
• alder-cli, alder-codegen, alder-kernel — 556a21c Track active nominal comparison pairs in derived equality so recursive values
  can compare cyclic payloads without repeatedly following the same cycle.
  Preserve payload dictionary checks, NaN inequality, and cleanup after failures. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Preserve explicitly universal type parameters during contextual Option lifting.
  Insert Some wrappers when required instead of specializing a generic function
  or trait method to an Option-shaped parameter. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Check generic call arguments from left to right, including piped arguments,
  so mismatches report the expected type and label the incompatible argument. — Thanks @rvcas!
• alder-cli, alder-codegen — a0b9a41 Short-circuit nested pin effects after failed enclosing pattern checks,
  including pins that suspend while awaiting a task. — Thanks @rvcas!
• alder-cli, alder-kernel — 36e654e Preserve interruption and deliver abort exactly once when a Promise extern
  requests cancellation synchronously during registration, including failed or
  malformed registrations. — Thanks @rvcas!
• alder-cli, alder-kernel — 92beacb Ignore late Promise rejection mapping after interruption invalidates the waiter,
  while still observing rejection and preserving exactly-once cancellation cleanup. — Thanks @rvcas!
• alder-cli, alder-codegen — a9f1d44 Preserve lexical break and continue targets when while-condition setup is
  lowered inside a generated JavaScript loop, including suspended conditions. — Thanks @rvcas!
• alder-cli, alder-driver — ca9ab0e Canonicalize and deduplicate workspace member roots so repeated patterns, parent-path spellings, and symlink aliases cannot compile one source tree under multiple identities. — Thanks @rvcas!
• alder-cli, alder-kernel — eaea2b7 Append variable-length hash payload bytes without spreading them into function
  arguments, preventing large strings from exceeding the JavaScript argument limit
  while preserving the existing hash byte format. — Thanks @rvcas!
• alder-cli, alder-solve — 556a21c Solve consistent direct-match Option depth constraints without dense closure.
  Report impossible constraint components consistently even when another component
  has ambiguous wrapping preferences.
  Preserve inferred record/error-row kinds while selecting contextual Some wrappers. — Thanks @rvcas!
• alder-ast, alder-solve — 23b763c Respect Boolean short circuits and false match guards when checking loop exits
  and structural divergence. — Thanks @rvcas!
• alder-ast, alder-solve — f7fb26b Include assignment indices when detecting function suspension, and check their
  early returns and error propagation against the enclosing function's contract. — Thanks @rvcas!
• alder-ast — 38a9ac9 Preserve pin-expression exits in structural match control-flow summaries.
  Distinguish matching from rejection so unreachable sibling patterns, alternatives,
  guards, and arm bodies cannot contribute exits.
  Apply guards per alternative, preserving retries after a false guard. — Thanks @rvcas!
• alder-ast, alder-codegen, alder-constrain, alder-driver, alder-solve — 138d0d0 Distinguish normal fallthrough from control-flow exits, reject missing function results after zero-iteration loops, accept returning branches and lambdas without artificial unit values, and preserve loop-tail and break-payload effects in generated JavaScript. — Thanks @rvcas!
• alder-ast, alder-can, alder-driver, alder-solve — f7fb26b Preserve ordered record-overlay relationships through inference, generalization, and owned interfaces. Keep independent input rows distinct, respect rightmost field overwrites, and check exposed fields against generic contracts. — Thanks @rvcas!
• alder-ast, alder-can, alder-solve — f7fb26b Base top-level generalization on resolved assignments rather than mutation permission flags. Preserve safe polymorphism for never-assigned function bindings while restricting shared replaceable functions, including writes inside nested closures. — Thanks @rvcas!
• alder-bundle, alder-can, alder-codegen, alder-kernel — 1efea6c Require Json evidence for module encode/decode calls and dispatch through the
  selected codec, including custom instances. Remove unchecked JSON entry points
  and fix public export names for imported direct dictionary calls. — Thanks @rvcas!
• alder-can — 808e7bb Include assignment targets in top-level inference dependencies, including writes inside nested functions, so write-only references preserve recursive groups and dependency ordering. — Thanks @rvcas!
• alder-can, alder-driver — 08c77e5 Reject imported types and traits bound under the same name, consistently with
  local declarations, including wildcard and renamed public re-exports. Preserve
  distinct aliases and report both conflicting source imports. — Thanks @rvcas!
• alder-can, alder-driver — daef79b Reject recursive type-alias dependencies during canonicalization and report a
  source-aware diagnostic explaining how to represent recursive data with enums.
  Expand local and imported alias references with instantiated canonical targets,
  including generic arguments and ordinary record field types. — Thanks @rvcas!
• alder-can — cc51b66 Honor local aliases when importing trait methods while preserving their original dispatch identity, and diagnose collisions at the aliased binding. — Thanks @rvcas!
• alder-can — 570ee29 Preserve individual repeated trait-bound clauses without panicking, and avoid
  false associated-type ambiguity when the same trait is mentioned more than once. — Thanks @rvcas!
• alder-can — 556a21c Resolve source-local type aliases in packaged standard-library function signatures
  and qualified public type aliases in caller annotations. Expose Fiber::MapOptions
  for traversal configuration. — Thanks @rvcas!
• alder-can, alder-solve — da17cab Support lowercase type variables in lambda annotations and share enclosing generic variables and trait bounds without leaking names between sibling scopes. — Thanks @rvcas!
• alder-codegen — f7fb26b Preserve left-to-right evaluation of array and tuple elements, call arguments,
  and tag payloads when later operands require setup statements. Evaluate earlier
  values before those statements without copying referenced mutable containers. — Thanks @rvcas!
• alder-codegen — 6010a5e Reject executable state expressions and component declarations until their M6
  runtime semantics exist, rather than silently emitting identity expressions and
  ordinary functions. Preserve provisional check-only support. — Thanks @rvcas!
• alder-codegen — b52e7ad Consume hidden trait dictionaries in extern adapters without leaking them into
  foreign JavaScript arguments, including Result and abort-aware Task wrappers. — Thanks @rvcas!
• alder-codegen — d6cff55 Preserve explicit module initialization dependencies when references resolve through re-exports to their original definitions. — Thanks @rvcas!
• alder-codegen, alder-solve — 556a21c Preserve contextual field types inside fresh Option-wrapped record and array
  payloads. Apply ordinary checked-call rules to bare pipe destinations, including
  Option lifting, omitted arguments, and dictionary passing. — Thanks @rvcas!
• alder-codegen, alder-kernel, alder-solve — 12b09ad Validate primitive Json trait decoding against the requested type, preserving
  validation inside derived and container codecs. Encode unit as null and BigInt
  as a decimal JSON string; reject non-finite JSON numbers instead of silently
  encoding them as null. — Thanks @rvcas!
• alder-codegen, alder-kernel, alder-solve — 677e20f Preserve record-tail identities during inference and publication, check ordinary
  field types at value boundaries, and read stored Option fields directly. — Thanks @rvcas!
• alder-codegen, alder-solve — 13079e7 Read stored Option fields directly in record destructuring and record-shaped
  enum patterns, preserving nested Option values without presence-based wrapping. — Thanks @rvcas!
• alder-codegen — 3662065 Reject query expressions during executable code generation with source context
  instead of emitting a runtime stub that always throws. Query execution remains
  deferred to M7; check-only handling is unchanged. — Thanks @rvcas!
• alder-codegen, alder-solve — f7fb26b Preserve template interpolation evaluation and string-conversion order across
  later setup statements. Check tagged templates against the actual tag function,
  including argument types and its return type, instead of assuming String.
  Preserve empty tagged-template segments around adjacent interpolations. — Thanks @rvcas!
• alder-codegen — f7fb26b Evaluate assignment targets before right-hand setup statements, preserving the
  original receiver across mutation. Support indexed targets with setup statements
  and capture compound-assignment values before right-hand effects, including
  dictionary-dispatched arithmetic. — Thanks @rvcas!
• alder-codegen — 05015b9 Reject executable markup and styles until the rendering/CSS backends exist.
  Remove placeholder object lowering that silently discarded markup directives;
  preserve provisional check-only support with source-aware build diagnostics. — Thanks @rvcas!
• alder-codegen — f7fb26b Preserve record field evaluation and spread copy order when later operands require setup statements. — Thanks @rvcas!
• alder-constrain, alder-driver, alder-solve — 0304ee5 Reject specialization and escape of declared generic function and trait method
  contracts, with source-aware diagnostics for invalid implementations. — Thanks @rvcas!
• alder-constrain, alder-driver, alder-solve — 556a21c Reject ordinary types in converted Result error annotations even when the
  function only forwards its argument without constructing or matching a Result.
  Validate unused alias and enum payload declarations too, and report invalid
  error arguments with a source-labeled error-row diagnostic.
  Check bodyless trait signatures, associated-type bindings, and error-group
  payloads without requiring a use site.
  Validate fixed error slots in partial Result constructors and match structural
  error rows when resolving higher-kinded trait implementations. — Thanks @rvcas!
• alder-constrain, alder-driver, alder-solve — a708527 Keep shared top-level state monomorphic, preserve safe factory polymorphism, and prevent interfaces from turning unresolved shared types into independent generics. Diagnose incomplete shared export types. — Thanks @rvcas!
• alder-constrain, alder-driver, alder-solve — 556a21c Detect cyclic structural error-group expansion and report the recursive source
  reference instead of aborting the compiler with a stack overflow. — Thanks @rvcas!
• alder-driver — 0b1add3 Keep workspace applications in distinct module namespaces using stable member-specific identities, preventing collisions between local imports, generated modules, and cached interfaces. — Thanks @rvcas!
• alder-driver, alder-solve — 556a21c Normalize adjacent closed record spread operands before comparing inferred
  contracts, so grouping fields cannot hide contradictory inherited-field types
  in local or imported functions. Also discard closed fields guaranteed shadowed
  by later closed writes across open spreads when comparing contracts. Preserve
  rightmost writes, other inherited fields, and runtime initializer evaluation.
  Known fields of acyclic open input records also establish guaranteed overwrites;
  opaque cyclic producer obligations do not. — Thanks @rvcas!
• alder-driver — 8918255 Make dependency ordering, compilation depth groups, and import-cycle selection deterministic regardless of module discovery and import order. — Thanks @rvcas!
• alder-driver — 0ddfea3 Locate trait implementation diagnostic labels by implementation identity so imports and omitted header-pass declarations cannot shift their source spans. — Thanks @rvcas!
• alder-driver — 0ddfea3 Label a locally declared trait when reporting superclass cycles spanning modules,
  instead of falling back to the start of the file for a foreign trait. — Thanks @rvcas!
• alder-driver, alder-solve — fd795d5 Report deferred error-row constraint failures at the local function reference,
  including calls through imported interfaces, instead of reusing definition
  coordinates against the caller's source. — Thanks @rvcas!
• alder-fmt, alder-parse — 94c055b Preserve parser-designated template, markup, raw macro, and comment text while formatting. Keep literal whitespace and line endings intact, validate verbatim payloads and physical token lines, and track formatting ranges through parser backtracking. — Thanks @rvcas!
• alder-kernel — 7780a12 Prevent all/race from stranding owned child fibers when a later task factory
  fails, and wait for partial-child cleanup before propagating that failure. — Thanks @rvcas!
• alder-kernel — 09541ea Preserve scheduler fairness across immediately ready Promise resumptions,
  child fibers, and finalizers using a shared host-yield budget. — Thanks @rvcas!
• alder-kernel — e41f380 Preserve Option layers across equality, showing, hashing, mapping, applicative operations, traversal, and map lookup. Distinguish kernel boxes from user Some variants and round-trip nested nullable JSON options with escaped envelopes. — Thanks @rvcas!
• alder-kernel — 27cf3f3 Unwind task cleanup for malformed runtime operations and synchronous handler
  defects instead of skipping cleanup or escaping the shared scheduler. — Thanks @rvcas!
• alder-kernel — 563e003 Execute nested task awaits with explicit fiber-local continuation frames,
  preserving lazy reuse and stack-safe success, failure, and interruption cleanup. — Thanks @rvcas!
• alder-solve — 556a21c Match constructor applications in generic trait implementation heads,
  including leftmost partial-constructor recovery. Preserve shared constructor
  bindings, prerequisite dictionaries, and overlap detection for recovered sections.
  Honor explicit constructor sections before applying leftmost recovery during
  coherence checking, including sections supplied by later trait arguments. — Thanks @rvcas!
• alder-solve — 3156c57 Check ordinary record field types across reachable loop exits independently of
  break order, rejecting incompatible result alternatives. — Thanks @rvcas!
• alder-solve — 556a21c Select trait implementations for function types by matching arity, parameter
  types, result types, and shared template variables. — Thanks @rvcas!
• alder-solve — e8ed91a Check implementation bounds against the trait contract and preserve declared method dictionary order, including inherited bounds and renamed type variables. — Thanks @rvcas!
• alder-solve — 556a21c Compare named Result error groups structurally when detecting overlapping implementations and selecting trait dictionaries, including aliases and fixed error slots in partial constructors. — Thanks @rvcas!
• alder-solve — 556a21c Collect tuple read and write projections before inferring a fixed length, making
  inference independent of projection order and preserving nested alias relations. — Thanks @rvcas!
• alder-solve — 556a21c Preserve error-row tails when checking trait implementation overlap, rejecting
  open-row instances that could match the same concrete Result constructor. — Thanks @rvcas!
• alder-solve — 80159fd Check payloads hidden in open record spread tails when they can overwrite an earlier property, including Option-valued fields. — Thanks @rvcas!
• alder-solve — 9c00543 Preserve universal error-row tails when unifying empty residual rows, allowing
  generic Result identities directly and through transparent aliases. — Thanks @rvcas!
• alder-solve — b58dec3 Accumulate inferred error rows across early returns and resolve mutually
  recursive exact unions without closing externally open error sources. — Thanks @rvcas!
• alder-solve — 69af036 Infer right-biased record spreads using ordinary field types. A later Option field overwrites earlier values even when it contains None. — Thanks @rvcas!
• alder-solve — 556a21c Allow fresh Err constructors to satisfy contextual multi-tag error rows while checking permitted tags and payload types. Preserve expected types through block result expressions without changing early-return boundaries. — Thanks @rvcas!
• alder-solve — 8055981 Infer loop expression results from reachable break values, isolate nested loop
  targets, and reject incompatible break payloads. — Thanks @rvcas!
• alder-solve — 30f6650 Check record-field assignments against their ordinary stored type, requiring
  Option values for Option fields and rejecting implicit payload lifting or
  traversal through an Option parent. — Thanks @rvcas!
• alder-solve — 556a21c Preserve record row tails when checking overlapping trait implementations,
  including shared residual-field constraints across trait arguments.
  Match record instance heads during dictionary selection so valid record
  implementations can be called, including across module boundaries. — Thanks @rvcas!
• alder-solve — 556a21c Index Option depth constraints by their incident variables instead of rescanning
  all constraints for every independent component. Preserve field initializer
  context in explicitly annotated lambda record returns. — Thanks @rvcas!
• alder-solve — f7fb26b Resolve newly closed record overlays after bare-function pipe calls before
  checking field access, preserving the final stored field type like ordinary calls. — Thanks @rvcas!
• alder-solve — 556a21c Require the built-in Result module identity when granting Result.err error-tag construction behavior, rather than accepting similarly named user modules. — Thanks @rvcas!

Dependency updates

• alder-cli: alder-bundle@0.3.0, alder-driver@0.4.0, alder-fmt@0.2.1, alder-runtime@0.2.2
• alder-ast: alder-source@0.3.0
• alder-bundle: alder-codegen@0.4.0, alder-kernel@0.4.0
• alder-can: alder-ast@0.3.0, alder-parse@0.3.0, alder-source@0.3.0
• alder-codegen: alder-ast@0.3.0, alder-solve@0.4.0
• alder-constrain: alder-ast@0.3.0
• alder-driver: alder-ast@0.3.0, alder-can@0.4.0, alder-codegen@0.4.0, alder-constrain@0.4.0, alder-parse@0.3.0, alder-solve@0.4.0, alder-source@0.3.0
• alder-fmt: alder-parse@0.3.0, alder-source@0.3.0
• alder-parse: alder-source@0.3.0
• alder-solve: alder-ast@0.3.0, alder-can@0.4.0, alder-constrain@0.4.0