• Carry the installed PAM runtime catalog into clean Native starter execution, so the candidate CLI can resolve Android PHP runtimes without host setup.
• Keep Laravel/backend sync adapters independent from the Native frontend while still certifying their own PHP dependency graphs.

• Certify Native 1.x dependents against this exact canonical release candidate before either side is published to Packagist.
• Preserve independent frontend, backend and plugin release ordering without a circular dependency on an already-public Native 1.x package.

• Keep the checked-out PAM candidate outside the Native Cargo workspace during the mandatory clean-starter release gate.
• Restore the end-to-end pam init --template mobile plus pam dev journey in release certification without weakening workspace isolation.

• Refresh the immutable Android ecosystem lock to the independently versioned plugin releases certified for the Native 1.x capability contract.
• Remove the final public Firebase-to-feature-flags dependency from aggregate release certification.

• Freeze the ABI, protocol and capability-negotiation contract for the 1.x line.
• Add deterministic Freeze optimization, retained Fiber lanes, native worklets, signed atomic OTA boot, stable brownfield hosts and independent plugin gates.
• Certify clean pam init --template mobile plus pam dev launch as a hard release prerequisite on a real Android emulator.
• Require PHP 8.5 by default and retain frontend/backend independence.

• Make reactive updates dependency-granular with indexed worklet bindings and a reusable evaluation stack, eliminating full binding scans and hot-path stack allocations.
• Add first-class 144 Hz scheduling alongside 60, 90, and 120 Hz budgets, and drive iOS commits at the display's real adaptive maximum frame rate.
• Add reproducible p50/p95/p99 engine budgets that fail CI on full-commit or patch regressions.
• Ship fat-LTO performance builds plus locally reproducible PGO training, while preserving symbols in the dedicated profiling artifact.
• Make the canonical monorepo directly Composer-installable so Packagist points to push-in/pam-native, while retaining the legacy split as a release mirror.

• ci: certify Camera and PAM Native 0.8 on Android

• test: certify protected native video playback

• test: certify camera Android compiler fix

• test: add media editor to native aggregate gates

• test: consume released protected video package

• test: certify media editor iOS render size fix

• test: add native canvas to aggregate gates

• test: certify canvas GPU and 3D modules

• fix: certify Filament clear color type

• build: register modular media and graphics ecosystem

• fix: qualify modular native view factories

• build: certify stable modular graphics releases

• fix: build Linux CLI on portable glibc baseline

• chore: prepare PAM Native 0.8.1

