PRIK 0.5.1

Breaking changes

• Fortran derived-type scalar fields now expose live, writable rank-zero NumPy
  views instead of copied scalars or strings. Generated contracts use T[()]
  and String[n][()]; an edited contract can still request a copied value with
  plain T or String[n]. Scalar allocatable and pointer fields also return
  a current view or None, and are omitted from default constructor keywords.
• Mutable Fortran module scalars now expose live rank-zero NumPy views instead
  of copied scalar values. Scalar allocatable and pointer module variables
  return a current view or None; read them again after native storage changes.
• Generated Fortran derived-type classes now use capitalized names such as
  Point_T for point_t; other Fortran names remain lowercase. Generated C
  names preserve source case, so Foo and foo remain distinct. Update Python
  imports and calls that relied on the old generated spellings.
• The Strided contract marker and dimension-step forms have been removed. Use
  T[::] for a strided axis and T[:] for a contiguous one.

Fortran and contract features

• TYPE(*) dummies accept supported NumPy scalar and array storage through
  the dummy's address or descriptor ABI, including direct BIND(C) calls.
  Contracts use AnyNative, shape subscripts, and ReadOnly for scalar inputs
  that may use immutable NumPy values. Callers retain buffers used by
  nonblocking native operations until completion.
• UCS-4 character(kind=selected_char_kind('ISO_10646')) uses UString and
  NumPy U<n> storage. selected_char_kind('ASCII') and 'DEFAULT' use
  String; numeric character kinds are classified with the selected compiler.
• Source commands accept repeated --module-source-dir paths, and
  build_fortran_extension accepts module_source_dirs. PRIK finds used module
  and submodule sources under those directories, including transitive
  dependencies, and reports missing or ambiguous definitions. Native libraries
  and prebuilt module directories remain explicit build inputs.
• --export-symbols and build_fortran_extension(export_symbols=...) select
  module-qualified public Fortran procedures, generics, and variables, including
  public facade re-exports. Required signature declarations remain available;
  the generated contract's __all__ records the Python surface. C source
  selection likewise records its Python surface in __all__.
• Source builds and generate --pyi now agree on Fortran project resolution,
  selected exports, names, and generated contracts. A contract build treats its
  edited __all__ as authoritative, including withheld dependencies and
  package sub-namespaces; relative sibling imports let a module leaf be built
  directly.
• Cross-module derived types, variables, procedures, callback interfaces, and
  generic interfaces now resolve through public use and re-export routes.
  A facade may expose a module variable as another live route to the same
  native storage, and merged generics retain specifics from every accessible
  contributor. A type used by another module's procedure keeps one native
  identity and can be constructed or returned through that module.
• Optional Fortran callbacks can be omitted or passed None. Optional
  arguments inside callback interfaces preserve PRESENT(), and assumed-shape
  callback array arguments are supported. Writable scalar callback dummies
  reach Python as rank-zero storage so writes reach the native caller.
• Supported optional arguments retain Fortran absence through forwarded native
  calls, including combinations that previously expanded into many generated
  call paths. Optional assumed-rank arrays retain their actual rank when
  present and may be omitted or passed None.
• Numeric, logical, and fixed-character reference dummies accept matching
  rank-zero NumPy storage as well as scalar values; a VALUE dummy or
  Immutable argument receives a copy.
• Contracts can rename classes, variables, constants, and callables while
  retaining their native targets through @bind or SourceName. Generated
  contracts preserve those targets, relative imports, overload links, pure
  specification functions, and Python publication when read back for a build.