feat: ship PAM Native UI Language 2 (#69)

feat: ship PAM Native Singularity architecture (#67)

release: make PHP 8.5 the Native baseline

chore(release): align PAM Native 0.6.73 metadata

feat(navigation): type imperative route destinations

feat(templates): expose shared element transitions

• Added the Laravel-inspired Route:: navigation facade for composable native stacks, adaptive bottom tabs, swipeable top tabs and responsive drawers. Navigator declarations may be nested without manually attaching hosts, and actions, system Back, state restoration and deep links recurse through the focused child graph.
• Added composable stack defaults, nested option groups and route-local fluent presentation, sheet, gesture and transition overrides. Deep-link aliases now accumulate per destination instead of replacing earlier patterns. Reusable immutable presets and RouteModule composition let feature packages own their route declarations without global registration order.
• Added string-backed enum destinations, typed Route::to() targets and the pam-native-routes generator for enum cases and statically typed route helper methods from a validated JSON contract.
• Added Shared Elements 2 with route-element timing or spring motion, resize strategy, snapshot cross-fade, corner interpolation, Android predictive Back progress and UIKit controller-host support. Cancellation restores original views and temporary native snapshots are bounded and released.
• Fixed iOS application delegate compatibility by exposing the window contract required by UIKit embedding hosts.
• Fixed generated Xcode product-name quoting and compiled the iOS bridge cleanly against both PHP 8.4 and PHP 8.5 headers.

• Fixed Android decorative children with ripple styling retaining clickable or long-clickable state without an event handler. Images and icons nested in a Pressable no longer intercept the parent's touch target, so tapping any point inside an icon button dispatches its action consistently.

• Fixed Android BottomSheet interactive keyboard behavior to move its configured detent above the IME. Bottom-anchored composers no longer remain clipped below the keyboard with inverted accessibility bounds.

• Bound Android rich-list empty-holder recovery to one attempt per holder and item identity. Legitimately empty conditional rows no longer trigger an endless RecyclerView rebind/layout loop at 60 FPS, while native subtrees released from a previously populated holder still remount on route resume.

• Fix Android KeyboardAvoidingView instances mounted while the IME is closing retaining an intermediate resize inset after the keyboard is hidden. PAM now reconciles newly mounted views with the authoritative IME visibility after traversal and animation settling.

• Fix Android KeyboardAvoidingView resize behavior to reduce its native viewport and reflow flex descendants. Fixed composers and footer actions now remain above the IME instead of staying at their pre-keyboard screen position.

• Fixed Android intrinsic text measurement for packaged fonts by reserving a small relative shaping/hinting allowance. Multi-word labels no longer wrap their final word into a clipped second line when numberOfLines="1" and the native TextView rounds slightly wider than the TTF advance metrics.

• Preserve native module results and runtime reload signals when sustained UI input fills the Android or iOS event queue. The bridge now evicts an older, disposable UI event instead of silently dropping HTTP, SQLite, timer, or other native completion callbacks, and prioritizes critical FIFO delivery ahead of the UI backlog so promises and durable outboxes cannot starve.

• Decode Android inline data:image/* assets on an isolated image lane. Small bundled UI assets such as icon masks now reach the first interactive frame without waiting behind remote photos, disk reads, or animated media decoding.

• Snapshot Android virtualized lists before critical memory trimming. Releasing recycled child trees may mutate the renderer view registry, so iterating the live LongSparseArray could crash a backgrounded application with ArrayIndexOutOfBoundsException. Critical trim now visits the stable snapshot exactly once while preserving the existing memory-release behavior.

• Add Android KeyboardAvoidingView behavior interactive for bottom sheets. The sheet follows the IME but clamps below safe top chrome, keeping headers, search fields, and actions visible instead of panning the entire surface off screen.

• Keep translated Android composer actions tappable above a geometrically overlapping message scroller while still honoring interactive camera and media overlays in the visual stacking order.

• Publish the translated composer touch-target refresh with synchronized Android, Rust protocol, and PHP SDK version metadata.

• Respect Android visual stacking when dispatching translated keyboard-avoidance touch targets. Absolute camera, media, and composer overlays now receive taps instead of leaking them to a visually covered input underneath.

• Invalidate dependency-skipped component trees before invoking template event handlers. Direct mutations of component properties from press, native-view, gesture, input, and other template events now reach the next encoded patch instead of reusing stale elements and native host properties.

• Remount empty Android rich-list holders when a retained navigation route becomes visible again. VirtualizedList and VirtualGrid now recover their cells after route transitions and reactive appearance changes even when the containing window itself never changed visibility.

• Use the React Native-compatible 46.5 × 27 logical-pixel footprint in the layout engine's intrinsic Switch geometry. This removes the legacy 52 × 48 frame before Android receives its exact native measure specs.

• Match the intrinsic Android Switch footprint used by React Native (46.5 × 27 logical pixels) while preserving authored exact dimensions and respecting bounded measure specs. Switches no longer expand compact rows to the platform widget's legacy 40dp minimum height.

• Remount empty Android rich-list holders when a retained window becomes visible again. VirtualizedList and VirtualGrid now recover cells whose native subtree was released while the app was backgrounded, without waiting for scrolling or a data change.

• Fully bind empty Android rich-list holders when a layout payload arrives before their initial materialization. VirtualizedList and VirtualGrid cells no longer remain blank after row-height, prefetch, or clipping setup.

• Respect min-width and min-height while intrinsically measuring the cross axis of flex children, including wrapped rows. Auto-sized controls now reserve their authored logical minimum before line sizing and placement instead of collapsing to their label's intrinsic extent.

• Keep Android pinch and rotation gestures inside their detector when nested in a ScrollView or pager. The detector now claims the touch stream when the second pointer lands and releases it when the gesture finishes, preventing a gallery pinch from being misinterpreted as horizontal page navigation.

• Recover Android autoFocus when an already-retained conditional ancestor becomes visible. Inputs inside p-if subtrees now focus and request the IME at the visibility transition, even after the initial bounded retry elapsed.

• Keep reactive Android autoFocus pending while its screen is detached or a navigation transition does not yet own window focus. A bounded retry now focuses the input and opens the IME as soon as that screen becomes active.

• Make Android autoFocus open the software keyboard for inputs introduced by reactive renders. The renderer waits for attachment/window focus with a bounded retry and respects showSoftInputOnFocus="false".

• Preserve independent CSS column-gap and row-gap values in flex and flex-wrap layouts. The retained Rust engine now applies the horizontal and vertical axes independently during line breaking, placement and intrinsic measurement, while gap remains the fallback for either omitted axis.

• Add an optional failure callback to PushNotifications::register() so FCM and APNs provider/configuration failures can recover application UI without throwing from an asynchronous native-module result. Existing positional API and exception behavior remain compatible when no callback is supplied.

• Add native baseline cross-axis alignment throughout the typed API, template renderer, scoped CSS utility compiler and Rust layout engine. Horizontal flex rows now align text and controls by their typographic baseline while wrapped lines calculate an independent baseline for each line.

• Match React Native text-input baselines on Android by disabling the platform font padding, and retry imperative scroll requests after the next rendered frame so end/target jumps survive concurrent content layout.

• Add bounded pressedScale feedback to Pressable on Android and iOS, compositing it with authored scaleX/scaleY transforms and the existing pressedOpacity animation. The declarative pressedScale attribute and fluent Pressable::pressedScale() API preserve a scale of 1 by default.

• Add typed scrollTargetAlignment (start, center, or end) to tokenized descendant scroll requests on Android and iOS scroll views and virtualized lists. Alignment accounts for target and viewport extent and clamps edge targets without changing the existing start-aligned default.

• Add an optional failure callback to Location::current() so permission, provider and timeout failures can recover application UI without throwing from an asynchronous native-module result. Existing positional parameters and exception behavior remain compatible when no failure callback is given.

• Add authenticated, observable sandbox downloads through Files::downloadWithProgress(), including validated request headers, typed byte progress, explicit failure callbacks and cancellation. The Android implementation streams off the UI thread, enforces the existing 256 MiB ceiling and atomically publishes only completed files.
• Add Files::open() and an app-private Android FileProvider, allowing a downloaded sandbox document to open in a compatible platform application without exposing file:// URIs or granting broad storage access.
• Extend Files::download() with optional validated request headers and a non-throwing failure callback while preserving its existing positional API.

• Add optional failure callbacks to Linking::open(), canOpen(), and initial() so applications can recover from asynchronous platform link failures without an uncaught exception.

• Add optional failure callbacks to AudioRecorder::start(), stop(), cancel(), discard(), and watch() so applications can recover their UI from asynchronous native recorder failures without an uncaught exception.

• Support tokenized scrollRequest, scrollTargetOffset, and scrollTargetTestId on Android and iOS virtualized lists, grids, and section lists, including variable-height cells and offscreen targets.

• Route Android MediaPlayer HTTP and HTTPS sources through the network URL overload instead of ContentResolver, fixing remote audio/video failures reported as No content provider while preserving content://, file:// and android.resource:// playback.

• Preserve explicit reactive scrollRequest commands on Android instead of restoring the pre-commit viewport afterward, fixing jump-to-target and jump-to-end controls that appeared to run but left the list in place.

• Treat Android and iOS file/media picker cancellation as normal UI control flow: Files::pick() now resolves null and Files::pickMany() resolves an empty list instead of raising a native-module failure when users press back.
• Resolve camera cancellation with null through MediaCapture::capture() as well, while preserving native failures for actual capture/import errors.

• Render Android MediaPlayer thumbnails as native posters and keep them visible until the first video frame reaches the TextureView, preventing blank media surfaces while remote playback prepares or buffers.

• Make declarative MediaPlayer autoPlay fully reactive on Android and iOS: switching the bound value to false now pauses a prepared player at its current position instead of leaving native playback running.